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

kevwan發表於2022-01-21
Go微服務
系列文章：
帶你十天輕鬆搞定 Go 微服務系列（一） 帶你十天輕鬆搞定 Go 微服務系列（二） 帶你十天輕鬆搞定 Go 微服務系列（三） 帶你十天輕鬆搞定 Go 微服務系列（四） 帶你十天輕鬆搞定 Go 微服務系列（五）

序言

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

  1. 環境搭建
  2. 服務拆分
  3. 使用者服務
  4. 產品服務
  5. 訂單服務（本文）
  6. 支付服務
  7. RPC 服務 Auth 驗證
  8. 服務監控
  9. 鏈路追蹤
  10. 分散式事務

期望通過本系列帶你在本機利用 Docker 環境利用 go-zero 快速開發一個商城系統，讓你快速上手微服務。

完整示例程式碼：github.com/nivin-studio/go-zero-ma...

首先，我們來看一下整體的服務拆分圖：

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

專案地址

github.com/zeromicro/go-zero

歡迎使用 go-zero 並 star 支援我們！

微信交流群

關注『微服務實踐』公眾號並點選 交流群 獲取社群群二維碼。

本作品採用《CC 協議》，轉載必須註明作者和本文連結

相關文章