AI 助理
备案控制台
开发者社区 数据库 文章 正文

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

2024-08-27 30
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
云数据库 Redis 版，标准版 2GB
推荐场景：
搭建游戏排行榜
RDS MySQL Serverless 基础系列，0.5-2RCU 50GB
推荐场景：
学生管理系统数据库设计 搭建个人博客
云原生内存数据库 Tair，内存型 2GB
推荐场景：
通过缓存加速数据库访问
简介： 带你十天轻松搞定 Go 微服务系列（六）

序言

我们通过一个系列文章跟大家详细展示一个 go-zero 微服务示例，整个系列分十篇文章，目录结构如下：

  1. 环境搭建：带你十天轻松搞定 Go 微服务系列（一）
  2. 服务拆分：带你十天轻松搞定 Go 微服务系列（二）
  3. 用户服务：带你十天轻松搞定 Go 微服务系列（三）
  4. 产品服务：带你十天轻松搞定 Go 微服务系列（四）
  5. 订单服务：带你十天轻松搞定 Go 微服务系列（五）
  6. 支付服务（本文）
  7. RPC 服务 Auth 验证
  8. 服务监控
  9. 链路追踪
  10. 分布式事务

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

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

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

6 支付服务（pay）

  • 进入服务工作区
$ cd mall/service/pay

6.1 生成 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;
  • 运行模板生成命令
$ goctl model mysql ddl -src ./model/pay.sql -dir ./model -c

6.2 生成 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)
}
  • 运行模板生成命令
$ goctl api go -api ./api/pay.api -dir ./api

6.3 生成 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);
}
  • 运行模板生成命令
$ goctl rpc proto -src ./rpc/pay.proto -dir ./rpc

6.4 编写 pay rpc 服务

6.4.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
  Pass:

6.4.2 添加 pay 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
}
  • 注册服务上下文 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),
 }
}

6.4.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/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)),
 }
}

6.4.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
 }
}
......
  • 添加支付创建逻辑
    支付流水创建流程，通过调用 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
}

6.4.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/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
}

6.4.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/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
}

6.5 编写 pay api 服务

6.5.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.5.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/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)),
 }
}

6.5.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/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
}

6.5.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/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
}

6.5.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/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
}

6.6 启动 pay rpc 服务

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

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

6.7 启动 pay api 服务

提示：启动服务需要在 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

