golang grpc 封装类 客户端代码 服务端代码

最新推荐文章于 2024-07-12 09:36:25 发布
最新推荐文章于 2024-07-12 09:36:25 发布
阅读量1.1k 收藏 1
点赞数
分类专栏： golang微服务 文章标签： golang
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zngfue/article/details/111266936
版权

最新小编在学习golang中的grpc在学习中也遇到了许多问题，我写了一个属于自己的grpc封装类分享给大家

helper 封装文件

package grpc_helper

import (
	"context"
	"google.golang.org/grpc"
	"net"
	"time"
)
var GrpcConn *GrpcHelper
type ServiceFn func(server *grpc.Server)
type ClientFn func(conn *grpc.ClientConn, ctx context.Context) (err error)
type GrpcHelperInterface interface {
	ServiceRegister( fn ServiceFn) (err error)
	ClientRegister(fn ClientFn) (err error)
}
type GrpcHelper struct {
	Conn *grpc.ClientConn
	Port string
	Host string
	//context.WithTimeout(context.Background(), time.Second/10)
	ContextFn func()(context.Context,context.CancelFunc)
	WithOutTime time.Duration
}

func (h *GrpcHelper) ClientRegister(fn ClientFn) error {
	if h.Conn == nil {
		conn, err := grpc.Dial(h.Host+":"+h.Port, grpc.WithInsecure(), grpc.WithBlock())
		if err != nil {
			return err
		}
		h.Conn=conn
	}
	defer h.Conn.Close()
	var ctx context.Context
	var cancel context.CancelFunc
	if h.ContextFn!=nil {
		ctx, cancel = h.ContextFn()
	}else{
		if h.WithOutTime==0 {
			ctx, cancel = context.WithTimeout(context.Background(), time.Second)
		}else{
			ctx, cancel = context.WithTimeout(context.Background(), h.WithOutTime)
		}
	}
	defer cancel()
	if err := fn(h.Conn, ctx); err != nil {
		return err
	}
	return nil
}
func (h *GrpcHelper) ServiceRegister( fn ServiceFn) (err error) {
	listener, err2 := net.Listen("tcp", h.Host+":"+h.Port)
	if err2 != nil {
		return err2
	}
	server := grpc.NewServer()
	fn(server)
	if err := server.Serve(listener); err != nil {
		return err
	}
	return
}
type GrpcOption struct {
	Port string //端口 "8080"
	Host string //地址 “ 127.0.0.1 ”
	ContextFn func()(context.Context,context.CancelFunc)
	WithOutTime time.Duration
}
func NewGrpcHelper(option GrpcOption) GrpcHelperInterface {
	 var g GrpcHelperInterface
	if option.Host=="" {
		option.Host="127.0.0.1"
	}
	if option.Port=="" {
		option.Port="8089"
	}
	 g = &GrpcHelper{
		Port: option.Port,
		Host: option.Host,
		ContextFn: option.ContextFn,
		WithOutTime: option.WithOutTime,
	}
	return g
}

helper_test.go

package grpc_helper

import (
	"context"
	"fmt"
	"google.golang.org/grpc"
	"testing"
	"time"
)

var grpcHelper GrpcHelperInterface

func test() GrpcOption  {
	return GrpcOption{
		Port: "55088",
		Host: "127.0.0.1",
		//延迟超时设置 方法重写 有优先于WithOutTime
		ContextFn: func() (context.Context, context.CancelFunc) {
			return context.WithTimeout(context.Background(),time.Second)
		},
		WithOutTime: time.Second*5,
	}
}
func service()  GrpcHelperInterface {
	if grpcHelper!=nil {
		return grpcHelper
	}else {
		grpcHelper = NewGrpcHelper(test())
		return grpcHelper
	}
}
func TestServiceHelper(t *testing.T) {
	service()
	if grpcHelper!=nil {
		err := grpcHelper.ServiceRegister(func(server *grpc.Server) {
			RegisterRoleServer(server, new(Role))
		})
		fmt.Println(err)
	}
}
func TestClientHelper(t *testing.T) {
	service()
	if  grpcHelper !=nil{
		var Re *RoleListResponse
		err := grpcHelper.ClientRegister(func(conn *grpc.ClientConn, ctx context.Context) (err error) {
			client := NewRoleClient(conn)
			req := RoleListRequest{
				Id:   1,
				Name: "ZhangSan32132",
				Age:  25,
			}
			Re, err = client.Rolelist(ctx, &req)
			return nil
		})
		fmt.Println(Re)
		fmt.Println(err)
	}
}

