grpc的server分析

最新推荐文章于 2024-05-15 12:38:59 发布
最新推荐文章于 2024-05-15 12:38:59 发布
阅读量923 收藏 25
点赞数 21
文章标签： golang rpc 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_31661765/article/details/135059020
版权

本文是在go.19.11的代码下分析的

option go_package = "./user";

// 用户登录
message LoginRequest {
  string Mobile = 1;
  string Password = 2;
}
message LoginResponse {
  int64 Id = 1;
  string Name = 2;
  int64 Gender = 3;
  string Mobile = 4;
}

首先我们如果用grpc的client调用登录的这个接口用作示例

用protoc，protoc-gen-go，protoc-gen-go-grpc的工具会生成两个文件，一个是proto的go结构体函数文件，一个是client，server的对应的回调函数的文件。

type LoginRequest struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	Mobile   string `protobuf:"bytes,1,opt,name=Mobile,proto3" json:"Mobile,omitempty"`
	Password string `protobuf:"bytes,2,opt,name=Password,proto3" json:"Password,omitempty"`
}


type LoginResponse struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	Id     int64  `protobuf:"varint,1,opt,name=Id,proto3" json:"Id,omitempty"`
	Name   string `protobuf:"bytes,2,opt,name=Name,proto3" json:"Name,omitempty"`
	Gender int64  `protobuf:"varint,3,opt,name=Gender,proto3" json:"Gender,omitempty"`
	Mobile string `protobuf:"bytes,4,opt,name=Mobile,proto3" json:"Mobile,omitempty"`
}
// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.3.0
// - protoc             v3.19.4
// source: rpc/user.proto

package user

import (
	context "context"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
)

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
// Requires gRPC-Go v1.32.0 or later.
const _ = grpc.SupportPackageIsVersion7

const (
	User_Login_FullMethodName    = "/user.User/Login"
	User_Register_FullMethodName = "/user.User/Register"
	User_UserInfo_FullMethodName = "/user.User/UserInfo"
)

// UserClient is the client API for User service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type UserClient interface {
	Login(ctx context.Context, in *LoginRequest, opts ...grpc.CallOption) (*LoginResponse, error)
	Register(ctx context.Context, in *RegisterRequest, opts ...grpc.CallOption) (*RegisterResponse, error)
	UserInfo(ctx context.Context, in *UserInfoRequest, opts ...grpc.CallOption) (*UserInfoResponse, error)
}

type userClient struct {
	cc grpc.ClientConnInterface
}

func NewUserClient(cc grpc.ClientConnInterface) UserClient {
	return &userClient{cc}
}

