add example for ddd

Author: jarry

domain-driven-design/c/README.md

@@ -0,0 +1,45 @@
+## C语言`DDD`目录结构
+```bash
+c/
+├── main.c                  // UI 层：应用程序的入口，处理用户交互
+├── domain/                 // 领域层：包含核心业务模型和逻辑
+│   ├── order.h             // 订单领域模型的头文件，定义订单属性和操作
+│   └── order.c             // 订单领域模型的实现，包含订单创建、取消等功能
+├── repository/             // 仓储层：管理数据存储和检索
+│   ├── order_repository.h  // 订单仓储的头文件，声明订单持久化的函数
+│   └── order_repository.c  // 订单仓储的实现，处理订单的保存和检索
+└── service/                // 服务层：提供高层业务逻辑
+    ├── order_service.h     // 订单服务的头文件，声明订单操作的服务函数
+    └── order_service.c     // 订单服务的实现，协调领域和仓储操作
+```
+
+
+## 解释
+
+- **`main.c`**: 该文件作为用户界面层，负责与用户交互，捕获输入并显示输出。它调用服务层来根据用户输入执行操作。
+
+- **`domain/`**: 该目录包含领域层，是业务逻辑的核心。包括：
+  - `order.h`: 定义 `Order` 结构体及其相关操作，如创建和取消订单。
+  - `order.c`: 实现 `order.h` 中声明的函数，处理订单管理的核心逻辑。
+
+- **`repository/`**: 该目录代表仓储层，抽象数据存储机制。包括：
+  - `order_repository.h`: 声明用于保存和检索订单的函数。
+  - `order_repository.c`: 实现仓储函数，管理订单数据的存储和检索。
+
+- **`service/`**: 该目录包含服务层，提供高层次的业务服务。包括：
+  - `order_service.h`: 声明协调领域和仓储层操作的服务函数。
+  - `order_service.c`: 实现服务函数，组织业务逻辑和数据访问。
+
+## 运行代码
+```shell
+$ c % make clean
+rm -f main.o domain/order.o repository/order_repository.o service/order_service.o order_system.o
+$ c % make
+gcc -Wall -Wextra -I./domain -I./repository -I./service   -c -o main.o main.c
+gcc -Wall -Wextra -I./domain -I./repository -I./service   -c -o domain/order.o domain/order.c
+gcc -Wall -Wextra -I./domain -I./repository -I./service   -c -o repository/order_repository.o repository/order_repository.c
+gcc -Wall -Wextra -I./domain -I./repository -I./service   -c -o service/order_service.o service/order_service.c
+gcc main.o domain/order.o repository/order_repository.o service/order_service.o -o order_system.o
+$ c % ./order_system.o 
+# 展示结果
+```

domain-driven-design/c/main.c

@@ -65,6 +65,7 @@ Apple clang version 16.0.0 (clang-1600.0.26.6)
 Target: arm64-apple-darwin24.3.0
 Thread model: posix
 InstalledDir: /Library/Developer/CommandLineTools/usr/bin
+jarry@MacBook-Pro c % make clean
 jarry@MacBook-Pro c % make                           
 gcc main.o domain/order.o repository/order_repository.o service/order_service.o -o order_system.o
 jarry@MacBook-Pro c % ./order_system.o 

domain-driven-design/go-web/README.md

