帶你十天輕鬆搞定 Go 微服務系列（五）
序言
我們通過一個系列文章跟大家詳細展示一個 go-zero 微服務示例，整個系列分十篇文章，目錄結構如下：
- 環境搭建
- 服務拆分
- 使用者服務
- 產品服務
- 訂單服務（本文）
- 支付服務
- RPC 服務 Auth 驗證
- 服務監控
- 鏈路追蹤
- 分散式事務
期望通過本系列帶你在本機利用 Docker 環境利用 go-zero 快速開發一個商城系統，讓你快速上手微服務。
完整示例程式碼：http://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:[email protected](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:[email protected](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...
專案地址
http://github.com/zeromicro/go-zero
http://gitee.com/kevwan/go-zero
歡迎使用 go-zero 並 star 支援我們！
微信交流群
關注『微服務實踐』公眾號並點選 交流群 獲取社群群二維碼。
「其他文章」
- 型別安全的 Go HTTP 請求
- 用 Go 快速開發一個 RESTful API 服務
- Go 專案配置檔案的定義和讀取
- 簡單易懂的 Go 泛型使用和實現原理介紹
- Go單體服務開發最佳實踐
- 通過 SingleFlight 模式學習 Go 併發程式設計
- 程序內優雅管理多個服務
- 構建 Go 應用 docker 映象的十八種姿勢
- 史上最強程式碼自測方法，沒有之一！
- 微服務從程式碼到k8s部署應有盡有大結局（k8s部署）
- 微服務從程式碼到k8s部署應有盡有系列（十四、部署環境搭建）
- 微服務從程式碼到k8s部署應有盡有系列（十三、服務監控）
- 微服務從程式碼到k8s部署應有盡有系列（十二、鏈路追蹤）
- 微服務從程式碼到k8s部署應有盡有系列（十一、日誌收集）
- 微服務從程式碼到k8s部署應有盡有系列（十、錯誤處理）
- 微服務從程式碼到k8s部署應有盡有系列（九、事務精講）
- 微服務從程式碼到k8s部署應有盡有系列（八、各種佇列）
- 微服務從程式碼到k8s部署應有盡有系列（七、支付服務）
- 微服務從程式碼到k8s部署應有盡有系列（五、民宿服務）
- 微服務從程式碼到k8s部署應有盡有系列（四、使用者中心）