帶你十天輕鬆搞定 Go 微服務系列（五）

序言

我們通過一個系列文章跟大家詳細展示一個 go-zero 微服務示例，整個系列分十篇文章，目錄結構如下：

1. 環境搭建：帶你十天輕鬆搞定 Go 微服務系列（一）

2. 服務拆分：帶你十天輕鬆搞定 Go 微服務系列（二）

3. 用戶服務：帶你十天輕鬆搞定 Go 微服務系列（三）

4. 產品服務：帶你十天輕鬆搞定 Go 微服務系列（四）

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:9002

Etcd:
  Hosts:
  - etcd:2379
  Key: order.rpc

Mysql:
  DataSource: root:123456@tcp(mysql:3306)/mall?charset=utf8mb4&parseTime=true&loc=Asia%2FShanghai

CacheRedis:
- Host: redis:6379
  Type: node
  Pass:

5.4.2 添加 order model 依賴

• 添加 Mysql 服務配置，CacheRedis 服務配置的實例化

$ vim rpc/internal/config/config.go

package config

import (
 "github.com/tal-tech/go-zero/core/stores/cache"
 "github.com/tal-tech/go-zero/zrpc"
)

type Config struct {
 zrpc.RpcServerConf

 Mysql struct {
  DataSource string
 }
    
 CacheRedis cache.CacheConf
}

• 註冊服務上下文 order model 的依賴

$ vim rpc/internal/svc/servicecontext.go

package svc

import (
 "mall/service/order/model"
 "mall/service/order/rpc/internal/config"

 "github.com/tal-tech/go-zero/core/stores/sqlx"
)

type ServiceContext struct {
 Config config.Config

 OrderModel 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.rpc

ProductRpc:
  Etcd:
    Hosts:
    - etcd:2379
    Key: product.rpc

• 添加 user rpc, product rpc 服務配置的實例化

$ vim rpc/internal/config/config.go

package config

import (
 "github.com/tal-tech/go-zero/core/stores/cache"
 "github.com/tal-tech/go-zero/zrpc"
)

type Config struct {
 zrpc.RpcServerConf

 Mysql struct {
  DataSource string
 }
    
 CacheRedis cache.CacheConf

 UserRpc    zrpc.RpcClientConf
 ProductRpc zrpc.RpcClientConf
}

• 註冊服務上下文 user rpc, product rpc 的依賴

$ vim rpc/internal/svc/servicecontext.go

package svc

import (
 "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.Config

 OrderModel model.OrderModel

 UserRpc    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 logic

import (
 "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 logic

import (
 "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 logic

import (
 "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 logic

import (
 "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 []*Order

 query := 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 logic

import (
 "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 logic

import (
 "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 = 1

 err = 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: 8002

Mysql:
  DataSource: root:123456@tcp(mysql:3306)/mall?charset=utf8mb4&parseTime=true&loc=Asia%2FShanghai

CacheRedis:
- 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 config

import (
 "github.com/tal-tech/go-zero/rest"
 "github.com/tal-tech/go-zero/zrpc"
)

type Config struct {
 rest.RestConf

 Auth struct {
  AccessSecret string
  AccessExpire int64
 }

 OrderRpc zrpc.RpcClientConf
}

• 註冊服務上下文 user rpc 的依賴

$ vim api/internal/svc/servicecontext.go

package svc

import (
 "mall/service/order/api/internal/config"
 "mall/service/order/rpc/orderclient"

 "github.com/tal-tech/go-zero/zrpc"
)

type ServiceContext struct {
 Config config.Config

 OrderRpc 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 logic

import (
 "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 logic

import (
 "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 logic

import (
 "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 logic

import (
 "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 logic

import (
 "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 支持我們！

微信交流羣

關注『微服務實踐』公衆號並點擊 交流羣 獲取社區羣二維碼。

本文由 Readfog 進行 AMP 轉碼，版權歸原作者所有。
來源：https://mp.weixin.qq.com/s/IeqOg0oiyLB_aKJqSoP3gw