@@ -0,0 +1,145 @@
+## Go语言`DDD`目录结构
+```bash
+go-order-system/
+│── cmd/
+│   └── main.go               # 应用入口
+│── internal/
+│   ├── domain/               # 领域层（核心业务逻辑和接口定义）
+│   │   ├── order/            # 订单聚合
+│   │   │   ├── order.go      # 订单实体（聚合根），包含核心业务逻辑
+│   │   │   └── order_repository.go # 订单仓储接口，定义对订单数据的操作
+│   ├── application/          # 应用层（协调领域逻辑，处理业务用例）
+│   │   ├── order_service.go  # 订单应用服务，调用领域层业务逻辑
+│   ├── infrastructure/       # 基础设施层（实现领域层定义的接口）
+│   │   ├── repository/       # 仓储实现
+│   │   │   ├── repository.go # 通用仓库接口（通用 CRUD 操作）
+│   │   │   └── order_repository_impl.go  # 订单仓储实现，具体的订单数据存储
+│   └── interfaces/           # 接口层（处理外部请求，如HTTP接口）
+│   │   ├── handlers/         # HTTP 处理器
+│   │       └── order_handler.go # 订单相关的HTTP处理器
+│   └── middleware/           # 中间件（例如：鉴权、拦截、认证等）
+│── pkg/                      # 可复用的公共库
+│   └── utils/                # 工具类（例如：日志、日期处理等）
+```
+
+## 运行
+```bash
+$ go run cmd/main.go
+# 展示结果 Starting server on :8080 successfully.
+# 通过 http://localhost:8080 访问系统
+```
+
+## Go 语言 DDD（领域驱动设计）特点
+
+### 1. 关注领域模型
+DDD 强调领域模型的构建，使用 **聚合（Aggregate）**、**实体（Entity）**、**值对象（Value Object）** 组织业务逻辑。
+
+在 Go 语言中，通常使用 `struct` 定义实体和值对象：
+
+```go
+// 实体（Entity）
+type User struct {
+    ID   int
+    Name string
+}
+```
+
+### 2. 分层架构
+DDD 通常采用 **分层架构**，Go 语言项目可以遵循如下结构：
+
+- **领域层（Domain Layer）**：核心业务逻辑，如 `domain` 目录下的实体和聚合。
+- **应用层（Application Layer）**：用例（Use Cases）和业务流程编排。
+- **基础设施层（Infrastructure Layer）**：数据库、缓存、外部 API 适配等。
+- **接口层（Interface Layer）**：提供 HTTP、gRPC 或 CLI 接口。
+
+### 3. 依赖倒置（Dependency Inversion）
+领域层不应直接依赖基础设施，而是通过 **接口（Interface）** 进行依赖倒置。例如：
+
+```go
+// 领域层：定义接口
+type UserRepository interface {
+    GetByID(id int) (*User, error)
+}
+```
+
+```go
+// 基础设施层：数据库实现
+type userRepositoryImpl struct {
+    db *sql.DB
+}
+
+func (r *userRepositoryImpl) GetByID(id int) (*User, error) {
+    // 数据库查询逻辑
+}
+```
+
+### 4. 聚合（Aggregate）管理
+
+聚合根（Aggregate Root）管理整个聚合的生命周期：
+
+```go
+type Order struct {
+    ID      int
+    Items   []OrderItem
+    Status  string
+}
+
+func (o *Order) AddItem(item OrderItem) {
+    o.Items = append(o.Items, item)
+}
+```
+
+### 5. 应用服务（Application Service）
+应用服务封装领域逻辑，避免外部直接操作领域对象：
+
+```go
+type OrderService struct {
+    repo OrderRepository
+}
+
+func (s *OrderService) CreateOrder(userID int, items []OrderItem) (*Order, error) {
+    order := Order{UserID: userID, Items: items, Status: "Pending"}
+    return s.repo.Save(order)
+}
+```
+
+### 6. 事件驱动（Event-Driven）
+使用 **领域事件（Domain Events）** 进行解耦，在 Go 语言中可通过 **Channel** 或 **Pub/Sub** 实现：
+
+```go
+type OrderCreatedEvent struct {
+    OrderID int
+}
+
+def publishEvent(event OrderCreatedEvent) {
+    go func() {
+        eventChannel <- event
+    }()
+}
+```
+
+### 7. 结合 CQRS（命令查询职责分离）
+DDD 可结合 CQRS（Command Query Responsibility Segregation），在 Go 语言中可用 **命令（Command）** 处理变更操作，用 **查询（Query）** 处理数据读取：
+
+```go
+type CreateOrderCommand struct {
+    UserID int
+    Items  []OrderItem
+}
+
+func (h *OrderHandler) Handle(cmd CreateOrderCommand) (*Order, error) {
+    return h.service.CreateOrder(cmd.UserID, cmd.Items)
+}
+```
+
+### 总结
+
+Go 语言的 DDD 实践强调：
+
+1. **使用 struct 作为领域模型**（Entity、Value Object、Aggregate）
+2. **依赖倒置**，通过接口定义领域层，不直接依赖基础设施
+3. **使用应用服务（Service）封装业务逻辑**，避免外部直接操作领域对象
+4. **事件驱动**，通过 Channel 或 Pub/Sub 进行解耦
+5. **结合 CQRS**，实现命令和查询分离，提高可扩展性
+
+通过 DDD 设计模式，可以使得项目业务逻辑更加清晰、模块化，便于扩展和维护。

