GO语言的三种RPC使用方式

本文栗子，服务端实现对字符串的md5加密。客户端传递字符串通过rpc方式调用服务端，获得 md5 加密后的密文。 共通过三种方式实现，（1）go 语言 原生 RPC方式 (2) go语言原生 RPC + protobuff 实现 （3） GRPC 框架实现

1.go原生 rpc

#server.go
package main

import (
	"crypto/md5"
	"encoding/hex"
	"net"
	"net/http"
	"net/rpc"
)
// 加密工具类
type EncryptionUtil struct {
}

// 加密方法
func (eu *EncryptionUtil) Encryption(req string, resp *string) error {
	*resp = ToMd5(req)
	return nil
}
// 封装 md5 方法
func ToMd5(s string) string{
	m := md5.New()
	m.Write([]byte (s))
	return hex.EncodeToString(m.Sum(nil))
}

func main() {
	// 功能对象注册
	encryption :=  new(EncryptionUtil)
	err := rpc.Register(encryption)  //rpc.RegisterName("自定义服务名",encryption)
	if err != nil {
		panic(err.Error())
	}
	// HTTP注册
	rpc.HandleHTTP()

	// 端口监听
	listen, err := net.Listen("tcp", ":8081")
	if err != nil {
		panic(err.Error())
	}
	// 启动服务
	_ = http.Serve(listen, nil)

}

#client.go
package main

import (
	"fmt"
	"net/rpc"
)

func main()  {
	// 建立连接
	client, err := rpc.DialHTTP("tcp", "localhost:8081")
	if err != nil {
		panic(err.Error())
	}
	// 参数
	req := "mclink"
	var resp *string
	// 同步调用
	err = client.Call("EncryptionUtil.Encryption", req, &resp)
	if err!= nil {
		panic(err.Error())
	}
	fmt.Println(*resp)

	// 异步调用
	syncCall := client.Go("EncryptionUtil.Encryption", req, &resp, nil)
	// 阻塞，异步调用成功后解除阻塞
	replayDone := <-syncCall.Done
	fmt.Println(replayDone)
	fmt.Println(*resp)

}

2.rpc 结合 protobuf

2.1 mac 安装 grpc 环境

需要先安装 grpc 命令和对应的相关包

brew tap grpc/grpc
brew install protobuf
go get -u github.com/golang/protobuf/proto
go get -u github.com/golang/protobuf/protoc-gen-go

2.2 编写 proto 文件

#message.proto
syntax = "proto3";

package message;
option go_package = "./;message";

// 加密请求
message  EncryptionRequest{
  string str = 1;
}
// 加密返回值
message EncryptionResult{
  string result = 1;
}

2.3 编译proto文件

protoc ./message.proto --go_out=./ 


# 得到的目录结构
.
├── client_test.go
├── message
│   ├── message.pb.go
│   └── message.proto
└── server.go

2.4 编写程序

#server.go
// 加密服务
type EncryptionService struct {
}

// 加密程序， 这里和原生的不同是，参数类型都使用了生成的 pb 文件里面的类
func (es *EncryptionService) Encryption(request *message.EncryptionRequest, response *message.EncryptionResult) error{
	md5Str := ToMd5(request.GetStr())
	response.Result = md5Str
	return nil
}

// 简单封装的 md5
func ToMd5(s string) string{
	m := md5.New()
	m.Write([]byte (s))
	return hex.EncodeToString(m.Sum(nil))
}


func main() {
	// 功能对象注册
	encryption :=  new(EncryptionService)
	err := rpc.Register(encryption)  //rpc.RegisterName("自定义服务名",encryption)
	if err != nil {
		panic(err.Error())
	}
	// HTTP注册
	rpc.HandleHTTP()

	// 端口监听
	listen, err := net.Listen("tcp", ":8081")
	if err != nil {
		panic(err.Error())
	}
	_ = http.Serve(listen, nil)
}

#client_test.go
func TestClient(t *testing.T)  {
	// 建立连接
	client, err := rpc.DialHTTP("tcp", "localhost:8081")
	if err != nil {
		panic(err.Error())
	}

	req := message.EncryptionRequest{Str: "mclink"}
	resp := message.EncryptionResult{}
	// 同步调用
	err = client.Call("EncryptionService.Encryption", &req, &resp)
	if err!= nil {
		panic(err.Error())
	}
	fmt.Println(resp.GetResult())

}

3.GRPC 实现

3.1 编写 proto 文件

syntax = "proto3";

package message;
option go_package = "./;message";

// 加密请求
message  EncryptionRequest{
  string str = 1;
}
// 加密返回值
message EncryptionResult{
  string result = 1;
}

// 加密service定义, 服务注册
service EncryptionService {
  rpc Encryption(EncryptionRequest) returns (EncryptionResult);
}

2.3 编译proto文件

go get -u google.golang.org/grpc

protoc ./message.proto --go_out=plugins=grpc:./ 


# 得到的目录结构
.
├── client_test.go
├── message
│   ├── message.pb.go
│   └── message.proto
└── server.go

2.4 编写程序

#server.go
// 加密服务实现类
type EncryptionServiceImpl struct {
}

// 加密程序
func (es *EncryptionServiceImpl) Encryption(ctx context.Context, request *message.EncryptionRequest) (*message.EncryptionResult, error){
	md5Str := ToMd5(request.GetStr())
	res := message.EncryptionResult{Result:md5Str}
	return &res,nil
}

// 简单封装的 md5
func ToMd5(s string) string{
	m := md5.New()
	m.Write([]byte (s))
	return hex.EncodeToString(m.Sum(nil))
}


func main() {
	// 创建一个 grpc server
	server := grpc.NewServer()

	message.RegisterEncryptionServiceServer(server, new(EncryptionServiceImpl))

	lis, err := net.Listen("tcp", ":8081")
	if err != nil {
		panic(err.Error())
	}
	_ = server.Serve(lis)
}

#client_test.go
func TestClient(t *testing.T)  {
	//1、Dail连接
	conn, err := grpc.Dial("localhost:8081", grpc.WithInsecure())
	if err != nil {
		panic(err.Error())
	}
	defer conn.Close()
	encryptionServiceClient := message.NewEncryptionServiceClient(conn)

	orderRequest := &message.EncryptionRequest{Str: "mclink"}
	result, err := encryptionServiceClient.Encryption(context.Background(), orderRequest)
	if result != nil {
		fmt.Println(result.Result)
	}
}