首页 技术 正文

带你十天轻松搞定 Go 微服务系列（五）

技术 2022年11月9日
0 收藏 753 点赞 2,499 浏览 17526 个字

序言

我们通过一个系列文章跟大家详细展示一个 go-zero 微服务示例，整个系列分十篇文章，目录结构如下：

  1. 环境搭建
  2. 服务拆分
  3. 用户服务
  4. 产品服务
  5. 订单服务（本文）
  6. 支付服务
  7. RPC 服务 Auth 验证
  8. 服务监控
  9. 链路追踪
  10. 分布式事务

期望通过本系列带你在本机利用 Docker 环境利用 go-zero 快速开发一个商城系统，让你快速上手微服务。

完整示例代码：https://github.com/nivin-studio/go-zero-mall

首先，我们来看一下整体的服务拆分图：

5 订单服务（order）

  • 进入服务工作区
$ cd mall/service/order

5.1 生成 order model 模型

  • 创建 sql 文件
$ vim model/order.sql
  • 编写 sql 文件
CREATE TABLE `order` (
`id` bigint unsigned NOT NULL AUTO_INCREMENT,
`uid` bigint unsigned NOT NULL DEFAULT '0' COMMENT '用户ID',
`pid` bigint unsigned NOT NULL DEFAULT '0' COMMENT '产品ID',
`amount` int(10) unsigned NOT NULL DEFAULT '0'  COMMENT '订单金额',
`status` tinyint(3) unsigned NOT NULL DEFAULT '0' COMMENT '订单状态',
`create_time` timestamp NULL DEFAULT CURRENT_TIMESTAMP,
`update_time` timestamp NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
PRIMARY KEY (`id`),
KEY `idx_uid` (`uid`),
KEY `idx_pid` (`pid`)
) ENGINE=InnoDB  DEFAULT CHARSET=utf8mb4;
  • 运行模板生成命令
$ goctl model mysql ddl -src ./model/order.sql -dir ./model -c

5.2 生成 order api 服务

  • 创建 api 文件
$ vim api/order.api
  • 编写 api 文件
type (
// 订单创建
CreateRequest {
Uid    int64 `json:"uid"`
Pid    int64 `json:"pid"`
Amount int64 `json:"amount"`
Status int64 `json:"status"`
}
CreateResponse {
Id int64 `json:"id"`
}
// 订单创建// 订单修改
UpdateRequest {
Id     int64 `json:"id"`
Uid    int64 `json:"uid,optional"`
Pid    int64 `json:"pid,optional"`
Amount int64 `json:"amount,optional"`
Status int64 `json:"status,optional"`
}
UpdateResponse {
}
// 订单修改// 订单删除
RemoveRequest {
Id int64 `json:"id"`
}
RemoveResponse {
}
// 订单删除// 订单详情
DetailRequest {
Id int64 `json:"id"`
}
DetailResponse {
Id     int64 `json:"id"`
Uid    int64 `json:"uid"`
Pid    int64 `json:"pid"`
Amount int64 `json:"amount"`
Status int64 `json:"status"`
}
// 订单详情// 订单列表
ListRequest {
Uid int64 `json:"uid"`
}
ListResponse {
Id     int64 `json:"id"`
Uid    int64 `json:"uid"`
Pid    int64 `json:"pid"`
Amount int64 `json:"amount"`
Status int64 `json:"status"`
}
// 订单列表
)@server(
jwt: Auth
)
service Order {
@handler Create
post /api/order/create(CreateRequest) returns (CreateResponse)@handler Update
post /api/order/update(UpdateRequest) returns (UpdateResponse)@handler Remove
post /api/order/remove(RemoveRequest) returns (RemoveResponse)@handler Detail
post /api/order/detail(DetailRequest) returns (DetailResponse)@handler List
post /api/order/list(ListRequest) returns (ListResponse)
}
  • 运行模板生成命令
$ goctl api go -api ./api/order.api -dir ./api

5.3 生成 order rpc 服务

  • 创建 proto 文件
$ vim rpc/order.proto
  • 编写 proto 文件
