基于netty的rpc框架

基于netty的rpc框架

[TOC]

如果你已经对以下东东有所了解，那么你就可以完成一个rpc框架了

• Java的反射技术
• java的动态代理机制
• 基于nio的框架netty
• 全世界最好的框架-spring
• java的序列化

神马是rpc？

• 在这个大数据时代，很多公司的服务器都是以集群的方式存在的。在我们传统的mvc后台开发中，我们就需要把不同层的服务部署到不同的服务器上面，这个每个服务器的的压力就会比较小了。

  但是这样也会带来一个问题——我在这台机器上如何才能调用到另一台机器的代码呢？这是个问题。

  我们先来举个栗子：

  

  这里写图片描述

  比如我们在一个传统mvc项目中，我们有一个UserController处理用户的请求，假如它长的这个样子：

  @RestController
  @RequestMapping(value = "/user")
  public class UserController {
  
      @Autowired
      UserService userService;
  
      @RequestMapping(value = "/current")
      public AjaxResponse login(String name,String password) {
          return AjaxResponse.success(userService.login(name,password));
      }
  }
  

  正常情况下，这个UserService的实现肯定是在同一个项目或者是本地的，早就已经被加入到spring容器中了，不过加入我们为了减少服务器的压力，我们将UserService的实现放到另一台服务器上，加入我们有一个膜法，可以在本地的Controller像调用本地方法一样调用另一台的userServiceImpl就好了，Rpc就是这样一种技术。

实现思路

• 表面上看这是一个很难完成的任务，本机怎么可能可以调用到远程的方法呢？不过如果我们这个任务拆分开来，就会发现只要一步一步来，其实还是挺简单的。

  我们可以换一种思路，既然直接调用不行，我们可以曲线救国呀，我们只要把调用方法的对象的名称，方法的名字，方法的参数与方法的类型都通过网络发送到另一台机器上，另一条机器接收到之后根据请求信息调用该对象的方法，然后在把执行结果通过网路直接返回回来不就ok了。其实，rpc框架的大体思路就是如此。

• 大体实现流程如下：

  1. 通过java的动态代理机制为我们UserService创建代理对象，在代理对象执行方法的时候实际上已经被我们定制的方法拦截。
  2. 在拦截的逻辑里面，我们在获取到调用的方法的所有接口，方法名，参数集合，参数类型集合后封装到一个JavaBean——request中去，然后我们将这个对象序列化之后通过网络传输到另一台机器上。
  3. 另一台机器接受到这个网络请求后，将数据反序列化为Request对象，从而了解我们请求的是具体是什么对象的什么方法，然后服务器通过反射的方式调用，并将执行结果通过另一个JavaBean——Response返回。
  4. 本机收到服务端的返回。整个rpc调用就完成了。

• 如下图所示，由于画图水平有限，不过大致就是这个意思：

  

  这里写图片描述

代码具体实现

1. 首先我们需要为我们的网络请求分装两个JavaBean，分别为Request与Response.。

   //在Request中应有的属性
   private String requestId;
   private String className;
   private String methodName;
   private Class[] parameterTypes;
   private Object[] parameters;
   //在response应该有的属性
   private String requestId;
   private Throwable error;
   private Object result;
   

2. 创建RpcClient，封装我们的网络请求流程。其中最重要的是这个方法：

   public Response send(Request request) throws InterruptedException {
           ClientBootstrap bootstrap = new ClientBootstrap();
           ExecutorService boss = Executors.newCachedThreadPool();
           ExecutorService work = Executors.newCachedThreadPool();
   
           bootstrap.setFactory(new NioClientSocketChannelFactory(boss,work));
           bootstrap.setPipelineFactory(new ChannelPipelineFactory() {
               @Override
               public ChannelPipeline getPipeline() throws Exception {
                   ChannelPipeline pipeline = Channels.pipeline();
                   pipeline.addLast("decoder",new ResponseDecoder());
                   pipeline.addLast("encoder",new RequestEncoder());
                   pipeline.addLast("handler",RpcClient.this);
                   return pipeline;
               }
           });
           ChannelFuture connect = bootstrap.connect(new InetSocketAddress(address, port)).sync();
           connect.getChannel().write(request).sync();
            //阻塞线程直到完成请求或者请求失败
           synchronized (obj){
               obj.wait();
           }
           connect.getChannel().close().sync();
   
           return this.response;
       }
   

   这里用netty3进行的网咯请求，这里ResponseDecoder与RequestEncoder是对Response与Request进行的序列化与反序列化，采用的谷歌的Protostuff序列化框架实现（为啥不用java自带的序列化工具呢？因为java自定的序列化附带了很多其他信息，序列化的字节长度比谷歌的长好几倍，所以是为了节约带宽，同时Protostuff的序列化支持多种编程语言）

3. 创建代理的工具类，返回代理对象。

   public T proxy(Class clazz){
           return (T) Proxy.newProxyInstance(clazz.getClassLoader(), new Class[] { clazz }, new InvocationHandler() {
               public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                   Request request = new Request();
                   request.setClassName(method.getDeclaringClass().getName());
                   request.setMethodName(method.getName());
                   request.setParameters(args);
                   request.setRequestId(UUID.randomUUID().toString());
                   request.setParameterTypes(method.getParameterTypes());
                   RpcClient client =new RpcClient(address,port);
                    //通过封装的网络框架进行网络请求
                   Response response = client.send(request);
                   if (response.getError()!=null){
                       throw response.getError();
                   }
                   else{
                       return response;
                   }
               }
           });
       }
   

4. 服务端在开启服务的时候就需要通过spring扫描所有的service实现类，将其装进spring的容器中。

   public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
           Map beansWithAnnotation = applicationContext.getBeansWithAnnotation(RPCService.class);
           for(Map.Entry entry :beansWithAnnotation.entrySet()){
               String interfaceName = entry.getValue().getClass()
                       .getAnnotation(RPCService.class).value().getName();
               serviceMap.put(interfaceName,entry.getValue());
           }
           startServer();
       }
   

   需要发布的服务类都需要使用@RPCService注解，这是一个自定义的注解。

5. 在服务端收到客户端的网络请求之后，我们就需要从spring容器中找到请求的服务类完成调用并返回执行结果。

   @Override
       public void messageReceived(ChannelHandlerContext ctx, MessageEvent event) throws Exception {
           Request request = (Request) event.getMessage();
           Response response = new Response();
           //调用请求类的请求方法执行并返回执行结果
           Object invoke = null;
           try {
               Object requestBean = serviceMap.get(request.getClassName());
               Class requestClazz = Class.forName(request.getClassName());
               Method method = requestClazz.getMethod(request.getMethodName(), request.getParameterTypes());
               invoke = method.invoke(requestBean, request.getParameters());
               response.setRequestId(UUID.randomUUID().toString());
               response.setResult(invoke);
           } catch (Exception e) {
               response.setError(e);
               response.setRequestId(UUID.randomUUID().toString());
           }
           System.out.println(request+""+response);
           //返回执行结果
           ctx.getChannel().write(response);
   
       }
   

总结

• 整体的流程还是比较简单的，就是具体实现的时候会有一些细节问题需要好好处理。虽然是第一次写这种轮子程序，不过感觉还是不错的。完整代码已上传到我的GitHub仓库里面，有兴趣的小伙伴可以去看看。