Golang语言怎么使用go-micro和gin开发微服务？

01  介绍

Go Micro 是一个分布式系统开发框架。Go Micro 提供了分布式系统开发的核心需求，包括 RPC 和事件驱动的通信。Gin 是一个用 Golang 编写的 web 框架。本文首先介绍怎么使用 go-micro 和 go-grpc 构建微服务，然后再介绍怎么集成 gin 和 go-micro。我们使用的 go-micro 版本是 v1.18.0，golang 版本是 v1.13，gin 版本是 v1.7.2。

成都网站制作、网站设计、外贸网站建设服务团队是一支充满着热情的团队，执着、敏锐、追求更好，是创新互联的标准与要求，同时竭诚为客户提供服务是我们的理念。创新互联把每个网站当做一个产品来开发，精雕细琢，追求一名工匠心中的细致，我们更用心！

02  使用 go-micro 和 go-grpc 构建微服务

在我们开始使用 go-micro 之前，我们还需要提前做一些准备工作。安装 protoc、protoc-gen-go 和 protoc-gen-micro，关于如何安装，读者朋友们可以参阅官方文档，我们在之前的文章中也介绍过，限于篇幅，本文不再赘述。

其实，我们可以使用 Go Micro 工具集以命令的方式快速生成模板文件，但是因为本文我们不准备介绍工具集的相关内容，所以我们使用手动创建文件的方式。

下面我们正式开始介绍如何构建服务，包括服务端服务和客户端服务。

服务端

服务端代码目录：

 
 
 
    
  
  
  
  1. ├── go.mod 
    2. 
  
  
  
  2. ├── go.sum 
    3. 
  
  
  
  3. ├── handler 
    4. 
  
  
  
  4. │   └── user 
    5. 
  
  
  
  5. │       └── user.go 
    6. 
  
  
  
  6. ├── main.go 
    7. 
  
  
  
  7. └── proto 
    8. 
  
  
  
  8.     └── user 
    9. 
  
  
  
  9.         ├── user.pb.go 
    10. 
  
  
  
  10.         ├── user.pb.micro.go 
    11. 
  
  
  
  11.         └── user.proto 
    12.

构建服务端服务，分为以下几个步骤：

  1. 编写 protobuf 文件

    第一步是编写 protobuf 文件，一般会将不同 package 的 protobuf 文件存放在单独的文件目录中。

    文件路径： proto/user/user.proto

       
   
   
      
    
    
    
    1. syntax = "proto3"; 
      2. 
    
    
    
    2.  
      3. 
    
    
    
    3. package user; 
      4. 
    
    
    
    4.  
      5. 
    
    
    
    5. service User { 
      6. 
    
    
    
    6.   rpc Login(LoginRequest) returns (LoginResponse) {} 
      7. 
    
    
    
    7. } 
      8. 
    
    
    
    8.  
      9. 
    
    
    
    9. message LoginRequest { 
      10. 
    
    
    
    10.   string email = 1; 
      11. 
    
    
    
    11.   string password = 2; 
      12. 
    
    
    
    12. } 
      13. 
    
    
    
    13.  
      14. 
    
    
    
    14. message LoginResponse { 
      15. 
    
    
    
    15.   string username = 1; 
      16. 
    
    
    
    16. } 
      17.

    阅读上面这段代码，我们在定义的 user.proto 文件中，创建了一个 rpc 服务。

  2. 生成文件

    第二步是生成文件，使用命令：

       
   
   
      
    
    
    
    1. protoc --proto_path=. --micro_out=. --go_out=. user.proto 
      2.

    执行以上命令，将会自动生成两个文件，分别是 user.pb.go 和  user.micro.go 。

    阅读 user.micro.go 文件，可以发现在该文件中已经自动生成了客户端和服务端的代码。

  3. 编写 handler

    第三步是编写服务端的 handler 代码。

    文件路径： handler/user/user.go

       
   
   
      
    
    
    
    1. type User struct{} 
      2. 
    
    
    
    2.  
      3. 
    
    
    
    3. func (u *User) Login(ctx context.Context, req *protoUser.LoginRequest, rsp *protoUser.LoginResponse) error { 
      4. 
    
    
    
    4.   if req.Email != "gopher@88.com" || req.Password != "123456" { 
      5. 
    
    
    
    5.     rsp.Username = "Sorry " + req.Email 
      6. 
    
    
    
    6.     return nil 
      7. 
    
    
    
    7.   } 
      8. 
    
    
    
    8.   rsp.Username = "Welcome " + req.Email 
      9. 
    
    
    
    9.   return nil 
      10. 
    
    
    
    10. } 
      11.

  4. 定义服务端服务

    第四步是定义服务端服务，需要注意的是，这里使用的是 grpc。在 main.go 文件中编写如下代码：

    文件路径： main.go

       
   
   
      
    
    
    
    1. func main() { 
      2. 
    
    
    
    2.   // 创建服务 
      3. 
    
    
    
    3.   service := grpc.NewService( 
      4. 
    
    
    
    4.     micro.Name("go.micro.srv.demo"), 
      5. 
    
    
    
    5.     micro.Version("v0.0.0"), 
      6. 
    
    
    
    6.     micro.RegisterTTL(time.Second * 10), 
      7. 
    
    
    
    7.     micro.RegisterInterval(time.Second * 5), 
      8. 
    
    
    
    8.   ) 
      9. 
    
    
    
    9.   // 注册处理器 
      10. 
    
    
    
    10.   err := protoUser.RegisterUserHandler(service.Server(), new(user.User)) 
      11. 
    
    
    
    11.   if err !=nil { 
      12. 
    
    
    
    12.     log.Fatal(err) 
      13. 
    
    
    
    13.   } 
      14. 
    
    
    
    14.   // 运行服务 
      15. 
    
    
    
    15.   if err = service.Run(); err != nil { 
      16. 
    
    
    
    16.     log.Fatal(err) 
      17. 
    
    
    
    17.   } 
      18. 
    
    
    
    18. } 
      19.

