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

最新推荐文章于 2024-05-09 11:44:42 发布
最新推荐文章于 2024-05-09 11:44:42 发布
阅读量348 收藏
点赞数
分类专栏： go 文章标签： gin 交互
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/YouMing_Li/article/details/134907380
版权

文章目录


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

一、简介

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

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

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

在这里插入图片描述

前置说明

  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

在这里插入图片描述

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整体代码结构如下：
在这里插入图片描述

三、关键词匹配服务

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

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路径需要改变一下，就不重复贴这里了，看下面目录结构即可

在这里插入图片描述

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

在这里插入图片描述

五、grpc 连接池实现

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

sync.Pool 知识补充

**结构如下：**主要是关注New字段，是一个方法，需要我们在初始化的时候提供，用于告知如何生成 池中的连接
在这里插入图片描述
Pool具有的方法： 主要关注Get和Put方法，用于获取和归还连接。与数据库连接池不太一样，数据库连接池一个连接用完了会自动返回池中，而sync.Pool中的连接用完了，需要我们手动的放回去，故提供了一个Put方法
在这里插入图片描述

定义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、连接池的使用

和连接池相关的代码文件如下：
在这里插入图片描述
各个接口，类之间的关系如下：
在这里插入图片描述

首先，由于我们gin web 服务需要调用多个不同rpc服务，每个远程rpc服务，我们都应该建立一个对应的客户端连接池，所以为了统一，建立一个ServiceClient接口，并提供一个默认实现DefaultClient。第二点，建立远程rpc服务的客户端时(我们给sync.Pool的New字段传的函数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，比较复杂的时候，还可以考虑使用函数式选项模式

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

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

在这里插入图片描述
终端也可以看到两个远程服务都调用成功啦
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

百里守约学编程
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
grpc-core-1.24.0-API文档-中文版.zip
05-09
赠送jar包：grpc-core-1.24.0.jar； 赠送原API文档：grpc-core-1.24.0-javadoc.jar； 赠送源代码：grpc-core-1.24.0-sources.jar； 赠送Maven依赖信息文件：grpc-core-1.24.0.pom； 包含翻译后的API文档：grpc-core-1.24.0-javadoc-API文档-中文(简体)版.zip； Maven坐标：io.grpc:grpc-core:1.24.0； 标签：core、grpc、jar包、java、中文文档； 使用方法：解压翻译后的API文档，用浏览器打开“index.html”文件，即可纵览文档内容。 人性化翻译，文档中的代码和结构保持不变，注释和说明精准翻译，请放心使用。
SkyApm.Transport.Grpc.Protocol.rar
05-29
废话不多说： 解压，替换项目 skywalking-netcore V7 官网上下载的包异常，替换上面的包从新编译即可通过。
warlock:grpcpool grpc客户端连接池
05-23
术士-grpc客户端连接池 这是golang grpc客户端连接池工具完整的链接状态检测机制获得的每个链接都是有效的。 项目成熟度 基本的api不会有更多更改。 它们将在上进行讨论，并包含所有错误或增强功能 目标 提供一些接口，尽可能高效，稳定和灵活。 文件 如何使用 go get github.com/ruiboma/warlock package main import ( "github.com/ruiboma/warlock" "google.golang.org/grpc" pb "google.golang.org/grpc/examples/helloworld/helloworld" ) func main () { cfg := warlock . NewConfig () cfg . ServerAdds = & [] string { "127.0.0.
grpc-java-1.9.0.tar.gz_gRPC-java_java Tcp _谷歌 RPC 框架
09-24
gRPC-java 1.9.0 已发布，gRPC-java 是谷歌 RPC 框架 gRPC 的 Java 实现。gRPC 是一个高性能、开源、通用的 RPC 框架，面向移动和 HTTP/2 设计，是由谷歌发布的首款基于 Protocol Buffers 的 RPC 框架。 gRPC 基于 HTTP/2 标准设计，带来诸如双向流、流控、头部压缩、单 TCP 连接上的多复用请求等特性。这些特性使得其在移动设备上表现更好，更省电且节省空间占用。
ginrpc：gin自动绑定，grpc和带注释的路由，gin注解路由，grpc，自动参数绑定工具
02-04
基于自动参数绑定 doc Golang杜松子酒自动参数绑定 支持RPC自动映射 支持对象注册 支持注释路由 基于json restful风格的 参数过滤和请求绑定的实现 代码注册简单，并支持多种注册方式 绑定支持 支持 支持 支持交易前后的交易（ ginrpc.WithBeforeAfter ） 正在安装 去国防部： go get -u github.com/xxjwxc/ginrpc@master API详细信息 支持三种界面模式 func（* gin.Context）// go-gin Raw接口 func（* api.Context）//自定义上下文类型 func（* api.Con
grpc 连接池实现
zhangzhen02的博客
03-30 5199
一，首先，grpc有没有必要实现连接池？ 测试及分析见前文：记一次web请求量上不去的排查记录，及grpc client请求优化 二，如果我们确实需要实现自己的连接池，代码如下： 1.首先引入apache的池化包 <dependency> <groupId>org.apache.commons</groupId> ...
golang工程——grpc 连接池简单实现
qq_43058348的博客
10-05 428
最后，连接池里的对象只是临时的，golang gc的时候也会释放掉一些不用的对象，连接池的对象也并不是一直存在的。在使用的时候，由于sync.Pool Get方法会pop处集合中的资源，使用完后需要Put回去。grpc连接池可以采用sync.Pool实现。可以有效减少重复创建grpc连接的资源消耗。
gRPC运行过程与流量控制机制
m0_60647847的博客
10-05 1376
总结一下，上面讲解了gRPC中三种流量控制（注意当前版本是v1.49.0），分别为BDP、connection level 、 sream level 流量控制。按照层次关系，先从整体的BDP介绍了原理与结构，然后顺着思路，从“唯一的TCP连接”引入了connection level流量控制，最后讲解最细粒度的stream level流量控制，并且，通过gRPC的源代码步骤，从连接建立到交互完成，我们过了一遍关键的源码，在源码中看流量控制机制的过程。
连接池的实现细节
Wengy的博客
06-24 313
1.引子 软件工程已经是一层轮子包一层轮子，层层堆叠的框架。每一层都留有配置供调整或能实现扩展。在工作中只依靠网上的配置说明根本无法使用好轮子，甚至还会出问题。 1.1各种数据库配置： Tomcat:实际案例，不全，有不合理，有少配 tomcat: poolProperties: initial-size: 5 max-wait: 2000 maxWaitMillis: 2000 max-total: 50
gin框架结合grpc
Bobdragery的博客
09-04 6725
一、创建 mkdir grpc-go-client cd grpc-go-client go mod grpc-go-client # 下载并安装gin go get -u github.com/gin-gonic/gin 二、创建main.go文件 Main.go package main import ( "fmt" "net/http" "github.com/gin-gonic/gin" ) func main(){ r := gin.Default() // 测试一个get请求
grpc-api-1.24.0-API文档-中英对照版.zip
05-03
赠送jar包：grpc-api-1.24.0.jar； 赠送原API文档：grpc-api-1.24.0-javadoc.jar； 赠送源代码：grpc-api-1.24.0-sources.jar； 赠送Maven依赖信息文件：grpc-api-1.24.0.pom； 包含翻译后的API文档：grpc-api-1.24.0-javadoc-API文档-中文(简体)-英语-对照版.zip； Maven坐标：io.grpc:grpc-api:1.24.0； 标签：api、grpc、jar包、java、中英对照文档； 使用方法：解压翻译后的API文档，用浏览器打开“index.html”文件，即可纵览文档内容。 人性化翻译，文档中的代码和结构保持不变，注释和说明精准翻译，请放心使用。 双语对照，边学技术、边学英语。
3gRPC.rar3gRPC.rar3gRPC.rar
04-22
3gRPC.rar3gRPC.rar3gRPC.rar
go微服务框架kratos学习笔记七(kratos warden 负载均衡 balancer)
靑い空゛
01-19 3134
go微服务框架kratos学习笔记七(kratos warden 负载均衡 balancer) 文章目录go微服务框架kratos学习笔记七(kratos warden 负载均衡 balancer)demodemo serverdemo client池daoservicep2croundrobingrpc官方负载均衡工作流程源码 本节看看kratos的学习负载均衡策略的使用。 kratos 的负...
GO-Grpc微服务开发五 服务调用优化
找不到我的路
11-08 968
GO-Grpc微服务开发四 服务调用优化获取服务进行缓存使用连接池 获取服务进行缓存 //初始化服务变量 var service []*consul.CatalogService //获取缓存句柄 bt, err := GetCacheClient() //服务缓存名称 key := &amp;amp;amp;quot;service_&amp;amp;amp;quot; + name //获取缓存 ...
golang文章整理
zhoutaotao123的博客
05-19 420
coder_learn 只争朝夕，不负韶华! golang????: 《Go语言编程入门与实战技巧》-黄靖钧 《Go语言核心编程》-李文塔 《Go编发编程实战》-郝林 《Go语言编程》-许式伟 《Go程序设计语言》-译本 Go语言圣经 《Go语言学习笔记》-雨痕 《Go 语言设计与实现》 《Go语言高级编程》- 柴树杉，曹春晖 《go语言101》 mysql : mysql45讲 mysql必知必会 计算机组成原理： 深入理解计算机系统 深入浅出计算机组成原理（极客时间） 算法： 数据结
使用grpc client pool复用连接
LLLLL2025的博客
04-03 3969
前言 前面使用了grpc进行客户端和服务端之间的数据传输。客户端每次使用前都需要先Dial，使用完之后直接就Close掉了，下一次请求进来又重新Dial，这样资源消耗十分严重，于是将rfyiamcool写的连接池改了一点点，实现连接的复用 先上对比 go test -bench=. -run=none goos: linux goarch: amd64 pkg: client Benchma...
【intro】Graph Isomorphism Network（GIN）
最新发布
Karen_Yu_的博客
05-09 534
图神经网络(gnn)是一种有效的图表示学习框架。gnn采用邻域聚合方案，通过递归聚合和变换相邻节点的表示向量来计算节点的表示向量。已经提出了许多GNN变体，并在节点和图分类任务上取得了最先进的结果。然而，尽管gnn彻底改变了图表示学习，但人们对其表示特性和局限性的理解有限。->一个理论框架，用来分析GNN捕获不同图结构的能力。
gin-vue-blog 前后端分离项目（已经部署）
席万里的博客
05-04 561
全栈开源项目
Gin入门指南：从零开始快速掌握Go Web框架Gin
赵士杰——成功并非一蹴而就，而是在持之以恒的努力中逐渐实现。
05-05 1835
中间件函数用于记录日志。路由和请求处理：Gin 提供了简单而灵活的路由功能，可以方便地定义不同URL路径的处理函数，并支持 GET、POST 等各种HTTP请求方法。函数用于返回成功结果，它接收 Gin 的上下文对象，以及三个自定义的参数，分别为状态码、提示信息和数据。一般来说，我们需要在处理请求的路由函数中使用 defer 语句将捕获的异常记录下来，所以我们可以通过中间件实现全局的异常处理。参数绑定和验证：Gin 提供了强大的参数绑定和验证功能，可以方便地将请求参数绑定到结构体中，并进行数据验证和转换。
com.alibaba.nacos.shaded.io.grpc.internal.JsonUtil
11-27
com.alibaba.nacos.shaded.io.grpc.internal.JsonUtil是gRPC框架中的一个工具类，用于将Java对象转换为JSON格式的字符串或将JSON格式的字符串转换为Java对象。它的具体实现可以在gRPC的源代码中找到。 如果您需要在自己的项目中使用JsonUtil，可以按照以下步骤进行操作： 1.在项目中引入gRPC的依赖，例如： ```xml <dependency> <groupId>io.grpc</groupId> <artifactId>grpc-netty-shaded</artifactId> <version>1.38.0</version> </dependency> ``` 2.在代码中使用JsonUtil，例如： ```java import com.alibaba.nacos.shaded.io.grpc.internal.JsonUtil; // 将Java对象转换为JSON格式的字符串 MyObject obj = new MyObject(); String jsonStr = JsonUtil.printJson(obj); // 将JSON格式的字符串转换为Java对象 String jsonStr = "{\"name\":\"John\",\"age\":30,\"city\":\"New York\"}"; MyObject obj = JsonUtil.parseJson(jsonStr, MyObject.class); ``` 注意：在使用JsonUtil时，需要保证Java对象的属性名与JSON格式的字符串中的键名一致，否则转换可能会失败。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值