文章详情

登录

短信预约-IT技能 免费直播动态提醒

选择考试省份

  • 北京
  • 上海
  • 天津
  • 重庆
  • 河北
  • 山东
  • 辽宁
  • 黑龙江
  • 吉林
  • 甘肃
  • 青海
  • 河南
  • 江苏
  • 湖北
  • 湖南
  • 江西
  • 浙江
  • 广东
  • 云南
  • 福建
  • 海南
  • 山西
  • 四川
  • 陕西
  • 贵州
  • 安徽
  • 广西
  • 内蒙
  • 西藏
  • 新疆
  • 宁夏
  • 兵团

请输入下面的图形验证码

提交验证

短信预约提醒成功

Java 从零开始手写 一 Reflect 反射实现通用调用之客户端

2024-12-02 19:03

关注

上一篇我们介绍了，如何实现基于反射的通用服务端。

这一节我们来一起学习下如何实现通用客户端。

因为内容较多，所以拆分为 2 个部分。

基本思路

所有的方法调用，基于反射进行相关处理实现。

[[431417]]

核心类

为了便于拓展，我们把核心类调整如下：

  1. package com.github.houbb.rpc.client.core; 
  2.  
  3.  
  4. import com.github.houbb.heaven.annotation.ThreadSafe; 
  5. import com.github.houbb.log.integration.core.Log; 
  6. import com.github.houbb.log.integration.core.LogFactory; 
  7. import com.github.houbb.rpc.client.core.context.RpcClientContext; 
  8. import com.github.houbb.rpc.client.handler.RpcClientHandler; 
  9. import com.github.houbb.rpc.common.constant.RpcConstant; 
  10. import io.netty.bootstrap.Bootstrap; 
  11. import io.netty.channel.*; 
  12. import io.netty.channel.nio.NioEventLoopGroup; 
  13. import io.netty.channel.socket.nio.NioSocketChannel; 
  14. import io.netty.handler.codec.serialization.ClassResolvers; 
  15. import io.netty.handler.codec.serialization.ObjectDecoder; 
  16. import io.netty.handler.codec.serialization.ObjectEncoder; 
  17. import io.netty.handler.logging.LogLevel; 
  18. import io.netty.handler.logging.LoggingHandler; 
  19.  
  20.  
  21.  
  22. @ThreadSafe 
  23. public class RpcClient { 
  24.  
  25.  
  26.     private static final Log log = LogFactory.getLog(RpcClient.class); 
  27.  
  28.  
  29.      
  30.     private final String address; 
  31.  
  32.  
  33.      
  34.     private final int port; 
  35.  
  36.  
  37.      
  38.     private final ChannelHandler channelHandler; 
  39.  
  40.  
  41.     public RpcClient(final RpcClientContext clientContext) { 
  42.         this.address = clientContext.address(); 
  43.         this.port = clientContext.port(); 
  44.         this.channelHandler = clientContext.channelHandler(); 
  45.     } 
  46.  
  47.  
  48.      
  49.     public ChannelFuture connect() { 
  50.         // 启动服务端 
  51.         log.info("RPC 服务开始启动客户端"); 
  52.  
  53.  
  54.         EventLoopGroup workerGroup = new NioEventLoopGroup(); 
  55.  
  56.  
  57.          
  58.         ChannelFuture channelFuture; 
  59.         try { 
  60.             Bootstrap bootstrap = new Bootstrap(); 
  61.             channelFuture = bootstrap.group(workerGroup) 
  62.                     .channel(NioSocketChannel.class) 
  63.                     .option(ChannelOption.SO_KEEPALIVE, true) 
  64.                     .handler(new ChannelInitializer(){ 
  65.                         @Override 
  66.                         protected void initChannel(Channel ch) throws Exception { 
  67.                             ch.pipeline() 
  68.                                     // 解码 bytes=>resp 
  69.                                     .addLast(new ObjectDecoder(Integer.MAX_VALUE, ClassResolvers.cacheDisabled(null))) 
  70.                                     // request=>bytes 
  71.                                     .addLast(new ObjectEncoder()) 
  72.                                     // 日志输出 
  73.                                     .addLast(new LoggingHandler(LogLevel.INFO)) 
  74.                                     .addLast(channelHandler); 
  75.                         } 
  76.                     }) 
  77.                     .connect(address, port) 
  78.                     .syncUninterruptibly(); 
  79.             log.info("RPC 服务启动客户端完成，监听地址 {}:{}", address, port); 
  80.         } catch (Exception e) { 
  81.             log.error("RPC 客户端遇到异常", e); 
  82.             throw new RuntimeException(e); 
  83.         } 
  84.         // 不要关闭线程池！！！ 
  85.  
  86.  
  87.         return channelFuture; 
  88.     } 
  89.  
  90.  
  91. } 