func (c *userClient) Login(ctx context.Context, in *LoginRequest, opts ...grpc.CallOption) (*LoginResponse, error) {
	out := new(LoginResponse)
	err := c.cc.Invoke(ctx, User_Login_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *userClient) Register(ctx context.Context, in *RegisterRequest, opts ...grpc.CallOption) (*RegisterResponse, error) {
	out := new(RegisterResponse)
	err := c.cc.Invoke(ctx, User_Register_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *userClient) UserInfo(ctx context.Context, in *UserInfoRequest, opts ...grpc.CallOption) (*UserInfoResponse, error) {
	out := new(UserInfoResponse)
	err := c.cc.Invoke(ctx, User_UserInfo_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// UserServer is the server API for User service.
// All implementations must embed UnimplementedUserServer
// for forward compatibility
type UserServer interface {
	Login(context.Context, *LoginRequest) (*LoginResponse, error)
	Register(context.Context, *RegisterRequest) (*RegisterResponse, error)
	UserInfo(context.Context, *UserInfoRequest) (*UserInfoResponse, error)
	mustEmbedUnimplementedUserServer()
}

// UnimplementedUserServer must be embedded to have forward compatible implementations.
type UnimplementedUserServer struct {
}

func (UnimplementedUserServer) Login(context.Context, *LoginRequest) (*LoginResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Login not implemented")
}
func (UnimplementedUserServer) Register(context.Context, *RegisterRequest) (*RegisterResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Register not implemented")
}
func (UnimplementedUserServer) UserInfo(context.Context, *UserInfoRequest) (*UserInfoResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UserInfo not implemented")
}
func (UnimplementedUserServer) mustEmbedUnimplementedUserServer() {}

// UnsafeUserServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to UserServer will
// result in compilation errors.
type UnsafeUserServer interface {
	mustEmbedUnimplementedUserServer()
}

func RegisterUserServer(s grpc.ServiceRegistrar, srv UserServer) {
	s.RegisterService(&User_ServiceDesc, srv)
}

func _User_Login_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(LoginRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(UserServer).Login(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: User_Login_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(UserServer).Login(ctx, req.(*LoginRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _User_Register_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RegisterRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(UserServer).Register(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: User_Register_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(UserServer).Register(ctx, req.(*RegisterRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _User_UserInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UserInfoRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(UserServer).UserInfo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: User_UserInfo_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(UserServer).UserInfo(ctx, req.(*UserInfoRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// User_ServiceDesc is the grpc.ServiceDesc for User service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var User_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "user.User",
	HandlerType: (*UserServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Login",
			Handler:    _User_Login_Handler,
		},
		{
			MethodName: "Register",
			Handler:    _User_Register_Handler,
		},
		{
			MethodName: "UserInfo",
			Handler:    _User_UserInfo_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "rpc/user.proto",
}

从上面的文件可以看出，grpc直接生成了client和server的两个接口，一一对应，当我们调用函数时，就是调用这里的函数，client不会出现调用.proto文件之外的接口，我们现在开始分析server 的login接口。

首先grpc的server会通过可选项模式，将UnaryServerInterceptor的函数数组，通过可选项模式传给

serverOptions的chainUnaryInts 属性

unaryInterceptorOption := grpc.ChainUnaryInterceptor(s.buildUnaryInterceptors()...)

func ChainUnaryInterceptor(interceptors ...UnaryServerInterceptor) ServerOption {
	return newFuncServerOption(func(o *serverOptions) {
		o.chainUnaryInts = append(o.chainUnaryInts, interceptors...)
	})
}

然后我们new一个server，server := grpc.NewServer(options...)

进入源码

func NewServer(opt ...ServerOption) *Server {
	opts := defaultServerOptions
	for _, o := range globalServerOptions {
		o.apply(&opts)
	}
	for _, o := range opt {
		o.apply(&opts)
	}
	s := &Server{
		lis:      make(map[net.Listener]bool),
		opts:     opts,
		conns:    make(map[string]map[transport.ServerTransport]bool),
		services: make(map[string]*serviceInfo),
		quit:     grpcsync.NewEvent(),
		done:     grpcsync.NewEvent(),
		czData:   new(channelzData),
	}
	chainUnaryServerInterceptors(s)
	chainStreamServerInterceptors(s)
	.
    .
    .
}

前面是通过可选项模式赋值，后面就进入chainUnaryServerInterceptors(s)

// chainUnaryServerInterceptors chains all unary server interceptors into one.
func chainUnaryServerInterceptors(s *Server) {
	// Prepend opts.unaryInt to the chaining interceptors if it exists, since unaryInt will
	// be executed before any other chained interceptors.
	interceptors := s.opts.chainUnaryInts
	if s.opts.unaryInt != nil {
		interceptors = append([]UnaryServerInterceptor{s.opts.unaryInt}, s.opts.chainUnaryInts...)
	}

	var chainedInt UnaryServerInterceptor
	if len(interceptors) == 0 {
		chainedInt = nil
	} else if len(interceptors) == 1 {
		chainedInt = interceptors[0]
	} else {
		chainedInt = chainUnaryInterceptors(interceptors)
	}

	s.opts.unaryInt = chainedInt
}

func chainUnaryInterceptors(interceptors []UnaryServerInterceptor) UnaryServerInterceptor {
	return func(ctx context.Context, req any, info *UnaryServerInfo, handler UnaryHandler) (any, error) {
		return interceptors[0](ctx, req, info, getChainUnaryHandler(interceptors, 0, info, handler))
	}
}

func getChainUnaryHandler(interceptors []UnaryServerInterceptor, curr int, info *UnaryServerInfo, finalHandler UnaryHandler) UnaryHandler {
	if curr == len(interceptors)-1 {
		return finalHandler
	}
	return func(ctx context.Context, req any) (any, error) {
		return interceptors[curr+1](ctx, req, info, getChainUnaryHandler(interceptors, curr+1, info, finalHandler))
	}
}

将UnaryServerInterceptor函数数组，进行递归调用，从0到n，其中的handler，就是我们前面生成的_User_Login_Handler函数，这个就是一个洋葱模型，和gin的模式差不多，gin是for递归，其实本质差不多，各位可以去试试，所以最终的s.opts.unaryInt = chainedInt，获取到了递归的一个函数的地址。

new完一个sever，然后就是注册了，user.RegisterUserServer(grpcServer, server.NewUserServer(ctx))，将自己实现的UserServer注册进来

type UserServer struct {
	svcCtx *svc.ServiceContext
	user.UnimplementedUserServer
}

func NewUserServer(svcCtx *svc.ServiceContext) *UserServer {
	return &UserServer{
		svcCtx: svcCtx,
	}
}

func (s *UserServer) Login(ctx context.Context, in *user.LoginRequest) (*user.LoginResponse, error) {
	l := logic.NewLoginLogic(ctx, s.svcCtx)
	return l.Login(in)
}

func (s *UserServer) Register(ctx context.Context, in *user.RegisterRequest) (*user.RegisterResponse, error) {
	l := logic.NewRegisterLogic(ctx, s.svcCtx)
	return l.Register(in)
}

func (s *UserServer) UserInfo(ctx context.Context, in *user.UserInfoRequest) (*user.UserInfoResponse, error) {
	l := logic.NewUserInfoLogic(ctx, s.svcCtx)
	return l.UserInfo(in)
}

UserServer的实现要满足前面生成的接口

type UserServer interface {
	Login(context.Context, *LoginRequest) (*LoginResponse, error)
	Register(context.Context, *RegisterRequest) (*RegisterResponse, error)
	UserInfo(context.Context, *UserInfoRequest) (*UserInfoResponse, error)
	mustEmbedUnimplementedUserServer()
}

如果没实现，就会调用这个接口

func (UnimplementedUserServer) Login(context.Context, *LoginRequest) (*LoginResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Login not implemented")
}

所以mustEmbedUnimplementedUserServer()是满足必须实现了这个接口。

最后进入注册的源码实现

func RegisterUserServer(s grpc.ServiceRegistrar, srv UserServer) {
	s.RegisterService(&User_ServiceDesc, srv)
}

var User_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "user.User",
	HandlerType: (*UserServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Login",
			Handler:    _User_Login_Handler,
		},
		{
			MethodName: "Register",
			Handler:    _User_Register_Handler,
		},
		{
			MethodName: "UserInfo",
			Handler:    _User_UserInfo_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "rpc/user.proto",
}

然后继续进入

func (s *Server) RegisterService(sd *ServiceDesc, ss any) {
	if ss != nil {
		ht := reflect.TypeOf(sd.HandlerType).Elem()
		st := reflect.TypeOf(ss)
		if !st.Implements(ht) {
			logger.Fatalf("grpc: Server.RegisterService found the handler of type %v that does not satisfy %v", st, ht)
		}
	}
	s.register(sd, ss)
}

func (s *Server) register(sd *ServiceDesc, ss any) {
	s.mu.Lock()
	defer s.mu.Unlock()
	s.printf("RegisterService(%q)", sd.ServiceName)
	if s.serve {
		logger.Fatalf("grpc: Server.RegisterService after Server.Serve for %q", sd.ServiceName)
	}
	if _, ok := s.services[sd.ServiceName]; ok {
		logger.Fatalf("grpc: Server.RegisterService found duplicate service registration for %q", sd.ServiceName)
	}
	info := &serviceInfo{
		serviceImpl: ss,
		methods:     make(map[string]*MethodDesc),
		streams:     make(map[string]*StreamDesc),
		mdata:       sd.Metadata,
	}
	for i := range sd.Methods {
		d := &sd.Methods[i]
		info.methods[d.MethodName] = d
	}
	for i := range sd.Streams {
		d := &sd.Streams[i]
		info.streams[d.StreamName] = d
	}
	s.services[sd.ServiceName] = info
}

首先是判断自己实现的UserServer是否全部是实现了UserServer的接口，然后将

// Server is a gRPC server to serve RPC requests.
type Server struct {
	opts serverOptions
    .
    .
    .
	services map[string]*serviceInfo // service name -> service info
    .
    .
    .

}

Methods: []grpc.MethodDesc{
		{
			MethodName: "Login",
			Handler:    _User_Login_Handler,
		},
    .
    .
    .
}

service全部加入到server的services的属性中，User_ServiceDesc的结构体的

ServiceName: "user.User",所以这里的key是"user.User"，serviceInfo的methods的属性其中有一个的key是"Login",value是MethodDesc上面的图中的这个（包含生成好的 _User_Login_Handler的handler的函数指针）

注册成功了，就要启动服务，我们看是怎么开始调用的server.Serve(lis)

func (s *Server) Serve(lis net.Listener) error {
	for {
		rawConn, err := lis.Accept()
		.
        .
        .
		go func() {
			s.handleRawConn(lis.Addr().String(), rawConn)
			s.serveWG.Done()
		}()
	}
}


func (s *Server) handleRawConn(lisAddr string, rawConn net.Conn) {
	if s.quit.HasFired() {
		rawConn.Close()
		return
	}
	rawConn.SetDeadline(time.Now().Add(s.opts.connectionTimeout))

	// Finish handshaking (HTTP2)
	st := s.newHTTP2Transport(rawConn)
	rawConn.SetDeadline(time.Time{})
	if st == nil {
		return
	}

	if !s.addConn(lisAddr, st) {
		return
	}
	go func() {
		s.serveStreams(st)
		s.removeConn(lisAddr, st)
	}()
}

看到上面是一个conn，一个协程，启动http2的transport，然后调用serveStreams函数

func (s *Server) serveStreams(st transport.ServerTransport) {
	defer st.Close(errors.New("finished serving streams for the server transport"))
	var wg sync.WaitGroup

	streamQuota := newHandlerQuota(s.opts.maxConcurrentStreams)
	st.HandleStreams(func(stream *transport.Stream) {
		wg.Add(1)

		streamQuota.acquire()
		f := func() {
			defer streamQuota.release()
			defer wg.Done()
			s.handleStream(st, stream)
		}

		if s.opts.numServerWorkers > 0 {
			select {
			case s.serverWorkerChannel <- f:
				return
			default:
				// If all stream workers are busy, fallback to the default code path.
			}
		}
		go f()
	})
	wg.Wait()
}

func (s *Server) handleStream(t transport.ServerTransport, stream *transport.Stream) {
    .
    .
    .
    sm := stream.Method()
	if sm != "" && sm[0] == '/' {
		sm = sm[1:]
	}
	pos := strings.LastIndex(sm, "/")

    service := sm[:pos]
	method := sm[pos+1:]

	srv, knownService := s.services[service]
	if knownService {
		if md, ok := srv.methods[method]; ok {
			s.processUnaryRPC(ctx, t, stream, srv, md, ti)
			return
		}
		if sd, ok := srv.streams[method]; ok {
			s.processStreamingRPC(ctx, t, stream, srv, sd, ti)
			return
		}
	}
    .
    .
    .


}

其中会调用handleStream函数，会解析出service的值是"user.User"，method是"Login"，然后在前面已经注册的srv.methods找到"Login"的*MethodDesc，然后处理processUnaryRPC函数。

提醒前面生成的文件的client为

User_Login_FullMethodName    = "/user.User/Login"

func (c *userClient) Login(ctx context.Context, in *LoginRequest, opts ...grpc.CallOption) (*LoginResponse, error) {
	out := new(LoginResponse)
	err := c.cc.Invoke(ctx, User_Login_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

这里的server解析出分割的service和method是根据客户端传过来的User_Login_FullMethodName解析出来的。

最后

func (s *Server) processUnaryRPC(ctx context.Context, t transport.ServerTransport, stream *transport.Stream, info *serviceInfo, md *MethodDesc, trInfo *traceInfo) (err error) {
    .
    .
    .
    reply, appErr := md.Handler(info.serviceImpl, ctx, df, s.opts.unaryInt)
    .
    .
    .
    if err := s.sendResponse(ctx, t, stream, reply, cp, opts, comp); err != nil {
    .
    .
    .

}

md.Handler就是_User_Login_Handler的值，info.serviceImpl的前面注册赋值的UserServer，df是序列化函数，s.opts.unaryInt是前面洋葱模型的首地址。

最后调用

func _User_Login_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(LoginRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(UserServer).Login(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: User_Login_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(UserServer).Login(ctx, req.(*LoginRequest))
	}
	return interceptor(ctx, in, info, handler)
}

其中srv.(UserServer).Login的函数传入handler，然后interceptor(ctx, in, info, handler)作为洋葱模型，将这些函数一层一层的调用，然后返回sendResponse。

grpc的server的主体实现逻辑还是很清晰简单，可能具体的难点是细节吧，由于本文内容已经很多了，go的rpc放到下章去讲。

最后，本人能力有限，如果上面的有纰漏和问题，欢迎大佬指出

qq_31661765
关注
  • 21
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
gRPC线程模型分析
02-25
在JDK1.4推出JavaNIO之前，基于Java的所有Socket通信都采用了同步阻塞模式（BIO），这种一请求一应答的通信模型简化了上层的应用开发，但是在性能和可靠性方面却存在着巨大的瓶颈。因此，在很长一段时间里，大型的应用服务器都采用C或者C++语言开发，因为它们可以直接使用操作系统提供的异步I/O或者AIO能力。当并发访问量增大、响应时间延迟增大之后，采用JavaBIO开发的服务端软件只有通过硬件的不断扩容来满足高并发和低时延，它极大地增加了企业的成本，并且随着集群规模的不断膨胀，系统的可维护性也面临巨大的挑战，只能通过采购性能更高的硬件服务器来解决问题，这会导致恶性循环,传统采用BI
WebApplication_GrpcServer.zip
01-07
netcore的GrPC示例.所谓RPC(remote procedure call 远程过程调用)框架实际是提供了一套机制，使得应用程序之间可以进行通信，而且也遵从server/client模型。使用的时候客户端调用server端提供的接口就像是调用本地的函数一样.
gRPC Server 端关闭流程
啦啦啦啦 la
04-04 4897
gRPC Server 端关闭流程 关闭 Server 关闭 Server 可以使用 shutdown 或者 shutdownNow 方法 shutdown server.shutdown().awaitTermination(10, TimeUnit.SECONDS); io.grpc.internal.ServerImpl#shutdown 开始顺序的关闭 Server，已经存在的请求会继续执行，新的请求会被拒绝 public ServerImpl shutdown() { boolean
gRPC教程与应用
个人学习笔记库，一篇一篇记录成长的足迹
06-21 4581
grpc直接实现了新的服务器，并允许用户自定义接口，在服务器中暴露这些接口，在程序中整合grpc服务器，然后将接口绑定到程序的方法，客户端在连接rpc服务器是调用接口，则会直接指向服务器程序的方法，因此就行在本地调用一样。grpc是使用期本身的语法定义接口的，在上面的例子中使用了go语言，将接口绑定到go语言的接口中，那么如果将grpc的接口绑定到其他语言中也是可以使用的。由于Go语言都是基于源码进行的，在其他语言中需要下载protobuf的工具包，帮助将proto的接口转换为对应语言的接口。
【golang】10、grpc server 和 client、proto
呆呆的猫的博客
10-26 1381
grpc 的 server 和 client、proto
gRPC Server 端启动流程
啦啦啦啦 la
04-04 3040
gRPC Server 端启动流程 gRPC Server 启动流程，底层实现以 Netty 为例； 核心类 io.grpc.Server Server 的定义接口，实现类是 io.grpc.internal.ServerImpl，实现了服务、方法与方法处理器的绑定，端口监听，不同类型的 Server 实现的调用，Server 生命周期管理等 io.grpc.BindableService 由编译器生成的服务抽象类的基础接口，并将实现类绑定到服务器，提供将服务的实现的实例绑定到 Server 的方式
grpc相关使用(二):grpc server端创建
qq_37716298的博客
05-29 1069
server端创建 创建项目 创建一个基础的spring boot项目 修改pom文件 第三方依赖版本 <properties> <java.version>1.8</java.version> <os-maven-plugin.version>1.6.1</os-maven-plugin.version> <protobuf-maven-plugin.version>0.6.1</protobuf-maven-pl
GRPC server启动流程简单梳理
why154285的博客
08-13 4221
GRPC server启动流程简单梳理 一、rpc和grpc 1、rpc (remote procedure call) : 使得应用程序之间可以进行通信，而且也遵从server/client模型。使用的时候客户端调用server端提供的接口就像是调用本地的函数一样. 2、grpc : google提供的rpc框架 grpc 通信结构图如下： grpc 和 restful API 比较 ①：grpc可以通过protobuf定义接口，可以有更加严格的接口约束 ②：protobuf 通过二进制传输，提高传输效
gRPC 服务端创建和调用原理解析
yine的专栏
08-01 4890
gRPC 是一个高性能、开源和通用的 RPC 框架，面向服务端和移动端，基于 HTTP/2 设计。由 Google 开发并开源，语言中立，当前支持 C、Java 和 Go 语言，其中 C 版本支持 C、C++、Node.js、C# 等。 RPC 入门 RPC 框架原理 RPC 框架的目标就是让远程服务调用更加简单、透明，RPC 框架负责屏蔽底层的传输方式（TCP 或者 UDP）、序列化方式（...
【go语言grpc之server端源码分析】
qq_37674060的博客
02-05 797
【go语言grpc之server端源码分析】
gripmock:gRPC模拟服务器
04-29
GripMock是用于GRPC服务的模拟服务器。 它使用.proto文件为您生成gRPC服务的实现。 如果您已经熟悉用于API服务的或并正在为GRPC寻找类似的东西，那么这是完美的选择。 这个怎么运作 GripMock具有2个主要组件： 在...
GrpcServer：pubsub用Grpc实现
02-09
GrpcServer 用Grpc实现的发布/订阅
使用grpc-server-spring-boot-starter及nacos搭建grpc服务
程序猿CKeen的专栏
05-07 3206
在上一篇文章《java使用protobuf-maven-plugin的插件编译proto文件》中，我们使用protobuf-maven-plugin已经生成了grpc的调用的库，这篇文章我们将讲解使用SpringCloud及nacos搭建grpc服务。 1. 先到nacos的github地址下载一个release版本，下载地址。 我们解压缩之后，进到nacos目录，执行如下指令启动nacos: sh ./bin/startup.sh -m standalone 运行成功后在网页访问：http:/
gRPC简介
止语的博客
02-26 2463
messagemessage：protobul定义了一个消息类型是通过关键字message字段指定，消息就是要传输的数据格式的定义，message类似go中的struct，在消息中承载的数据分别对应的是一个字段，每个字段都有一个名字和一种类型。required：消息体中的必填字段，不设置时会导致编码异常，在protobf2中使用，在protobuf3中删除optional：消息体中的可选字段，protobuf3中取消了required和optional等说明关键字，默认都是optional。
protoc-gen-grpc-go生成的grpc Server接口中带mustEmbedUnimplemented***方法解决办法
Mirale的专栏
01-28 5776
1. 在serverImpl结构体中嵌入Unimplemented***Server结构体 2. 在使用protoc生成server代码时命令行加上关闭选项，protoc --go-grpc_out=require_unimplemented_servers=false 目前这个问题似乎时跟protoc-gen-go最新版本有关，这个特性社区还在讨论当中，后续可能会变动。我使用的版本如下； libprotoc 3.19.3 protoc-gen-go v1.27.1 ...
gRPC使用
js010111的博客
06-13 626
grcp远程过程调用
rpc王者—gRPC框架
12-22
gRPC框架视频教程，该课程内容主要包括grpc入门、安装、文件编写和编译、grpc-server编写、grpc-client编写。
grpc分析
weixin_56766616的博客
04-05 266
grpc简单分析
golang template: “xxx.html“ is an incomplete or empty template 解决方法
最新发布
05-15 140
这个异常一般是因为在使用 template.New("xxx.html") 时这里的名称非真实存在的视图文件名导致， 这个地方有点坑， 明明ParseFiles函数已经指定了视图路径了，而这里的New里面的名字居然还必须是你后面指定的视图路径中的文件名！
grpc server 如何请求client
06-01
在 gRPC 中，服务器不能主动请求客户端，它只能等待客户端发起请求。这是因为 gRPC 是基于请求/响应模型的，客户端需要向服务器发起请求，服务器才会响应请求。服务器只能在收到客户端的请求之后，才能向客户端发送...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值