说明

java 从零开始手写 RPC (01) 基于 socket 实现

java 从零开始手写 RPC (02)-netty4 实现客户端和服务端

写完了客户端和服务端，那么如何实现客户端和服务端的调用呢？

下面就让我们一起来看一下。

接口定义

计算方法

  1. package com.github.houbb.rpc.common.service;
  3. import com.github.houbb.rpc.common.model.CalculateRequest;
  4. import com.github.houbb.rpc.common.model.CalculateResponse;
  6. /**
  7.  * <p> 计算服务接口 </p>
  8.  *
  9.  * <pre> Created: 2018/8/24 下午4:47  </pre>
  10.  * <pre> Project: fake  </pre>
  11.  *
  12.  * @author houbinbin
  13.  * @since 0.0.1
  14.  */
  15. public interface Calculator {
  17.     /**
  18.      * 计算加法
  19.      * @param request 请求入参
  20.      * @return 返回结果
  21.      */
  22.     CalculateResponse sum(final CalculateRequest request);
  24. }

pojo

对应的参数对象：

  • CalculateRequest
  1. package com.github.houbb.rpc.common.model;
  3. import java.io.Serializable;
  5. /**
  6.  * <p> 请求入参 </p>
  7.  *
  8.  * <pre> Created: 2018/8/24 下午5:05  </pre>
  9.  * <pre> Project: fake  </pre>
  10.  *
  11.  * @author houbinbin
  12.  * @since 0.0.3
  13.  */
  14. public class CalculateRequest implements Serializable {
  16.     private static final long serialVersionUID = 6420751004355300996L;
  18.     /**
  19.      * 参数一
  20.      */
  21.     private int one;
  23.     /**
  24.      * 参数二
  25.      */
  26.     private int two;
  28.     public CalculateRequest() {
  29.     }
  31.     public CalculateRequest(int one, int two) {
  32.         this.one = one;
  33.         this.two = two;
  34.     }
  36.     //getter setter toString
  38. }
  • CalculateResponse
  1. package com.github.houbb.rpc.common.model;
  3. import java.io.Serializable;
  5. /**
  6.  * <p> 请求入参 </p>
  7.  *
  8.  * <pre> Created: 2018/8/24 下午5:05  </pre>
  9.  * <pre> Project: fake  </pre>
  10.  *
  11.  * @author houbinbin
  12.  * @since 0.0.3
  13.  */
  14. public class CalculateResponse implements Serializable {
  16.     private static final long serialVersionUID = -1972014736222511341L;
  18.     /**
  19.      * 是否成功
  20.      */
  21.    private boolean success;
  23.     /**
  24.      * 二者的和
  25.      */
  26.    private int sum;
  28.     public CalculateResponse() {
  29.     }
  31.     public CalculateResponse(boolean success, int sum) {
  32.         this.success = success;
  33.         this.sum = sum;
  34.     }
  36.     //getter setter toString
  37. }

客户端

核心部分

RpcClient 需要添加对应的 Handler，调整如下：

  1. Bootstrap bootstrap = new Bootstrap();
  2. ChannelFuture channelFuture = bootstrap.group(workerGroup)
  3.         .channel(NioSocketChannel.class)
  4.         .option(ChannelOption.SO_KEEPALIVE, true)
  5.         .handler(new ChannelInitializer<Channel>(){
  6.             @Override
  7.             protected void initChannel(Channel ch) throws Exception {
  8.                 ch.pipeline()
  9.                         .addLast(new LoggingHandler(LogLevel.INFO))
  10.                         .addLast(new CalculateRequestEncoder())
  11.                         .addLast(new CalculateResponseDecoder())
  12.                         .addLast(new RpcClientHandler());
  13.             }
  14.         })
  15.         .connect(RpcConstant.ADDRESS, port)
  16.         .syncUninterruptibly();

netty 中的 handler 泳道设计的非常优雅，让我们的代码可以非常灵活地进行拓展。

接下来我们看一下对应的实现。