syntax = "proto3";package orderclient;option go_package = "order";// 订单创建
message CreateRequest {
    int64 Uid = 1;
    int64 Pid = 2;
    int64 Amount = 3;
    int64 Status = 4;
}
message CreateResponse {
int64 id = 1;
}
// 订单创建// 订单修改
message UpdateRequest {
    int64 id = 1;
    int64 Uid = 2;
    int64 Pid = 3;
    int64 Amount = 4;
    int64 Status = 5;
}
message UpdateResponse {
}
// 订单修改// 订单删除
message RemoveRequest {
    int64 id = 1;
}
message RemoveResponse {
}
// 订单删除// 订单详情
message DetailRequest {
    int64 id = 1;
}
message DetailResponse {
    int64 id = 1;
    int64 Uid = 2;
    int64 Pid = 3;
    int64 Amount = 4;
    int64 Status = 5;
}
// 订单详情// 订单列表
message ListRequest {
    int64 uid = 1;
}
message ListResponse {
    repeated DetailResponse data = 1;
}
// 订单列表// 订单支付
message PaidRequest {
    int64 id = 1;
}
message PaidResponse {
}
// 订单支付service Order {
    rpc Create(CreateRequest) returns(CreateResponse);
    rpc Update(UpdateRequest) returns(UpdateResponse);
    rpc Remove(RemoveRequest) returns(RemoveResponse);
    rpc Detail(DetailRequest) returns(DetailResponse);
    rpc List(ListRequest) returns(ListResponse);
    rpc Paid(PaidRequest) returns(PaidResponse);
}
  • 运行模板生成命令
$ goctl rpc proto -src ./rpc/order.proto -dir ./rpc

5.4 编写 order rpc 服务

5.4.1 修改配置文件

  • 修改 order.yaml 配置文件
$ vim rpc/etc/order.yaml
  • 修改服务监听地址，端口号为0.0.0.0:9002，Etcd 服务配置，Mysql 服务配置，CacheRedis 服务配置
Name: order.rpc
ListenOn: 0.0.0.0:9002Etcd:
  Hosts:
  - etcd:2379
  Key: order.rpcMysql:
  DataSource: root:123456@tcp(mysql:3306)/mall?charset=utf8mb4&parseTime=true&loc=Asia%2FShanghaiCacheRedis:
- Host: redis:6379
  Type: node
  Pass:

5.4.2 添加 order model 依赖

  • 添加 Mysql 服务配置，CacheRedis 服务配置的实例化
$ vim rpc/internal/config/config.go
package configimport (
"github.com/tal-tech/go-zero/core/stores/cache"
"github.com/tal-tech/go-zero/zrpc"
)type Config struct {
zrpc.RpcServerConfMysql struct {
DataSource string
}CacheRedis cache.CacheConf
}
  • 注册服务上下文 order model 的依赖
$ vim rpc/internal/svc/servicecontext.go
package svcimport (
"mall/service/order/model"
"mall/service/order/rpc/internal/config""github.com/tal-tech/go-zero/core/stores/sqlx"
)type ServiceContext struct {
Config config.ConfigOrderModel model.OrderModel
}func NewServiceContext(c config.Config) *ServiceContext {
conn := sqlx.NewMysql(c.Mysql.DataSource)
return &ServiceContext{
Config:     c,
OrderModel: model.NewOrderModel(conn, c.CacheRedis),
}
}

5.4.3 添加 user rpc，product rpc 依赖

  • 添加 user rpc, product rpc 服务配置
$ vim rpc/etc/order.yaml
Name: order.rpc
ListenOn: 0.0.0.0:9002
Etcd:
  Hosts:
  - etcd:2379
  Key: order.rpc......UserRpc:
  Etcd:
    Hosts:
    - etcd:2379
    Key: user.rpcProductRpc:
  Etcd:
    Hosts:
    - etcd:2379
    Key: product.rpc
  • 添加 user rpc, product rpc 服务配置的实例化
$ vim rpc/internal/config/config.go
package configimport (
"github.com/tal-tech/go-zero/core/stores/cache"
"github.com/tal-tech/go-zero/zrpc"
)type Config struct {
zrpc.RpcServerConfMysql struct {
DataSource string
}CacheRedis cache.CacheConfUserRpc    zrpc.RpcClientConf
ProductRpc zrpc.RpcClientConf
}
  • 注册服务上下文 user rpc, product rpc 的依赖
