kratos 框架商城微服务实战之商品服务 (十)

大家好，今天咱们终于可以写商品服务中的商品模块了，前面花了 4 篇文章，都是为了创建一个完整的商品所需的数据，就这对比一些电商平台，像商品的售后信息、运费模版、商品促销活动信息等，还有很多需要补的，不过那些都不算有太大影响。咱们还是主要先把整个项目跑起来。

众所周知，一个电商的商品设计是比较复杂的，咱们这里不过多的深究商品设计的每个表是否合理，是否漏写之类的问题，主要是为了搞明白 kratos 的使用和微服务相关的调用关系。当然我真正的编写时也会尽可能的让此项目的商品设计合理一些。但大量的表设计呀，重复性的 curd 就不会在文章中体现了，具体的代码参看 GitHub 上的源码。当然你觉得不合理的地方，欢迎给项目提 PR。

注：竖排 … 代码省略，为了保持文章的篇幅简洁，我会将一些不必要的代码使用竖排的 . 来代替，你在复制本文代码块的时候，切记不要将 . 也一同复制进去。

⚠️ ⚠️ ⚠️ 接下来新增或修改的代码， wire 注入的文件中需要修改的代码，都不会再本文中提及了。例如 biz、service 层的修改，自己编写的过程中，千万不要忘记 wire 注入，更不要忘记，执行 make wire 命令，重新生成项目的 wire 文件。具体使用方法可参考 kratos 官方文档 ⚠️ ⚠️ ⚠️

商品信息

设计商品表

• data 目录下新建数据表相关的文件

base.go 文件内容：

package data

import (
    "database/sql/driver"
    "encoding/json"
    "gorm.io/gorm"
    "time"
)

type GormList []string

func (g GormList) Value() (driver.Value, error) {
    return json.Marshal(g)
}

func (g *GormList) Scan(value interface{}) error {
    return json.Unmarshal(value.([]byte), &g)
}

type BaseFields struct {
    ID        int64          `gorm:"primarykey;type:int" json:"id"` // bigint
    CreatedAt time.Time      `gorm:"column:add_time" json:"created_at"`
    UpdatedAt time.Time      `gorm:"column:update_time" json:"updated_at"`
    DeletedAt gorm.DeletedAt `json:"deleted_at"`
}

goods.go文件内容

package data

import (
    "github.com/go-kratos/kratos/v2/log"
    "golang.org/x/net/context"
    "goods/internal/biz"
    "goods/internal/domain"
)

// Goods 商品表
type Goods struct {
    BaseFields
    CategoryID int32 `gorm:"index:category_id;type:int;comment:分类ID;not null"`
    BrandsID   int32 `gorm:"index:brand_id;type:int;comment:品牌ID ;not null"`
    TypeID     int64 `gorm:"index:type_id;type:int;comment:商品类型ID ;not null"`

    Name            string   `gorm:"type:varchar(100);not null;comment:商品名称"`
    NameAlias       string   `gorm:"type:varchar(100);not null;comment:商品别名"`
    GoodsSn         string   `gorm:"type:varchar(100);not null;comment:商品编号"`
    GoodsTags       string   `gorm:"type:varchar(100);not null;comment:商品标签"`
    MarketPrice     int64    `gorm:"type:int;default:0;not null;comment:商品展示价格"`
    GoodsBrief      string   `gorm:"type:varchar(100);not null;comment:商品简介"`
    GoodsFrontImage string   `gorm:"type:varchar(200);not null;comment:商品封面图"`
    GoodsImages     GormList `gorm:"type:varchar(1000);not null;comment:商品的介绍图"` // 切片类型转为 json 到数据库，取出来是切片类型

    OnSale   bool  `gorm:"default:false;comment:是否上架;not null "`
    ShipFree bool  `gorm:"default:false;comment:是否免运费; not null"`
    ShipID   int32 `gorm:"type:int;comment:运费模版ID;not null"`
    IsNew    bool  `gorm:"default:false;comment:是否新品;not null"`
    IsHot    bool  `gorm:"comment:是否热卖商品;default:false;not null"`

    ClickNum int64 `gorm:"default:0;type:int; comment 商品详情点击数"`
    SoldNum  int64 `gorm:"default:0;type:int; comment 商品销售数"`
    FavNum   int64 `gorm:"default:0;type:int; comment 商品收藏数"`

    // 售前服务信息、售后服务信息、商品促销活动信息
}

