关于golang:带你十天轻松搞定-Go-微服务系列六

8次阅读

共计 12670 个字符，预计需要花费 32 分钟才能阅读完成。

咱们通过一个系列文章跟大家具体展现一个 go-zero 微服务示例，整个系列分十篇文章，目录构造如下：

环境搭建
服务拆分
用户服务
产品服务
订单服务
领取服务（本文）
RPC 服务 Auth 验证
服务监控
链路追踪
分布式事务

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

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

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

进入服务工作区

$ cd mall/service/pay

创立 sql 文件

$ vim model/pay.sql

编写 sql 文件

CREATE TABLE `pay` (
    `id` bigint unsigned NOT NULL AUTO_INCREMENT,
    `uid` bigint unsigned NOT NULL DEFAULT '0' COMMENT '用户 ID',
    `oid` bigint unsigned NOT NULL DEFAULT '0' COMMENT '订单 ID',
    `amount` int(10) unsigned NOT NULL DEFAULT '0'  COMMENT '产品金额',
    `source` tinyint(3) 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_oid` (`oid`)
) ENGINE=InnoDB  DEFAULT CHARSET=utf8mb4;

运行模板生成命令

$ goctl model mysql ddl -src ./model/pay.sql -dir ./model -c

创立 api 文件

$ vim api/pay.api

编写 api 文件

type (
    // 领取创立
    CreateRequest {
        Uid    int64 `json:"uid"`
        Oid    int64 `json:"oid"`
        Amount int64 `json:"amount"`
    }
    CreateResponse {Id int64 `json:"id"`}
    // 领取创立

    // 领取详情
    DetailRequest {Id int64 `json:"id"`}
    DetailResponse {
        Id     int64 `json:"id"`
        Uid    int64 `json:"uid"`
        Oid    int64 `json:"oid"`
        Amount int64 `json:"amount"`
        Source int64 `json:"source"`
        Status int64 `json:"status"`
    }
    // 领取详情

    // 领取回调
    CallbackRequest {
        Id     int64 `json:"id"`
        Uid    int64 `json:"uid"`
        Oid    int64 `json:"oid"`
        Amount int64 `json:"amount"`
        Source int64 `json:"source"`
        Status int64 `json:"status"`
    }
    CallbackResponse { }
    // 领取回调

)

@server(jwt: Auth)
service Pay {
    @handler Create
    post /api/pay/create(CreateRequest) returns (CreateResponse)
    
    @handler Detail
    post /api/pay/detail(DetailRequest) returns (DetailResponse)
    
    @handler Callback
    post /api/pay/callback(CallbackRequest) returns (CallbackResponse)
}

运行模板生成命令

$ goctl api go -api ./api/pay.api -dir ./api

创立 proto 文件

$ vim rpc/pay.proto

编写 proto 文件

syntax = "proto3";

package payclient;

option go_package = "pay";

// 领取创立
message CreateRequest {
    int64 Uid = 1;
    int64 Oid = 2;
    int64 Amount = 3;
}
message CreateResponse {int64 id = 1;}
// 领取创立

// 领取详情
message DetailRequest {int64 id = 1;}
message DetailResponse {
    int64 id = 1;
    int64 Uid = 2;
    int64 Oid = 3;
    int64 Amount = 4;
    int64 Source = 5;
    int64 Status = 6;
}
// 领取详情

// 领取详情
message CallbackRequest {
    int64 id = 1;
    int64 Uid = 2;
    int64 Oid = 3;
    int64 Amount = 4;
    int64 Source = 5;
    int64 Status = 6;
}
message CallbackResponse {
}
// 领取详情


service Pay {rpc Create(CreateRequest) returns(CreateResponse);
    rpc Detail(DetailRequest) returns(DetailResponse);
    rpc Callback(CallbackRequest) returns(CallbackResponse);
}

运行模板生成命令

$ goctl rpc proto -src ./rpc/pay.proto -dir ./rpc

批改 pay.yaml 配置文件

$ vim rpc/etc/pay.yaml

批改服务监听地址，端口号为 0.0.0.0:9003，Etcd 服务配置，Mysql 服务配置，CacheRedis 服务配置

Name: pay.rpc
ListenOn: 0.0.0.0:9003

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

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

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

增加 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
}

注册服务上下文 pay model 的依赖

$ vim rpc/internal/svc/servicecontext.go

package svc

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

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

type ServiceContext struct {
    Config config.Config
    
    PayModel model.PayModel
}

func NewServiceContext(c config.Config) *ServiceContext {conn := sqlx.NewMysql(c.Mysql.DataSource)
    return &ServiceContext{
        Config:   c,
        PayModel: model.NewPayModel(conn, c.CacheRedis),
    }
}

增加 user rpc, order rpc 服务配置

$ vim rpc/etc/pay.yaml

Name: pay.rpc
ListenOn: 0.0.0.0:9003
Etcd:
  Hosts:
  - etcd:2379
  Key: pay.rpc

...

UserRpc:
  Etcd:
    Hosts:
    - etcd:2379
    Key: user.rpc

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

增加 user rpc, order 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
    OrderRpc zrpc.RpcClientConf
}

注册服务上下文 user rpc, order rpc 的依赖

$ vim rpc/internal/svc/servicecontext.go

package svc

import (
    "mall/service/order/rpc/orderclient"
    "mall/service/pay/model"
    "mall/service/pay/rpc/internal/config"
    "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
    
    PayModel model.PayModel

    UserRpc  userclient.User
    OrderRpc orderclient.Order
}

func NewServiceContext(c config.Config) *ServiceContext {conn := sqlx.NewMysql(c.Mysql.DataSource)
    return &ServiceContext{
        Config:   c,
        PayModel: model.NewPayModel(conn, c.CacheRedis),
        UserRpc:  userclient.NewUser(zrpc.MustNewClient(c.UserRpc)),
        OrderRpc: orderclient.NewOrder(zrpc.MustNewClient(c.OrderRpc)),
    }
}

增加依据 oid 查问订单领取记录 PayModel 办法 FindOneByOid

$ vim model/paymodel.go

package model

...

var (
    ...

    cachePayIdPrefix  = "cache:pay:id:"
    cachePayOidPrefix = "cache:pay:oid:"
)

type (
    PayModel interface {Insert(data *Pay) (sql.Result, error)
        FindOne(id int64) (*Pay, error)
        FindOneByOid(oid int64) (*Pay, error)
        Update(data *Pay) error
        Delete(id int64) error
    }

    ...
)

...

func (m *defaultPayModel) FindOneByOid(oid int64) (*Pay, error) {payOidKey := fmt.Sprintf("%s%v", cachePayOidPrefix, oid)
    var resp Pay
    err := m.QueryRow(&resp, payOidKey, func(conn sqlx.SqlConn, v interface{}) error {query := fmt.Sprintf("select %s from %s where `oid` = ? limit 1", payRows, m.table)
        return conn.QueryRow(v, query, oid)
    })
    switch err {
    case nil:
        return &resp, nil
    case sqlc.ErrNotFound:
        return nil, ErrNotFound
    default:
        return nil, err
    }
}

......

增加领取创立逻辑

领取流水创立流程，通过调用 user rpc 服务查问验证用户是否存在，再通过调用 order rpc 服务查问验证订单是否存在，而后通过查问库判断此订单是否曾经创立过领取流水，最初创立落库。

$ vim rpc/internal/logic/createlogic.go

package logic

import (
    "context"

    "mall/service/order/rpc/order"
    "mall/service/pay/model"
    "mall/service/pay/rpc/internal/svc"
    "mall/service/pay/rpc/pay"
    "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 *pay.CreateRequest) (*pay.CreateResponse, error) {
    // 查问用户是否存在
    _, err := l.svcCtx.UserRpc.UserInfo(l.ctx, &user.UserInfoRequest{Id: in.Uid,})
    if err != nil {return nil, err}

    // 查问订单是否存在
    _, err = l.svcCtx.OrderRpc.Detail(l.ctx, &order.DetailRequest{Id: in.Oid,})
    if err != nil {return nil, err}

    // 查问订单是否曾经创立领取
    _, err = l.svcCtx.PayModel.FindOneByOid(in.Oid)
    if err == nil {return nil, status.Error(100, "订单已创立领取")
    }

    newPay := model.Pay{
        Uid:    in.Uid,
        Oid:    in.Oid,
        Amount: in.Amount,
        Source: 0,
        Status: 0,
    }

    res, err := l.svcCtx.PayModel.Insert(&newPay)
    if err != nil {return nil, status.Error(500, err.Error())
    }

    newPay.Id, err = res.LastInsertId()
    if err != nil {return nil, status.Error(500, err.Error())
    }

    return &pay.CreateResponse{Id: newPay.Id,}, nil
}

$ vim rpc/internal/logic/detaillogic.go

package logic

import (
    "context"

    "mall/service/pay/model"
    "mall/service/pay/rpc/internal/svc"
    "mall/service/pay/rpc/pay"

    "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 *pay.DetailRequest) (*pay.DetailResponse, error) {
    // 查问领取是否存在
    res, err := l.svcCtx.PayModel.FindOne(in.Id)
    if err != nil {
        if err == model.ErrNotFound {return nil, status.Error(100, "领取不存在")
        }
        return nil, status.Error(500, err.Error())
    }

    return &pay.DetailResponse{
        Id:     res.Id,
        Uid:    res.Uid,
        Oid:    res.Oid,
        Amount: res.Amount,
        Source: res.Source,
        Status: res.Status,
    }, nil
}

领取流水回调流程，通过调用 user rpc 服务查问验证用户是否存在，再通过调用 order rpc 服务查问验证订单是否存在，而后通过查问库判断此订单领取流水是否存在，以及回调领取金额和库中流水领取金额是否统一，最初更新领取流水状态和通过调用 order rpc 服务更新订单状态。

$ vim rpc/internal/logic/callbacklogic.go

package logic

import (
    "context"

    "mall/service/order/rpc/order"
    "mall/service/pay/model"
    "mall/service/pay/rpc/internal/svc"
    "mall/service/pay/rpc/pay"
    "mall/service/user/rpc/user"

    "github.com/tal-tech/go-zero/core/logx"
    "google.golang.org/grpc/status"
)

type CallbackLogic struct {
    ctx    context.Context
    svcCtx *svc.ServiceContext
    logx.Logger
}

func NewCallbackLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CallbackLogic {
    return &CallbackLogic{
        ctx:    ctx,
        svcCtx: svcCtx,
        Logger: logx.WithContext(ctx),
    }
}

func (l *CallbackLogic) Callback(in *pay.CallbackRequest) (*pay.CallbackResponse, error) {
    // 查问用户是否存在
    _, err := l.svcCtx.UserRpc.UserInfo(l.ctx, &user.UserInfoRequest{Id: in.Uid,})
    if err != nil {return nil, err}

    // 查问订单是否存在
    _, err = l.svcCtx.OrderRpc.Detail(l.ctx, &order.DetailRequest{Id: in.Oid,})
    if err != nil {return nil, err}

    // 查问领取是否存在
    res, err := l.svcCtx.PayModel.FindOne(in.Id)
    if err != nil {
        if err == model.ErrNotFound {return nil, status.Error(100, "领取不存在")
        }
        return nil, status.Error(500, err.Error())
    }
    // 领取金额与订单金额不符
    if in.Amount != res.Amount {return nil, status.Error(100, "领取金额与订单金额不符")
    }

    res.Source = in.Source
    res.Status = in.Status

    err = l.svcCtx.PayModel.Update(res)
    if err != nil {return nil, status.Error(500, err.Error())
    }

    // 更新订单领取状态
    _, err = l.svcCtx.OrderRpc.Paid(l.ctx, &order.PaidRequest{Id: in.Oid,})
    if err != nil {return nil, status.Error(500, err.Error())
    }

    return &pay.CallbackResponse{}, nil}

批改 pay.yaml 配置文件

$ vim api/etc/pay.yaml

批改服务地址，端口号为 0.0.0.0:8003，Mysql 服务配置，CacheRedis 服务配置，Auth 验证配置

Name: Pay
Host: 0.0.0.0
Port: 8003

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

增加 pay rpc 服务配置

$ vim api/etc/pay.yaml

Name: Pay
Host: 0.0.0.0
Port: 8003

......

PayRpc:
  Etcd:
    Hosts:
    - etcd:2379
    Key: pay.rpc

增加 pay 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
    }

    PayRpc zrpc.RpcClientConf
}

注册服务上下文 pay rpc 的依赖

$ vim api/internal/svc/servicecontext.go

package svc

import (
    "mall/service/pay/api/internal/config"
    "mall/service/pay/rpc/payclient"

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

type ServiceContext struct {
    Config config.Config
    
    PayRpc payclient.Pay
}

func NewServiceContext(c config.Config) *ServiceContext {
    return &ServiceContext{
        Config: c,
        PayRpc: payclient.NewPay(zrpc.MustNewClient(c.PayRpc)),
    }
}

$ vim api/internal/logic/createlogic.go

package logic

import (
    "context"

    "mall/service/pay/api/internal/svc"
    "mall/service/pay/api/internal/types"
    "mall/service/pay/rpc/pay"

    "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.PayRpc.Create(l.ctx, &pay.CreateRequest{
        Uid:    req.Uid,
        Oid:    req.Oid,
        Amount: req.Amount,
    })
    if err != nil {return nil, err}

    return &types.CreateResponse{Id: res.Id,}, nil
}

$ vim api/internal/logic/detaillogic.go

package logic

import (
    "context"

    "mall/service/pay/api/internal/svc"
    "mall/service/pay/api/internal/types"
    "mall/service/pay/rpc/pay"

    "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.PayRpc.Detail(l.ctx, &pay.DetailRequest{Id: req.Id,})
    if err != nil {return nil, err}

    return &types.DetailResponse{
        Id:     req.Id,
        Uid:    res.Uid,
        Oid:    res.Oid,
        Amount: res.Amount,
        Source: res.Source,
        Status: res.Status,
    }, nil
}

$ vim api/internal/logic/callbacklogic.go

package logic

import (
    "context"

    "mall/service/pay/api/internal/svc"
    "mall/service/pay/api/internal/types"
    "mall/service/pay/rpc/pay"

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

type CallbackLogic struct {
    logx.Logger
    ctx    context.Context
    svcCtx *svc.ServiceContext
}

func NewCallbackLogic(ctx context.Context, svcCtx *svc.ServiceContext) CallbackLogic {
    return CallbackLogic{Logger: logx.WithContext(ctx),
        ctx:    ctx,
        svcCtx: svcCtx,
    }
}

func (l *CallbackLogic) Callback(req types.CallbackRequest) (resp *types.CallbackResponse, err error) {
    _, err = l.svcCtx.PayRpc.Callback(l.ctx, &pay.CallbackRequest{
        Id:     req.Id,
        Uid:    req.Uid,
        Oid:    req.Oid,
        Amount: req.Amount,
        Source: req.Source,
        Status: req.Status,
    })
    if err != nil {return nil, err}

    return &types.CallbackResponse{}, nil}

提醒：启动服务须要在 golang 容器中启动

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

提醒：启动服务须要在 golang 容器中启动

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

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

欢送应用 go-zero 并 star 反对咱们！

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

正文完

golang

发表至： golang

2022-04-02

0

关于golang:Go语言中的次方表示

关于golang:zookeeper集群环境部署

Go语言HTTP请求流式写入body

关于golang:golang-的包管理

关于php:酷瓜云课堂局域网课程点播系统

关于golang:带你十天轻松搞定-Go-微服务系列六

序言

6 领取服务（pay）

6.1 生成 pay model 模型

6.2 生成 pay api 服务

6.3 生成 pay rpc 服务

6.4 编写 pay rpc 服务

6.4.1 批改配置文件

6.4.2 增加 pay model 依赖

6.4.3 增加 user rpc，order rpc 依赖

6.4.4 增加领取创立逻辑 Create

6.4.5 增加领取详情逻辑 Detail

6.4.6 增加领取回调逻辑 Callback

6.5 编写 pay api 服务

6.5.1 批改配置文件

6.5.2 增加 pay rpc 依赖

6.5.3 增加领取创立逻辑 Create

6.5.4 增加领取详情逻辑 Detail

6.5.5 增加领取回调逻辑 Callback

6.6 启动 pay rpc 服务

6.7 启动 pay api 服务

我的项目地址

微信交换群

站内搜索