完成以上 4 个步骤，我们就已经实现了服务端 rpc 服务，接下来，我们开始编写客户端代码。

客户端

客户端代码目录：

 
 
 
    
  
  
  
  1. ├── go.mod 
    2. 
  
  
  
  2. ├── go.sum 
    3. 
  
  
  
  3. ├── main.go 
    4. 
  
  
  
  4. ├── proto 
    5. 
  
  
  
  5. │   └── user 
    6. 
  
  
  
  6. │       ├── user.pb.go 
    7. 
  
  
  
  7. │       ├── user.pb.micro.go 
    8. 
  
  
  
  8. │       └── user.proto 
    9. 
  
  
  
  9. └── router 
    10. 
  
  
  
  10.     ├── router.go 
    11. 
  
  
  
  11.     └── v1 
    12. 
  
  
  
  12.         └── user.go 
    13.

构建客户端服务，分为以下几个步骤：

  1. 拷贝 proto 文件和生成文件

    第一步是拷贝服务端的 proto 文件和生成文件，目的是为了保证服务端和客户端的类型一致性。

  2. 定义客户端服务

    第二步是定义客户端：

    文件路径： router/v1/user.go

       
   
   
      
    
    
    
    1. func NewUserClient() protoUser.UserService { 
      2. 
    
    
    
    2.   // 创建服务 
      3. 
    
    
    
    3.   service := grpc.NewService() 
      4. 
    
    
    
    4.  
      5. 
    
    
    
    5.   // 创建客户端 
      6. 
    
    
    
    6.   userClient := protoUser.NewUserService("go.micro.srv.demo", service.Client()) 
      7. 
    
    
    
    7.  
      8. 
    
    
    
    8.   return userClient 
      9. 
    
    
    
    9. } 
      10.

  3. rpc 调用远程服务的方法

    第三步是 rpc 调用远程服务的方法：

    文件路径： router/v1/user.go

       
   
   
      
    
    
    
    1. client := NewUserClient() 
      2. 
    
    
    
    2.  
      3. 
    
    
    
    3. // rpc 调用远程服务的方法 
      4. 
    
    
    
    4. resp, err := client.Login(context.TODO(), &protoUser.LoginRequest{Email: param.Email, Password: param.Password}) 
      5. 
    
    
    
    5. if err != nil { 
      6. 
    
    
    
    6.   fmt.Println(err) 
      7. 
    
    
    
    7. } 
      8.