type goodsRepo struct {
    data *Data
    log  *log.Helper
}

// NewGoodsRepo .
func NewGoodsRepo(data *Data, logger log.Logger) biz.GoodsRepo {
    return &goodsRepo{
        data: data,
        log:  log.NewHelper(logger),
    }
}

func (p *Goods) ToDomain() *domain.Goods {
    return &domain.Goods{
        ID:              p.ID,
        CategoryID:      p.CategoryID,
        BrandsID:        p.BrandsID,
        TypeID:          p.TypeID,
        Name:            p.Name,
        NameAlias:       p.NameAlias,
        GoodsSn:         p.GoodsSn,
        GoodsTags:       p.GoodsTags,
        MarketPrice:     p.MarketPrice,
        GoodsBrief:      p.GoodsBrief,
        GoodsFrontImage: p.GoodsFrontImage,
        GoodsImages:     p.GoodsImages,
        OnSale:          p.OnSale,
        ShipFree:        p.ShipFree,
        ShipID:          p.ShipID,
        IsNew:           p.IsNew,
        IsHot:           p.IsHot,
        ClickNum:        p.ClickNum,
        SoldNum:         p.SoldNum,
        FavNum:          p.FavNum,
    }
}

• 新建 goods_sku.go 文件

package data

import (
    "github.com/go-kratos/kratos/v2/log"
    "golang.org/x/net/context"
    "goods/internal/biz"
    "goods/internal/domain"
)

// GoodsSku 商品SKU 表
type GoodsSku struct {
    BaseFields
    GoodsID        int64  `gorm:"index:goods_id;type:int;comment:商品ID;not null"`
    GoodsSn        string `gorm:"type:varchar(100);not null;comment:商品编号"`
    GoodsName      string `gorm:"type:varchar(100);not null;comment:商品名称"`
    SkuName        string `gorm:"type:varchar(100);comment:SKU名称;not null"`
    SkuCode        string `gorm:"type:varchar(100);comment:SKUCode;not null"`
    BarCode        string `gorm:"type:varchar(100);comment:条码;not null"`
    Price          int64  `gorm:"type:int;comment:商品售价;not null"`
    PromotionPrice int64  `gorm:"type:int;comment:商品促销售价;not null"`
    Points         int64  `gorm:"type:int;comment:赠送积分;not null"`
    RemarksInfo    string `gorm:"type:varchar(100);comment:备注信息;not null"`
    Pic            string `gorm:"type:varchar(500);not null;comment:规格参数对应的图片" json:"pic"`
    OnSale         bool   `gorm:"comment:是否上架;default:false;not null"`
    AttrInfo       string `gorm:"type:varchar(2000);comment:商品属性信息JSON;not null"`
    Inventory      int64  `gorm:"type:int;comment:商品SKU库存冗余字段;not null"`
}

// GoodsSpecificationSku 商品规格和商品Sku关联表
type GoodsSpecificationSku struct {
    BaseFields
    SkuID           int64  `gorm:"index:sku_id;type:int;comment:商品SKU_ID;not null"`
    SkuCode         string `gorm:"type:varchar(100);comment:商品SKU_Code;not null"`
    SpecificationId int64  `gorm:"index:specification_id;type:int;comment:商品规格ID;not null"`
    ValueId         int64  `gorm:"index:value_id;type:int;comment:商品规格值表ID;not null"`
}

type goodsSkuRepo struct {
    data *Data
    log  *log.Helper
}

// NewGoodsSkuRepoRepo .
func NewGoodsSkuRepoRepo(data *Data, logger log.Logger) biz.GoodsSkuRepo {
    return &goodsSkuRepo{
        data: data,
        log:  log.NewHelper(logger),
    }
}

