55.手写实现grpc连接池以及gin和grpc交互

文章目录

  • 一、简介
    • 前置说明
  • 二、敏感词过滤服务
    • 1、定义sensitive.proto文件
    • 2、protoc生成pb.go文件
    • 3、sensitive服务端实现
  • 三、关键词匹配服务
    • 1、编写keywords.proto文件
    • 2、生成pb.go文件
    • 3、keywords服务端实现
  • 四、gin web 路由服务
    • 1、新建grpcpool服务作为gin web服务
    • 2、根据proto文件,分别生成keywords服务和sensitive服务的pb.go文件
  • 五、grpc 连接池实现
    • 1、连接池的实现,通过sync.Pool实现
    • 2、连接池的使用

代码地址: https://gitee.com/lymgoforIT/golang-trick/tree/master/33-grpc-pool

一、简介

当我们在使用需要连接的资源时,一般都应该想到可以通过池化的技术去做一定的性能优化。比如数据库连接池就是最常见的连接池。

在微服务中,服务与服务之间的通信也是需要建立连接的,如果需要频繁的交互,那么 建立连接池就可以避免每次交互都需要新建连接的性能消耗。

本案例就是要手写一个grpc的客户端连接池,整合到gin web服务中,而这个web服务需要频繁调用另外两个grpc远程服务,分别是关键词匹配服务和敏感词过滤服务(当然这里不会有很复杂的匹配和过滤上的业务逻辑,毕竟主要演示的是调用链路),链路大致如下:

55.手写实现grpc连接池以及gin和grpc交互_第1张图片

前置说明

  1. 因为本博客主要学习的是连接池的实现方法、grpc服务的开发、gin web服务的开发、以及gin web 服务调用远程grpc服务此外,该案例会包含三个服务,工作中一般这三个服务会在不同的服务器上,这里为了演示,就在同一个代码包下,通过不同的端口号模拟多个服务。
  2. gin web 服务调用grpc服务时,本案例中我们也没有用到服务注册与发现功能,而是在gin web服务中写死了grpc客户端

二、敏感词过滤服务

该服务就一个接口,接收一段文本,然后输出是否包含敏感词,为了简便,我们不真的校验是否包含敏感词,直接返回true即可。

1、定义sensitive.proto文件

syntax  = "proto3";
package sensitive;

option go_package = "33-grpc-pool/sensitive/proto";

message ValidateRequest{
    string input = 1;
}

message ValidateResponse {
    bool ok = 1;
    string word = 2;
}

service SensitiveFilter {
    rpc Validate(ValidateRequest) returns (ValidateResponse);
}

2、protoc生成pb.go文件

 protoc --proto_path=33-grpc-pool/sensitive/proto --go_out=. --go-grpc_out=. 33-grpc-pool/sensitive/proto/sensitive.proto

55.手写实现grpc连接池以及gin和grpc交互_第2张图片

3、sensitive服务端实现

编写服务端代码server.go

package server

import (
	"context"
	"fmt"
	"golang-trick/33-grpc-pool/sensitive/proto"
)

type SensitiveServer struct {
	proto.UnimplementedSensitiveFilterServer
}

func (s SensitiveServer) Validate(ctx context.Context, request *proto.ValidateRequest) (*proto.ValidateResponse, error) {
	fmt.Printf("%+v\n", request)
	// 我们直接认为没有敏感词,直接返回true,敏感词为空
	return &proto.ValidateResponse{
		Ok:   true,
		Word: "",
	}, nil
}

启动服务代码main.go

package main

import (
	"flag"
	"fmt"
	"golang-trick/33-grpc-pool/sensitive/proto"
	"golang-trick/33-grpc-pool/sensitive/sensitive-server/server"
	"log"
	"net"

	"google.golang.org/grpc"
)

var (
	port = flag.Int("port", 50051, "")
)

func main() {
	flag.Parse()
	// 监听端口
	lis, err := net.Listen("tcp", fmt.Sprintf(":%d", *port))
	if err != nil {
		log.Fatal(err)
	}

	// 建立rpc服务,并注册SensitiveServer
	s := grpc.NewServer()
	proto.RegisterSensitiveFilterServer(s, &server.SensitiveServer{})

	// 启动服务
	err = s.Serve(lis)
	if err != nil {
		log.Fatal(err)
	}
}