domain-driven-design/go-web/cmd/main.go

@@ -0,0 +1,76 @@
+// 入口页面
+package main
+
+import (
+  "go-order-system/internal/application"
+  "go-order-system/internal/infrastructure/repository"
+  "go-order-system/internal/interfaces/handlers"
+  "go-order-system/internal/middleware"
+  "log"
+  "net/http"
+)
+
+// 默认欢迎页面
+func defaultPage(w http.ResponseWriter, r *http.Request) {
+  w.Header().Set("Content-Type", "text/html; charset=utf-8")
+  w.WriteHeader(http.StatusOK)
+
+  htmlResponse := `
+  <h1>Welcome to DDD example.</h1>
+  <pre>
+    测试
+    <code>
+    创建：curl -X POST "http://localhost:8080/orders/create" -H "Content-Type: application/json" -d '{"customer_name": "齐天大圣", "total_amount": 99.99}'
+    查询：curl -X GET "http://localhost:8080/orders/get?id=订单号"
+    更新：curl -X PUT "http://localhost:8080/orders/update?id=订单号" -H "Content-Type: application/json" -d '{"customer_name": "孙悟空", "total_amount": 11.22}'
+    删除：curl -X DELETE "http://localhost:8080/orders/delete?id=订单号"
+    查询：curl -X GET "http://localhost:8080/orders/get?id=订单号"
+    </code>
+  </pre>
+	`
+  w.Write([]byte(htmlResponse))
+}
+
+func initRouter(orderHandler *handlers.OrderHandler) {
+  // 配置路由并将中间件应用到每个处理器
+  http.HandleFunc("/", middleware.LoggingMiddleware(defaultPage))                           // 欢迎页面
+  http.HandleFunc("/orders/create", middleware.LoggingMiddleware(orderHandler.CreateOrder)) // 创建订单
+  http.HandleFunc("/orders/get", middleware.LoggingMiddleware(orderHandler.GetOrder))       // 查询订单
+  http.HandleFunc("/orders/update", middleware.LoggingMiddleware(orderHandler.UpdateOrder)) // 更新订单
+  http.HandleFunc("/orders/delete", middleware.LoggingMiddleware(orderHandler.DeleteOrder)) // 删除订单
+}
+
+func main() {
+  // 创建订单仓储实现
+  orderRepo := repository.NewOrderRepositoryImpl()
+
+  // 创建订单应用服务
+  orderService := application.NewOrderService(orderRepo)
+
+  // 创建 HTTP 处理器
+  orderHandler := handlers.NewOrderHandler(orderService)
+
+  initRouter(orderHandler)
+
+  // 打印日志确认服务器启动
+  log.Println("Starting server on :8080 successfully.")
+
+  // 启动 HTTP 服务器
+  if err := http.ListenAndServe(":8080", nil); err != nil {
+    log.Fatalf("Server failed: %v", err)
+  }
+}
+
+/*
+// 在控制台运行项目
+jarry@MacBook-Pro go-web % go run cmd/main.go
+
+// 执行curl测试，可以得到结果，控制台输出如下
+2023/04/21 15:43:45 Starting server on :8080 successfully.
+2023/04/21 15:43:50 REQUEST: POST /orders/create took 147.375µs
+2023/04/21 15:44:00 REQUEST: GET /orders/get took 152.833µs
+2023/04/21 15:44:20 REQUEST: PUT /orders/update took 140µs
+2023/04/21 15:44:29 REQUEST: GET /orders/get took 44µs
+2023/04/21 15:44:41 REQUEST: DELETE /orders/delete took 116.167µs
+2023/04/21 15:44:44 REQUEST: GET /orders/get took 13.166µs
+*/