func (p *GoodsSku) ToDomain() *domain.GoodsSku {
    return &domain.GoodsSku{
        ID:             p.ID,
        GoodsID:        p.GoodsID,
        GoodsSn:        p.GoodsSn,
        GoodsName:      p.GoodsName,
        SkuName:        p.SkuName,
        SkuCode:        p.SkuCode,
        BarCode:        p.BarCode,
        Price:          p.Price,
        PromotionPrice: p.PromotionPrice,
        Points:         p.Points,
        RemarksInfo:    p.RemarksInfo,
        Pic:            p.Pic,
        Inventory:      p.Inventory,
        OnSale:         p.OnSale,
        AttrInfo:       p.AttrInfo,
    }
}

• 新建 inventory.go 文件

添加商品 sku 库存的方法比较简单这些先写了。

package data

import (
    "context"
    "github.com/go-kratos/kratos/v2/log"
    "goods/internal/biz"
    "goods/internal/domain"
)

type GoodsInventory struct {
    BaseFields
    SkuID     int64 `gorm:"index:sku_id;type:int;comment:商品SKU_ID;not null"`
    Inventory int64 `gorm:"type:int;comment:商品库存;not null"`
}

type inventoryRepo struct {
    data *Data
    log  *log.Helper
}

// NewInventoryRepo .
func NewInventoryRepo(data *Data, logger log.Logger) biz.InventoryRepo {
    return &inventoryRepo{
        data: data,
        log:  log.NewHelper(logger),
    }
}

func (p *GoodsInventory) ToDomain() *domain.Inventory {
    return &domain.Inventory{
        ID:        p.ID,
        SkuID:     p.SkuID,
        Inventory: p.Inventory,
    }
}

func (i inventoryRepo) Create(ctx context.Context, inventory *domain.Inventory) (*domain.Inventory, error) {
    info := GoodsInventory{
        SkuID:     inventory.SkuID,
        Inventory: inventory.Inventory,
    }
    if err := i.data.DB(ctx).Save(&info).Error; err != nil {
        return nil, err
    }
    return info.ToDomain(), nil
}

新建domain 层下的文件

• goods.go

package domain

type Goods struct {
    ID              int64
    CategoryID      int32
    BrandsID        int32
    TypeID          int64
    Name            string
    NameAlias       string
    GoodsSn         string
    GoodsTags       string
    MarketPrice     int64
    GoodsBrief      string
    GoodsFrontImage string
    GoodsImages     []string
    OnSale          bool
    ShipFree        bool
    ShipID          int32
    IsNew           bool
    IsHot           bool
    ClickNum        int64
    SoldNum         int64
    FavNum          int64
    Sku             []*GoodsSku
}

type GoodsInfoResponse struct {
    GoodsID int64
}

• goods_sku.go

package domain

type GoodsSku struct {
    ID             int64
    GoodsID        int64
    GoodsSn        string
    GoodsName      string
    SkuName        string
    SkuCode        string
    BarCode        string
    Price          int64
    PromotionPrice int64
    Points         int64
    RemarksInfo    string
    Pic            string
    Inventory      int64
    OnSale         bool
    AttrInfo       string
    Specification  []*SpecificationInfo
    GroupAttr      []*GroupAttr
}

type SpecificationInfo struct {
    SpecificationID      int64
    SpecificationValueID int64
}

type GroupAttr struct {
    GroupId   int64   `json:"group_id"`
    GroupName string  `json:"group_name"`
    Attr      []*Attr `json:"attr"`
}

type Attr struct {
    AttrID        int64  `json:"attr_id"`
    AttrName      string `json:"attr_name"`
    AttrValueID   int64  `json:"attr_value_id"`
    AttrValueName string `json:"attr_value_name"`
}

type GoodsSpecificationSku struct {
    ID              int64
    SkuID           int64
    SkuCode         string
    SpecificationId int64
    ValueId         int64
}

• inventory.go

package domain

type Inventory struct {
    ID        int64
    SkuID     int64
    Inventory int64
}

构造商品创建方法

• 修改 goods.proto 文件

syntax = "proto3";

...

service Goods {
    rpc CreateGoods(CreateGoodsRequest) returns (CreateGoodsResponse);
}