当前sensitive整体代码结构如下:
55.手写实现grpc连接池以及gin和grpc交互_第3张图片

三、关键词匹配服务

关键词匹配 服务,编码与上面的敏感词过滤服务几乎一模一样,主要就是改了proto文件以及服务的实现。但编码流程完全没变的。
我们写完后会发现,keywords服务sensitive服务的代码结构一致。再次强调一下,这里为了演示,所以两个微服务写到了一起,通过端口分为两个微服务启动,实际一般是不同的两个微服务项目,部署到不同的机器上的。
55.手写实现grpc连接池以及gin和grpc交互_第4张图片

1、编写keywords.proto文件

syntax  = "proto3";
package sensitive;

option go_package = "33-grpc-pool/keywords/proto";

message MatchRequest{
    string input = 1;
}

message MatchResponse {
    bool ok = 1;
    string word = 2;
}

service KeyWordsMatch {
    rpc Match(MatchRequest) returns (MatchResponse);
}

2、生成pb.go文件

注意命令中的路径和sensitive服务的有所不同,需要修改

protoc --proto_path=33-grpc-pool/keywords/proto --go_out=. --go-grpc_out=. 33-grpc-pool/keywords/proto/keywords.proto

3、keywords服务端实现

编写服务端代码server.go

package server

import (
	"context"
	"fmt"
	"golang-trick/33-grpc-pool/keywords/proto"
)

type KwServer struct {
	proto.UnimplementedKeyWordsMatchServer
}

func (k KwServer) Match(ctx context.Context, request *proto.MatchRequest) (*proto.MatchResponse, error) {
	fmt.Printf("%+v\n", request)
	// 我们直接认为没有敏感词,直接返回true,敏感词为空
	return &proto.MatchResponse{
		Ok:   true,
		Word: "",
	}, nil
}

服务启动代码main.go

注意端口换为了50052,sensitive服务的是50051

package main

import (
	"flag"
	"fmt"
	"golang-trick/33-grpc-pool/keywords/keywords-server/server"
	"golang-trick/33-grpc-pool/keywords/proto"
	"log"
	"net"

	"google.golang.org/grpc"
)

var (
	port = flag.Int("port", 50052, "")
)

func main() {
	flag.Parse()
	// 监听端口
	lis, err := net.Listen("tcp", fmt.Sprintf(":%d", *port))
	if err != nil {
		log.Fatal(err)
	}

	// 建立rpc服务,并注册SensitiveServer
	s := grpc.NewServer()
	proto.RegisterKeyWordsMatchServer(s, &server.KwServer{})

	// 启动服务
	err = s.Serve(lis)
	if err != nil {
		log.Fatal(err)
	}
}

四、gin web 路由服务

1、新建grpcpool服务作为gin web服务

由于proto文件与上面两个服务的一样的,只是go_package路径需要改变一下,就不重复贴这里了,看下面目录结构即可

55.手写实现grpc连接池以及gin和grpc交互_第5张图片

2、根据proto文件,分别生成keywords服务和sensitive服务的pb.go文件

因为gin web 服务相当于路由服务,里面会通过rpc调用远程的两个服务,所以那两个远程服务的客户端代码就是写到gin web 服务中的,因此也需要pb.go文件存根。生成后如下:

keywords客户端存根生成命令

 protoc --proto_path=33-grpc-pool/grpcpool/services/keywords/proto --go_out=. --go-grpc_out=. 33-grpc-pool/grpcpool/services/keywords/proto/keywords.proto

sensitive客户端存根生成命令

protoc --proto_path=33-grpc-pool/grpcpool/services/sensitive/proto --go_out=. --go-grpc_out=. 33-grpc-pool/grpcpool/services/sensitive/proto/sensitive.proto

55.手写实现grpc连接池以及gin和grpc交互_第6张图片

五、grpc 连接池实现

1、连接池的实现,通过sync.Pool实现

sync.Pool 知识补充

**结构如下:**主要是关注New字段,是一个方法,需要我们在初始化的时候提供,用于告知如何生成 池中的连接
55.手写实现grpc连接池以及gin和grpc交互_第7张图片
Pool具有的方法: 主要关注GetPut方法,用于获取和归还连接。与数据库连接池不太一样,数据库连接池一个连接用完了会自动返回池中,而sync.Pool中的连接用完了,需要我们手动的放回去,故提供了一个Put方法
55.手写实现grpc连接池以及gin和grpc交互_第8张图片