domain-driven-design/go-web/go.mod

@@ -0,0 +1,5 @@
+module go-order-system
+
+go 1.19
+
+require github.com/gorilla/mux v1.8.1

domain-driven-design/go-web/go.sum

@@ -0,0 +1,2 @@
+github.com/gorilla/mux v1.8.1 h1:TuBL49tXwgrFYWhqrNgrUNEY92u81SPhu7sTdzQEiWY=
+github.com/gorilla/mux v1.8.1/go.mod h1:AKf9I4AEqPTmMytcMc0KkNouC66V3BtZ4qD5fmWSiMQ=

domain-driven-design/go-web/internal/application/order_service.go

@@ -0,0 +1,91 @@
+// 应用层（协调领域逻辑，处理业务用例）：订单应用服务
+package application
+
+import (
+  "fmt"
+  "go-order-system/internal/domain/order"
+)
+
+// OrderService 订单应用服务，协调领域逻辑和业务用例
+type OrderService struct {
+  OrderRepository order.OrderRepository // 订单仓储接口
+}
+
+// 创建OrderService实例对象
+func NewOrderService(orderRepo order.OrderRepository) *OrderService {
+  return &OrderService{orderRepo}
+}
+
+// CreateOrder 创建订单并保存到仓储中
+func (s *OrderService) CreateOrder(id int, customerName string, amount float64) (*order.Order, error) {
+  // 创建订单
+  newOrder := order.NewOrder(id, customerName, amount)
+  if newOrder == nil {
+    return nil, fmt.Errorf("订单创建失败")
+  }
+
+  // 保存订单
+  err := s.OrderRepository.Save(newOrder)
+  if err != nil {
+    return nil, fmt.Errorf("订单保存失败: %v", err)
+  }
+
+  return newOrder, nil
+}
+
+// CancelOrder 取消订单
+func (s *OrderService) CancelOrder(id int) error {
+  order, err := s.OrderRepository.FindByID(id) // 获取订单
+  if err != nil {
+    return fmt.Errorf("订单取消失败：%v", err)
+  }
+
+  order.Cancel()                      // 执行领域逻辑：取消订单
+  err = s.OrderRepository.Save(order) // 保存更新后的订单
+  if err != nil {
+    return fmt.Errorf("订单取消失败：%v", err)
+  }
+  return nil
+}
+
+// GetOrder 查询订单
+func (s *OrderService) GetOrder(id int) (*order.Order, error) {
+  return s.OrderRepository.FindByID(id)
+}
+
+// UpdateOrder 更新订单的客户信息和金额
+func (s *OrderService) UpdateOrder(id int, customerName string, amount float64) (*order.Order, error) {
+  // 获取订单
+  order, err := s.OrderRepository.FindByID(id)
+  if err != nil {
+    return nil, fmt.Errorf("订单未找到: %v", err)
+  }
+
+  // 更新订单的客户信息和金额
+  order.UpdateCustomerInfo(customerName)
+  order.UpdateAmount(amount)
+
+  // 保存更新后的订单
+  err = s.OrderRepository.Save(order)
+  if err != nil {
+    return nil, fmt.Errorf("更新订单失败: %v", err)
+  }
+
+  return order, nil
+}
+
+// DeleteOrder 删除订单
+func (s *OrderService) DeleteOrder(id int) error {
+  // 获取订单
+  order, err := s.OrderRepository.FindByID(id)
+  if err != nil {
+    return fmt.Errorf("订单未找到: %v", err)
+  }
+  // 从仓储中删除订单
+  err = s.OrderRepository.Delete(order.ID)
+  if err != nil {
+    return fmt.Errorf("删除订单失败: %v", err)
+  }
+
+  return nil
+}