grpc proto自动生成的文件 role.pb.go

// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.25.0
// 	protoc        v3.14.0
// source: role.proto

//option go_package="pb";

package grpc_helper

import (
	context "context"
	proto "github.com/golang/protobuf/proto"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	reflect "reflect"
	sync "sync"
)

const (
	// Verify that this generated code is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
	// Verify that runtime/protoimpl is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)

// This is a compile-time assertion that a sufficiently up-to-date version
// of the legacy proto package is being used.
const _ = proto.ProtoPackageIsVersion4

type RoleResponse 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"`
	Age  int32  `protobuf:"varint,3,opt,name=age,proto3" json:"age,omitempty"`
}

func (x *RoleResponse) Reset() {
	*x = RoleResponse{}
	if protoimpl.UnsafeEnabled {
		mi := &file_role_proto_msgTypes[0]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *RoleResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*RoleResponse) ProtoMessage() {}

func (x *RoleResponse) ProtoReflect() protoreflect.Message {
	mi := &file_role_proto_msgTypes[0]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use RoleResponse.ProtoReflect.Descriptor instead.
func (*RoleResponse) Descriptor() ([]byte, []int) {
	return file_role_proto_rawDescGZIP(), []int{0}
}

func (x *RoleResponse) GetId() int64 {
	if x != nil {
		return x.Id
	}
	return 0
}

func (x *RoleResponse) GetName() string {
	if x != nil {
		return x.Name
	}
	return ""
}

func (x *RoleResponse) GetAge() int32 {
	if x != nil {
		return x.Age
	}
	return 0
}

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

	Rolelist []*RoleResponse `protobuf:"bytes,3,rep,name=Rolelist,proto3" json:"Rolelist,omitempty"`
}

func (x *RoleListResponse) Reset() {
	*x = RoleListResponse{}
	if protoimpl.UnsafeEnabled {
		mi := &file_role_proto_msgTypes[1]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *RoleListResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*RoleListResponse) ProtoMessage() {}

func (x *RoleListResponse) ProtoReflect() protoreflect.Message {
	mi := &file_role_proto_msgTypes[1]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use RoleListResponse.ProtoReflect.Descriptor instead.
func (*RoleListResponse) Descriptor() ([]byte, []int) {
	return file_role_proto_rawDescGZIP(), []int{1}
}

func (x *RoleListResponse) GetRolelist() []*RoleResponse {
	if x != nil {
		return x.Rolelist
	}
	return nil
}

type RoleListRequest 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"`
	Age  int32  `protobuf:"varint,3,opt,name=age,proto3" json:"age,omitempty"`
}

func (x *RoleListRequest) Reset() {
	*x = RoleListRequest{}
	if protoimpl.UnsafeEnabled {
		mi := &file_role_proto_msgTypes[2]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *RoleListRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*RoleListRequest) ProtoMessage() {}

func (x *RoleListRequest) ProtoReflect() protoreflect.Message {
	mi := &file_role_proto_msgTypes[2]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use RoleListRequest.ProtoReflect.Descriptor instead.
func (*RoleListRequest) Descriptor() ([]byte, []int) {
	return file_role_proto_rawDescGZIP(), []int{2}
}

func (x *RoleListRequest) GetId() int64 {
	if x != nil {
		return x.Id
	}
	return 0
}

func (x *RoleListRequest) GetName() string {
	if x != nil {
		return x.Name
	}
	return ""
}

func (x *RoleListRequest) GetAge() int32 {
	if x != nil {
		return x.Age
	}
	return 0
}

type RoleInfo 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"`
	Age  int32  `protobuf:"varint,3,opt,name=age,proto3" json:"age,omitempty"`
}

func (x *RoleInfo) Reset() {
	*x = RoleInfo{}
	if protoimpl.UnsafeEnabled {
		mi := &file_role_proto_msgTypes[3]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *RoleInfo) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*RoleInfo) ProtoMessage() {}

func (x *RoleInfo) ProtoReflect() protoreflect.Message {
	mi := &file_role_proto_msgTypes[3]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use RoleInfo.ProtoReflect.Descriptor instead.
func (*RoleInfo) Descriptor() ([]byte, []int) {
	return file_role_proto_rawDescGZIP(), []int{3}
}

func (x *RoleInfo) GetId() int64 {
	if x != nil {
		return x.Id
	}
	return 0
}

func (x *RoleInfo) GetName() string {
	if x != nil {
		return x.Name
	}
	return ""
}

func (x *RoleInfo) GetAge() int32 {
	if x != nil {
		return x.Age
	}
	return 0
}

var File_role_proto protoreflect.FileDescriptor

var file_role_proto_rawDesc = []byte{
	0x0a, 0x0a, 0x72, 0x6f, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x03, 0x70, 0x72,
	0x63, 0x22, 0x44, 0x0a, 0x0c, 0x52, 0x6f, 0x6c, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
	0x65, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x02, 0x69,
	0x64, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52,
	0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x61, 0x67, 0x65, 0x18, 0x03, 0x20, 0x01,
	0x28, 0x05, 0x52, 0x03, 0x61, 0x67, 0x65, 0x22, 0x41, 0x0a, 0x10, 0x52, 0x6f, 0x6c, 0x65, 0x4c,
	0x69, 0x73, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2d, 0x0a, 0x08, 0x52,
	0x6f, 0x6c, 0x65, 0x6c, 0x69, 0x73, 0x74, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x11, 0x2e,
	0x70, 0x72, 0x63, 0x2e, 0x52, 0x6f, 0x6c, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
	0x52, 0x08, 0x52, 0x6f, 0x6c, 0x65, 0x6c, 0x69, 0x73, 0x74, 0x22, 0x47, 0x0a, 0x0f, 0x52, 0x6f,
	0x6c, 0x65, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x0e, 0x0a,
	0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x02, 0x69, 0x64, 0x12, 0x12, 0x0a,
	0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d,
	0x65, 0x12, 0x10, 0x0a, 0x03, 0x61, 0x67, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x03,
	0x61, 0x67, 0x65, 0x22, 0x40, 0x0a, 0x08, 0x52, 0x6f, 0x6c, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x12,
	0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x02, 0x69, 0x64, 0x12,
	0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e,
	0x61, 0x6d, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x61, 0x67, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05,
	0x52, 0x03, 0x61, 0x67, 0x65, 0x32, 0x77, 0x0a, 0x04, 0x52, 0x6f, 0x6c, 0x65, 0x12, 0x39, 0x0a,
	0x08, 0x52, 0x6f, 0x6c, 0x65, 0x6c, 0x69, 0x73, 0x74, 0x12, 0x14, 0x2e, 0x70, 0x72, 0x63, 0x2e,
	0x52, 0x6f, 0x6c, 0x65, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a,
	0x15, 0x2e, 0x70, 0x72, 0x63, 0x2e, 0x52, 0x6f, 0x6c, 0x65, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65,
	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x34, 0x0a, 0x07, 0x52, 0x6f, 0x6c, 0x65,
	0x41, 0x64, 0x64, 0x12, 0x14, 0x2e, 0x70, 0x72, 0x63, 0x2e, 0x52, 0x6f, 0x6c, 0x65, 0x4c, 0x69,
	0x73, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x11, 0x2e, 0x70, 0x72, 0x63, 0x2e,
	0x52, 0x6f, 0x6c, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x62, 0x06,
	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
}

var (
	file_role_proto_rawDescOnce sync.Once
	file_role_proto_rawDescData = file_role_proto_rawDesc
)

func file_role_proto_rawDescGZIP() []byte {
	file_role_proto_rawDescOnce.Do(func() {
		file_role_proto_rawDescData = protoimpl.X.CompressGZIP(file_role_proto_rawDescData)
	})
	return file_role_proto_rawDescData
}

var file_role_proto_msgTypes = make([]protoimpl.MessageInfo, 4)
var file_role_proto_goTypes = []interface{}{
	(*RoleResponse)(nil),     // 0: prc.RoleResponse
	(*RoleListResponse)(nil), // 1: prc.RoleListResponse
	(*RoleListRequest)(nil),  // 2: prc.RoleListRequest
	(*RoleInfo)(nil),         // 3: prc.RoleInfo
}
var file_role_proto_depIdxs = []int32{
	0, // 0: prc.RoleListResponse.Rolelist:type_name -> prc.RoleResponse
	2, // 1: prc.Role.Rolelist:input_type -> prc.RoleListRequest
	2, // 2: prc.Role.RoleAdd:input_type -> prc.RoleListRequest
	1, // 3: prc.Role.Rolelist:output_type -> prc.RoleListResponse
	0, // 4: prc.Role.RoleAdd:output_type -> prc.RoleResponse
	3, // [3:5] is the sub-list for method output_type
	1, // [1:3] is the sub-list for method input_type
	1, // [1:1] is the sub-list for extension type_name
	1, // [1:1] is the sub-list for extension extendee
	0, // [0:1] is the sub-list for field type_name
}

func init() { file_role_proto_init() }
func file_role_proto_init() {
	if File_role_proto != nil {
		return
	}
	if !protoimpl.UnsafeEnabled {
		file_role_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*RoleResponse); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_role_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*RoleListResponse); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_role_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*RoleListRequest); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_role_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*RoleInfo); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: file_role_proto_rawDesc,
			NumEnums:      0,
			NumMessages:   4,
			NumExtensions: 0,
			NumServices:   1,
		},
		GoTypes:           file_role_proto_goTypes,
		DependencyIndexes: file_role_proto_depIdxs,
		MessageInfos:      file_role_proto_msgTypes,
	}.Build()
	File_role_proto = out.File
	file_role_proto_rawDesc = nil
	file_role_proto_goTypes = nil
	file_role_proto_depIdxs = nil
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConnInterface

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion6