文章标签：
云数据库 Tair（兼容 Redis）
云数据库 RDS MySQL 版
Go
微服务
API
关系型数据库
MySQL
关键词：
Go微服务
相关实践学习
基于Redis实现在线游戏积分排行榜
本场景将介绍如何基于Redis数据库实现在线游戏中的游戏玩家积分排行榜功能。
云数据库 Redis 版使用教程
云数据库Redis版是兼容Redis协议标准的、提供持久化的内存数据库服务，基于高可靠双机热备架构及可无缝扩展的集群架构，满足高读写性能场景及容量需弹性变配的业务需求。 产品详情：https://www.aliyun.com/product/kvstore     ------------------------------------------------------------------------- 阿里云数据库体验：数据库上云实战 开发者云会免费提供一台带自建MySQL的源数据库 ECS 实例和一台目标数据库 RDS实例。跟着指引，您可以一步步实现将ECS自建数据库迁移到目标数据库RDS。 点击下方链接，领取免费ECS&RDS资源，30分钟完成数据库上云实战！https://developer.aliyun.com/adc/scenario/51eefbd1894e42f6bb9acacadd3f9121?spm=a2c6h.13788135.J_3257954370.9.4ba85f24utseFl
1603458909890196
目录
相关文章
1603458909890196
|
23天前
|
监控 Go 微服务
带你十天轻松搞定 Go 微服务系列全集+勘误
带你十天轻松搞定 Go 微服务系列全集+勘误
1603458909890196
26 2
1603458909890196
|
23天前
|
存储 监控 Go
带你十天轻松搞定 Go 微服务系列（九、链路追踪）
带你十天轻松搞定 Go 微服务系列（九、链路追踪）
1603458909890196
29 2
1603458909890196
|
23天前
|
消息中间件 人工智能 供应链
go-zero 微服务实战系列（二、服务拆分）
go-zero 微服务实战系列（二、服务拆分）
1603458909890196
57 1
1603458909890196
|
23天前
|
关系型数据库 MySQL Go
带你十天轻松搞定 Go 微服务系列（四）
带你十天轻松搞定 Go 微服务系列（四）
1603458909890196
28 1
1603458909890196
|
23天前
|
NoSQL Go API
带你十天轻松搞定 Go 微服务系列（七）
带你十天轻松搞定 Go 微服务系列（七）
1603458909890196
22 0
1603458909890196
|
23天前
|
关系型数据库 Go API
带你十天轻松搞定 Go 微服务系列（三）
带你十天轻松搞定 Go 微服务系列（三）
1603458909890196
25 0
叫个什么名字
|
17天前
|
缓存 安全 Java
如何利用Go语言提升微服务架构的性能
在当今的软件开发中，微服务架构逐渐成为主流选择，它通过将应用程序拆分为多个小服务来提升灵活性和可维护性。然而，如何确保这些微服务高效且稳定地运行是一个关键问题。Go语言，以其高效的并发处理能力和简洁的语法，成为解决这一问题的理想工具。本文将探讨如何通过Go语言优化微服务架构的性能，包括高效的并发编程、内存管理技巧以及如何利用Go生态系统中的工具来提升服务的响应速度和资源利用率。
叫个什么名字
25 3
1603458909890196
|
23天前
|
消息中间件 缓存 Kafka
go-zero微服务实战系列（八、如何处理每秒上万次的下单请求）
go-zero微服务实战系列（八、如何处理每秒上万次的下单请求）
1603458909890196
50 2
1603458909890196
|
23天前
|
监控 Go API
带你十天轻松搞定 Go 微服务之大结局（分布式事务）
带你十天轻松搞定 Go 微服务之大结局（分布式事务）
1603458909890196
31 2
1603458909890196
|
23天前
|
缓存 NoSQL Redis
go-zero微服务实战系列（七、请求量这么高该如何优化）
go-zero微服务实战系列（七、请求量这么高该如何优化）
1603458909890196
59 1

热门文章

最新文章

  • 1
    简析Go与其他语言不同的类型
  • 2
    Go 第三方 log 库之 logrus 使用
  • 3
    Golang之继承模拟
  • 4
    Go语言，互斥锁使用
  • 5
    对于云原生时代的后端业务开发和项目系统学习，选Go Or Java？
  • 6
    [典藏版]Golang三色标记+混合写屏障GC模式全分析
  • 7
    golang的filepath包的几个函数的细微区别
  • 8
    开启Golang编程第一章
  • 9
    go语言多态接口样例
  • 10
    go-项目配置govendor【详细教程】
  • 1
    Go语言：多重返回值的神奇之处
    86
  • 2
    什么是协程（Goroutine）？探索Go语言并发的奇妙世界
    62
  • 3
    Go语言中如何判断map中是否包含某个key？
    617
  • 4
    Go语言中tag的用处及详细介绍
    157
  • 5
    Go语言中的int和int32：同一个概念吗？
    402
  • 6
    Go语言的接口比较：两个interface能否比较？
    402
  • 7
    Go语言GC(垃圾回收)的工作原理
    125
  • 8
    Go语言协程泄漏(Goroutine Leak)：原因和解决方案
    402
  • 9
    Go面向对象是如何实现的？
    63
  • 10
    Go中的GMP状态详解
    89

    • 相关课程

    更多
  • Go语言核心编程 - 数据结构和算法
  • Go语言核心编程 - 基础语法、数组、切片、Map
  • Go语言核心编程 - 面向对象、文件、单元测试、反射、TCP编程
  • Go语言完全自学手册图文教程
  • 阿里云K8S微服务部署案例
  • 开源微服务最佳实践

    • 相关电子书

    更多
  • Go语言路上踩过的坑
  • gohbase ：HBase go客户端
  • Go构建日请求千亿级微服务实践

    • 相关实验场景

    更多
  • 通过EDAS实现K8s微服务应用的金丝雀发布
  • SAE极速部署弹性微服务商城
  • 基于MSE实现微服务的全链路灰度
  • 星轨SOP编排中心实战课程
  • RocketMQ的常规运维实践应用
  • 基于云原生网关实现微服务的多版本线上灰度
    • 下一篇
    基于LNMP搭建WordPress