完成以上 3 步，我们就已经基本编写完客户端的代码。

03  gin 和 go-micro 集成

接下来，我们介绍如何集成 gin 和 go-micro，该部分代码也是在客户端中，共需要两个步骤。

  1. 创建路由

    文件路径： router/router.go

       
   
   
      
    
    
    
    1. func NewRouter() *gin.Engine { 
      2. 
    
    
    
    2.   r := gin.New() 
      3. 
    
    
    
    3.    
      4. 
    
    
    
    4.   userControllerV1 := new(v1.User) 
      5. 
    
    
    
    5.  
      6. 
    
    
    
    6.   // 路由分组 
      7. 
    
    
    
    7.   v1 := r.Group("/v1") 
      8. 
    
    
    
    8.   { 
      9. 
    
    
    
    9.     v1.Use(gin.Logger(), gin.Recovery()) 
      10. 
    
    
    
    10.     userV1 := v1.Group("/user") 
      11. 
    
    
    
    11.     { 
      12. 
    
    
    
    12.       userV1.POST("/login", userControllerV1.Login) 
      13. 
    
    
    
    13.     } 
      14. 
    
    
    
    14.   } 
      15. 
    
    
    
    15.  
      16. 
    
    
    
    16.   return r 
      17. 
    
    
    
    17. } 
      18.

  2. 启动（监听）服务

    文件路径： main.go

       
   
   
      
    
    
    
    1. func main() { 
      2. 
    
    
    
    2.   r := router.NewRouter() 
      3. 
    
    
    
    3.   server := &http.Server{ 
      4. 
    
    
    
    4.     Addr:           ":8080", 
      5. 
    
    
    
    5.     Handler:        r, 
      6. 
    
    
    
    6.     ReadTimeout:    time.Second * 10, 
      7. 
    
    
    
    7.     WriteTimeout:   time.Second * 10, 
      8. 
    
    
    
    8.     MaxHeaderBytes: 1 << 20, 
      9. 
    
    
    
    9.   } 
      10. 
    
    
    
    10.   if err := server.ListenAndServe(); err != nil { 
      11. 
    
    
    
    11.     log.Fatal(err) 
      12. 
    
    
    
    12.   } 
      13. 
    
    
    
    13. } 
      14.

至此，我们已经完成了集成 gin 和 go-micro，启动服务端服务和客户端服务后，我们就可以使用以下命令进行 cURL 测试：

 
 
 
    
  
  
  
  1. curl --location --request POST 'http://127.0.0.1:8080/v1/user/login' \ 
    2. 
  
  
  
  2. --header 'Content-Type: application/json' \ 
    3. 
  
  
  
  3. --data-raw '{ 
    4. 
  
  
  
  4.     "email": "gopher@88.com", 
    5. 
  
  
  
  5.     "password": "123456" 
    6. 
  
  
  
  6. }' 
    7.

04  总结

本文我们主要介绍怎么使用 go-micro 和 go-grpc 构建微服务，和怎么集成 gin 和 go-micro，并没有介绍 gin 和 go-micro 的使用方法，如果读者朋友们还不了解 gin 和 go-micro，建议先阅读 gin 和 go-micro 官方文档，也可以参考公众号之前推送的关于 gin 的文章。

本文题目：Golang语言怎么使用go-micro和gin开发微服务？
分享路径：http://www.csdahua.cn/qtweb/news28/146178.html

网站建设、网络推广公司-快上网，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 快上网

成都快上网为您推荐相关内容

移动网站建设知识

行业网站建设

手机app　　 　正泰动物　　 　宜宾做网站　　 　乐山服务器托管　　 　成都网站改版　　 　一元广告　　 　成都网站制作　　 　设计网站　　 　虚拟主机　　 　网站建设报价方案　　 　双流网站建设　　 　广汉锦华橡塑　　 　网站空间　　 　成都塑料加工　　 　绵阳机房托管　　 　成都网络公司　　 　成都品牌网站建设　　 　西信中心　　 　成都宣传海报　　 　绵阳梓潼网站建设