Golang 领域模型 - 聚合根

package aggregate

import (
    "errors"

    "github.com/8treenet/freedom/example/fshop/domain/dependency"
    "github.com/8treenet/freedom/example/fshop/domain/dto"
    "github.com/8treenet/freedom/example/fshop/domain/entity"
    "github.com/8treenet/freedom/infra/transaction"
)

// 支付订单聚合根
type OrderPayCmd struct {
    entity.Order                  //派生订单实体
    userEntity *entity.User       //关联用户实体
    userRepo  dependency.UserRepo //依赖倒置资用户资源库
    orderRepo dependency.OrderRepo //依赖倒置资订单资源库
    tx        transaction.Transaction  //依赖倒置事务基础设施
}

// Pay 支付.
func (cmd *OrderPayCmd) Pay() error {
    if cmd.Status != entity.OrderStatusNonPayment {
        //不是支付状态
        return errors.New("未知错误")
    }
    if cmd.userEntity.Money < cmd.TotalPrice {
        return errors.New("余额不足")
    }

    //扣除用户金钱
    //修复支付状态
    cmd.userEntity.AddMoney(-cmd.TotalPrice)
    cmd.Order.Pay()

    //委托事务基础设施
    e := cmd.tx.Execute(func() error {
        if e := cmd.orderRepo.Save(&cmd.Order); e != nil {
            return e
        }

        return cmd.userRepo.Save(cmd.userEntity)
    })
    return e
}

package aggregate

import (
    "github.com/8treenet/freedom"
    "github.com/8treenet/freedom/example/fshop/domain/dependency"
    "github.com/8treenet/freedom/infra/transaction"
)

func init() {
    freedom.Prepare(func(initiator freedom.Initiator) {
        initiator.BindFactory(func() *OrderFactory {
            //绑定创建工厂函数到框架，
            //框架会根据客户的使用做依赖倒置和依赖注入的处理
            return &OrderFactory{}
        })
    })
}

// OrderFactory 订单聚合根工厂
type OrderFactory struct {
    UserRepo     dependency.UserRepo     //依赖倒置用户资源库
    OrderRepo    dependency.OrderRepo    //依赖倒置订单资源库
    TX           transaction.Transaction //依赖倒置事务组件
    Worker       freedom.Worker          //运行时，一个请求绑定一个运行时
}

// NewOrderPayCmd 创建订单支付聚合根
func (factory *OrderFactory) NewOrderPayCmd(orderNo string, userId int) (*OrderPayCmd, error) {
    factory.Worker.Logger().Info("创建订单支付聚合根")
    orderEntity, err := factory.OrderRepo.Find(orderNo, userId)
    if err != nil {
        return nil, err
    }

    userEntity, err := factory.UserRepo.Get(userId)
    if err != nil {
        return nil, err
    }
    cmd := &OrderPayCmd{
        Order:      *orderEntity,
        userEntity: userEntity,
        userRepo:   factory.UserRepo,
        orderRepo:  factory.OrderRepo,
        tx:         factory.TX,
    }
    return cmd, nil
}

package aggregate

const (
    shopGoodsType = 1 //直接购买类型
    shopCartType  = 2 //购物车购买类型
)
type ShopType interface {
    //返回购买的类型 单独商品 或购物车
    GetType() int
    //如果是直接购买类型 返回商品id和数量
    GetDirectGoods() (int, int)
}

type ShopCmd interface {
    Shop() error
}


//接口的实现
type shopType struct {
    stype    int
    goodsId  int
    goodsNum int
}

func (st *shopType) GetType() int {
    return st.stype
}

func (st *shopType) GetDirectGoods() (int, int) {
    return st.goodsId, st.goodsNum
}

package aggregate

import (
    "github.com/8treenet/freedom"
    "github.com/8treenet/freedom/example/fshop/domain/dependency"
    "github.com/8treenet/freedom/example/fshop/domain/entity"
    "github.com/8treenet/freedom/infra/transaction"
)

func init() {
	freedom.Prepare(func(initiator freedom.Initiator) {
        // 绑定创建工厂函数到框架，
        // 框架会根据客户的使用做依赖倒置和依赖注入的处理。
		initiator.BindFactory(func() *ShopFactory {
			// 创建shopFactory
			return &ShopFactory{}
		})
	})
}

// ShopFactory 购买聚合根抽象工厂
type ShopFactory struct {
    UserRepo  dependency.UserRepo     //依赖倒置用户资源库
    CartRepo  dependency.CartRepo     //依赖倒置购物车资源库
    GoodsRepo dependency.GoodsRepo    //依赖倒置商品资源库
    OrderRepo dependency.OrderRepo    //依赖倒置订单资源库
    TX        transaction.Transaction //依赖倒置事务组件
}

// NewGoodsShopType 创建商品购买类型
func (factory *ShopFactory) NewGoodsShopType(goodsId, goodsNum int) ShopType {
    return &shopType{
        stype:    shopGoodsType,
        goodsId:  goodsId,
        goodsNum: goodsNum,
    }
}

// NewCartShopType 创建购物车购买类型
func (factory *ShopFactory) NewCartShopType() ShopType {
    return &shopType{
        stype: shopCartType,
    }
}

// NewShopCmd 创建抽象聚合根
func (factory *ShopFactory) NewShopCmd(userId int, stype ShopType) (ShopCmd, error) {
    if stype.GetType() == 2 {
        return factory.newCartShopCmd(userId)
    }
    goodsId, goodsNum := stype.GetDirectGoods()
    return factory.newGoodsShopCmd(userId, goodsId, goodsNum)
}

// newGoodsShopCmd 创建购买商品聚合根
func (factory *ShopFactory) newGoodsShopCmd(userId, goodsId, goodsNum int) (*GoodsShopCmd, error) {}
// newCartShopCmd 创建购买聚合根
func (factory *ShopFactory) newCartShopCmd(userId int) (*CartShopCmd, error) {

package domain
// Shop 普通商品购买
func (g *Goods) Shop(goodsId, goodsNum, userId int) (e error) {
    //使用抽象工厂 创建普通商品购买类型
    shopType := g.ShopFactory.NewGoodsShopType(goodsId, goodsNum)
    //使用抽象工厂 创建抽象聚合根
    cmd, e := g.ShopFactory.NewShopCmd(userId, shopType)
    if e != nil {
        return
    }
    return cmd.Shop()
}
package domain
// Shop 购物车批量购买
func (c *Cart) Shop(userId int) (e error) {
    //使用抽象工厂  购物车批量购买类型
    shopType := c.ShopFactory.NewCartShopType()
    //使用抽象工厂 创建抽象聚合根
    cmd, e := c.ShopFactory.NewShopCmd(userId, shopType)
    if e != nil {
        return
    }
    return cmd.Shop()
}