RpcClientHandler

  1. package com.github.houbb.rpc.client.handler;
  3. import com.github.houbb.log.integration.core.Log;
  4. import com.github.houbb.log.integration.core.LogFactory;
  5. import com.github.houbb.rpc.client.core.RpcClient;
  6. import com.github.houbb.rpc.common.model.CalculateRequest;
  7. import com.github.houbb.rpc.common.model.CalculateResponse;
  8. import io.netty.channel.ChannelHandlerContext;
  9. import io.netty.channel.SimpleChannelInboundHandler;
  11. /**
  12.  * <p> 客户端处理类 </p>
  13.  *
  14.  * <pre> Created: 2019/10/16 11:30 下午  </pre>
  15.  * <pre> Project: rpc  </pre>
  16.  *
  17.  * @author houbinbin
  18.  * @since 0.0.2
  19.  */
  20. public class RpcClientHandler extends SimpleChannelInboundHandler {
  22.     private static final Log log = LogFactory.getLog(RpcClient.class);
  24.     @Override
  25.     public void channelActive(ChannelHandlerContext ctx) throws Exception {
  26.         CalculateRequest request = new CalculateRequest(1, 2);
  28.         ctx.writeAndFlush(request);
  29.         log.info("[Client] request is :{}", request);
  30.     }
  32.     @Override
  33.     protected void channelRead0(ChannelHandlerContext ctx, Object msg) throws Exception {
  34.         CalculateResponse response = (CalculateResponse)msg;
  35.         log.info("[Client] response is :{}", response);
  36.     }
  38. }

这里比较简单，channelActive 中我们直接发起调用，入参的对象为了简单，此处固定写死。

channelRead0 中监听服务端的相应结果，并做日志输出。

CalculateRequestEncoder

请求参数是一个对象，netty 是无法直接传输的，我们将其转换为基本对象：

  1. package com.github.houbb.rpc.client.encoder;
  3. import com.github.houbb.rpc.common.model.CalculateRequest;
  4. import io.netty.buffer.ByteBuf;
  5. import io.netty.channel.ChannelHandlerContext;
  6. import io.netty.handler.codec.MessageToByteEncoder;
  8. /**
  9.  * @author binbin.hou
  10.  * @since 0.0.3
  11.  */
  12. public class CalculateRequestEncoder extends MessageToByteEncoder<CalculateRequest> {
  14.     @Override
  15.     protected void encode(ChannelHandlerContext ctx, CalculateRequest msg, ByteBuf out) throws Exception {
  16.         int one = msg.getOne();
  17.         int two = msg.getTwo();
  19.         out.writeInt(one);
  20.         out.writeInt(two);
  21.     }
  23. }

CalculateResponseDecoder

针对服务端的响应，也是同理。

我们需要把基本的类型，封装转换为我们需要的对象。

  1. package com.github.houbb.rpc.client.decoder;
  3. import com.github.houbb.rpc.common.model.CalculateResponse;
  4. import io.netty.buffer.ByteBuf;
  5. import io.netty.channel.ChannelHandlerContext;
  6. import io.netty.handler.codec.ByteToMessageDecoder;
  8. import java.util.List;
  10. /**
  11.  * 响应参数解码
  12.  * @author binbin.hou
  13.  * @since 0.0.3
  14.  */
  15. public class CalculateResponseDecoder extends ByteToMessageDecoder {
  17.     @Override
  18.     protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
  19.         boolean success = in.readBoolean();
  20.         int sum = in.readInt();
  22.         CalculateResponse response = new CalculateResponse(success, sum);
  23.         out.add(response);
  24.     }
  26. }

服务端

设置处理类