message CreateGoodsRequest {
  int64 id = 1;
  int32 categoryId = 2 [(validate.rules).int32.gte = 1];
  int32 brandId = 3 [(validate.rules).int32.gte = 1];
  int64 typeId = 4 [(validate.rules).int64.gte = 1];
  string name = 5 [(validate.rules).string.min_len = 1];
  string nameAlias = 6;
  string goodsTags = 7;
  string goodsSn = 8 [(validate.rules).string.min_len = 1];
  int64 shopPrice = 9;
  int64 marketPrice = 10;
  int64 inventory = 11;
  string goodsBrief = 12;
  string goodsFrontImage = 13;
  repeated string goodsImages = 14;
  bool shipFree = 15;
  int32 shipId = 16;
  bool isNew = 17;
  bool isHot = 18;
  bool onSale = 19;
  // 根据商品类型 选择商品规格和商品属性信息 
  message goodsSku {
    int64 id = 1;
    int64 goodsId = 2;
    string skuName = 3 [(validate.rules).string.min_len = 1];
    string code = 4 [(validate.rules).string.min_len = 1];
    string barCode = 5 [(validate.rules).string.min_len = 1];
    int64 price = 6;
    int64 promotionPrice = 7;
    int64 points = 8;
    string image = 9;
    int32 sort = 10;
    int64 inventory = 11;
    // 商品规格
    message specification {
      int64 sId = 1 [(validate.rules).int64.gte = 1];
      int64 vId = 2 [(validate.rules).int64.gte = 1];
    }
    repeated specification specificationInfo = 12;
    // 商品属性组
    message groupAttr {
      int64 groupId = 1 [(validate.rules).int64.gte = 1];
      string groupName = 2 [(validate.rules).string.min_len = 1];
      message attr {
        int64 attrId = 1 [(validate.rules).int64.gte = 1];
        string attrName = 2 [(validate.rules).string.min_len = 1];
        int64 attrValueId = 3 [(validate.rules).int64.gte = 1];
        string attrValueName = 4 [(validate.rules).string.min_len = 1];
      }
      repeated attr attrInfo = 3;
    }
    repeated groupAttr groupAttrInfo = 13;
  }
  repeated goodsSku sku = 20;
}


message CreateGoodsResponse {
  int64 ID = 1;
}

• 修改 service 目录下的 goods.go

package service

import (
    "context"
    v1 "goods/api/goods/v1"
    "goods/internal/domain"
)

// CreateGoods 创建商品
func (g *GoodsService) CreateGoods(ctx context.Context, r *v1.CreateGoodsRequest) (*v1.CreateGoodsResponse, error) {
    var goodsSku []*domain.GoodsSku
    for _, sku := range r.Sku {
        res := &domain.GoodsSku{
            GoodsName:      r.Name,
            GoodsSn:        r.GoodsSn,
            SkuName:        sku.SkuName,
            SkuCode:        sku.Code,
            BarCode:        sku.BarCode,
            Price:          sku.Price,
            PromotionPrice: sku.PromotionPrice,
            Points:         sku.Points,
            Pic:            sku.Image,
            Inventory:      sku.Inventory,
            OnSale:         r.OnSale,
        }

        for _, specification := range sku.SpecificationInfo {
            s := &domain.SpecificationInfo{
                SpecificationID:      specification.SId,
                SpecificationValueID: specification.VId,
            }
            res.Specification = append(res.Specification, s)
        }
        for _, attrGroup := range sku.GroupAttrInfo {
            group := &domain.GroupAttr{
                GroupId:   attrGroup.GroupId,
                GroupName: attrGroup.GroupName,
            }
            for _, attr := range attrGroup.AttrInfo {
                s := &domain.Attr{
                    AttrID:        attr.AttrId,
                    AttrName:      attr.AttrName,
                    AttrValueID:   attr.AttrValueId,
                    AttrValueName: attr.AttrValueName,
                }
                group.Attr = append(group.Attr, s)
            }
            res.GroupAttr = append(res.GroupAttr, group)
        }
        goodsSku = append(goodsSku, res)
    }

    goodsInfo := &domain.Goods{
        ID:              r.Id,
        CategoryID:      r.CategoryId,
        BrandsID:        r.BrandId,
        TypeID:          r.TypeId,
        Name:            r.Name,
        NameAlias:       r.NameAlias,
        GoodsSn:         r.GoodsSn,
        GoodsTags:       r.GoodsTags,
        MarketPrice:     r.MarketPrice,
        GoodsBrief:      r.GoodsBrief,
        GoodsFrontImage: r.GoodsFrontImage,
        GoodsImages:     r.GoodsImages,
        OnSale:          r.OnSale,
        ShipFree:        r.ShipFree,
        ShipID:          r.ShipId,
        IsNew:           r.IsNew,
        IsHot:           r.IsHot,
        Sku:             goodsSku,
    }

    result, err := g.g.CreateGoods(ctx, goodsInfo)
    if err != nil {
        return nil, err
    }
    return &v1.CreateGoodsResponse{ID: result.GoodsID}, nil

}