$ vim rpc/internal/svc/servicecontext.go
package svcimport (
"mall/service/order/model"
"mall/service/order/rpc/internal/config"
"mall/service/product/rpc/productclient"
"mall/service/user/rpc/userclient""github.com/tal-tech/go-zero/core/stores/sqlx"
"github.com/tal-tech/go-zero/zrpc"
)type ServiceContext struct {
Config config.ConfigOrderModel model.OrderModelUserRpc    userclient.User
ProductRpc productclient.Product
}func NewServiceContext(c config.Config) *ServiceContext {
conn := sqlx.NewMysql(c.Mysql.DataSource)
return &ServiceContext{
Config:     c,
OrderModel: model.NewOrderModel(conn, c.CacheRedis),
UserRpc:    userclient.NewUser(zrpc.MustNewClient(c.UserRpc)),
ProductRpc: productclient.NewProduct(zrpc.MustNewClient(c.ProductRpc)),
}
}

5.4.4 添加订单创建逻辑 Create

订单创建流程，通过调用 user rpc 服务查询验证用户是否存在，再通过调用 product rpc 服务查询验证产品是否存在，以及判断产品库存是否充足。验证通过后，创建用户订单，并通过调用 product rpc 服务更新产品库存。

$ vim rpc/internal/logic/createlogic.go
package logicimport (
"context""mall/service/order/model"
"mall/service/order/rpc/internal/svc"
"mall/service/order/rpc/order"
"mall/service/product/rpc/product"
"mall/service/user/rpc/user""github.com/tal-tech/go-zero/core/logx"
"google.golang.org/grpc/status"
)type CreateLogic struct {
ctx    context.Context
svcCtx *svc.ServiceContext
logx.Logger
}func NewCreateLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CreateLogic {
return &CreateLogic{
ctx:    ctx,
svcCtx: svcCtx,
Logger: logx.WithContext(ctx),
}
}func (l *CreateLogic) Create(in *order.CreateRequest) (*order.CreateResponse, error) {
// 查询用户是否存在
_, err := l.svcCtx.UserRpc.UserInfo(l.ctx, &user.UserInfoRequest{
Id: in.Uid,
})
if err != nil {
return nil, err
}// 查询产品是否存在
productRes, err := l.svcCtx.ProductRpc.Detail(l.ctx, &product.DetailRequest{
Id: in.Pid,
})
if err != nil {
return nil, err
}
// 判断产品库存是否充足
if productRes.Stock <= 0 {
return nil, status.Error(500, "产品库存不足")
}newOrder := model.Order{
Uid:    in.Uid,
Pid:    in.Pid,
Amount: in.Amount,
Status: 0,
}
        // 创建订单
res, err := l.svcCtx.OrderModel.Insert(&newOrder)
if err != nil {
return nil, status.Error(500, err.Error())
}newOrder.Id, err = res.LastInsertId()
if err != nil {
return nil, status.Error(500, err.Error())
}
        // 更新产品库存
_, err = l.svcCtx.ProductRpc.Update(l.ctx, &product.UpdateRequest{
Id:     productRes.Id,
Name:   productRes.Name,
Desc:   productRes.Desc,
                Stock:  productRes.Stock - 1,
Amount: productRes.Amount,
Status: productRes.Status,
})
if err != nil {
return nil, err
}return &order.CreateResponse{
Id: newOrder.Id,
}, nil
}

!注意：这里的产品库存更新存在数据一致性问题，在以往的项目中我们会使用数据库的事务进行这一系列的操作来保证数据的一致性。但是因为我们这边把“订单”和“产品”分成了不同的微服务，在实际的项目中他们可能拥有不同的数据库，所以我们要考虑在跨服务的情况下还能保证数据的一致性，这就涉及到了分布式事务的使用，在后面的章节中我们将介绍使用分布式事务来修改这个下单的逻辑。

5.4.5 添加订单详情逻辑 Detail

$ vim rpc/internal/logic/detaillogic.go
package logicimport (
"context""mall/service/order/model"
"mall/service/order/rpc/internal/svc"
"mall/service/order/rpc/order""github.com/tal-tech/go-zero/core/logx"
"google.golang.org/grpc/status"
)type DetailLogic struct {
ctx    context.Context
svcCtx *svc.ServiceContext
logx.Logger
}func NewDetailLogic(ctx context.Context, svcCtx *svc.ServiceContext) *DetailLogic {
return &DetailLogic{
ctx:    ctx,
svcCtx: svcCtx,
Logger: logx.WithContext(ctx),
}
}func (l *DetailLogic) Detail(in *order.DetailRequest) (*order.DetailResponse, error) {
// 查询订单是否存在
res, err := l.svcCtx.OrderModel.FindOne(in.Id)
if err != nil {
if err == model.ErrNotFound {
return nil, status.Error(100, "订单不存在")
}
return nil, status.Error(500, err.Error())
}return &order.DetailResponse{
Id:     res.Id,
Uid:    res.Uid,
Pid:    res.Pid,
Amount: res.Amount,
Status: res.Status,
}, nil
}