RpcServer 中的处理类要稍微调整一下，其他的保持不变。

  1. ServerBootstrap serverBootstrap = new ServerBootstrap();
  2. serverBootstrap.group(workerGroup, bossGroup)
  3.         .channel(NioServerSocketChannel.class)
  4.         // 打印日志
  5.         .handler(new LoggingHandler(LogLevel.INFO))
  6.         .childHandler(new ChannelInitializer<Channel>() {
  7.             @Override
  8.             protected void initChannel(Channel ch) throws Exception {
  9.                 ch.pipeline()
  10.                         .addLast(new CalculateRequestDecoder())
  11.                         .addLast(new CalculateResponseEncoder())
  12.                         .addLast(new RpcServerHandler());
  13.             }
  14.         })
  15.         // 这个参数影响的是还没有被accept 取出的连接
  16.         .option(ChannelOption.SO_BACKLOG, 128)
  17.         // 这个参数只是过一段时间内客户端没有响应，服务端会发送一个 ack 包，以判断客户端是否还活着。
  18.         .childOption(ChannelOption.SO_KEEPALIVE, true);

RpcServerHandler

一开始这里是空实现，我们来添加一下对应的实现。

  1. package com.github.houbb.rpc.server.handler;
  3. import com.github.houbb.log.integration.core.Log;
  4. import com.github.houbb.log.integration.core.LogFactory;
  5. import com.github.houbb.rpc.common.model.CalculateRequest;
  6. import com.github.houbb.rpc.common.model.CalculateResponse;
  7. import com.github.houbb.rpc.common.service.Calculator;
  8. import com.github.houbb.rpc.server.service.CalculatorService;
  9. import io.netty.channel.ChannelHandlerContext;
  10. import io.netty.channel.SimpleChannelInboundHandler;
  12. /**
  13.  * @author binbin.hou
  14.  * @since 0.0.1
  15.  */
  16. public class RpcServerHandler extends SimpleChannelInboundHandler {
  18.     private static final Log log = LogFactory.getLog(RpcServerHandler.class);
  20.     @Override
  21.     public void channelActive(ChannelHandlerContext ctx) throws Exception {
  22.         final String id = ctx.channel().id().asLongText();
  23.         log.info("[Server] channel {} connected " + id);
  24.     }
  26.     @Override
  27.     protected void channelRead0(ChannelHandlerContext ctx, Object msg) throws Exception {
  28.         final String id = ctx.channel().id().asLongText();
  30.         CalculateRequest request = (CalculateRequest)msg;
  31.         log.info("[Server] receive channel {} request: {} from ", id, request);
  33.         Calculator calculator = new CalculatorService();
  34.         CalculateResponse response = calculator.sum(request);
  36.         // 回写到 client 端
  37.         ctx.writeAndFlush(response);
  38.         log.info("[Server] channel {} response {}", id, response);
  39.     }
  41. }

读取到客户端的访问之后，我们获取到计算的入参 CalculateRequest，然后调用 sum 方法，获取到对应的 CalculateResponse，将结果通知客户端。

CalculateRequestDecoder

这里和客户端是一一对应的，我们首先把 netty 传递的基本类型转换为 CalculateRequest 对象。

  1. package com.github.houbb.rpc.server.decoder;
  3. import com.github.houbb.rpc.common.model.CalculateRequest;
  4. import io.netty.buffer.ByteBuf;
  5. import io.netty.channel.ChannelHandlerContext;
  6. import io.netty.handler.codec.ByteToMessageDecoder;
  8. import java.util.List;
  10. /**
  11.  * 请求参数解码
  12.  * @author binbin.hou
  13.  * @since 0.0.3
  14.  */
  15. public class CalculateRequestDecoder extends ByteToMessageDecoder {
  17.     @Override
  18.     protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
  19.         int one = in.readInt();
  20.         int two = in.readInt();
  22.         CalculateRequest request = new CalculateRequest(one, two);
  23.         out.add(request);
  24.     }
  26. }

CalculateResponseEncoder

这里和客户端类似，我们需要把 response 转换为基本类型进行网络传输。

  1. package com.github.houbb.rpc.server.encoder;
  3. import com.github.houbb.rpc.common.model.CalculateResponse;
  4. import io.netty.buffer.ByteBuf;
  5. import io.netty.channel.ChannelHandlerContext;
  6. import io.netty.handler.codec.MessageToByteEncoder;
  8. /**
  9.  * @author binbin.hou
  10.  * @since 0.0.3
  11.  */
  12. public class CalculateResponseEncoder extends MessageToByteEncoder<CalculateResponse> {
  14.     @Override
  15.     protected void encode(ChannelHandlerContext ctx, CalculateResponse msg, ByteBuf out) throws Exception {
  16.         boolean success = msg.isSuccess();
  17.         int result = msg.getSum();
  18.         out.writeBoolean(success);
  19.         out.writeInt(result);
  20.     }
  22. }