可以灵活指定对应的服务端地址、端口信息。

ChannelHandler 作为处理参数传入。

ObjectDecoder、ObjectEncoder、LoggingHandler 都和服务端类似，是 netty 的内置实现。

RpcClientHandler

客户端的 handler 实现如下：

  1.  
  2.  
  3.  
  4. package com.github.houbb.rpc.client.handler; 
  5.  
  6.  
  7. import com.github.houbb.log.integration.core.Log; 
  8. import com.github.houbb.log.integration.core.LogFactory; 
  9. import com.github.houbb.rpc.client.core.RpcClient; 
  10. import com.github.houbb.rpc.client.invoke.InvokeService; 
  11. import com.github.houbb.rpc.common.rpc.domain.RpcResponse; 
  12. import io.netty.channel.ChannelHandlerContext; 
  13. import io.netty.channel.SimpleChannelInboundHandler; 
  14.  
  15.  
  16.  
  17. public class RpcClientHandler extends SimpleChannelInboundHandler { 
  18.  
  19.  
  20.     private static final Log log = LogFactory.getLog(RpcClient.class); 
  21.  
  22.  
  23.      
  24.     private final InvokeService invokeService; 
  25.  
  26.  
  27.     public RpcClientHandler(InvokeService invokeService) { 
  28.         this.invokeService = invokeService; 
  29.     } 
  30.  
  31.  
  32.     @Override 
  33.     protected void channelRead0(ChannelHandlerContext ctx, Object msg) throws Exception { 
  34.         RpcResponse rpcResponse = (RpcResponse)msg; 
  35.         invokeService.addResponse(rpcResponse.seqId(), rpcResponse); 
  36.         log.info("[Client] response is :{}", rpcResponse); 
  37.     } 
  38.  
  39.  
  40.     @Override 
  41.     public void channelReadComplete(ChannelHandlerContext ctx) throws Exception { 
  42.         // 每次用完要关闭，不然拿不到response，我也不知道为啥（目测得了解netty才行） 
  43.         // 个人理解：如果不关闭，则永远会被阻塞。 
  44.         ctx.flush(); 
  45.         ctx.close(); 
  46.     } 
  47.  
  48.  
  49.     @Override 
  50.     public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception { 
  51.         cause.printStackTrace(); 
  52.         ctx.close(); 
  53.     } 
  54. } 

 只有 channelRead0 做了调整，基于 InvokeService 对结果进行处理。

InvokeService

接口

  1. package com.github.houbb.rpc.client.invoke; 
  2.  
  3.  
  4. import com.github.houbb.rpc.common.rpc.domain.RpcResponse; 
  5.  
  6.  
  7.  
  8. public interface InvokeService { 
  9.  
  10.  
  11.      
  12.     InvokeService addRequest(final String seqId); 
  13.  
  14.  
  15.      
  16.     InvokeService addResponse(final String seqId, final RpcResponse rpcResponse); 
  17.  
  18.  
  19.      
  20.     RpcResponse getResponse(final String seqId); 
  21.  
  22.  
  23. } 

 主要是对入参、出参的设置，以及出参的获取。

