kratos 框架商城微服务实战之购物车服务 (十二)

本文最后更新于:4 天前

大家好,好久不见,由于公司的工作实在太忙,耽搁了好久,实在抱歉。今天咱们开始写商城里面的购物车服务,废话少说咱们开始。

注:竖排 … 代码省略,为了保持文章的篇幅简洁,我会将一些不必要的代码使用竖排的 . 来代替,你在复制本文代码块的时候,切记不要将 . 也一同复制进去。文章写的不清晰的地方可通过 GitHub 源码进行查看, 也感谢您指出不足之处,欢迎大佬指教。

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

准备工作

由于前面几篇文章(第一篇和第四篇)都已经写过了,如何初始化一个 kratos 项目,并修改部分主要的文件,来变成自己的服务并编写业务。所以此篇文章就不做重复性的工作了,这篇编写一个购物车的创建,让购物车服务先存在,废话少说开始写。

Cart 服务目录存放的位置

1
2
3
4
5
6
// 整体的项目 目录结构如下
|-- kratos-shop
|-- service
|-- user // 原先的用户服务
|-- cart // 新增的购物车服务
|-- shop // interface

购物车表设计

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

cart.go 文件内容:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
package data

import (
"cart/internal/domain" // 引入 domain 层
"context"
"time"

"github.com/go-kratos/kratos/v2/errors"
"gorm.io/gorm"

"cart/internal/biz"

"github.com/go-kratos/kratos/v2/log"
)

type ShopCart struct {
ID int64 `gorm:"primarykey;type:int" json:"id"`
UserId int64 `gorm:"type:int;not null;comment:用户id" json:"user_id"`
GoodsId int64 `gorm:"type:int;not null;comment:商品id" json:"goods_id"`
SkuId int64 `gorm:"type:int;not null;comment:sku_id" json:"sku_id"`
GoodsPrice int64 `gorm:"type:int;not null;comment:商品价格" json:"goods_price"`
GoodsNum int32 `gorm:"type:int;not null;comment:商品数量" json:"goods_num"`
GoodsSn string `gorm:"type:varchar(500);default:;comment:商品编号"`
GoodsName string `gorm:"type:varchar(500);default:;comment:商品名称"`
IsSelect bool `gorm:"type:tinyint;comment:是否选中;default:false" json:"is_select"`
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"`
}

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

func NewCartRepo(data *Data, logger log.Logger) biz.CartRepo {
return &cartRepo{
data: data,
log: log.NewHelper(logger),
}
}

// domain 层转换
func (p *ShopCart) ToDomain() *domain.ShopCart {
return &domain.ShopCart{
ID: p.ID,
UserId: p.UserId,
GoodsId: p.GoodsId,
SkuId: p.SkuId,
GoodsPrice: p.GoodsPrice,
GoodsNum: p.GoodsNum,
GoodsSn: p.GoodsSn,
GoodsName: p.GoodsName,
IsSelect: p.IsSelect,
}
}

新建domain 层下的文件

internal/domain/cart.go

cart.go 文件内容:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package domain

type ShopCart struct {
ID int64
UserId int64
GoodsId int64
SkuId int64
GoodsPrice int64
GoodsNum int32
GoodsSn string
GoodsName string
IsSelect bool
}

购物车方法

定义购物车创建方法

api/cart/v1/cart.proto

  • cart.proto 文件创建内容:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
syntax = "proto3";

package cart.v1;

import "validate/validate.proto";

option go_package = "cart/api/cart/v1;v1";

// 购物车
service Cart {
rpc CreateCart (CreateCartRequest) returns (CartInfoReply); // 添加商品进购物车
...
}

message CartInfoReply {
int64 id = 1;
int64 userId = 2;
int64 goodsId = 3;
string goodsSn = 4;
string goodsName = 5;
int64 skuId = 6;
int64 goodsPrice = 7;
int32 goodsNum = 8;
bool isSelect = 9;
}

message CreateCartRequest {
int64 id = 1;
int64 userId = 2 [(validate.rules).int64 = {gt:0}];
int64 goodsId = 3 [(validate.rules).int64 = {gt:0}];
string goodsSn = 4 [(validate.rules).string.min_len = 1];
string goodsName = 5 [(validate.rules).string.min_len = 1];
int64 skuId = 6 [(validate.rules).int64 = {gt:0}];
int64 goodsPrice = 7 [(validate.rules).int64 = {gt:0}];
int32 goodsNum = 8 [(validate.rules).int32 = {gt:0}];
bool isSelect = 9 [(validate.rules).bool.const = true];
}

实现购物车创建方法

internal/service/cart.go

  • cart.go 内容如下:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
package service

import (
"cart/internal/biz"
"cart/internal/domain"
"context"

v1 "cart/api/cart/v1"
)

type CartService struct {
v1.UnimplementedCartServer
cart *biz.CartUsecase
}

func NewCartService(cart *biz.CartUsecase) *CartService {
return &CartService{cart: cart}
}