CalculatorService

服务端对应的实现类。

  1. public class CalculatorService implements Calculator {
  3.     @Override
  4.     public CalculateResponse sum(CalculateRequest request) {
  5.         int sum = request.getOne()+request.getTwo();
  7.         return new CalculateResponse(true, sum);
  8.     }
  10. }

测试

服务端

启动服务端：

  1. new RpcServer().start();

服务端启动日志：

  1. [DEBUG] [2021-10-05 11:53:11.795] [main] [c.g.h.l.i.c.LogFactory.setImplementation] - Logging initialized using 'class com.github.houbb.log.integration.adaptors.stdout.StdOutExImpl' adapter.
  2. [INFO] [2021-10-05 11:53:11.807] [Thread-0] [c.g.h.r.s.c.RpcServer.run] - RPC 服务开始启动服务端
  3. 十月 05, 2021 11:53:13 上午 io.netty.handler.logging.LoggingHandler channelRegistered
  4. 信息: [id: 0xd399474f] REGISTERED
  5. 十月 05, 2021 11:53:13 上午 io.netty.handler.logging.LoggingHandler bind
  6. 信息: [id: 0xd399474f] BIND: 0.0.0.0/0.0.0.0:9527
  7. 十月 05, 2021 11:53:13 上午 io.netty.handler.logging.LoggingHandler channelActive
  8. 信息: [id: 0xd399474f, L:/0:0:0:0:0:0:0:0:9527] ACTIVE
  9. [INFO] [2021-10-05 11:53:13.101] [Thread-0] [c.g.h.r.s.c.RpcServer.run] - RPC 服务端启动完成，监听【9527】端口

客户端

启动客户端：

  1. new RpcClient().start();

日志如下：

  1. [DEBUG] [2021-10-05 11:54:12.158] [main] [c.g.h.l.i.c.LogFactory.setImplementation] - Logging initialized using 'class com.github.houbb.log.integration.adaptors.stdout.StdOutExImpl' adapter.
  2. [INFO] [2021-10-05 11:54:12.164] [Thread-0] [c.g.h.r.c.c.RpcClient.run] - RPC 服务开始启动客户端
  3. 十月 05, 2021 11:54:13 上午 io.netty.handler.logging.LoggingHandler channelRegistered
  4. 信息: [id: 0x4d75c580] REGISTERED
  5. 十月 05, 2021 11:54:13 上午 io.netty.handler.logging.LoggingHandler connect
  6. 信息: [id: 0x4d75c580] CONNECT: /127.0.0.1:9527
  7. 十月 05, 2021 11:54:13 上午 io.netty.handler.logging.LoggingHandler channelActive
  8. 信息: [id: 0x4d75c580, L:/127.0.0.1:54030 - R:/127.0.0.1:9527] ACTIVE
  9. [INFO] [2021-10-05 11:54:13.403] [Thread-0] [c.g.h.r.c.c.RpcClient.run] - RPC 服务启动客户端完成，监听端口：9527
  10. 十月 05, 2021 11:54:13 上午 io.netty.handler.logging.LoggingHandler write
  11. 信息: [id: 0x4d75c580, L:/127.0.0.1:54030 - R:/127.0.0.1:9527] WRITE: 8B
  12.          +-------------------------------------------------+
  13.          |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
  14. +--------+-------------------------------------------------+----------------+
  15. |00000000| 00 00 00 01 00 00 00 02                         |........        |
  16. +--------+-------------------------------------------------+----------------+
  17. 十月 05, 2021 11:54:13 上午 io.netty.handler.logging.LoggingHandler flush
  18. 信息: [id: 0x4d75c580, L:/127.0.0.1:54030 - R:/127.0.0.1:9527] FLUSH
  19. [INFO] [2021-10-05 11:54:13.450] [nioEventLoopGroup-2-1] [c.g.h.r.c.c.RpcClient.channelActive] - [Client] request is :CalculateRequest{one=1, two=2}
  20. 十月 05, 2021 11:54:13 上午 io.netty.handler.logging.LoggingHandler channelRead
  21. 信息: [id: 0x4d75c580, L:/127.0.0.1:54030 - R:/127.0.0.1:9527] READ: 5B
  22.          +-------------------------------------------------+
  23.          |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
  24. +--------+-------------------------------------------------+----------------+
  25. |00000000| 01 00 00 00 03                                  |.....           |
  26. +--------+-------------------------------------------------+----------------+
  27. 十月 05, 2021 11:54:13 上午 io.netty.handler.logging.LoggingHandler channelReadComplete
  28. 信息: [id: 0x4d75c580, L:/127.0.0.1:54030 - R:/127.0.0.1:9527] READ COMPLETE
  29. [INFO] [2021-10-05 11:54:13.508] [nioEventLoopGroup-2-1] [c.g.h.r.c.c.RpcClient.channelRead0] - [Client] response is :CalculateResponse{success=true, sum=3}