5.4.6 添加订单更新逻辑 Update

$ vim rpc/internal/logic/updatelogic.go
package logicimport (
"context""mall/service/order/model"
"mall/service/order/rpc/internal/svc"
"mall/service/order/rpc/order""github.com/tal-tech/go-zero/core/logx"
"google.golang.org/grpc/status"
)type UpdateLogic struct {
ctx    context.Context
svcCtx *svc.ServiceContext
logx.Logger
}func NewUpdateLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UpdateLogic {
return &UpdateLogic{
ctx:    ctx,
svcCtx: svcCtx,
Logger: logx.WithContext(ctx),
}
}func (l *UpdateLogic) Update(in *order.UpdateRequest) (*order.UpdateResponse, error) {
// 查询订单是否存在
res, err := l.svcCtx.OrderModel.FindOne(in.Id)
if err != nil {
if err == model.ErrNotFound {
return nil, status.Error(100, "订单不存在")
}
return nil, status.Error(500, err.Error())
}if in.Uid != 0 {
res.Uid = in.Uid
}
if in.Pid != 0 {
res.Pid = in.Pid
}
if in.Amount != 0 {
res.Amount = in.Amount
}
if in.Status != 0 {
res.Status = in.Status
}err = l.svcCtx.OrderModel.Update(res)
if err != nil {
return nil, status.Error(500, err.Error())
}return &order.UpdateResponse{}, nil
}

5.4.7 添加订单删除逻辑 Remove

$ vim rpc/internal/logic/removelogic.go
package logicimport (
"context""mall/service/order/model"
"mall/service/order/rpc/internal/svc"
"mall/service/order/rpc/order""github.com/tal-tech/go-zero/core/logx"
"google.golang.org/grpc/status"
)type RemoveLogic struct {
ctx    context.Context
svcCtx *svc.ServiceContext
logx.Logger
}func NewRemoveLogic(ctx context.Context, svcCtx *svc.ServiceContext) *RemoveLogic {
return &RemoveLogic{
ctx:    ctx,
svcCtx: svcCtx,
Logger: logx.WithContext(ctx),
}
}func (l *RemoveLogic) Remove(in *order.RemoveRequest) (*order.RemoveResponse, error) {
// 查询订单是否存在
res, err := l.svcCtx.OrderModel.FindOne(in.Id)
if err != nil {
if err == model.ErrNotFound {
return nil, status.Error(100, "订单不存在")
}
return nil, status.Error(500, err.Error())
}err = l.svcCtx.OrderModel.Delete(res.Id)
if err != nil {
return nil, status.Error(500, err.Error())
}return &order.RemoveResponse{}, nil
}

5.4.8 添加订单列表逻辑 List

  • 添加根据 uid 查询用户所有订单的 OrderModel 方法 FindAllByUid
$ vim model/ordermodel.go
package model......type (
OrderModel interface {
Insert(data *Order) (sql.Result, error)
FindOne(id int64) (*Order, error)
FindAllByUid(uid int64) ([]*Order, error)
Update(data *Order) error
Delete(id int64) error
}......
)......func (m *defaultOrderModel) FindAllByUid(uid int64) ([]*Order, error) {
var resp []*Orderquery := fmt.Sprintf("select %s from %s where `uid` = ?", orderRows, m.table)
err := m.QueryRowsNoCache(&resp, query, uid)switch err {
case nil:
return resp, nil
case sqlc.ErrNotFound:
return nil, ErrNotFound
default:
return nil, err
}
}......
  • 添加订单列表逻辑