定义grpc-client-pool.go文件实现连接池,内容如下

package services

import (
	"log"
	"sync"

	"google.golang.org/grpc"
	"google.golang.org/grpc/connectivity"
)

// 注意这里是大写开头,定义的是一个接口
type ClientPool interface {
	Get() *grpc.ClientConn
	Put(conn *grpc.ClientConn)
}

// 注意这里是小写开头,定义的是结构体,用于实现上面的ClientPool接口
type clientPool struct {
	pool sync.Pool
}

// 获取连接池对象,并定义新建连接的方法,返回ClientPool接口类型
func GetPool(target string, opts ...grpc.DialOption) (ClientPool, error) {
	return &clientPool{
		pool: sync.Pool{
			New: func() any {
				conn, err := grpc.Dial(target, opts...)
				if err != nil {
					log.Fatal(err)
				}
				return conn
			},
		},
	}, nil
}

// 从连接池中获取一个连接
func (c *clientPool) Get() *grpc.ClientConn {
	conn := c.pool.Get().(*grpc.ClientConn)

	// 当连接不可用时,关闭当前连接,并新建一个连接
	if conn.GetState() == connectivity.Shutdown || conn.GetState() == connectivity.TransientFailure {
		conn.Close()
		conn = c.pool.New().(*grpc.ClientConn)
	}
	return conn
}

// 与数据库连接池不太一样,数据库连接池一个连接用完了会自动返回池中
// 而sync.Pool中的连接用完了,需要我们手动的放回去,故提供一个Put方法
func (c *clientPool) Put(conn *grpc.ClientConn) {
	// 当连接不可用时,关闭当前连接,并不再放回池中
	if conn.GetState() == connectivity.Shutdown || conn.GetState() == connectivity.TransientFailure {
		conn.Close()
		return
	}

	c.pool.Put(conn)
}


2、连接池的使用

和连接池相关的代码文件如下:
55.手写实现grpc连接池以及gin和grpc交互_第9张图片
各个接口,类之间的关系如下:
55.手写实现grpc连接池以及gin和grpc交互_第10张图片

首先,由于我们gin web 服务需要调用多个不同rpc服务,每个远程rpc服务,我们都应该建立一个对应的客户端连接池,所以为了统一,建立一个ServiceClient接口,并提供一个默认实现DefaultClient。第二点,建立远程rpc服务的客户端时(我们给sync.PoolNew字段传的函数grpc.Dial(target, opts...)),可能想传入不同的可选项,所以我们提供了一个opts文件,专门存放这些可选性,如安全连接校验等。

client.go

package client

import (
	"golang-trick/33-grpc-pool/grpcpool/services"
	"log"
)

type ServiceClient interface {
	GetPool(addr string) services.ClientPool
}

type DefaultClient struct {
}

func (c *DefaultClient) GetPool(addr string) services.ClientPool {
	pool, err := services.GetPool(addr, c.getOptions()...)
	if err != nil {
		log.Fatal(err)
	}
	return pool
}

// 还可以有很多其他的实现,比如KeywordsClient,SensitiveClient等,这里为了简单,就只写了DefaultClient

opts.go

package client

import (
	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials/insecure"
)

func (c *DefaultClient) getOptions() (opts []grpc.DialOption) {
	opts = make([]grpc.DialOption, 0)
	opts = append(opts, grpc.WithTransportCredentials(insecure.NewCredentials()))
	return opts
}

// 不同的实现可能有不同的opts,比较复杂的时候,还可以考虑使用函数式选项模式

现在可以分别创建keywordssensitive服务对应的客户端连接池对象了,使用单例

33-grpc-pool/grpcpool/services/keywords/client.go

package keywords

import (
	"golang-trick/33-grpc-pool/grpcpool/services"
	"golang-trick/33-grpc-pool/grpcpool/services/client"
	"sync"
)

//	注意是小写的,因为一个gin web服务,我们只希望它对一个grpc服务持有的连接池是一个单例
// 因此小写,避免其他地方可以构造这个结构体的对象。然后这里通过once控制是单例
type kwClient struct {
	// 内嵌client.DefaultClient,从而实现了ServiceClient接口
	// 如果有其他实现,比如KeywordsClient ,那么内嵌KeywordsClient即可
	client.DefaultClient
}

