go语言gRPC框架实战解析

矫情吗；* 2023-07-06 09:57 1阅读 0赞

### 1 grpc中的要点： ###

#### 1.1 grpc 是什么？ ####

grpc是一个服务器，用于定义服务，指定方法，客户端可以通过他直接调用不同服务器上的方法。轻松创建分布式服务。

#### 1.2 在代码中有什么用？ ####

实现客户端跨语言调用不同服务器服务端的方法

#### 1.3 proto buffers 是什么？ ####

proto buffer 称为协议缓冲区，用于定义结构化数据，并使用编译器，将数据生成指定语言的接口方法，其中包括客户端和服务器代码，还有其他序列化代码；

#### 1.4 proto buffers 如何定义和使用？ ####

结构化定义（定义方法和参数），参考：[Protocol Buffers官方文档][Protocol Buffers]  
由定义生成go代码，使用命令  
protoc --go\_out=. snowflake.proto  
或  
protoc --go\_out=plugins=grpc:. snowflake.proto  
或  
protoc -I proto --go\_out=plugins=grpc:proto proto/snowflake.proto  
其他语言转化  
protoc --proto\_path=IMPORT\_PATH --cpp\_out=DST\_DIR --java\_out=DST\_DIR --python\_out=DST\_DIR path/to/file.proto

### 2 grpc实战代码： ###

使用grpc完成GetName接口，从数据持久化到测试。

#### 2.1 数据库持久化层 ####

用于持久化数据库；实现最基础的底层GetName方法。

package service
    
    import (
    	"errors"
    	"github.com/gitstliu/go-id-worker"
    	"imcs/common/config"
    	"strconv"
    )
    
    var worker *idworker.IdWorker
    
    //初始化
    func init() { 
    	workerId := config.GetInt64("snowflake.worker-id")
    	dataCenterId := config.GetInt64("snowflake.data-center-id")
    	worker = &idworker.IdWorker{ }
    	if err := worker.InitIdWorker(workerId, dataCenterId); err != nil { 
    		panic(err)
    	}
    }
    func GetName(mess string) (string, error) { 
    	replee := "worker test +++" + mess
    	return replee, nil
    }

#### 2.2 业务层 ####

组合底层方法，实现业务功能。  
**注意：**  
server中的方法必须同下面proto buffer中定义的GetName方法一致。

package server
    
    import (
    	"context"
    	"errors"
    	"imcs/proto"
    	"imcs/snowflake/service"
    )
    
    //grpc server
    type SnowflakeGRPCServer struct { 
    }
    func (s *SnowflakeGRPCServer) GetName(ctx context.Context, request *proto.SnowflakeRequest) (*proto.SnowflakeResponse, error) { 
    	response := new(proto.SnowflakeResponse)
    	if request.Messs != "" { 
    		if replee, err := service.GetName(request.Messs); err == nil { 
    			response.Replee = replee
    		} else { 
    			return nil, err
    		}
    	} else { 
    		return nil, errors.New("The count should greater than 0!")
    	}
    	return response, nil
    }

#### 2.3 proto buffer 转化层 ####

定义客户端接口、服务端接口和代码语言，并完成调用；

syntax = "proto3"; // 最新版，支持多种语言转化
    option java_package = "cc.iooc.common.rpc.snowflake.proto";
    option java_multiple_files = true;
    
    package proto;
    
    service Snowflake {  // 定义服务方法
        rpc GetName (SnowflakeRequest) returns (SnowflakeResponse) { 
        }
    }
    
    //定义参数
    message SnowflakeRequest { 
        int32 count = 1;
        string messs = 2;
    }
    
    message SnowflakeResponse { 
        repeated string ids = 1;
        string replee = 2;
    }

然后，使用不同的proto buffer 实现接口的语言转化和代码的生成；  
操作：在proto文件同级目录下，使用命令  
protoc -I proto --go\_out=plugins=grpc:proto proto/snowflake.proto  
自动生成代码snowflake.pb.go

