Newer
Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
English | [中文README](README.zh_CN.md)
# Overview
DDD Firework is a framework that supports the implementation of DDD (Domain-Driven Design). It provides a complete lifecycle wrapper for domain entities, including creation, modification, persistence, event sending, event listening, and integration with components such as locks, databases, and eventbuses.
# Features
1. Providing a unified application-level interface ICommand to encapsulate the entire lifecycle (build, behavior, persistence, event sending, etc.) management of domain layer entities.
2. Automatic detection of changes to domain entities and persistence, without the need for users to handle complex storage logic.
3. Support for rapid rebuild of complex aggregations (multiple levels of entity combinations), without the need to write specific query statements.
4. Support for domain events, including domain event sending, registration of listener functions, and event callbacks.
5. Hexagonal architecture with abstract definitions of each underlying component (locks, persistence, event buses, etc.) allows for flexible pluggable components.
# Architecture
# Usage
1. Define domain entities
import ddd "github.com/bytedance/dddfirework"
type Order struct {
ddd.BaseEntity
UserID string
TotalAmount int64
Remark string
}
2. Register persistence models
import ddd "github.com/bytedance/dddfirework"
import "github.com/bytedance/dddfirework/executor/sql"
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
func init() {
mysql.RegisterEntity2Model(&domain.Order{}, func(entity, parent ddd.IEntity, op ddd.OpType) (mysql.IModel, error) {
do := entity.(*domain.Order)
return &po.OrderPO{
ID: do.GetID(),
User: do.UserID,
TotalAmount: do.TotalAmount,
Remark: do.Remark,
}, nil
}, func(m mysql.IModel, do ddd.IEntity) error {
orderPO, order := m.(*po.OrderPO), do.(*domain.Order)
order.UserID = orderPO.User
order.TotalAmount = orderPO.TotalAmount
order.Remark = orderPO.Remark
return nil
}
}
3. Define Command
type UpdateOrderOpt struct {
Remark *string
}
type UpdateOrderCommand struct {
ddd.Command
orderID string
opt UpdateOrderOpt
}
func NewUpdateOrderCommand(orderID string, opt UpdateOrderOpt) *UpdateOrderCommand {
return &UpdateOrderCommand{
orderID: orderID,
opt: opt,
}
}
func (c *UpdateOrderCommand) Init(ctx context.Context) (lockIDs []string, err error) {
return []string{c.orderID}, nil
}
func (c *UpdateOrderCommand) Build(ctx context.Context, builder dddfirework.DomainBuilder) (roots []dddfirework.IEntity, err error) {
order := &domain.Order{
ID: id,
Items: []*domain.SaleItem{},
Coupons: []*domain.Coupon{},
}
if err := builder.Build(ctx, order, &order.Items, &order.Coupons); err != nil {
return nil, err
}
return []dddfirework.IEntity{order}, nil
}
func (c *UpdateOrderCommand) Act(ctx context.Context, container dddfirework.RootContainer, roots ...dddfirework.IEntity) error {
order := roots[0].(*domain.Order)
if c.opt.Remark != nil {
order.Remark = *c.opt.Remark
order.Dirty()
}
return nil
}
4. Execute command
import (
ddd "github.com/bytedance/dddfirework"
db_executor "github.com/bytedance/dddfirework/executor/sql"
db_eventbus "github.com/bytedance/dddfirework/eventbus/mysql"
db_lock "github.com/bytedance/dddfirework/lock/db"
"gorm.io/driver/mysql"
"gorm.io/gorm"
)
func main() {
lock := db_lock.NewDBLock(db, time.Second*10)
executor := db_executor.NewExecutor(db)
eventBus := db_eventbus.NewEventBus("svc_example", db)
engine := dddfirework.NewEngine(lock, executor, eventBus.Options()...)
engine.RunCommand(ctx, command.NewUpdateOrderCommand(
req.ID, command.UpdateOrderOpt{Remark: req.Remark},
))
}
