AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

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

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

序言

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

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

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

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

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

4. 产品服务（product）

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

4.1 生成 product model 模型

  • 创建 sql 文件
$ vim model/product.sql
  • 编写 sql 文件
CREATE TABLE `product` (
 `id` bigint unsigned NOT NULL AUTO_INCREMENT,
 `name` varchar(255)  NOT NULL DEFAULT '' COMMENT '产品名称',
 `desc` varchar(255)  NOT NULL DEFAULT '' COMMENT '产品描述',
        `stock` int(10) unsigned NOT NULL DEFAULT '0' COMMENT '产品库存',
 `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`)
) ENGINE=InnoDB  DEFAULT CHARSET=utf8mb4;
  • 运行模板生成命令
$ goctl model mysql ddl -src ./model/product.sql -dir ./model -c

4.2 生成 product api 服务

  • 创建 api 文件
$ vim api/product.api
  • 编写 api 文件
type (
 // 产品创建
 CreateRequest {
  Name   string `json:"name"`
  Desc   string `json:"desc"`
  Stock  int64  `json:"stock"`
  Amount int64  `json:"amount"`
  Status int64  `json:"status"`
 }
 CreateResponse {
  Id int64 `json:"id"`
 }
 // 产品创建
 // 产品修改
 UpdateRequest {
  Id     int64  `json:"id"`
  Name   string `json:"name,optional"`
  Desc   string `json:"desc,optional"`
  Stock  int64  `json:"stock"`
  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"`
  Name   string `json:"name"`
  Desc   string `json:"desc"`
  Stock  int64  `json:"stock"`
  Amount int64  `json:"amount"`
  Status int64  `json:"status"`
 }
 // 产品详情
)
@server(
 jwt: Auth
)
service Product {
 @handler Create
 post /api/product/create(CreateRequest) returns (CreateResponse)
 
 @handler Update
 post /api/product/update(UpdateRequest) returns (UpdateResponse)
 
 @handler Remove
 post /api/product/remove(RemoveRequest) returns (RemoveResponse)
 
 @handler Detail
 post /api/product/detail(DetailRequest) returns (DetailResponse)
}
  • 运行模板生成命令
$ goctl api go -api ./api/product.api -dir ./api

4.3 生成 product rpc 服务

  • 创建 proto 文件
$ vim rpc/product.proto
  • 编写 proto 文件
syntax = "proto3";
package productclient;
option go_package = "product";
// 产品创建
message CreateRequest {
    string Name = 1;
    string Desc = 2;
    int64 Stock = 3;
    int64 Amount = 4;
    int64 Status = 5;
}
message CreateResponse {
  int64 id = 1;
}
// 产品创建
// 产品修改
message UpdateRequest {
    int64 id = 1;
    string Name = 2;
    string Desc = 3;
    int64 Stock = 4;
    int64 Amount = 5;
    int64 Status = 6;
}
message UpdateResponse {
}
// 产品修改
// 产品删除
message RemoveRequest {
    int64 id = 1;
}
message RemoveResponse {
}
// 产品删除
// 产品详情
message DetailRequest {
    int64 id = 1;
}
message DetailResponse {
    int64 id = 1;
    string Name = 2;
    string Desc = 3;
    int64 Stock = 4;
    int64 Amount = 5;
    int64 Status = 6;
}
// 产品详情
service Product {
    rpc Create(CreateRequest) returns(CreateResponse);
    rpc Update(UpdateRequest) returns(UpdateResponse);
    rpc Remove(RemoveRequest) returns(RemoveResponse);
    rpc Detail(DetailRequest) returns(DetailResponse);
}
  • 运行模板生成命令
$ goctl rpc proto -src ./rpc/product.proto -dir ./rpc

4.4 编写 product rpc 服务

4.4.1 修改配置文件

  • 修改 product.yaml 配置文件
$ vim rpc/etc/product.yaml
  • 修改服务监听地址，端口号为0.0.0.0:9001，Etcd 服务配置，Mysql 服务配置，CacheRedis 服务配置
Name: product.rpc
ListenOn: 0.0.0.0:9001
Etcd:
  Hosts:
  - etcd:2379
  Key: product.rpc
Mysql:
  DataSource: root:123456@tcp(mysql:3306)/mall?charset=utf8mb4&parseTime=true&loc=Asia%2FShanghai