$ vim rpc/internal/logic/listlogic.go
package logicimport (
"context""mall/service/order/model"
"mall/service/order/rpc/internal/svc"
"mall/service/order/rpc/order"
"mall/service/user/rpc/user""github.com/tal-tech/go-zero/core/logx"
"google.golang.org/grpc/status"
)type ListLogic struct {
ctx    context.Context
svcCtx *svc.ServiceContext
logx.Logger
}func NewListLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ListLogic {
return &ListLogic{
ctx:    ctx,
svcCtx: svcCtx,
Logger: logx.WithContext(ctx),
}
}func (l *ListLogic) List(in *order.ListRequest) (*order.ListResponse, error) {
// 查询用户是否存在
_, err := l.svcCtx.UserRpc.UserInfo(l.ctx, &user.UserInfoRequest{
Id: in.Uid,
})
if err != nil {
return nil, err
}// 查询订单是否存在
list, err := l.svcCtx.OrderModel.FindAllByUid(in.Uid)
if err != nil {
if err == model.ErrNotFound {
return nil, status.Error(100, "订单不存在")
}
return nil, status.Error(500, err.Error())
}orderList := make([]*order.DetailResponse, 0)
for _, item := range list {
orderList = append(orderList, &order.DetailResponse{
Id:     item.Id,
Uid:    item.Uid,
Pid:    item.Pid,
Amount: item.Amount,
Status: item.Status,
})
}return &order.ListResponse{
Data: orderList,
}, nil
}

5.4.9 添加订单支付逻辑 Paid

$ vim rpc/internal/logic/paidlogic.go
package logicimport (
"context""mall/service/order/model"
"mall/service/order/rpc/internal/svc"
"mall/service/order/rpc/order""github.com/tal-tech/go-zero/core/logx"
"google.golang.org/grpc/status"
)type PaidLogic struct {
ctx    context.Context
svcCtx *svc.ServiceContext
logx.Logger
}func NewPaidLogic(ctx context.Context, svcCtx *svc.ServiceContext) *PaidLogic {
return &PaidLogic{
ctx:    ctx,
svcCtx: svcCtx,
Logger: logx.WithContext(ctx),
}
}func (l *PaidLogic) Paid(in *order.PaidRequest) (*order.PaidResponse, error) {
// 查询订单是否存在
res, err := l.svcCtx.OrderModel.FindOne(in.Id)
if err != nil {
if err == model.ErrNotFound {
return nil, status.Error(100, "订单不存在")
}
return nil, status.Error(500, err.Error())
}res.Status = 1err = l.svcCtx.OrderModel.Update(res)
if err != nil {
return nil, status.Error(500, err.Error())
}return &order.PaidResponse{}, nil
}

5.5 编写 order api 服务

5.5.1 修改配置文件

  • 修改 order.yaml 配置文件
$ vim api/etc/order.yaml
  • 修改服务地址，端口号为0.0.0.0:8002，Mysql 服务配置，CacheRedis 服务配置，Auth 验证配置
Name: Order
Host: 0.0.0.0
Port: 8002Mysql:
  DataSource: root:123456@tcp(mysql:3306)/mall?charset=utf8mb4&parseTime=true&loc=Asia%2FShanghaiCacheRedis:
- Host: redis:6379
  Type: node
  Pass:Auth:
  AccessSecret: uOvKLmVfztaXGpNYd4Z0I1SiT7MweJhl
  AccessExpire: 86400

5.5.2 添加 order rpc 依赖

  • 添加 order rpc 服务配置
$ vim api/etc/order.yaml
Name: Order
Host: 0.0.0.0
Port: 8002......OrderRpc:
  Etcd:
    Hosts:
    - etcd:2379
    Key: order.rpc
  • 添加 order rpc 服务配置的实例化
$ vim api/internal/config/config.go
package configimport (
"github.com/tal-tech/go-zero/rest"
"github.com/tal-tech/go-zero/zrpc"
)type Config struct {
rest.RestConfAuth struct {
AccessSecret string
AccessExpire int64
}OrderRpc zrpc.RpcClientConf
}
  • 注册服务上下文 user rpc 的依赖
$ vim api/internal/svc/servicecontext.go
package svcimport (
"mall/service/order/api/internal/config"
"mall/service/order/rpc/orderclient""github.com/tal-tech/go-zero/zrpc"
)type ServiceContext struct {
Config config.ConfigOrderRpc orderclient.Order
}func NewServiceContext(c config.Config) *ServiceContext {
return &ServiceContext{
Config:   c,
OrderRpc: orderclient.NewOrder(zrpc.MustNewClient(c.OrderRpc)),
}
}

5.5.3 添加订单创建逻辑 Create