#### 2.4 客户接口层 ####

动态获取客户，调用转化层的GetName接口；

package client
    
    import (
    	"context"
    	"google.golang.org/grpc"
    	"imcs/common/config"
    	"imcs/common/log"
    	"imcs/common/rpc"
    	"imcs/proto"
    )
    
    type SnowflakeGRPCClient struct { 
    	Address string
    }
    func NewSnowflakeGRPCClient() *SnowflakeGRPCClient { 
    	return &SnowflakeGRPCClient{ Address: config.GetString("grpc.client.snowflake.address")}
    }
    
    func (s *SnowflakeGRPCClient) GetName(mess string) string { 
    	// 到grpc连接池获取当前客户的grpc连接
    	conn, err := rpc.GetConn(s.Address)
    	if err != nil { 
    		log.Errorf("snowflake client: %v", err)
    		return "nil"
    	}
    	// 方法最后，关闭连接
    	defer rpc.Close(s.Address, conn)
    	response, err := func(conn *grpc.ClientConn) (interface{ }, error) { 
    		// 调用grpc生成的客户端
    		client := proto.NewSnowflakeClient(conn)
    		// 调用grpc生成的接口及其实现方法
    		// 给proto生成的请求对象（SnowflakeRequest）的属性（Mess）设置值
    		response, err := client.GetName(context.Background(), &proto.SnowflakeRequest{ Messs: mess})
    		return response, err
    	}(conn)
    	if err != nil { 
    		log.Error(err)
    		return "nil"
    	}
    	// 从生成的相应对象（SnowflakeResponse）中获取属性值（Replee）作为返回值
    	return response.(*proto.SnowflakeResponse).Replee
    }

#### 2.5 测试层 ####

使用go语言自带的测试类，对客户端获取到的接口进行测试，包括：功能测试、压力测试。  
**注意：**  
测试文件的名称和测试方法的名称按规范来，请网上查询。

package client
    
    import (
    	"fmt"
    	"testing"
    )
    func TestGetName(t *testing.T) { 
    	model := NewSnowflakeGRPCClient()
    	fmt.Println(model.GetName("name test ====>"))
    }

#### 2.6.网关层 ####

用于微服务之间的调用和拦截。  
这层可以选配

package server
    
    import (
    	"context"
    	"encoding/json"
    	"errors"
    	"imcs/common/response"
    	"imcs/proto"
    	"imcs/snowflake/service"
    )
    
    //api server
    type SnowflakeApiServer struct { 
    }
    
    func (s *SnowflakeApiServer) Request(ctx context.Context, request *proto.GatewayRequest) (*proto.GatewayResponse, error) { 
    	resp := new(proto.GatewayResponse)
    	method := request.Method
    	params := map[string]interface{ }{ }
    	err := json.Unmarshal(request.Param, &params)
    	if err != nil { 
    		return nil, err
    	}
    	var baseResp *response.BaseResponse
    	switch method { 
    	case "snowflake.id":
    		baseResp, err = id()
    	case "snowflake.ids":
    		baseResp, err = ids(params)
    	case "snowflake.GetName":
    		baseResp, err = GetName(params)
    	default:
    		return nil, errors.New("snowflake method not found")
    	}
    	if err == nil { 
    		if respBytes, err := json.Marshal(*baseResp); err == nil { 
    			resp.Result = respBytes
    			return resp, nil
    		} else { 
    			return nil, err
    		}
    	}
    	return nil, err
    }
    
    func GetName(params map[string]interface{ }) (r *response.BaseResponse, err error) { 
    	countInter := params["mess"]
    	if mess, ok := countInter.(string); ok { 
    		if replee, e := service.GetName(mess); e != nil { 
    			err = e
    		} else { 
    			r = response.NewBaseResponseOkWithData(replee)
    		}
    	} else { 
    		err = errors.New("snowflake replee params error")
    	}
    	return
    }

[Protocol Buffers]: https://developers.google.cn/protocol-buffers/docs/proto?hl=en