可以看到，输出了对应的请求参数和响应结果。

当然，此时服务端也有对应的新增日志：

  1. 十月 05, 2021 11:54:13 上午 io.netty.handler.logging.LoggingHandler channelRead
  2. 信息: [id: 0xd399474f, L:/0:0:0:0:0:0:0:0:9527] READ: [id: 0xbc9f5927, L:/127.0.0.1:9527 - R:/127.0.0.1:54030]
  3. 十月 05, 2021 11:54:13 上午 io.netty.handler.logging.LoggingHandler channelReadComplete
  4. 信息: [id: 0xd399474f, L:/0:0:0:0:0:0:0:0:9527] READ COMPLETE
  5. [INFO] [2021-10-05 11:54:13.432] [nioEventLoopGroup-2-1] [c.g.h.r.s.h.RpcServerHandler.channelActive] - [Server] channel {} connected 00e04cfffe360988-00001d34-00000001-2a80d950d8166c0c-bc9f5927
  6. [INFO] [2021-10-05 11:54:13.495] [nioEventLoopGroup-2-1] [c.g.h.r.s.h.RpcServerHandler.channelRead0] - [Server] receive channel 00e04cfffe360988-00001d34-00000001-2a80d950d8166c0c-bc9f5927 request: CalculateRequest{one=1, two=2} from
  7. [INFO] [2021-10-05 11:54:13.505] [nioEventLoopGroup-2-1] [c.g.h.r.s.h.RpcServerHandler.channelRead0] - [Server] channel 00e04cfffe360988-00001d34-00000001-2a80d950d8166c0c-bc9f5927 response CalculateResponse{success=true, sum=3}

小结

为了便于大家学习，以上源码已经开源：

https://github.com/houbb/rpc

希望本文对你有所帮助，如果喜欢，欢迎点赞收藏转发一波。

我是老马，期待与你的下次相遇。