func (s *CartService) CreateCart(ctx context.Context, req *v1.CreateCartRequest) (*v1.CartInfo, error) {

// biz 层定义的方法,经过 domian 层进行参数转换
rv, err := s.cart.CreateCart(ctx, &domain.ShopCart{
UserId: req.UserId,
GoodsId: req.GoodsId,
SkuId: req.SkuId,
GoodsPrice: req.GoodsPrice,
GoodsNum: req.GoodsNum,
GoodsSn: req.GoodsSn,
GoodsName: req.GoodsName,
IsSelect: req.IsSelect,
})

if err != nil {
return nil, err
}

return &v1.CartInfo{
Id: rv.ID,
UserId: rv.UserId,
GoodsId: rv.GoodsId,
GoodsSn: rv.GoodsSn,
GoodsName: rv.GoodsName,
SkuId: rv.SkuId,
GoodsPrice: rv.GoodsPrice,
GoodsNum: rv.GoodsNum,
IsSelect: rv.IsSelect,
}, nil
}
  • internal/biz/cart.go 内容如下:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
package biz

import (
"cart/internal/domain"
"context"

"github.com/go-kratos/kratos/v2/log"
)

type CartRepo interface {
Create(ctx context.Context, c *domain.ShopCart) (*domain.ShopCart, error)
}

type CartUsecase struct {
repo CartRepo
log *log.Helper
}

func NewCartUsecase(repo CartRepo, logger log.Logger) *CartUsecase {
return &CartUsecase{repo: repo, log: log.NewHelper(logger)}
}

func (uc *CartUsecase) CreateCart(ctx context.Context, c *domain.ShopCart) (*domain.ShopCart, error) {
return uc.repo.Create(ctx, c)
}

  • internal/data/cart.go 新增内容:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

...

func (r *cartRepo) Create(ctx context.Context, c *domain.ShopCart) (*domain.ShopCart, error) {
var shopCart ShopCart
if result := r.data.db.Where(&ShopCart{UserId: c.UserId, SkuId: c.SkuId}).First(&shopCart); result.RowsAffected == 1 {
shopCart.GoodsNum += c.GoodsNum
} else {
shopCart.UserId = c.UserId
shopCart.GoodsId = c.GoodsId
shopCart.SkuId = c.SkuId
shopCart.GoodsPrice = c.GoodsPrice
shopCart.GoodsNum = c.GoodsNum
shopCart.GoodsSn = c.GoodsSn
shopCart.GoodsName = c.GoodsName
shopCart.IsSelect = c.IsSelect
}

if result := r.data.db.Save(&shopCart); result.Error != nil {
return nil, errors.InternalServer("CREATE_CART_NOT_FOUND", "创建购物车失败")
}

return shopCart.ToDomain(), nil
}

这里可以看到,创建购物车数据的时候,只判断了用户是否有同等商品的购物车数据。除此之外并未进行其他业务逻辑的判断,比如,用户是否存在、商品是否正确,而是拿到数据之后,直接进行存储入库。

这里基于咱们项目整体架构的设计,service 层下的所有个体服务,尤其涉及到登录之后的服务,都假设用户已经通过了 bff 层 也就是 service 同级目录的 shop 或者 admin 的业务逻辑验证,servcie 服务只提供粒度够细,较少业务无关,有利于重用,利于单元测试的方法。bff 层的代码更多的是面向用户的业务逻辑的。

拿这个创建购物接口来说,shop 服务中用户创建购物车接口的方法里面,就会判断用户是否登录(用户服务)、商品是否存在(商品服务)、库存(库存服务)是否可以插入购物之类的逻辑验证。

单元测试

  • 新增 cart_test.go 文件

    internal/data/cart_test.go,
    这里和第二篇文章的单元测试流程是相同,一样的初始化测试的代码就不贴出来了。

  • 编写测试 data 下的 create 方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
package data_test

import (
"cart/internal/biz"
"cart/internal/data"
"cart/internal/domain"

. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)

var _ = Describe("Cart", func() {
var ro biz.CartRepo
BeforeEach(func() {
ro = data.NewCartRepo(Db, nil)
})
// 设置 It 块来添加单个规格
It("CreateCart", func() {
cartData := domain.ShopCart{
UserId: 1,
GoodsId: 1,
SkuId: 1,
GoodsPrice: 1000,
GoodsNum: 10,
GoodsSn: "20232232231",
GoodsName: "Mate 40 Pro",
IsSelect: true,
}
c, err := ro.Create(ctx, &cartData)
Ω(err).ShouldNot(HaveOccurred())
Ω(c.UserId).Should(Equal(int64(1)))
Ω(c.GoodsNum).Should(Equal(int32(10)))

// 二次验证创建相同商品的数据,只增加商品数量
cartData2 := domain.ShopCart{
UserId: 1,
GoodsId: 1,
SkuId: 1,
GoodsPrice: 1000,
GoodsNum: 10,
GoodsSn: "20232232231",
GoodsName: "Mate 40 Pro",
IsSelect: true,
}
c2, err := ro.Create(ctx, &cartData2)
Ω(err).ShouldNot(HaveOccurred())
Ω(c2.UserId).Should(Equal(int64(1)))
Ω(c2.GoodsNum).Should(Equal(int32(20)))
})

})

结果如图共 1 个测试 1 个通过 0 个失败。

工具验证创建方法

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


如图故意不把 goodsid 的参数设置为 0 ,并为通过接口的参数验证。

如图把 goodsid 填写正确,就创建成功了。

结束语

在啰嗦几句,最近这几天忙成狗,天天写前端代码,各种样式,交互效果,都要写吐了。打算合理规划一下时间,争取早日把整个项目跑通。

这里特别感谢一下一直支持观看此系列的同学,更感谢你们的打赏、点赞、分享

关注我获取更新