$ vim api/internal/logic/createlogic.go
package logicimport (
"context""mall/service/order/api/internal/svc"
"mall/service/order/api/internal/types"
"mall/service/order/rpc/orderclient""github.com/tal-tech/go-zero/core/logx"
)type CreateLogic struct {
logx.Logger
ctx    context.Context
svcCtx *svc.ServiceContext
}func NewCreateLogic(ctx context.Context, svcCtx *svc.ServiceContext) CreateLogic {
return CreateLogic{
Logger: logx.WithContext(ctx),
ctx:    ctx,
svcCtx: svcCtx,
}
}func (l *CreateLogic) Create(req types.CreateRequest) (resp *types.CreateResponse, err error) {
res, err := l.svcCtx.OrderRpc.Create(l.ctx, &orderclient.CreateRequest{
Uid:    req.Uid,
Pid:    req.Pid,
Amount: req.Amount,
Status: req.Status,
})
if err != nil {
return nil, err
}return &types.CreateResponse{
Id: res.Id,
}, nil
}

5.5.4 添加订单详情逻辑 Detail

$ vim api/internal/logic/detaillogic.go
package logicimport (
"context""mall/service/order/api/internal/svc"
"mall/service/order/api/internal/types"
"mall/service/order/rpc/orderclient""github.com/tal-tech/go-zero/core/logx"
)type DetailLogic struct {
logx.Logger
ctx    context.Context
svcCtx *svc.ServiceContext
}func NewDetailLogic(ctx context.Context, svcCtx *svc.ServiceContext) DetailLogic {
return DetailLogic{
Logger: logx.WithContext(ctx),
ctx:    ctx,
svcCtx: svcCtx,
}
}func (l *DetailLogic) Detail(req types.DetailRequest) (resp *types.DetailResponse, err error) {
res, err := l.svcCtx.OrderRpc.Detail(l.ctx, &orderclient.DetailRequest{
Id: req.Id,
})
if err != nil {
return nil, err
}return &types.DetailResponse{
Id:     res.Id,
Uid:    res.Uid,
Pid:    res.Pid,
Amount: res.Amount,
Status: res.Status,
}, nil
}

5.5.5 添加订单更新逻辑 Update

$ vim api/internal/logic/updatelogic.go
package logicimport (
"context""mall/service/order/api/internal/svc"
"mall/service/order/api/internal/types"
"mall/service/order/rpc/orderclient""github.com/tal-tech/go-zero/core/logx"
)type UpdateLogic struct {
logx.Logger
ctx    context.Context
svcCtx *svc.ServiceContext
}func NewUpdateLogic(ctx context.Context, svcCtx *svc.ServiceContext) UpdateLogic {
return UpdateLogic{
Logger: logx.WithContext(ctx),
ctx:    ctx,
svcCtx: svcCtx,
}
}func (l *UpdateLogic) Update(req types.UpdateRequest) (resp *types.UpdateResponse, err error) {
_, err = l.svcCtx.OrderRpc.Update(l.ctx, &orderclient.UpdateRequest{
Id:     req.Id,
Uid:    req.Uid,
Pid:    req.Pid,
Amount: req.Amount,
Status: req.Status,
})
if err != nil {
return nil, err
}return &types.UpdateResponse{}, nil
}

5.5.6 添加订单删除逻辑 Remove

$ vim api/internal/logic/removelogic.go
package logicimport (
"context""mall/service/order/api/internal/svc"
"mall/service/order/api/internal/types"
"mall/service/order/rpc/orderclient""github.com/tal-tech/go-zero/core/logx"
)type RemoveLogic struct {
logx.Logger
ctx    context.Context
svcCtx *svc.ServiceContext
}func NewRemoveLogic(ctx context.Context, svcCtx *svc.ServiceContext) RemoveLogic {
return RemoveLogic{
Logger: logx.WithContext(ctx),
ctx:    ctx,
svcCtx: svcCtx,
}
}func (l *RemoveLogic) Remove(req types.RemoveRequest) (resp *types.RemoveResponse, err error) {
_, err = l.svcCtx.OrderRpc.Remove(l.ctx, &orderclient.RemoveRequest{
Id: req.Id,
})
if err != nil {
return nil, err
}return &types.RemoveResponse{}, nil
}

5.5.7 添加订单列表逻辑 List