• 修改 biz 目录下的 goods.go

package biz

import (
    "context"
    "encoding/json"
    "errors"
    "github.com/go-kratos/kratos/v2/log"
    "goods/internal/domain"
)

type GoodsRepo interface {
    CreateGoods(ctx context.Context, goods *domain.Goods) (*domain.Goods, error)
}

type GoodsUsecase struct {
    repo              GoodsRepo
    tr                Transaction
    skuRepo           GoodsSkuRepo
    categoryRepo      CategoryRepo
    brandRepo         BrandRepo
    typeRepo          GoodsTypeRepo
    specificationRepo SpecificationRepo
    goodsAttrRepo     GoodsAttrRepo
    inventoryRepo     InventoryRepo
    log               *log.Helper
}

func NewGoodsUsecase(repo GoodsRepo, skuRepo GoodsSkuRepo, tx Transaction, gRepo GoodsTypeRepo, cRepo CategoryRepo,
    bRepo BrandRepo, sRepo SpecificationRepo, aRepo GoodsAttrRepo, iRepo InventoryRepo, logger log.Logger) *GoodsUsecase {

    return &GoodsUsecase{
        repo:              repo,
        skuRepo:           skuRepo,
        tr:                tx,
        typeRepo:          gRepo,
        categoryRepo:      cRepo,
        brandRepo:         bRepo,
        specificationRepo: sRepo,
        goodsAttrRepo:     aRepo,
        inventoryRepo:     iRepo,
        log:               log.NewHelper(logger),
    }
}