CacheRedis:
- Host: redis:6379
  Type: node # node可以不写，可以设为cluster
  # Pass: xxx # 如果有密码

4.4.2 添加 product 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
}
  • 注册服务上下文 product model 的依赖
$ vim rpc/internal/svc/servicecontext.go
package svc
import (
 "mall/service/product/model"
 "mall/service/product/rpc/internal/config"
 "github.com/tal-tech/go-zero/core/stores/sqlx"
)
type ServiceContext struct {
 Config config.Config
    
 ProductModel model.ProductModel
}
func NewServiceContext(c config.Config) *ServiceContext {
 conn := sqlx.NewMysql(c.Mysql.DataSource)
 return &ServiceContext{
  Config:       c,
  ProductModel: model.NewProductModel(conn, c.CacheRedis),
 }
}

4.4.3 添加产品创建逻辑 Create

$ vim rpc/internal/logic/createlogic.go
package logic
import (
 "context"
 "mall/service/product/model"
 "mall/service/product/rpc/internal/svc"
 "mall/service/product/rpc/product"
 "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 *product.CreateRequest) (*product.CreateResponse, error) {
 newProduct := model.Product{
  Name:   in.Name,
  Desc:   in.Desc,
  Stock:  in.Stock,
  Amount: in.Amount,
  Status: in.Status,
 }
 res, err := l.svcCtx.ProductModel.Insert(&newProduct)
 if err != nil {
  return nil, status.Error(500, err.Error())
 }
 newProduct.Id, err = res.LastInsertId()
 if err != nil {
  return nil, status.Error(500, err.Error())
 }
 return &product.CreateResponse{
  Id: newProduct.Id,
 }, nil
}

4.4.4 添加产品详情逻辑 Detail

$ vim rpc/internal/logic/detaillogic.go
package logic
import (
 "context"
 "mall/service/product/model"
 "mall/service/product/rpc/internal/svc"
 "mall/service/product/rpc/product"
 "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 *product.DetailRequest) (*product.DetailResponse, error) {
 // 查询产品是否存在
 res, err := l.svcCtx.ProductModel.FindOne(in.Id)
 if err != nil {
  if err == model.ErrNotFound {
   return nil, status.Error(100, "产品不存在")
  }
  return nil, status.Error(500, err.Error())
 }
 return &product.DetailResponse{
  Id:     res.Id,
  Name:   res.Name,
  Desc:   res.Desc,
  Stock:  res.Stock,
  Amount: res.Amount,
  Status: res.Status,
 }, nil
}

4.4.5 添加产品更新逻辑 Update

$ vim rpc/internal/logic/updatelogic.go
package logic
import (
 "context"
 "mall/service/product/model"
 "mall/service/product/rpc/internal/svc"
 "mall/service/product/rpc/product"
 "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 *product.UpdateRequest) (*product.UpdateResponse, error) {
 // 查询产品是否存在
 res, err := l.svcCtx.ProductModel.FindOne(in.Id)
 if err != nil {
  if err == model.ErrNotFound {
   return nil, status.Error(100, "产品不存在")
  }
  return nil, status.Error(500, err.Error())
 }
 if in.Name != "" {
  res.Name = in.Name
 }
 if in.Desc != "" {
  res.Desc = in.Desc
 }
 if in.Stock != 0 {
  res.Stock = in.Stock
 }
 if in.Amount != 0 {
  res.Amount = in.Amount
 }
 if in.Status != 0 {
  res.Status = in.Status
 }
 err = l.svcCtx.ProductModel.Update(res)
 if err != nil {
  return nil, status.Error(500, err.Error())
 }
 return &product.UpdateResponse{}, nil
}

4.4.6 添加产品删除逻辑 Remove

$ vim rpc/internal/logic/removelogic.go
package logic
import (
 "context"
 "mall/service/product/model"
 "mall/service/product/rpc/internal/svc"
 "mall/service/product/rpc/product"
 "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 *product.RemoveRequest) (*product.RemoveResponse, error) {
 // 查询产品是否存在
 res, err := l.svcCtx.ProductModel.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.ProductModel.Delete(res.Id)
 if err != nil {
  return nil, status.Error(500, err.Error())
 }
 return &product.RemoveResponse{}, nil
}

