分层概念
在领域驱动设计中，通常将一个应用系统划分为四层架构，分别是表现层、应用层、领域层和基础设施层。
- 表现层：负责处理用户界面和用户交互，如接收用户输入，显示输出结果等。
- 应用层：负责协调应用程序的活动，如处理业务用例和业务流程等。
- 领域层：负责实现业务逻辑和业务规则，包含领域模型和领域服务等。
- 基础设施层：负责提供技术支持，如数据持久化、消息传递、日志记录等。
这四层之间有着严格的依赖关系，上层依赖于下层，而下层不依赖于上层。这样的分层架构有助于实现高内聚低耦合的设计原则。
目录架构参考
├─catalog // 商品目录子域
│ ├─application // 应用层
│ │ ├─brand
│ │ ├─category
│ │ ├─collection
│ │ └─product
│ ├─domain // 领域层
│ │ ├─brand // 商品品牌模块
│ │ ├─category // 商品类目模块
│ │ ├─collection // 商品集合模块
│ │ └─product // 商品模块
│ ├─infrastructure // 基础设施层
│ │ └─persistent // 持久化
│ │ ├─jpa
│ │ ├─mybatis
│ │ └─redis
│ └─presentation // 表现层
│ ├─graphql
│ ├─grpc
│ ├─rest
│ ├─view
│ └─websocket
└─order
├─application
│ ├─dispute
│ ├─review
│ ├─shipping
│ └─source
├─domain
│ ├─dispute
│ ├─review
│ ├─shipping
│ └─source
├─infrastructure
└─presentation [^2^][1]
表现层demo
package main
import (
"fmt"
"net/http"
)
func main() {
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
fmt.Fprint(w, "Hello, this is the presentation layer!")
})
fmt.Println("Starting server on port 8080")
err := http.ListenAndServe(":8080", nil)
if err != nil {
panic(err)
}
}
应用层demo
package main
import "fmt"
type Order struct {
ID string
}
type OrderService interface {
CreateOrder(order Order) error
}
type OrderServiceImpl struct{}
func (s *OrderServiceImpl) CreateOrder(order Order) error {
fmt.Printf("Creating order with ID: %s\n", order.ID)
return nil
}
func main() {
orderService := &OrderServiceImpl{}
order := Order{ID: "123"}
err := orderService.CreateOrder(order)
if err != nil {
panic(err)
}
}
领域层demo
package main
import (
"errors"
"fmt"
)
type Order struct {
ID string
Quantity int
}
func (o *Order) Validate() error {
if o.ID == "" {
return errors.New("order ID cannot be empty")
}
if o.Quantity <= 0 {
return errors.New("order quantity must be greater than 0")
}
return nil
}
func main() {
order := Order{ID: "123", Quantity: 2}
err := order.Validate()
if err != nil {
panic(err)
}
fmt.Println("Order is valid")
}
基础设施层demo
package main
import "fmt"
type Order struct {
ID string
}
type OrderRepository interface {
Save(order Order) error
}
type OrderRepositoryImpl struct{}
func (r *OrderRepositoryImpl) Save(order Order) error {
fmt.Printf("Saving order with ID: %s\n", order.ID)
return nil
}
func main() {
orderRepository := &OrderRepositoryImpl{}
order := Order{ID: "123"}
err := orderRepository.Save(order)
if err != nil {
panic(err)
}
}