func (g GoodsUsecase) CreateGoods(ctx context.Context, r *domain.Goods) (*domain.GoodsInfoResponse, error) {
    var (
        err   error
        goods *domain.Goods
    )
    // 判断品牌是否存在
    _, err = g.brandRepo.IsBrandByID(ctx, r.BrandsID)
    if err != nil {
        return nil, errors.New("品牌不存在")
    }

    // 判断分类是否存在
    _, err = g.categoryRepo.GetCategoryByID(ctx, r.CategoryID)
    if err != nil {
        return nil, errors.New("分类不存在")
    }
    // 判断商品类型是否存在
    _, err = g.typeRepo.IsExistsByID(ctx, r.TypeID)
    if err != nil {
        return nil, errors.New("商品类型不存在")
    }
    // 判断商品规格和属性是否存在
    for _, sku := range r.Sku {
        var sIDs []*int64
        for _, info := range sku.Specification {
            sIDs = append(sIDs, &info.SpecificationID)
        }

        specList, err := g.specificationRepo.ListByIds(ctx, sIDs...)
        if err != nil {
            return nil, err
        }
        for _, sId := range sIDs {
            info := specList.FindById(*sId)
            if info == nil {
                return nil, errors.New("商品规格不存在")
            }
        }
        var attrIDs []int64
        for _, attr := range sku.GroupAttr {
            for _, id := range attr.Attr {
                attrIDs = append(attrIDs, id.AttrID)
            }
        }
        attrList, err := g.goodsAttrRepo.ListByIds(ctx, attrIDs...)
        if err != nil {
            return nil, err
        }

        for _, attr := range sku.GroupAttr {
            for _, id := range attr.Attr {
                attrIDs = append(attrIDs, id.AttrID)
                true := attrList.IsNotExist(attr.GroupId, id.AttrID)
                if true {
                    return nil, errors.New("商品属性不存在")
                }
            }
        }
    }

    err = g.tr.ExecTx(ctx, func(ctx context.Context) error {
        // 更新商品表
        goods, err = g.repo.CreateGoods(ctx, &domain.Goods{
            CategoryID:      r.CategoryID,
            BrandsID:        r.BrandsID,
            TypeID:          r.TypeID,
            Name:            r.Name,
            NameAlias:       r.NameAlias,
            GoodsSn:         r.GoodsSn,
            GoodsTags:       r.GoodsTags,
            MarketPrice:     r.MarketPrice,
            GoodsBrief:      r.GoodsBrief,
            GoodsFrontImage: r.GoodsFrontImage,
            GoodsImages:     r.GoodsImages,
            OnSale:          r.OnSale,
            IsNew:           r.IsNew,
            IsHot:           r.IsHot,
            ShipFree:        r.ShipFree,
            ShipID:          r.ShipID,
        })
        if err != nil {
            return err
        }
        // 更新商品 SKU 表
        for _, v := range r.Sku {
            res := &domain.GoodsSku{
                GoodsID:        goods.ID,
                GoodsSn:        goods.GoodsSn,
                GoodsName:      goods.Name,
                SkuName:        v.SkuName,
                SkuCode:        v.SkuCode,
                BarCode:        v.BarCode,
                Price:          v.Price,
                PromotionPrice: v.PromotionPrice,
                Points:         v.Points,
                RemarksInfo:    v.RemarksInfo,
                Pic:            v.Pic,
                Inventory:      v.Inventory,
                OnSale:         v.OnSale,
            }

            goodsAttr, err := json.Marshal(v.GroupAttr)
            if err != nil {
                return err
            }
            res.AttrInfo = string(goodsAttr)

            // 插入 sku 表
            skuInfo, err := g.skuRepo.Create(ctx, res)
            if err != nil {
                return err
            }

            // 插入库存表
            _, err = g.inventoryRepo.Create(ctx, &domain.Inventory{
                SkuID:     skuInfo.ID,
                Inventory: skuInfo.Inventory,
            })
            if err != nil {
                return err
            }
            // 插入 sku 规格关联关系表
            var skuRelation []*domain.GoodsSpecificationSku
            for _, spec := range v.Specification {
                skuRelation = append(skuRelation, &domain.GoodsSpecificationSku{
                    SkuID:           skuInfo.ID,
                    SkuCode:         skuInfo.SkuCode,
                    SpecificationId: spec.SpecificationID,
                    ValueId:         spec.SpecificationValueID,
                })
            }

            // 插入商品规格关联关系表
            err = g.skuRepo.CreateSkuRelation(ctx, skuRelation)
            if err != nil {
                return err
            }

        }
        return nil
    })

    if err != nil {
        return nil, err
    }
    return &domain.GoodsInfoResponse{GoodsID: goods.ID}, nil
}

实现业务逻辑方法

• 判断品牌

biz 目录下的 brand.go 新增方法

package biz

...

type BrandRepo interface {

    ...

    IsBrandByID(context.Context, int32) (*domain.Brand, error)

}

在data 录下的 brand.go 文件中实现 IsBrandByID 方法

package data

...


func (r *BrandRepo) IsBrandByID(ctx context.Context, id int32) (*domain.Brand, error) {
    var b Brand
    if err := r.data.db.Table("brands").Where("id = ?", id).First(&b).Error; err != nil {
        return nil, err
    }

    return b.ToDomain(), nil
}

• 判断分类

biz 目录下的 category.go 新增方法

package biz

...

type CategoryRepo interface {
    ...

    GetCategoryByID(ctx context.Context, id int32) (*CategoryInfo, error)
}

在data 目录下的category.go 文件中实现 GetCategoryByID

package data

...


func (r *CategoryRepo) GetCategoryByID(ctx context.Context, id int32) (*biz.CategoryInfo, error) {
    var categories Category
    if res := r.data.db.First(&categories, id); res.RowsAffected == 0 {
        return nil, errors.New("商品分类不存在")
    }

    info := &biz.CategoryInfo{
        ID:             categories.ID,
        Name:           categories.Name,
        ParentCategory: categories.ParentCategoryID,
        Level:          categories.Level,
        IsTab:          categories.IsTab,
        Sort:           categories.Sort,
    }
    return info, nil
}