实现

  1. package com.github.houbb.rpc.client.invoke.impl; 
  2.  
  3.  
  4. import com.github.houbb.heaven.util.guava.Guavas; 
  5. import com.github.houbb.heaven.util.lang.ObjectUtil; 
  6. import com.github.houbb.log.integration.core.Log; 
  7. import com.github.houbb.log.integration.core.LogFactory; 
  8. import com.github.houbb.rpc.client.core.RpcClient; 
  9. import com.github.houbb.rpc.client.invoke.InvokeService; 
  10. import com.github.houbb.rpc.common.exception.RpcRuntimeException; 
  11. import com.github.houbb.rpc.common.rpc.domain.RpcResponse; 
  12.  
  13.  
  14. import java.util.Set; 
  15. import java.util.concurrent.ConcurrentHashMap; 
  16.  
  17.  
  18.  
  19. public class DefaultInvokeService implements InvokeService { 
  20.  
  21.  
  22.     private static final Log LOG = LogFactory.getLog(DefaultInvokeService.class); 
  23.  
  24.  
  25.      
  26.     private final Set requestSet; 
  27.  
  28.  
  29.      
  30.     private final ConcurrentHashMap responseMap; 
  31.  
  32.  
  33.     public DefaultInvokeService() { 
  34.         requestSet = Guavas.newHashSet(); 
  35.         responseMap = new ConcurrentHashMap<>(); 
  36.     } 
  37.  
  38.  
  39.     @Override 
  40.     public InvokeService addRequest(String seqId) { 
  41.         LOG.info("[Client] start add request for seqId: {}", seqId); 
  42.         requestSet.add(seqId); 
  43.         return this; 
  44.     } 
  45.  
  46.  
  47.     @Override 
  48.     public InvokeService addResponse(String seqId, RpcResponse rpcResponse) { 
  49.         // 这里放入之前，可以添加判断。 
  50.         // 如果 seqId 必须处理请求集合中，才允许放入。或者直接忽略丢弃。 
  51.         LOG.info("[Client] 获取结果信息，seq: {}, rpcResponse: {}", seqId, rpcResponse); 
  52.         responseMap.putIfAbsent(seqId, rpcResponse); 
  53.  
  54.  
  55.         // 通知所有等待方 
  56.         LOG.info("[Client] seq 信息已经放入，通知所有等待方", seqId); 
  57.  
  58.  
  59.         synchronized (this) { 
  60.             this.notifyAll(); 
  61.         } 
  62.  
  63.  
  64.         return this; 
  65.     } 
  66.  
  67.  
  68.     @Override 
  69.     public RpcResponse getResponse(String seqId) { 
  70.         try { 
  71.             RpcResponse rpcResponse = this.responseMap.get(seqId); 
  72.             if(ObjectUtil.isNotNull(rpcResponse)) { 
  73.                 LOG.info("[Client] seq {} 对应结果已经获取: {}", seqId, rpcResponse); 
  74.                 return rpcResponse; 
  75.             } 
  76.  
  77.  
  78.             // 进入等待 
  79.             while (rpcResponse == null) { 
  80.                 LOG.info("[Client] seq {} 对应结果为空，进入等待", seqId); 
  81.                 // 同步等待锁 
  82.                 synchronized (this) { 
  83.                     this.wait(); 
  84.                 } 
  85.  
  86.  
  87.                 rpcResponse = this.responseMap.get(seqId); 
  88.                 LOG.info("[Client] seq {} 对应结果已经获取: {}", seqId, rpcResponse); 
  89.             } 
  90.  
  91.  
  92.             return rpcResponse; 
  93.         } catch (InterruptedException e) { 
  94.             throw new RpcRuntimeException(e); 
  95.         } 
  96.     } 
  97. } 

 使用 requestSet 存储对应的请求入参。

使用 responseMap 存储对应的请求出参，在获取的时候通过同步 while 循环等待，获取结果。

此处，通过 notifyAll() 和 wait() 进行等待和唤醒。

ReferenceConfig-服务端配置

说明

我们想调用服务端，首先肯定要定义好要调用的对象。

ReferenceConfig 就是要告诉 rpc 框架，调用的服务端信息。