4.5 编写 product api 服务

4.5.1 修改配置文件

  • 修改 product.yaml 配置文件
$ vim api/etc/product.yaml
  • 修改服务地址，端口号为0.0.0.0:8001，Mysql 服务配置，CacheRedis 服务配置，Auth 验证配置
Name: Product
Host: 0.0.0.0
Port: 8001
Mysql:
  DataSource: root:123456@tcp(mysql:3306)/mall?charset=utf8mb4&parseTime=true&loc=Asia%2FShanghai
CacheRedis:
- Host: redis:6379
  Type: node # node可以不写，可以设为cluster
  # Pass: xxx # 如果有密码
Auth:
  AccessSecret: uOvKLmVfztaXGpNYd4Z0I1SiT7MweJhl
  AccessExpire: 86400

4.5.2 添加 product rpc 依赖

  • 添加 product rpc 服务配置
$ vim api/etc/product.yaml
Name: Product
Host: 0.0.0.0
Port: 8001
...
ProductRpc:
  Etcd:
    Hosts:
    - etcd:2379
    Key: product.rpc
  • 添加 product 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
 }
 ProductRpc zrpc.RpcClientConf
}
  • 注册服务上下文 product rpc 的依赖
$ vim api/internal/svc/servicecontext.go
package svc
import (
 "mall/service/product/api/internal/config"
 "mall/service/product/rpc/productclient"
 "github.com/tal-tech/go-zero/zrpc"
)
type ServiceContext struct {
 Config config.Config
    
 ProductRpc productclient.Product
}
func NewServiceContext(c config.Config) *ServiceContext {
 return &ServiceContext{
  Config:     c,
  ProductRpc: productclient.NewProduct(zrpc.MustNewClient(c.ProductRpc)),
 }
}

4.5.3 添加产品创建逻辑 Create

$ vim api/internal/logic/createlogic.go
package logic
import (
 "context"
 "mall/service/product/api/internal/svc"
 "mall/service/product/api/internal/types"
 "mall/service/product/rpc/product"
 "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.ProductRpc.Create(l.ctx, &product.CreateRequest{
  Name:   req.Name,
  Desc:   req.Desc,
  Stock:  req.Stock,
  Amount: req.Amount,
  Status: req.Status,
 })
 if err != nil {
  return nil, err
 }
 return &types.CreateResponse{
  Id: res.Id,
 }, nil
}

4.5.4 添加产品详情逻辑 Detail

$ vim api/internal/logic/detaillogic.go
package logic
import (
 "context"
 "mall/service/product/api/internal/svc"
 "mall/service/product/api/internal/types"
 "mall/service/product/rpc/product"
 "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.ProductRpc.Detail(l.ctx, &product.DetailRequest{
  Id: req.Id,
 })
 if err != nil {
  return nil, err
 }
 return &types.DetailResponse{
  Id:     res.Id,
  Name:   res.Name,
  Desc:   res.Desc,
  Stock:  res.Stock,
  Amount: res.Amount,
  Status: res.Status,
 }, nil
}

4.5.5 添加产品更新逻辑 Update

$ vim api/internal/logic/updatelogic.go
package logic
import (
 "context"
 "mall/service/product/api/internal/svc"
 "mall/service/product/api/internal/types"
 "mall/service/product/rpc/product"
 "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.ProductRpc.Update(l.ctx, &product.UpdateRequest{
  Id:     req.Id,
  Name:   req.Name,
  Desc:   req.Desc,
  Stock:  req.Stock,
  Amount: req.Amount,
  Status: req.Status,
 })
 if err != nil {
  return nil, err
 }
 return &types.UpdateResponse{}, nil
}

4.5.6 添加产品删除逻辑 Remove

$ vim api/internal/logic/removelogic.go
package logic
import (
 "context"
 "mall/service/product/api/internal/svc"
 "mall/service/product/api/internal/types"
 "mall/service/product/rpc/product"
 "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.ProductRpc.Remove(l.ctx, &product.RemoveRequest{
  Id: req.Id,
 })
 if err != nil {
  return nil, err
 }
 return &types.RemoveResponse{}, nil
}

4.6 启动 product rpc 服务

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

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

4.7 启动 product api 服务

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

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

项目地址

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
30 0
带你十天轻松搞定 Go 微服务系列（六）
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