• 查询商品类型

biz 目录下的 goods_type.go 新增方法

package biz

...

type GoodsTypeRepo interface {

    ...

    IsExistsByID(context.Context, int64) (*domain.GoodsType, error)
}

在data 目录下的goods_type.go 文件中实现 IsExistsByID

package data

...

func (g *goodsTypeRepo) IsExistsByID(ctx context.Context, typeID int64) (*domain.GoodsType, error) {
    var goodsType GoodsType
    if res := g.data.db.First(&goodsType, typeID); res.RowsAffected == 0 {
        return nil, errors.New("商品类型不存在")
    }
    return goodsType.ToDomain(), nil
}

• 判断商品规格和属性

biz 目录下的 specifications.go 新增方法

package biz

...


type SpecificationRepo interface {

    ...

    ListByIds(ctx context.Context, id ...*int64) (domain.SpecificationList, error)
}

在data 目录下的specifications.go 文件中实现 ListByIds

package data

...

func (g *specificationRepo) ListByIds(ctx context.Context, id ...*int64) (domain.SpecificationList, error) {
    var l []*SpecificationsAttr
    if err := g.data.DB(ctx).Where("id IN (?)", id).Find(&l).Error; err != nil {
        return nil, err
    }

    var res domain.SpecificationList
    for _, item := range l {
        res = append(res, item.ToDomain())
    }
    return res, nil
}

在 domain 目录下的 specification.go 文件中编写验证方法

package domain

...

type SpecificationList []*Specification

func (p SpecificationList) FindById(id int64) *Specification {
    for _, item := range p {
        if item.ID == id {
            return item
        }
    }
    return nil
}

biz 目录下的 goods_attr.go 新增方法

package biz

...

type GoodsAttrRepo interface {

    ...

    ListByIds(ctx context.Context, id ...int64) (domain.GoodsAttrList, error)
}

在data 目录下的goods_attr.go 文件中实现 ListByIds

package data

...


func (g *goodsAttrRepo) ListByIds(ctx context.Context, ids ...int64) (domain.GoodsAttrList, error) {
    var l []*GoodsAttr
    if err := g.data.DB(ctx).Where("id IN (?)", ids).Find(&l).Error; err != nil {
        return nil, errors.New("属性不存在")
    }

    var res domain.GoodsAttrList
    for _, item := range l {
        res = append(res, item.ToDomain())
    }
    return res, nil
}

在 domain 目录下的 goods_attr.go 文件中编写验证方法

package domian

...

type GoodsAttrList []*GoodsAttr

func (p GoodsAttrList) IsNotExist(groupId, attrId int64) bool {
    for _, item := range p {
        if item.GroupID != groupId && item.ID != attrId {
            return true
        }
    }
    return false
}

编写入库的业务逻辑

• data 目录下的 goods.go实现 CreateGoods 方法

package data

...

func (g goodsRepo) CreateGoods(c context.Context, goods *domain.Goods) (*domain.Goods, error) {
    product := &Goods{
        CategoryID:      goods.CategoryID,
        BrandsID:        goods.BrandsID,
        TypeID:          goods.TypeID,
        Name:            goods.Name,
        NameAlias:       goods.NameAlias,
        GoodsSn:         goods.GoodsSn,
        GoodsTags:       goods.GoodsTags,
        MarketPrice:     goods.MarketPrice,
        GoodsBrief:      goods.GoodsBrief,
        GoodsFrontImage: goods.GoodsFrontImage,
        GoodsImages:     goods.GoodsImages,
        OnSale:          goods.OnSale,
        ShipFree:        goods.ShipFree,
        ShipID:          goods.ShipID,
        IsNew:           goods.IsNew,
        IsHot:           goods.IsHot,
    }

    result := g.data.DB(c).Save(product)
    if result.Error != nil {
        return nil, result.Error
    }
    return product.ToDomain(), nil
}

• 在biz目录下新建goods_sku.go

package biz

import (
    "context"
    "github.com/go-kratos/kratos/v2/log"
    "goods/internal/domain"
)