接口

  1. package com.github.houbb.rpc.client.config.reference; 
  2.  
  3.  
  4. import com.github.houbb.rpc.common.config.component.RpcAddress; 
  5.  
  6.  
  7. import java.util.List; 
  8.  
  9.  
  10.  
  11. public interface ReferenceConfig { 
  12.  
  13.  
  14.      
  15.     ReferenceConfig serviceId(final String serviceId); 
  16.  
  17.  
  18.      
  19.     String serviceId(); 
  20.  
  21.  
  22.      
  23.     Class serviceInterface(); 
  24.  
  25.  
  26.      
  27.     ReferenceConfig serviceInterface(final Class serviceInterface); 
  28.  
  29.  
  30.      
  31.     ReferenceConfig addresses(final String addresses); 
  32.  
  33.  
  34.      
  35.     T reference(); 
  36.  
  37.  
  38. } 

实现

  1. package com.github.houbb.rpc.client.config.reference.impl; 
  2.  
  3.  
  4. import com.github.houbb.heaven.constant.PunctuationConst; 
  5. import com.github.houbb.heaven.util.common.ArgUtil; 
  6. import com.github.houbb.heaven.util.guava.Guavas; 
  7. import com.github.houbb.heaven.util.lang.NumUtil; 
  8. import com.github.houbb.rpc.client.config.reference.ReferenceConfig; 
  9. import com.github.houbb.rpc.client.core.RpcClient; 
  10. import com.github.houbb.rpc.client.core.context.impl.DefaultRpcClientContext; 
  11. import com.github.houbb.rpc.client.handler.RpcClientHandler; 
  12. import com.github.houbb.rpc.client.invoke.InvokeService; 
  13. import com.github.houbb.rpc.client.invoke.impl.DefaultInvokeService; 
  14. import com.github.houbb.rpc.client.proxy.ReferenceProxy; 
  15. import com.github.houbb.rpc.client.proxy.context.ProxyContext; 
  16. import com.github.houbb.rpc.client.proxy.context.impl.DefaultProxyContext; 
  17. import com.github.houbb.rpc.common.config.component.RpcAddress; 
  18. import io.netty.channel.ChannelFuture; 
  19. import io.netty.channel.ChannelHandler; 
  20.  
  21.  
  22. import java.util.List; 
  23.  
  24.  
  25.  
  26. public class DefaultReferenceConfig implements ReferenceConfig { 
  27.  
  28.  
  29.      
  30.     private String serviceId; 
  31.  
  32.  
  33.      
  34.     private Class serviceInterface; 
  35.  
  36.  
  37.      
  38.     private List rpcAddresses; 
  39.  
  40.  
  41.      
  42.     private List channelFutures; 
  43.  
  44.  
  45.      
  46.     @Deprecated 
  47.     private RpcClientHandler channelHandler; 
  48.  
  49.  
  50.      
  51.     private InvokeService invokeService; 
  52.  
  53.  
  54.     public DefaultReferenceConfig() { 
  55.         // 初始化信息 
  56.         this.rpcAddresses = Guavas.newArrayList(); 
  57.         this.channelFutures = Guavas.newArrayList(); 
  58.         this.invokeService = new DefaultInvokeService(); 
  59.     } 
  60.  
  61.  
  62.     @Override 
  63.     public String serviceId() { 
  64.         return serviceId; 
  65.     } 
  66.  
  67.  
  68.     @Override 
  69.     public DefaultReferenceConfig serviceId(String serviceId) { 
  70.         this.serviceId = serviceId; 
  71.         return this; 
  72.     } 
  73.  
  74.  
  75.     @Override 
  76.     public Class serviceInterface() { 
  77.         return serviceInterface; 
  78.     } 
  79.  
  80.  
  81.     @Override 
  82.     public DefaultReferenceConfig serviceInterface(Class serviceInterface) { 
  83.         this.serviceInterface = serviceInterface; 
  84.         return this; 
  85.     } 
  86.  
  87.  
  88.     @Override 
  89.     public ReferenceConfig addresses(String addresses) { 
  90.         ArgUtil.notEmpty(addresses, "addresses"); 
  91.  
  92.  
  93.         String[] addressArray = addresses.split(PunctuationConst.COMMA); 
  94.         ArgUtil.notEmpty(addressArray, "addresses"); 
  95.  
  96.  
  97.         for(String address : addressArray) { 
  98.             String[] addressSplits = address.split(PunctuationConst.COLON); 
  99.             if(addressSplits.length < 2) { 
  100.                 throw new IllegalArgumentException("Address must be has ip and port, like 127.0.0.1:9527"); 
  101.             } 
  102.             String ip = addressSplits[0]; 
  103.             int port = NumUtil.toIntegerThrows(addressSplits[1]); 
  104.             // 包含权重信息 
  105.             int weight = 1; 
  106.             if(addressSplits.length >= 3) { 
  107.                 weight = NumUtil.toInteger(addressSplits[2], 1); 
  108.             } 
  109.  
  110.  
  111.             RpcAddress rpcAddress = new RpcAddress(ip, port, weight); 
  112.             this.rpcAddresses.add(rpcAddress); 
  113.         } 
  114.  
  115.  
  116.         return this; 
  117.     } 
  118.  
  119.  
  120.      
  121.     @Override 
  122.     public T reference() { 
  123.         // 1. 启动 client 端到 server 端的连接信息 
  124.         // 1.1 为了提升性能，可以将所有的 client=>server 的连接都调整为一个 thread。 
  125.         // 1.2 初期为了简单，直接使用同步循环的方式。 
  126.         // 创建 handler 
  127.         // 循环连接 
  128.         for(RpcAddress rpcAddress : rpcAddresses) { 
  129.             final ChannelHandler channelHandler = new RpcClientHandler(invokeService); 
  130.             final DefaultRpcClientContext context = new DefaultRpcClientContext(); 
  131.             context.address(rpcAddress.address()).port(rpcAddress.port()).channelHandler(channelHandler); 
  132.             ChannelFuture channelFuture = new RpcClient(context).connect(); 
  133.             // 循环同步等待 
  134.             // 如果出现异常，直接中断？捕获异常继续进行？？ 
  135.             channelFutures.add(channelFuture); 
  136.         } 
  137.  
  138.  
  139.         // 2. 接口动态代理 
  140.         ProxyContext proxyContext = buildReferenceProxyContext(); 
  141.         return ReferenceProxy.newProxyInstance(proxyContext); 
  142.     } 
  143.  
  144.  
  145.      
  146.     private ProxyContext buildReferenceProxyContext() { 
  147.         DefaultProxyContext proxyContext = new DefaultProxyContext<>(); 
  148.         proxyContext.serviceId(this.serviceId); 
  149.         proxyContext.serviceInterface(this.serviceInterface); 
  150.         proxyContext.channelFutures(this.channelFutures); 
  151.         proxyContext.invokeService(this.invokeService); 
  152.         return proxyContext; 
  153.     } 
  154.  
  155.  
  156. } 

 这里主要根据指定的服务端信息，初始化对应的代理实现。

