Flamingo Commerce: 基于DDD和端口适配器架构的电商插件库

Flamingo Commerce是一个基于领域驱动设计(DDD)和端口适配器架构(Hexagonal Architecture)的Golang电商框架。它提供了一套模块化的电商功能组件，可以灵活组合使用。

核心架构理念

1. 领域驱动设计(DDD)实现

Flamingo Commerce将电商领域划分为多个限界上下文(Bounded Context)，如：

• 产品目录(Product)
• 购物车(Cart)
• 订单(Order)
• 支付(Payment)
• 客户(Customer)

每个限界上下文都有自己独立的领域模型。

2. 端口适配器架构

Flamingo采用端口(接口)和适配器模式，核心业务逻辑通过接口定义，具体实现可以替换：

业务核心 <-- 端口(接口) --> 适配器(实现)

主要功能模块

1. 产品目录模块

// 产品服务接口(端口)
type ProductService interface {
    Get(ctx context.Context, marketplaceCode string) (domain.BasicProduct, error)
    List(ctx context.Context, filters ...SearchFilter) ([]domain.BasicProduct, error)
}

// 使用示例
func (h *ProductHandler) Get(c web.Context) error {
    product, err := h.productService.Get(c.Request().Context(), c.Params("code"))
    if err != nil {
        return c.Response().Status(404).JSON(nil)
    }
    return c.Response().JSON(product)
}

2. 购物车模块

// 购物车服务接口
type CartService interface {
    GetCart(ctx context.Context, cartID string) (*domain.Cart, error)
    AddItem(ctx context.Context, cartID string, item domain.AddRequest) (*domain.Cart, error)
    DeleteItem(ctx context.Context, cartID string, itemID string) (*domain.Cart, error)
}

// 添加商品到购物车示例
func (h *CartHandler) AddItem(c web.Context) error {
    var addRequest domain.AddRequest
    if err := c.Bind(&addRequest); err != nil {
        return c.Response().Status(400).JSON(err.Error())
    }
    
    cart, err := h.cartService.AddItem(c.Request().Context(), c.Params("cartId"), addRequest)
    if err != nil {
        return c.Response().Status(500).JSON(err.Error())
    }
    
    return c.Response().JSON(cart)
}

3. 订单模块

// 订单服务接口
type OrderService interface {
    PlaceOrder(ctx context.Context, cart *domain.Cart) (domain.Order, error)
    GetOrder(ctx context.Context, orderID string) (domain.Order, error)
}

// 下单示例
func (h *OrderHandler) PlaceOrder(c web.Context) error {
    cart, err := h.cartService.GetCart(c.Request().Context(), c.Params("cartId"))
    if err != nil {
        return c.Response().Status(400).JSON(err.Error())
    }
    
    order, err := h.orderService.PlaceOrder(c.Request().Context(), cart)
    if err != nil {
        return c.Response().Status(500).JSON(err.Error())
    }
    
    return c.Response().JSON(order)
}

依赖注入配置

Flamingo使用依赖注入(DI)来组装各个模块：

// 模块定义
type CommerceModule struct {}

// Configure 注册服务
func (m *CommerceModule) Configure(injector *dingo.Injector) {
    // 注册产品服务
    injector.Bind(new(productDomain.ProductService)).To(productApplication.ProductServiceImpl{})
    
    // 注册购物车服务
    injector.Bind(new(cartDomain.CartService)).To(cartApplication.CartServiceImpl{})
    
    // 注册订单服务
    injector.Bind(new(orderDomain.OrderService)).To(orderApplication.OrderServiceImpl{})
}

自定义适配器实现

可以替换默认实现，例如使用MongoDB作为产品存储：

// MongoDB产品仓库实现
type MongoProductRepository struct {
    collection *mongo.Collection
}

func (r *MongoProductRepository) Get(ctx context.Context, code string) (productDomain.BasicProduct, error) {
    var product productDomain.BasicProduct
    err := r.collection.FindOne(ctx, bson.M{"code": code}).Decode(&product)
    return product, err
}

// 注册自定义仓库
func (m *CustomModule) Configure(injector *dingo.Injector) {
    injector.Bind(new(productDomain.ProductRepository)).To(MongoProductRepository{})
}

路由配置

// 注册路由
func (m *WebModule) Configure(router *routing.Router) {
    router.Get("/products/:code", productHandler.Get)
    router.Post("/cart/:cartId/items", cartHandler.AddItem)
    router.Post("/orders/:cartId", orderHandler.PlaceOrder)
}

优势特点

1. 模块化设计：可以只使用需要的模块
2. 可替换实现：所有核心功能都有接口定义，可以自定义实现
3. 领域驱动：清晰的业务边界和模型
4. 前后端分离：提供REST API，适合现代前端框架集成
5. 可扩展性：易于添加新功能或修改现有功能

使用建议

1. 从核心模块(产品、购物车、订单)开始
2. 根据需要逐步添加支付、配送等模块
3. 自定义适配器实现以集成现有系统
4. 利用事件系统处理跨领域逻辑
5. 遵循DDD原则设计自己的限界上下文

Flamingo Commerce提供了电商系统的基础构建块，开发者可以专注于业务逻辑的实现，而不必从零开始构建电商基础设施。