$ vim api/internal/logic/listlogic.go
package logicimport (
"context""mall/service/order/api/internal/svc"
"mall/service/order/api/internal/types"
"mall/service/order/rpc/orderclient""github.com/tal-tech/go-zero/core/logx"
)type ListLogic struct {
logx.Logger
ctx    context.Context
svcCtx *svc.ServiceContext
}func NewListLogic(ctx context.Context, svcCtx *svc.ServiceContext) ListLogic {
return ListLogic{
Logger: logx.WithContext(ctx),
ctx:    ctx,
svcCtx: svcCtx,
}
}func (l *ListLogic) List(req types.ListRequest) (resp []*types.ListResponse, err error) {
res, err := l.svcCtx.OrderRpc.List(l.ctx, &orderclient.ListRequest{
Uid: req.Uid,
})
if err != nil {
return nil, err
}orderList := make([]*types.ListResponse, 0)
for _, item := range res.Data {
orderList = append(orderList, &types.ListResponse{
Id:     item.Id,
Uid:    item.Uid,
Pid:    item.Pid,
Amount: item.Amount,
Status: item.Status,
})
}return orderList, nil
}

5.6 启动 order rpc 服务

!提示：启动服务需要在 golang 容器中启动

$ cd mall/service/order/rpc
$ go run order.go -f etc/order.yaml
Starting rpc server at 127.0.0.1:9002...

5.7 启动 order api 服务

!提示：启动服务需要在 golang 容器中启动

$ cd mall/service/order/api
$ go run order.go -f etc/order.yaml
Starting server at 0.0.0.0:8002...

项目地址

https://github.com/zeromicro/go-zero

欢迎使用 go-zero 并 star 支持我们！

微信交流群

关注『微服务实践』公众号并点击 交流群 获取社区群二维码。

点赞 753

贡献者

上一篇： 带你十天轻松搞定 Go 微服务系列（三）
下一篇： 带你十天轻松搞定 Go 微服务系列（六）
相关推荐
python开发_常用的python模块及安装方法
python开发_常用的python模块及安装方法
adodb：我们领导推荐的数据库连接组件bsddb3：BerkeleyDB的连接组件Cheetah-1.0：我比较喜欢这个版本的cheeta…
技术
日期：2022-11-24 点赞：878 阅读：9,078
Educational Codeforces Round 11 C. Hard Process 二分
Educational Codeforces Round 11 C. Hard Process 二分
C. Hard Process题目连接：http://www.codeforces.com/contest/660/problem/CDes…
技术
日期：2022-11-24 点赞：807 阅读：5,553
下载Ubuntn 17.04 内核源代码
下载Ubuntn 17.04 内核源代码
zengkefu@server1:/usr/src$ uname -aLinux server1 4.10.0-19-generic #21…
技术
日期：2022-11-24 点赞：569 阅读：6,402
可用Active Desktop Calendar V7.86 注册码序列号
可用Active Desktop Calendar V7.86 注册码序列号
可用Active Desktop Calendar V7.86 注册码序列号Name: www.greendown.cn Code: &nb…
技术
日期：2022-11-24 点赞：733 阅读：6,177
Android调用系统相机、自定义相机、处理大图片
Android调用系统相机、自定义相机、处理大图片
Android调用系统相机和自定义相机实例本博文主要是介绍了android上使用相机进行拍照并显示的两种方式，并且由于涉及到要把拍到的照片显…
技术
日期：2022-11-24 点赞：512 阅读：7,814
Struts的使用
Struts的使用
一、Struts2的获取　　Struts的官方网站为：http://struts.apache.org/　　下载完Struts2的jar包,…
技术
日期：2022-11-24 点赞：671 阅读：4,898
Lomu

贡献者

这家伙很懒，只想把你留下。

文章
94
收藏
0
人气
302,510
粉丝
进主页
文章展示
  • [ 技术 ] python开发_常用的python模块及安装方法
  • [ 技术 ] Educational Codeforces Round 11 C. Hard Process 二分
  • [ 技术 ] 下载Ubuntn 17.04 内核源代码
  • [ 技术 ] 可用Active Desktop Calendar V7.86 注册码序列号
  • [ 技术 ] Android调用系统相机、自定义相机、处理大图片
  • [ 技术 ] Struts的使用
    • 个人收藏笔记记录
    我的笔记
    首页 首页 菜单 首页 首页