这里还可以拓展指定权重，便于后期负载均衡拓展，本期暂时不做实现。

ReferenceProxy

说明

所有的 rpc 调用，客户端只有服务端的接口。

那么，怎么才能和调用本地方法一样调用远程方法呢?

答案就是动态代理。

实现

实现如下：

  1. package com.github.houbb.rpc.client.proxy; 
  2.  
  3.  
  4. import com.github.houbb.heaven.util.lang.ObjectUtil; 
  5. import com.github.houbb.heaven.util.lang.reflect.ReflectMethodUtil; 
  6. import com.github.houbb.log.integration.core.Log; 
  7. import com.github.houbb.log.integration.core.LogFactory; 
  8. import com.github.houbb.rpc.client.proxy.context.ProxyContext; 
  9. import com.github.houbb.rpc.common.rpc.domain.RpcResponse; 
  10. import com.github.houbb.rpc.common.rpc.domain.impl.DefaultRpcRequest; 
  11. import com.github.houbb.rpc.common.support.id.impl.Uuid; 
  12. import com.github.houbb.rpc.common.support.time.impl.DefaultSystemTime; 
  13. import io.netty.channel.Channel; 
  14.  
  15.  
  16. import java.lang.reflect.InvocationHandler; 
  17. import java.lang.reflect.Method; 
  18. import java.lang.reflect.Proxy; 
  19.  
  20.  
  21.  
  22. public class ReferenceProxy implements InvocationHandler { 
  23.  
  24.  
  25.     private static final Log LOG = LogFactory.getLog(ReferenceProxy.class); 
  26.  
  27.  
  28.      
  29.     private final ProxyContext proxyContext; 
  30.  
  31.  
  32.      
  33.     private ReferenceProxy(ProxyContext proxyContext) { 
  34.         this.proxyContext = proxyContext; 
  35.     } 
  36.  
  37.  
  38.      
  39.     @Override 
  40.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
  41.         // 反射信息处理成为 rpcRequest 
  42.         final String seqId = Uuid.getInstance().id(); 
  43.         final long createTime = DefaultSystemTime.getInstance().time(); 
  44.         DefaultRpcRequest rpcRequest = new DefaultRpcRequest(); 
  45.         rpcRequest.serviceId(proxyContext.serviceId()); 
  46.         rpcRequest.seqId(seqId); 
  47.         rpcRequest.createTime(createTime); 
  48.         rpcRequest.paramValues(args); 
  49.         rpcRequest.paramTypeNames(ReflectMethodUtil.getParamTypeNames(method)); 
  50.         rpcRequest.methodName(method.getName()); 
  51.  
  52.  
  53.         // 调用远程 
  54.         LOG.info("[Client] start call remote with request: {}", rpcRequest); 
  55.         proxyContext.invokeService().addRequest(seqId); 
  56.  
  57.  
  58.         // 这里使用 load-balance 进行选择 channel 写入。 
  59.         final Channel channel = getChannel(); 
  60.         LOG.info("[Client] start call channel id: {}", channel.id().asLongText()); 
  61.  
  62.  
  63.         // 对于信息的写入，实际上有着严格的要求。 
  64.         // writeAndFlush 实际是一个异步的操作，直接使用 sync() 可以看到异常信息。 
  65.         // 支持的必须是 ByteBuf 
  66.         channel.writeAndFlush(rpcRequest).sync(); 
  67.  
  68.  
  69.         // 循环获取结果 
  70.         // 通过 Loop+match  wait/notifyAll 来获取 
  71.         // 分布式根据 redis+queue+loop 
  72.         LOG.info("[Client] start get resp for seqId: {}", seqId); 
  73.         RpcResponse rpcResponse = proxyContext.invokeService().getResponse(seqId); 
  74.         LOG.info("[Client] start get resp for seqId: {}", seqId); 
  75.         Throwable error = rpcResponse.error(); 
  76.         if(ObjectUtil.isNotNull(error)) { 
  77.             throw error; 
  78.         } 
  79.         return rpcResponse.result(); 
  80.     } 
  81.  
  82.  
  83.      
  84.     private Channel getChannel() { 
  85.         return proxyContext.channelFutures().get(0).channel(); 
  86.     } 
  87.  
  88.  
  89.      
  90.     @SuppressWarnings("unchecked") 
  91.     public static  T newProxyInstance(ProxyContext proxyContext) { 
  92.         final Class interfaceClass = proxyContext.serviceInterface(); 
  93.         ClassLoader classLoader = interfaceClass.getClassLoader(); 
  94.         Class[] interfaces = new Class[]{interfaceClass}; 
  95.         ReferenceProxy proxy = new ReferenceProxy(proxyContext); 
  96.         return (T) Proxy.newProxyInstance(classLoader, interfaces, proxy); 
  97.     } 
  98.  
  99.  
  100. } 