java 从零开始手写 RPC (03) 如何实现客户端调用服务端？的更多相关文章

  1. java 从零开始手写 RPC (04) -序列化

    序列化 java 从零开始手写 RPC (01) 基于 socket 实现 java 从零开始手写 RPC (02)-netty4 实现客户端和服务端 java 从零开始手写 RPC (03) 如何实 ...

  2. java 从零开始手写 RPC (05) reflect 反射实现通用调用之服务端

    通用调用 java 从零开始手写 RPC (01) 基于 socket 实现 java 从零开始手写 RPC (02)-netty4 实现客户端和服务端 java 从零开始手写 RPC (03) 如何 ...

  3. java 从零开始手写 RPC (07)-timeout 超时处理

    <过时不候> 最漫长的莫过于等待 我们不可能永远等一个人 就像请求 永远等待响应 超时处理 java 从零开始手写 RPC (01) 基于 socket 实现 java 从零开始手写 RP ...

  4. java 从零开始手写 RPC (01) 基于 websocket 实现

    RPC 解决的问题 RPC 主要是为了解决的两个问题: 解决分布式系统中,服务之间的调用问题. 远程调用时,要能够像本地调用一样方便,让调用者感知不到远程调用的逻辑. 这一节我们来学习下如何基于 we ...

  5. 从零开始手写 dubbo rpc 框架

    rpc rpc 是基于 netty 实现的 java rpc 框架,类似于 dubbo. 主要用于个人学习,由渐入深,理解 rpc 的底层实现原理. 前言 工作至今,接触 rpc 框架已经有很长时间. ...

  6. 手写RPC框架指北另送贴心注释代码一套

    Angular8正式发布了,Java13再过几个月也要发布了,技术迭代这么快,框架的复杂度越来越大,但是原理是基本不变的.所以沉下心看清代码本质很重要,这次给大家带来的是手写RPC框架. 完整代码以及 ...

  7. 看了这篇你就会手写RPC框架了

    一.学习本文你能学到什么? RPC的概念及运作流程 RPC协议及RPC框架的概念 Netty的基本使用 Java序列化及反序列化技术 Zookeeper的基本使用(注册中心) 自定义注解实现特殊业务逻 ...

  8. 手写RPC框架（六）整合Netty

    手写RPC框架(六)整合Netty Netty简介: Netty是一个基于NIO的,提供异步,事件驱动的网络应用工具,具有高性能高可靠性等特点. 使用传统的Socket来进行网络通信,服务端每一个连接 ...

  9. 【MQ】java 从零开始实现消息队列 mq-02-如何实现生产者调用消费者？

    前景回顾 上一节我们学习了如何实现基于 netty 客服端和服务端的启动. [mq]从零开始实现 mq-01-生产者.消费者启动 [mq]java 从零开始实现消息队列 mq-02-如何实现生产者调用 ...

随机推荐

  1. 刷题-力扣-1738. 找出第 K 大的异或坐标值

    1738. 找出第 K 大的异或坐标值 题目链接 来源:力扣(LeetCode) 链接:https://leetcode-cn.com/problems/find-kth-largest-xor-co ...

  2. cs_play

    # -*-coding:utf-8-*-__author__ = "logan.xu"###构造函数#class Role:# n = 123# # 类变量 比如 n = 123# ...

  3. Spring笔记（2）

    一.AOP简介 1.概念: 面向切面编程(Aspect-Oriented Programming),可以说是OOP(Object-Oriented Programing,面向对象编程)的补充和完善. ...

  4. VMware 部署虚拟环境

    2021-08-23 1. 版本介绍 本地主机操作系统:windows 10虚拟软件版本:VMware workstation 14centos镜像版本:centos 7.5 2. 设置 2.1 基础 ...

  5. centos7 配置 ftp 服务器（本地用户）

    2021-09-02 1. 安装 # 安装 vsftpd yum -y install vsftpd 2. 启动服务并添加到开机自启 # 启动 vsftpd systemctl start vsftp ...

  6. python variable scope 变量作用域

    python 中变量的作用域经常让我感到很迷 In Python, on the other hand, variables declared in if-statements, for-loop b ...

  7. RabbitMQ-进阶

    目录 过期时间TTL 设置队列TTL 消息确认机制的配置 死信队列 内存磁盘的监控 RabbitMQ的内存控制 命令的方式 配置文件方式 rabbitmq.conf RabbitMQ的内存换页 Rab ...

  8. Vue 2.0 与 Vue 3.0 响应式原理比较

    Vue 2.0 的响应式是基于Object.defineProperty实现的 当你把一个普通的 JavaScript 对象传入 Vue 实例作为 data 选项,Vue 将遍历此对象所有的 prop ...

  9. Docker编排工具Docker Compose的使用

    一.安装docker compose 官网推荐方式之一: sudo curl -L "https://github.com/docker/compose/releases/download/ ...

  10. Mysql常用sql语句（10）- is null 空值查询

    测试必备的Mysql常用sql语句系列 https://www.cnblogs.com/poloyy/category/1683347.html 前言 is null是一个关键字来的,用于判断字段的值 ...