var pool services.ClientPool
var once sync.Once

// 实际工作中,这里应该用服务的注册与发现机制,这里只是会了简单演示,所以写死了服务端的地址
var kwAddr = "localhost:50052"

func GetKwClientPool() services.ClientPool {
	once.Do(func() {
		c := &kwClient{}
		// 实际调用的是内嵌的DefaultClient的GetPool
		pool = c.GetPool(kwAddr)
	})
	return pool
}

33-grpc-pool/grpcpool/services/sensitive/client.go

package sensitive

import (
	"golang-trick/33-grpc-pool/grpcpool/services"
	"golang-trick/33-grpc-pool/grpcpool/services/client"
	"sync"
)

//	注意是小写的,因为一个gin web服务,我们只希望它对一个grpc服务持有的连接池是一个单例
// 因此小写,避免其他地方可以构造这个结构体的对象。然后这里通过once控制是单例
type sensitiveClient struct {
	// 内嵌client.DefaultClient,从而实现了ServiceClient接口
	// 如果有其他实现,比如SensitiveClient ,那么内嵌SensitiveClient即可
	client.DefaultClient
}

var pool services.ClientPool
var once sync.Once

// 实际工作中,这里应该用服务的注册与发现机制,这里只是会了简单演示,所以写死了服务端的地址
var sensitiveAddr = "localhost:50051"

func GetSensitiveClientPool() services.ClientPool {
	once.Do(func() {
		c := &sensitiveClient{}
		// 实际调用的是内嵌的DefaultClient的GetPool
		pool = c.GetPool(sensitiveAddr)
	})
	return pool
}

gin web启动函数main.go

package main

import (
	"golang-trick/33-grpc-pool/grpcpool/controllers"

	"github.com/gin-gonic/gin"
)

func main() {
	r := gin.Default()
	r.GET("/ping", controllers.Ping)

	r.Run()
}

ping函数中通过客户端连接池调用远程服务

package controllers

import (
	"context"
	"fmt"
	"golang-trick/33-grpc-pool/grpcpool/services/keywords"
	kwProto "golang-trick/33-grpc-pool/grpcpool/services/keywords/proto"
	"golang-trick/33-grpc-pool/grpcpool/services/sensitive"
	sensitiveProto "golang-trick/33-grpc-pool/grpcpool/services/sensitive/proto"

	"net/http"

	"github.com/gin-gonic/gin"
)

func Ping(ctx *gin.Context) {
	// 建立一个sensitive服务的客户端单例连接,并调用sensitive远程rpc服务的Validate接口
	spool := sensitive.GetSensitiveClientPool()
	sconn := spool.Get()
	// 注意用完后需要将连接手动放回连接池
	defer spool.Put(sconn)
	sensitiveClient := sensitiveProto.NewSensitiveFilterClient(sconn)
	sIn := &sensitiveProto.ValidateRequest{Input: "今天天气很好"}
	sensitiveRes, err := sensitiveClient.Validate(context.Background(), sIn)
	fmt.Printf("%+v    %+v  \n", sensitiveRes, err)

	// 建立一个keywords服务的客户端单例连接,并调用keywords远程rpc服务的Match接口
	kpool := keywords.GetKwClientPool()
	kconn := kpool.Get()
	// 注意用完后需要将连接手动放回连接池
	defer kpool.Put(kconn)
	keywordsClient := kwProto.NewKeyWordsMatchClient(kconn)
	kIn := &kwProto.MatchRequest{Input: "今天天气很好"}
	keywordsRes, err := keywordsClient.Match(context.Background(), kIn)
	fmt.Printf("%+v    %+v  \n", keywordsRes, err)

	ctx.JSON(http.StatusOK, gin.H{
		"message": "pong",
	})
}

测试:
启动keywords服务和sensitive服务,以及gin web服务,然后访问http://localhost:8080/ping

55.手写实现grpc连接池以及gin和grpc交互_第11张图片
终端也可以看到两个远程服务都调用成功啦
55.手写实现grpc连接池以及gin和grpc交互_第12张图片
55.手写实现grpc连接池以及gin和grpc交互_第13张图片
在这里插入图片描述

你可能感兴趣的:(go,gin,交互)