客户端初始化 newProxyInstance 的就是创建的代理的过程。

客户端调用远程方法，实际上是调用 invoke 的过程。

(1)构建反射 invoke 请求信息，添加 reqId

(2)netty 远程调用服务端

(3)同步获取响应信息

测试

引入 maven

  1.  
  2.     com.github.houbb 
  3.     rpc-client 
  4.     0.0.6 
  5.  

测试代码

  1. public static void main(String[] args) { 
  2.     // 服务配置信息 
  3.     ReferenceConfig config = new DefaultReferenceConfig(); 
  4.     config.serviceId(ServiceIdConst.CALC); 
  5.     config.serviceInterface(CalculatorService.class); 
  6.     config.addresses("localhost:9527"); 
  7.  
  8.  
  9.     CalculatorService calculatorService = config.reference(); 
  10.     CalculateRequest request = new CalculateRequest(); 
  11.     request.setOne(10); 
  12.     request.setTwo(20); 
  13.  
  14.  
  15.     CalculateResponse response = calculatorService.sum(request); 
  16.     System.out.println(response); 
  17. } 

 测试日志：

  1. [DEBUG] [2021-10-05 14:16:17.534] [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 14:16:17.625] [main] [c.g.h.r.c.c.RpcClient.connect] - RPC 服务开始启动客户端 
  3. ... 
  4. [INFO] [2021-10-05 14:16:19.328] [main] [c.g.h.r.c.c.RpcClient.connect] - RPC 服务启动客户端完成，监听地址 localhost:9527 
  5. [INFO] [2021-10-05 14:16:19.346] [main] [c.g.h.r.c.p.ReferenceProxy.invoke] - [Client] start call remote with request: DefaultRpcRequest{seqId='a525c5a6196545f5a5241b2cdc2ec2c2', createTime=1633414579339, serviceId='calc', methodName='sum', paramTypeNames=[com.github.houbb.rpc.server.facade.model.CalculateRequest], paramValues=[CalculateRequest{one=10, two=20}]} 
  6. [INFO] [2021-10-05 14:16:19.347] [main] [c.g.h.r.c.i.i.DefaultInvokeService.addRequest] - [Client] start add request for seqId: a525c5a6196545f5a5241b2cdc2ec2c2 
  7. [INFO] [2021-10-05 14:16:19.348] [main] [c.g.h.r.c.p.ReferenceProxy.invoke] - [Client] start call channel id: 00e04cfffe360988-000017bc-00000000-399b9d7e1b88839d-5ccc4a29 
  8. 十月 05, 2021 2:16:19 下午 io.netty.handler.logging.LoggingHandler write 
  9. 信息: [id: 0x5ccc4a29, L:/127.0.0.1:50596 - R:localhost/127.0.0.1:9527] WRITE: DefaultRpcRequest{seqId='a525c5a6196545f5a5241b2cdc2ec2c2', createTime=1633414579339, serviceId='calc', methodName='sum', paramTypeNames=[com.github.houbb.rpc.server.facade.model.CalculateRequest], paramValues=[CalculateRequest{one=10, two=20}]} 
  10. 十月 05, 2021 2:16:19 下午 io.netty.handler.logging.LoggingHandler flush 
  11. 信息: [id: 0x5ccc4a29, L:/127.0.0.1:50596 - R:localhost/127.0.0.1:9527] FLUSH 
  12. [INFO] [2021-10-05 14:16:19.412] [main] [c.g.h.r.c.p.ReferenceProxy.invoke] - [Client] start get resp for seqId: a525c5a6196545f5a5241b2cdc2ec2c2 
  13. [INFO] [2021-10-05 14:16:19.413] [main] [c.g.h.r.c.i.i.DefaultInvokeService.getResponse] - [Client] seq a525c5a6196545f5a5241b2cdc2ec2c2 对应结果为空，进入等待 
  14. 十月 05, 2021 2:16:19 下午 io.netty.handler.logging.LoggingHandler channelRead 
  15. 信息: [id: 0x5ccc4a29, L:/127.0.0.1:50596 - R:localhost/127.0.0.1:9527] READ: DefaultRpcResponse{seqId='a525c5a6196545f5a5241b2cdc2ec2c2', error=null, result=CalculateResponse{success=true, sum=30}} 
  16. ... 
  17. [INFO] [2021-10-05 14:16:19.505] [nioEventLoopGroup-2-1] [c.g.h.r.c.i.i.DefaultInvokeService.addResponse] - [Client] 获取结果信息，seq: a525c5a6196545f5a5241b2cdc2ec2c2, rpcResponse: DefaultRpcResponse{seqId='a525c5a6196545f5a5241b2cdc2ec2c2', error=null, result=CalculateResponse{success=true, sum=30}} 
  18. [INFO] [2021-10-05 14:16:19.505] [nioEventLoopGroup-2-1] [c.g.h.r.c.i.i.DefaultInvokeService.addResponse] - [Client] seq 信息已经放入，通知所有等待方 
  19. [INFO] [2021-10-05 14:16:19.506] [nioEventLoopGroup-2-1] [c.g.h.r.c.c.RpcClient.channelRead0] - [Client] response is :DefaultRpcResponse{seqId='a525c5a6196545f5a5241b2cdc2ec2c2', error=null, result=CalculateResponse{success=true, sum=30}} 
  20. [INFO] [2021-10-05 14:16:19.506] [main] [c.g.h.r.c.i.i.DefaultInvokeService.getResponse] - [Client] seq a525c5a6196545f5a5241b2cdc2ec2c2 对应结果已经获取: DefaultRpcResponse{seqId='a525c5a6196545f5a5241b2cdc2ec2c2', error=null, result=CalculateResponse{success=true, sum=30}} 
  21. [INFO] [2021-10-05 14:16:19.507] [main] [c.g.h.r.c.p.ReferenceProxy.invoke] - [Client] start get resp for seqId: a525c5a6196545f5a5241b2cdc2ec2c2 
  22. CalculateResponse{success=true, sum=30} 

