用go从零构建写一个RPC（仿gRPC，tRPC）--- 版本1（Client端） ...

这里我们来实现这个RPC的client端
为了实现RPC的效果，我们调用的Hello方法，即server端的方法，应该是由署理来调用，让proxy内里封装网络请求，消息的发送和接受处置惩罚。而上一篇文章提到的服务端的署理已经在.rpc.go文件中实现，我们将客户端的实现也写在这里
ClientProxy

1. // 客户端代理接口
2. type HelloClientProxy interface  {
3.         Hello(ctx context.Context, in *HelloRequest, opts ...client.Option) (*HelloReply, error)
4. }
7. // 客户端代理实现
8. type HelloClientProxyImpl struct {
9.         client client.Client
10.         opts   []client.Option
11. }
13. // 创建客户端代理
14. func NewHelloClientProxy(opts ...client.Option) HelloClientProxy {
15.         return &HelloClientProxyImpl{
16.                 client: client.DefaultClient,
17.                 opts:   opts,
18.         }
19. }

复制代码

• 这里的HelloClientProxyImpl此中的client类主要是负责invoke方法，抽象网络IO和编解码，opts主要是记录客户端启动时传入的配置项，如server的ip地址等
  
• 创建出客户端署理，我们就可以通过署理来调用Hello方法
  

2. // 实现Hello方法
3. func (c *HelloClientProxyImpl) Hello(ctx context.Context, req *HelloRequest, opts ...client.Option) (*HelloReply, error) {
4.         // 创建一个msg结构，存储service相关的数据，如serviceName等，并放到context中
5.         // 用msg结构可以避免在context中太多withValue传递过多的参数
6.        
7.         msg := internel.NewMsg()
8.         msg.WithServiceName("helloworld")
9.         msg.WithMethodName("Hello")
10.         ctx = context.WithValue(ctx, internel.ContextMsgKey, msg)
11.         rsp := &HelloReply{}
12.         // 这里需要将opts添加前面newProxy时传入的opts
13.         newOpts := append(c.opts, opts...)
14.         err := c.client.Invoke(ctx, req, rsp, newOpts...)
15.         if err != nil {
16.                 return nil, err
17.         }
18.         return rsp, nil
19. }

复制代码

• 这里需要明确service的名字和对应方法，为了后续封装在协议数据里，到达server端才能正确路由。当署理类实现了这个Hello后，我们就可以通过proxy.Hello得到相应结果，Invoke方法隐藏了详细的网络处置惩罚，我们跟进Invoke方法
  

Client（clientTransPort）

上文提到，client类主要处置惩罚invoke方法，我们可以预见它的职责就是，

• 序列化请求体
  
• 编码
  
• 发送请求，接受响应
  
• 解码
  
• 反序列化响应体
  
• 返回客户端
  为了代码的解耦，我们和server的处置惩罚一样，将以上操纵放到clientTransPort上，client持有transPort，让transPort处置惩罚以上的逻辑
  

2. // 实现Send方法
3. func (c *clientTransport) Send(ctx context.Context, reqBody interface{}, rspBody interface{}, opt *ClientTransportOption) error {
4.         // 获取连接
5.         // TODO 这里的连接后续可以优化从连接池获取
6.         conn, err := net.Dial("tcp", opt.Address)
7.         if err != nil {
8.                 return err
9.         }
10.         defer conn.Close()
11.         // reqbody序列化
12.         reqData, err := codec.Marshal(reqBody)
13.         if err != nil {
14.                 return err
15.         }
16.         // reqbody编码，返回请求帧
17.         framedata, err := opt.Codec.Encode(ctx, reqData)
18.         if err != nil {
19.                 return err
20.         }
21.         // 写数据到连接中
22.         err = c.tcpWriteFrame(ctx, conn, framedata)
23.         if err != nil {
24.                 return err
25.         }
26.         // 读取tcp帧
27.         rspDataBuf, err := c.tcpReadFrame(ctx, conn)
28.         if err != nil {
29.                 return err
30.         }
31.         // 获取msg
32.         ctx, msg := internel.GetMessage(ctx)
33.         // rspDataBuf解码，提取响应体数据
34.         rspData, err := opt.Codec.Decode(msg, rspDataBuf)
35.         if err != nil {
36.                 return err
37.         }
38.         // 将rspData反序列化为rspBody
39.     err = codec.Unmarshal(rspData, rspBody)
40.         if err != nil {
41.                 return err
42.         }
43.         return nil
44. }

复制代码

• 序列化是根据protobuf协议，编码的格式我们之间写Server的时间提到，我们需要将数据编码成以下格式：
  
  
  
  
• 当编码完成后，我们就需要写数据到连接中，并监听该连接的数据，当有数据后，我们再依次解码得到响应体，再将响应体反序列化，返回客户端。
  
• 写数据到连接和读连接中的数据也很简朴，这里我们直接开启一个连接，调用Write写，而codec.ReadFrame在server端的时间已经介绍过
  

1. func (c *clientTransport) tcpWriteFrame(ctx context.Context, conn net.Conn, frame []byte) error {
3.         // 写入tcp
4.         _, err := conn.Write(frame)
5.         if err != nil {
6.                 return fmt.Errorf("write frame error: %v", err)
7.         }
8.         return nil
9. }
11. func (c *clientTransport) tcpReadFrame(ctx context.Context, conn net.Conn) ([]byte, error) {
12.         return codec.ReadFrame(conn)
13. }

复制代码

效果测试

至此client端处置惩罚完毕，我们来看看效果：

1. //client端的测试main.go:
2. func main() {
3.         c := pb.NewHelloClientProxy(client.WithTarget("127.0.0.1:8000"))
4.         if c == nil {
5.                 fmt.Println("Failed to create client")
6.                 return
7.         }
9.         rsp, err := c.Hello(context.Background(), &pb.HelloRequest{Msg: "world"})
10.         if err != nil {
11.                 fmt.Println("RPC call error:", err)
12.                 return
13.         }
14.         fmt.Println("Response:", rsp.Msg)
15. }
17. // server端的测试的main.go
18. func main() {
19.         // Create a new server instance
20.         s := server.NewServer()
22.         // Register the HelloService with the server
23.         pb.RegisterHelloServer(s, &HelloServerImpl{})
25.         // Start the server on port 50051
26.         if err := s.Serve(":8000"); err != nil {
27.                 panic(err)
28.         }
30.         fmt.Print("启动成功")
31. }
34. // 创建一个HelloServer的实现类
35. type HelloServerImpl struct{}
36. // 实现HelloServer接口的Hello方法
37. func (h *HelloServerImpl) Hello(req *pb.HelloRequest) (*pb.HelloReply, error) {
38.         // 这里可以实现具体的业务逻辑
39.         reply := &pb.HelloReply{
40.                 Msg: "Hello " + req.Msg,
41.         }
42.         return reply, nil
43. }

复制代码

server端启动：

server端吸收到client的连接请求：

client收到响应：

如今version1开发完了，现在的版本主要是实现底子功能，而且为了考虑后续的扩展性做了比力多的解耦，在后面的版本，我们可以徐徐提拔这个rpc的性能和融入更多的功能

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。