分别以google.golang.org/grpc和net/rpc简单理解RPC

待我称王封你为后i 2023-02-14 05:47 8阅读 0赞

筚路蓝缕，以启山林。抚有蛮夷，以属华夏。不鸣则已，一鸣惊人。  
                                                                                                          ——《左传\`宣公十二年》

> rpc：远程过程调用，是一个思想，一个概念。核心是分布式应用间通信，屏蔽不同语言，解耦(个人认为)。
> 
> net/rpc包是一个go自带的rpc实现方式，可以基于tcp、http、json rpc等方式进行调用。
> 
> gRpc基于Netty HTTP/2协议栈封装底层通信，启动时启动一个Netty server。
> 
> **特别提醒(踩坑后可以返回来再看)**：如果没有用go module模式，那么需要在src下手动创建google.golang.org目录并进入该目录手动执行git clone https://e.coding.net/robinqiwei/googleprotobuf.git protobuf，否则包不能正确拉取（报找不到google.golang.org/protobuf/proto...等一堆错）；如果用的go module模式，那么这个是自动完成的，无需手动创建。

**目录**

net/rpc

google.golang.org/grpc

--------------------

## net/rpc ##

实践目标：server端与client端可以实现通信。此实例采用TCP方式调用。项目目录结构：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hZWlhfOTk4Nw_size_16_color_FFFFFF_t_70][]

pub.go

package base1_public
    
    import (
    	"fmt"
    	"net/rpc"
    )
    
    const HelloServiceName = "pkg.HelloService"
    
    type HelloServiceInterface interface {
    	HelloS(request string, reply *string) error // 之所以命名为HelloS，是为了验证与其对应之处
    }
    
    func RegisterHelloService(svc HelloServiceInterface) error {
    	return rpc.RegisterName(HelloServiceName, svc)
    }
    
    type HelloService struct{}
    
    func (p *HelloService) HelloS(request string, reply *string) error {
    	*reply = "hello:" + request
    	fmt.Println("服务端回复：", *reply)
    	return nil
    }

服务端

package main
    
    import (
    	"log"
    	"net"
    	"net/rpc"
    	"rpc-test/base1_public"
    )
    
    func main() {
    	base1_public.RegisterHelloService(new(base1_public.HelloService))
    
    	listener, err := net.Listen("tcp", ":3234")
    	if err != nil {
    		log.Fatal("ListenTCP error:", err)
    	}
    
    	for {
    		conn, err := listener.Accept()
    		if err != nil {
    			log.Fatal("Accept error:", err)
    		}
    
    		go rpc.ServeConn(conn) // 此次server被终止时才会执行下次循环继续开启新的server，否则一直阻塞等待
    	}
    }

客户端

package main
    
    import (
    	"fmt"
    	"log"
    	"net/rpc"
    	"rpc-test/base1_public"
    )
    
    type HelloServiceClient struct {
    	*rpc.Client
    }
    
    
    func DialHelloService(network, address string) (*HelloServiceClient, error) {
    	c, err := rpc.Dial(network, address)
    	if err != nil {
    		return nil, err
    	}
    	return &HelloServiceClient{Client: c}, nil
    }
    
    func (p *HelloServiceClient) start(request string, reply *string) error {
    	// 方式1
    	//return p.Client.Call(base1_public.HelloServiceName+".HelloS", request, reply) // HelloS与接口的方法名对应即可
    
    	// 方式2
    	helloCall := p.Client.Go(base1_public.HelloServiceName+".HelloS", request, reply, nil)
    	//helloCall = <-helloCall.Done
    	return (<-helloCall.Done).Error
    	//if err := helloCall.Error; err != nil {
    	//	log.Fatal(err)
    	//}
    
    }
    
    func main() {
    	client, err := DialHelloService("tcp", "localhost:3234")
    	if err != nil {
    		log.Fatal("dialing:", err)
    	}
    
    	var reply string
    	err = client.start("哈哈哈", &reply)
    	if err != nil {
    		log.Fatal(err)
    	}
    	fmt.Println("收到的回复：", reply)
    }

分别启动服务端和客户端，控制台分别如下：

服务端回复： hello:哈哈哈
    
    收到的回复： hello:哈哈哈

http、json-rpc等方式的调用可移步：[https://blog.csdn.net/ffzhihua/article/details/83270771][https_blog.csdn.net_ffzhihua_article_details_83270771]

## google.golang.org/grpc ##

实践目标：服务端有两个服务，客户端我要使用(调用)这两个服务。

背景设计：远端某个地方有两个服务：分别是加密服务和解密服务，client调用时只需传明文或密文作为参数即可。

项目结构如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hZWlhfOTk4Nw_size_16_color_FFFFFF_t_70 1][]

通过.proto文件约定好服务接口、参数等，通过工具protoc-gen-go生成客户端和服务端共用的对照表。

secret.proto

syntax = "proto3";
    
    package proto;
    
    service SecretService {
      rpc Encrypt(SecretRequest) returns (SecretResponse) {}
      rpc Decrypt(SecretRequest) returns (SecretResponse) {}
    }
    
    message SecretRequest {
      string request = 1;
    }
    
    message SecretResponse {
      string response = 1;
    }

生成的secret.pb.go挺长，这里就不贴了。生成方式及环境搭建可移步[https://blog.csdn.net/HYZX\_9987/article/details/106462026][https_blog.csdn.net_HYZX_9987_article_details_106462026]

服务端

package main
    
    import (
    	"context"
    	"encoding/base64"
    	"fmt"
    	pt "gRpc-demo/proto"
    	"google.golang.org/grpc"
    	"log"
    	"net"
    )
    
    const PORT = "9001"
    
    type SecretServiceStruct struct{}
    
    // 加密服务
    func (s *SecretServiceStruct) Encrypt(ctx context.Context, r *pt.SecretRequest) (*pt.SecretResponse, error) {
    	log.Print("调用了加密服务：", r.Request)
    	secret := base64.StdEncoding.EncodeToString([]byte(r.Request))
    	return &pt.SecretResponse{Response: r.GetRequest() + "加密成功:" + secret}, nil
    }
    
    // 解密服务
    func (s *SecretServiceStruct) Decrypt(ctx context.Context, r *pt.SecretRequest) (*pt.SecretResponse, error) {
    	log.Print("调用了解密服务：", r.Request)
    	str, err := base64.StdEncoding.DecodeString(r.Request)
    	if err != nil {
    		log.Fatalf("服务端解密失败: %v", err.Error())
    		return &pt.SecretResponse{Response: ""}, err
    	}
    	return &pt.SecretResponse{Response: r.GetRequest() + "解密成功:" + string(str)}, nil
    }
    
    func main() {
    	server := grpc.NewServer()
    	pt.RegisterSecretServiceServer(server, &SecretServiceStruct{})
    	lis, err := net.Listen("tcp", ":"+PORT)
    	if err != nil {
    		log.Fatalf("net.Listen err: %v", err)
    	}
    
    	addr := fmt.Sprintf("%s", lis.Addr())
    	log.Printf("Listening on %v", addr)
    	log.Fatal(server.Serve(lis))
    }

客户端

package main
    
    import (
    	"context"
    	pt "gRpc-demo/proto"
    	"google.golang.org/grpc"
    	"log"
    	"strings"
    )
    
    const PORT = "9001"
    
    var str = `this is gRpc`
    
    func main() {
    	// 上面gRPC的服务没有提供证书支持，因此客户端在连接服务器中通过grpc.WithInsecure()选项跳过对服务器证书的验证
    	conn, err := grpc.Dial(":"+PORT, grpc.WithInsecure())
    	if err != nil {
    		log.Fatalf("grpc.Dial err: %v", err)
    	}
    	defer conn.Close()
    
    	client := pt.NewSecretServiceClient(conn)
    	resp0, err := client.Encrypt(context.Background(), &pt.SecretRequest{
    		Request: str,
    	})
    	if err != nil {
    		log.Fatalf("client.Encrypt err: %v", err)
    	}
    	secretStr := strings.Split(resp0.GetResponse(), ":")[1]
    	log.Printf("请求加密服务: %s", secretStr)
    
    	resp1, err := client.Decrypt(context.Background(), &pt.SecretRequest{
    		Request: secretStr,
    	})
    	if err != nil {
    		log.Fatalf("client.Decrypt err: %v", err)
    	}
    
    	resStr := strings.Split(resp1.GetResponse(), ":")[1]
    	log.Printf("请求解密服务: %s", resStr)
    }

分别启动服务端、客户端，控制台分别如下：

服务端：
    2020/06/01 09:41:20 Listening on [::]:9001
    2020/06/01 09:41:37 调用了加密服务：this is gRpc
    2020/06/01 09:41:37 调用了解密服务：dGhpcyBpcyBnUnBj
    
    客户端：
    2020/06/01 09:41:37 请求加密服务: dGhpcyBpcyBnUnBj
    2020/06/01 09:41:37 请求解密服务: this is gRpc

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hZWlhfOTk4Nw_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200601092142689.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hZWlhfOTk4Nw==,size_16,color_FFFFFF,t_70
[https_blog.csdn.net_ffzhihua_article_details_83270771]: https://blog.csdn.net/ffzhihua/article/details/83270771
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hZWlhfOTk4Nw_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200601093327315.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hZWlhfOTk4Nw==,size_16,color_FFFFFF,t_70
[https_blog.csdn.net_HYZX_9987_article_details_106462026]: https://blog.csdn.net/HYZX_9987/article/details/106462026