type Sku struct {
    ID             int64
    GoodsID        int64
    GoodsSn        string
    GoodsName      string
    SkuName        string
    SkuCode        string
    BarCode        string
    Price          int64
    PromotionPrice int64
    Points         int64
    RemarksInfo    string
    Pic            string
    Inventory      int64
    OnSale         bool
    AttrInfo       string
}

type GoodsSkuRepo interface {
    Create(context.Context, *domain.GoodsSku) (*domain.GoodsSku, error)
    CreateSkuRelation(context.Context, []*domain.GoodsSpecificationSku) error
}

type GoodsSkuUsecase struct {
    repo GoodsSkuRepo
    log  *log.Helper
}

func NewGoodsSkuUsecase(repo GoodsSkuRepo, logger log.Logger) *GoodsSkuUsecase {
    return &GoodsSkuUsecase{repo: repo, log: log.NewHelper(logger)}
}

• data 目录下的 goods_sku.go实现 Create 方法和 CreateSkuRelation

package data

...


func (g *goodsSkuRepo) Create(ctx context.Context, req *domain.GoodsSku) (*domain.GoodsSku, error) {
    sku := &GoodsSku{
        GoodsID:        req.GoodsID,
        GoodsSn:        req.GoodsSn,
        GoodsName:      req.GoodsName,
        SkuName:        req.SkuName,
        SkuCode:        req.SkuCode,
        BarCode:        req.BarCode,
        Price:          req.Price,
        PromotionPrice: req.PromotionPrice,
        Points:         req.Points,
        RemarksInfo:    req.RemarksInfo,
        Pic:            req.Pic,
        OnSale:         req.OnSale,
        AttrInfo:       req.AttrInfo,
        Inventory:      req.Inventory,
    }

    if err := g.data.DB(ctx).Save(sku).Error; err != nil {
        return nil, err
    }
    return sku.ToDomain(), nil
}

func (g *goodsSkuRepo) CreateSkuRelation(ctx context.Context, req []*domain.GoodsSpecificationSku) error {
    var info []*GoodsSpecificationSku
    for _, sku := range req {
        i := GoodsSpecificationSku{
            SkuID:           sku.SkuID,
            SkuCode:         sku.SkuCode,
            SpecificationId: sku.SpecificationId,
            ValueId:         sku.ValueId,
        }
        info = append(info, &i)
    }
    result := g.data.DB(ctx).Table("goods_specification_skus").Save(&info)
    return result.Error
}

• 在biz目录下新建inventory.go文件

package biz

import (
    "context"
    "github.com/go-kratos/kratos/v2/log"
    "goods/internal/domain"
)

type InventoryRepo interface {
    Create(context.Context, *domain.Inventory) (*domain.Inventory, error)
}

type InventoryUsecase struct {
    repo InventoryRepo
    log  *log.Helper
}

func NewInventoryUsecase(repo InventoryRepo, logger log.Logger) *InventoryUsecase {
    return &InventoryUsecase{repo: repo, log: log.NewHelper(logger)}
}

创建库存的方法在上面已经写过了，商品规格和商品 sku 的关联关系创建方法上面也已经写过了。

测试

没错还是通过 BloomRPC 工具进行测试。

如图创建成功了，这里的参数太多了，如果你跟我用的是同一个工具，它会自动构建所需的参数，你只需根据自己的需要简单修改一下就可以了。

结束语

本篇只提供了一个商品创建的方法，其他方法没有在文章中体现，单元测试方法也没有编写，重复性的工作这里就不编写了，通过前几篇的文章，相信你可以自己完善剩余的方法。

经过这么多天的编写，商品服务算是告一断落了，当然商品管理的 HTTP 服务还是会编写的，以后会新建一个商城后台管理的前端的项目来管理商品，他们是通过 HTTP 服务进行的，并不是直接调用这里的 rpc 服务。后期也会加入 Elasticsearch 搜索服务进行商品检索。

下一篇准备开始写购物车和订单服务，敬请期待

感谢您的耐心阅读，动动手指点个赞吧。

本作品采用《CC 协议》，转载必须注明作者和本文链接