小结

现在看来有一个小问题，要求服务端必须指定 port，这有点不太合理，比如代理域名，后续需要优化。

这里的启动声明方式也比较基础，后续可以考虑和 spring 进行整合。

 

来源：今日头条内容投诉

免责声明：

① 本站未注明“稿件来源”的信息均来自网络整理。其文字、图片和音视频稿件的所属权归原作者所有。本站收集整理出于非商业性的教育和科研之目的，并不意味着本站赞同其观点或证实其内容的真实性。仅作为临时的测试数据，供内部测试之用。本站并未授权任何人以任何方式主动获取本站任何信息。

② 本站未注明“稿件来源”的临时测试数据将在测试完成后最终做删除处理。有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

软考中级精品资料免费领

  • 历年真题答案解析
  • 备考技巧名师总结
  • 高频考点精准押题

  • 2024年上半年信息系统项目管理师第二批次真题及答案解析（完整版）

    难度     813人已做
    查看

  • 【考后总结】2024年5月26日信息系统项目管理师第2批次考情分析

    难度     354人已做
    查看

  • 【考后总结】2024年5月25日信息系统项目管理师第1批次考情分析

    难度     318人已做
    查看

  • 2024年上半年软考高项第一、二批次真题考点汇总（完整版）

    难度     435人已做
    查看

  • 2024年上半年系统架构设计师考试综合知识真题

    难度     224人已做
    查看

相关文章

发现更多好内容

猜你喜欢

AI推送时光机

Java 从零开始手写 一 Reflect 反射实现通用调用之客户端

后端开发Java2024-12-02

Java 从零开始手写 RPC—Reflect 反射实现通用调用之服务端

后端开发Java2024-12-02

Java 从零开始手写 RPC—如何实现客户端调用服务端？

后端开发Java2024-12-02

Java 从零开始手写 RPC-Netty4 实现客户端和服务端

后端开发Java2024-12-02
位置：首页-资讯-后端开发
咦！没有更多了？去看看其它编程学习网 内容吧
首页课程
资料下载问答资讯