Always keep a beginner's mind, don|
收藏闪存小组博问

Dancing-Pierre

园龄：1年10个月粉丝：3关注：0

学习笔记：带你十天轻松完成 Go 微服务系列（六）- 支付服务

学习笔记：带你十天轻松搞定 Go 微服务系列（六）- 支付服务

1、学习课程

带你十天轻松搞定 Go 微服务系列（六、支付服务）

今天是学习 go 微服务的第六天，我们继续接着昨天的步骤，进入服务工作区

$ cd mall/service/pay

2、生成 pay model 模型

创建 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;

运行模板生成命令（注意在 golang 容器下运行）

参考：Linux下部署go-zero，运行goctl model运行模板生成命令报错解决方法

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

3、生成 pay api 服务

创建 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)
}

运行模板生成命令（注意在 golang 容器下运行）

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

4、生成 pay rpc 服务

创建 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);
}

运行模板生成命令（注意在 golang 容器下运行）

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

5、编写 pay rpc 服务

5.1 修改配置文件

修改 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

5.2 添加 pay model 依赖

添加 Mysql 服务配置，CacheRedis 服务配置的实例化

$ vim rpc/internal/config/config.go
package config
 
import (
 "github.com/zeromicro/go-zero/core/stores/cache"
 "github.com/zeromicro/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/zeromicro/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),
 }
}

5.3 添加 user rpc，order rpc 依赖

添加 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/zeromicro/go-zero/core/stores/cache"
 "github.com/zeromicro/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/zeromicro/go-zero/core/stores/sqlx"
 "github.com/zeromicro/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)),
 }
}

5.4 添加支付创建逻辑 Create

添加根据 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
 }
}
 
......

添加支付创建逻辑

$ 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/zeromicro/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
}

5.5 添加支付详情逻辑 Detail

$ 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/zeromicro/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
}

5.6 添加支付回调逻辑 Callback

支付流水回调流程，通过调用 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/zeromicro/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
}

6、编写 pay api 服务

6.1 修改配置文件

修改 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

6.2 添加 pay rpc 依赖

添加 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/zeromicro/go-zero/rest"
 "github.com/zeromicro/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/zeromicro/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)),
 }
}

6.3 添加支付创建逻辑 Create

$ 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/zeromicro/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
}

6.4 添加支付详情逻辑 Detail

$ 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/zeromicro/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
}

6.5 添加支付回调逻辑 Callback

$ 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/zeromicro/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
}

7、启动 pay rpc 服务

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

$ cd mall/service/pay/rpc
$ go run pay.go -f etc/pay.yaml

有的人会报错

2022/03/10 10:00:30 {"@timestamp":"2022-03-10T10:00:30.357+08:00","level":"error","content":"discovbuilder.go:33 bad resolver state"}
2022/03/10 10:00:33 rpc dial: discov://etcd:2379/user.rpc, error: context deadline exceeded, make sure rpc service "user.rpc" is already started
exit status 1

在这里插入图片描述

这是要求我们开启 user.rpc 的服务（参考：学习笔记：带你十天轻松搞定 Go 微服务系列（三）- 用户服务）

接着运行$ go run pay.go -f etc/pay.yaml接着报错

2022/03/10 10:03:07 {"@timestamp":"2022-03-10T10:03:07.705+08:00","level":"error","content":"discovbuilder.go:33 bad resolver state"}
2022/03/10 10:03:10 rpc dial: discov://etcd:2379/order.rpc, error: context deadline exceeded, make sure rpc service "order.rpc" is already started
exit status 1

这是要求我们开启 order.rpc 的服务（参考：学习笔记：带你十天轻松完搞定 Go 微服务系列（五）- 订单服务）

运行订单服务的order.rpc会报错如下：

2022/03/10 10:04:10 {"@timestamp":"2022-03-10T10:04:10.415+08:00","level":"error","content":"discovbuilder.go:33 bad resolver state"}
2022/03/10 10:04:13 rpc dial: discov://etcd:2379/product.rpc, error: context deadline exceeded, make sure rpc service "product.rpc" is already started
exit status 1

在这里插入图片描述

这是要求我们开启 product.rpc 的服务（参考：学习笔记：带你十天轻松完搞定 Go 微服务系列（四）- 产品服务）

再运行$ go run pay.go -f etc/pay.yaml，出现 Starting rpc server at 127.0.0.1:9003…就证明没问题了，如下图：
在这里插入图片描述

8、启动 pay api 服务

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

$ cd mall/service/pay/api
$ go run pay.go -f etc/pay.yaml

出现 Starting server at 0.0.0.0:8003…就证明没问题了，如下图：

在这里插入图片描述

9、系列

学习笔记：带你十天轻松搞定 Go 微服务系列（一）- 环境搭建
学习笔记：带你十天轻松搞定 Go 微服务系列（二）- 服务拆分
学习笔记：带你十天轻松搞定 Go 微服务系列（三）- 用户服务
学习笔记：带你十天轻松搞定 Go 微服务系列（四）- 产品服务
学习笔记：带你十天轻松搞定 Go 微服务系列（五）- 订单服务
学习笔记：带你十天轻松搞定 Go 微服务系列（六）- 支付服务
学习笔记：带你十天轻松搞定 Go 微服务系列（七）- RPC 服务 Auth 验证
学习笔记：带你十天轻松搞定 Go 微服务系列（八）- 服务监控
学习笔记：带你十天轻松搞定 Go 微服务系列（九）- 链路追踪
学习笔记：带你十天轻松搞定 Go 微服务系列大结局（十）- 分布式事务

本文作者：Dancing-Pierre

本文链接：https://www.cnblogs.com/wyc-1009/p/17548111.html

版权声明：本作品采用知识共享署名-非商业性使用-禁止演绎 2.5 中国大陆许可协议进行许可。

posted @   Dancing-Pierre  阅读(28)  评论(0)  编辑  收藏  举报  
点击右上角即可分享
微信分享提示
AI IDE Trae
评论
收藏
关注
推荐
深色
回顶
收起