// RoleClient is the client API for Role service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type RoleClient interface {
	Rolelist(ctx context.Context, in *RoleListRequest, opts ...grpc.CallOption) (*RoleListResponse, error)
	RoleAdd(ctx context.Context, in *RoleListRequest, opts ...grpc.CallOption) (*RoleResponse, error)
}

type roleClient struct {
	cc grpc.ClientConnInterface
}

func NewRoleClient(cc grpc.ClientConnInterface) RoleClient {
	return &roleClient{cc}
}

func (c *roleClient) Rolelist(ctx context.Context, in *RoleListRequest, opts ...grpc.CallOption) (*RoleListResponse, error) {
	out := new(RoleListResponse)
	err := c.cc.Invoke(ctx, "/prc.Role/Rolelist", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *roleClient) RoleAdd(ctx context.Context, in *RoleListRequest, opts ...grpc.CallOption) (*RoleResponse, error) {
	out := new(RoleResponse)
	err := c.cc.Invoke(ctx, "/prc.Role/RoleAdd", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// RoleServer is the server API for Role service.
type RoleServer interface {
	Rolelist(context.Context, *RoleListRequest) (*RoleListResponse, error)
	RoleAdd(context.Context, *RoleListRequest) (*RoleResponse, error)
}

// UnimplementedRoleServer can be embedded to have forward compatible implementations.
type UnimplementedRoleServer struct {
}

func (*UnimplementedRoleServer) Rolelist(context.Context, *RoleListRequest) (*RoleListResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Rolelist not implemented")
}
func (*UnimplementedRoleServer) RoleAdd(context.Context, *RoleListRequest) (*RoleResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RoleAdd not implemented")
}

func RegisterRoleServer(s *grpc.Server, srv RoleServer) {
	s.RegisterService(&_Role_serviceDesc, srv)
}

func _Role_Rolelist_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RoleListRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RoleServer).Rolelist(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/prc.Role/Rolelist",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RoleServer).Rolelist(ctx, req.(*RoleListRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Role_RoleAdd_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RoleListRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RoleServer).RoleAdd(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/prc.Role/RoleAdd",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RoleServer).RoleAdd(ctx, req.(*RoleListRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _Role_serviceDesc = grpc.ServiceDesc{
	ServiceName: "prc.Role",
	HandlerType: (*RoleServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Rolelist",
			Handler:    _Role_Rolelist_Handler,
		},
		{
			MethodName: "RoleAdd",
			Handler:    _Role_RoleAdd_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "role.proto",
}

role.go 实现  接口方法  Rolelist

package grpc_helper

import (
	"context"
)

type Role struct {

}

func (r Role) Rolelist(ctx context.Context, request *RoleListRequest) (rrs *RoleListResponse, err error) {

	var rsOne []*RoleResponse
	var ss RoleListResponse
	rsOne=append(rsOne,&RoleResponse{
		Id: 30,Name: request.Name,Age: 30,
	} )
	rsOne=append(rsOne,&RoleResponse{
		Id: 25,Name: request.Name,Age: 25,
	} )
	ss.Rolelist=rsOne
	rrs=&ss
	return


}

func (r Role) RoleAdd(ctx context.Context, request *RoleListRequest) (*RoleResponse, error) {
	panic("implement me")
}

 

zngfue
关注
专栏目录
Golang 学习之 grpc 的使用
weixin_41335923的博客
04-12 1954
Golang gRPC的学习，简单的介绍了一下 Protobuf 和 gRPC 定义，同时解析了 grpc-go 的 helloworld 案例 笔者想转 Go 开发
10分钟学会 gRPC
CCqwas的博客
03-16 370
介绍 我猜测大部分长期使用Java的开发者应该较少会接触gRPC，毕竟在Java圈子里大部分使用的还是Dubbo/SpringClound这两类服务框架。 我也是近段时间有机会从零开始重构业务才接触到gRPC的，当时选择gRPC时也有几个原因： 基于云原生的思路开发部署项目，而在云原生中gRPC几乎已经是标准的通讯协议了。 开发语言选择了 Go，在 Go 圈子中gRPC显然是更好的选择。 公司内部有部分业务使用的是Python开发，在多语言兼容性上...
Go-一个golang的后端通用脚手架封装httpgrpcxorm
08-14
一个golang的后端通用脚手架封装 http grpc xorm
gRPC 封装client
国产-达芬奇
07-10 779
rpc-client/client.go package rpc_clients import ( "context" "google.golang.org/grpc" "lch-tests/protobufs/workload" "log" "time" ) var ( WorkloadClient workload.WorkloadServiceClient ) type Conn struct { clientConn *grpc.ClientConn callTime
网格服务 grpc 客户端封装-利用接口指针反射设置grpc客户端
aaqq123456654321的博客
04-18 531
// authsvr_grpc.pd.go package authsvr type AuthClient interface { } // package handler func TestInitRpcClient(t *testing.T) { var authclent authsvr.AuthClient // grpc serve 端口, grpc 客户端new 函数, grpc 客户端接口指针 InitMicroRpcClient(":9001", authsvr.NewAuthCl
golang gRPC示例
dazheng
06-18 4225
gRPC是一个高性能、通用的开源RPC框架，其由Google主要面向移动应用开发并基于HTTP/2协议标准而设计，基于ProtoBuf(Protocol Buffers)序列化协议开发，且支持众多开发语言。gRPC提供了一种简单的方法来精确地定义服务和为iOS、Android和后台支持服务自动生成可靠性很强的客户端功能库。客户端充分利用高级流和链接功能，从而有助于节省带宽、降低的TCP链接次数、节省
支持grpc的服务器,用Golang构建gRPC服务
weixin_36378951的博客
07-29 328
本教程提供了Go使用gRPC的基础教程在教程中你将会学到如何：在.proto文件中定义一个服务。使用protocol buffer编译器生成客户端和服务端代码。使用gRPC的Go API为你的服务写一个客户端和服务器。继续之前，请确保你已经对gRPC概念有所了解，并且熟悉protocol buffer。需要注意的是教程中的示例使用的是proto3版本的protocol buffer：你可以在Pro...
gRPC：gRPC环境搭建与配置
最新发布
kkchenjj的博客
07-12 1223
创建一个.proto文件，定义你的服务接口和消息类型。gRPC是一个高性能、开源和通用的RPC框架，由Google开发。它基于HTTP/2协议，支持多种编程语言，如C++, Java, Python, Go等。gRPC使用Protocol Buffers作为接口定义语言（IDL），允许客户端和服务器进行高效的数据序列化。通过gRPC，开发者可以定义服务，指定方法名称、参数和返回类型，然后gRPC工具会生成相应的客户端和服务器代码，简化了网络通信的开发过程。在这个例子中，我们定义了一个名为。
【笔记】Go + gRPC
weixin_55970480的博客
07-20 639
Go + gRPC
第三十四期:花了一个星期，我终于把RPC框架整明白了！
歌谣的博客
10-27 335
RPC(Remote Procedure Call)：远程过程调用，它是一种通过网络从远程计算机程序上请求服务，而不需要了解底层网络技术的思想。 作者：李金葵 RPC(Remote Procedure Call)：远程过程调用，它是一种通过网络从远程计算机程序上请求服务，而不需要了解底层网络技术的思想。 RPC 是一种技术思想而非一种规范或协议，常见 RPC 技术和框架有： 应用级的服务框...
grpc在golang开发中所需要的依赖包
08-07
此模式不适用于go mod。只需要将解压后的src文件里的内容放到gopath的src里即可
最全1，2024年最新实现原理分析
2401_84904308的博客
05-13 668
RPC是的简称，中文叫远程过程调用，简单的说，就是调用远程方法和调用本地方法一样那么grpc就是由google开发的一个高性能、通用的开源RPC框架gRPC是一种现代开源高性能远程过程调用(RPC)框架，可在任何环境中运行。它可以高效地连接数据中心内的服务，并支持负载平衡、跟踪、健康检查和身份验证等插件功能。它适用于分布式计算的最后一英里，以连接设备、移动应用程序和浏览器到后端服务。公司已使用gRPC连接其环境中的多个服务，从连接少数服务到跨多种语言的数据中心内数百种服务。
Go语言操作grpc详细使用
一年之内毫无半点成绩，想起来做人真是没趣。
09-18 1415
proto文件，最后的服务函数写这个，然后编译文件。proto文件，最后的服务函数写这个，然后编译文件。proto文件，最后的服务函数写这个，然后编译文件。proto文件，最后的服务函数写这个，然后编译文件。在pbfiles的文件目录下，运行下面的命令。会在proto_go下生成两个文件。
【gRPC开发】go语言构建简单的服务端和客户端
weixin_45685541的博客
02-23 1366
gRPC开发:go语言构建简单的服务端和客户端 准备工作 安装protocol buffers 到protocol buffers到github到release页面下载指导压缩包（本文以mac 系统安装protocol buffers为栗子，其他系统方法类型） 下载完毕后解压并进入解压后到目录 直接依次执行一下命令进行protocol buffers的安装 1. ./configure 2. make 3. make check 4. sudo make install 5. protoc
封装一个自己的golang操作MySQL数据库工具
XiaoBai-Zhuai's Blog
04-05 2637
封装一个自己的golang操作MySQL数据库工具准备工作导入驱动连接mysql增删改查增删改查 准备工作 首先我们要准备一个写golang的IDE，我用的是goland，还可以用vscode。 然后我们要知道golang的基本使用。 其次我们还要知道连接MySQL的基本步骤，如果有jdbc的封装经历就更好啦。 那就开始吧！ 导入驱动 跟Java一样，go也没有内置mysql的驱动，所以我们要使用go get github.com/go-sql-driver/mysql下载mysql驱动。 然后在impor
GRPC基础使用-golang
qiu18610714529的博客
06-07 347
grpc基础使用
go mod tidy 中遇到的错误
baobaoxiannv的博客
11-30 1367
所以修复方法也是相当简单，将依赖的版本使用。目前依赖的版本是不包含这个包的。分支还是存在这个目录的，但是在。从输出日志可以看出是由于。层层调用，最后调用到了了。从上游github来看。分支这个目录就被删除了。关键字替换为实际的版本。
gprc从启动到运行 - 在生产中运行gRPC
u013500740的博客
11-19 929
我们将讨论如何为gRPC服务和客户端开发单元测试或集成测试，以及如何将它们与持续集成工具集成。 然后我们将进入gRPC应用程序的连续部署，我们将探索一些在虚拟机(vm)、Docker和Kubernetes上的部署模式。 最后，要在生产环境中运行gRPC应用程序，您需要有一个可靠的可观察平台形式。 在这里，我们将讨论用于gRPC应用程序的不同可观察性工具，并探索gRPC应用程序的故障排除和调试技术。 让我们从测试这些应用程序开始讨论。 测试gRPC应用程序 您开发的任何软件应用程序(包括gRPC应用程序)都需
Protoc与GRPC的使用
a1023934860的博客
05-27 4628
Protobuf与GRPC 安装 https://github.com/protocolbuffers/protobuf/releases 已经有构建好的运行文件，可以下载压缩包在bin/目录下找到，如果想自己构建请访问https://github.com/protocolbuffers/protobuf/blob/main/src/README.md 安装完成后运行protoc --version查看是否成功。 protoc作用是将.proto文件转换，至于转换成什么语言需要我们指定参数，比如Go语言需要
golang实现grpc服务端与客户端
05-23
接下来，我们需要实现gRPC服务端和客户端。以下是一个简单的示例： 服务端： ``` package main import ( "log" "net" "google.golang.org/grpc" pb "path/to/myservice" ) type myServiceServer struct{} ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值