RPC？揭开他神秘的面纱

RPC是什么？

通常的说法：就是所谓的Remote Procedure Call,即远程过程调用，其实在开发中的实现有很多：socket、rmi、rest、netty等等。那么为什么会有RPC这样的东西存在呢？？？？假如，一个开发者，在开发业务的同时，还要去关注网络的通信问题，对开发者来说，压力确实会大很多，所以才会有各式各样的网络通信框架以保证网络交互过程中的稳定，解放开发者网络方面的问题。

 

RPC只是别人家的孩子？小菜鸟做不了相关的处理？

其实RPC的底层实现机制有很多，实现的方式方法也有很多种，这里记录一次比较简单也比较low的实现（socket+BIO），不过的确能够做到解放开发者对网络的关注。

1、使用的工具：idea     使用maven快速构建项目

注意：可以使用lombok依赖可以减少一定的工作量，后面的bean对象使用了里面的@Data注解。

<dependency>
  <groupId>org.projectlombok</groupId>
  <artifactId>lombok</artifactId>
  <version>1.18.8</version>
</dependency>

2、创建rpc-api工程，即：rpc的定制规则工程

1. 创建定义的UserDto,作为定制的传输对象。（注意实现序列化）
2.   创建UserService,即定制的传输方法                                                                             

      3.使用maven的  clean install 命令发布

 

3、创建rpc-provide工程，即：服务的提供者  ，需要引入rpc-api的依赖

<dependency>
  <groupId>com.qww.rpc</groupId>
  <artifactId>rpc-api</artifactId>
  <version>1.0-SNAPSHOT</version>
</dependency>

• 使用一个UserServiceImpl去实现制定规则的方法----addUser()方法

  

• 创建一个BIOSocketServer类，去接收客户端的请求连接。
• 问题1：使用BIO，只能实现1对1的，即一个线程绑定一个流，怎么办呢？    用线程池+轮询的机制即可。
• 问题2：线程池.submit(线程)中的线程需要干嘛？    无非就是接收请求参数，和处理参数返回的过程。即读，写操作。
• 问题3：服务端需要做什么事情？   除了问题2所述，还有请求的分发问题，这里使用反射来做。

所以，就有以下实现：

• 分发处理类

/**
 * @ClassName:serviceDispatch
 * @Description: 分发处理类
 * @Author:Q-W-W
 * @Date:2019/10/22 22:43
 * @Version:1.0
 **/
public class ServiceDispatch {

    public static Object dispatch(Object requestObj){
        /**
         * requestObj
         * 该对象中会有个标识
         * if(1) ->  userServiceImpl().method();
         * if(2) ->  orderServiceImpl().method();
         * 即根据标识，去调用相应的方法
         *
         * 既然调用的方法很多，那就用优雅的方式去实现-反射
         * 1、类的全路径
         * 2、方法名
         * 3、参数列表
         */
        RpcTransformObj rpcTransformObj = (RpcTransformObj) requestObj;
        String fullClassName = rpcTransformObj.getFullClassName();
        String methodName = rpcTransformObj.getMethodName();
        Object[] args = rpcTransformObj.getArgs();

        Class[] types = new Class[args.length];
        for (int i = 0; i < args.length; i++) {
            types[i] = args[i].getClass();
        }
        Object repsObj = null;
        try {
            Class clazz = Class.forName(fullClassName);
            Method method = clazz.getDeclaredMethod(methodName, types);

            repsObj = method.invoke(clazz.newInstance(), args);
        } catch (Exception e) {
            e.printStackTrace();
        }

        return repsObj;
    }
}

• BIO服务类

  /**
   * @ClassName:BIOSocketServer
   * @Description: BIO服务类
   * @Author:Q-W-W
   * @Date:2019/10/22 22:56
   * @Version:1.0
   **/
  public class BIOSocketServer {
      static ExecutorService executorService = Executors.newFixedThreadPool(100);
  
      public static void startServer(int port) throws Exception {
  
          ServerSocket serverSocket = new ServerSocket(port);
  
          //阻塞等待客户端的连接，一旦连接成功，得到一个socket对象
          /*Socket socket = serverSocket.accept();*/
          //bio存在一个问题：流的阻塞和线程是强绑定关系（1对1，即一个线程操作一个流）
          //解决方案：使用线程池
  
          while(true){
              Socket socket = serverSocket.accept();
              executorService.submit(new RPCRequestHandler(socket));
          }
      }
  }

• RPC请求处理类

  /**
   * @ClassName:RPCRequestHandler
   * @Description: 请求处理类
   * @Author:Q-W-W
   * @Date:2019/10/22 23:03
   * @Version:1.0
   **/
  public class RPCRequestHandler implements Runnable{
      private Socket socket;
  
      public RPCRequestHandler(Socket socket) {
          this.socket = socket;
      }
      @Override
      public void run() {
          ObjectOutputStream oos = null;
          ObjectInputStream ois = null;
          try {
              ois = new ObjectInputStream(socket.getInputStream());
              //获取客户请求的对象
              Object object = ois.readObject();
              Object respObj = ServiceDispatch.dispatch(object);
  
              oos = new ObjectOutputStream(socket.getOutputStream());
              oos.writeObject(respObj);
  
              oos.flush();
          } catch (Exception e) {
              e.printStackTrace();
          }finally {
              if(oos!=null){
                  try {
                      oos.close();
                  } catch (IOException e) {
                      e.printStackTrace();
                  }
              }
  
              if(ois!=null){
                  try {
                      ois.close();
                  } catch (IOException e) {
                      e.printStackTrace();
                  }
              }
          }
  
      }
  }
  

• 至此，服务端已经开发完成，main方法内容，即：启动一个服务监听

  public class BootStrap
  {
      public static void main( String[] args ) throws Exception {
          BIOSocketServer.startServer(8088);
      }
  }

 

4、创建rpc-caller，即：rpc客户端工程，同样需要引入rpc-api规则的依赖。

• 如何才能实现定制的userService的add方法呢？实例化userServiceImpl????那就要引入服务端的依赖，那和本地调用有什么区别呢？              所以，这里使用java的动态代理技术。
• 那在动态代理中的RpcInvocationHandler，如何获取class?写死类路径？？  一般用注册中心或配置文件，现在简单点，使用在定制工程rpc-api中添加注解的方式获取。
• 创建一个动态代理工厂以及实现InvocationHandle的实现类。
• rpc-api工程需要补充的注解：

  @Retention(RetentionPolicy.RUNTIME)
  @Target(ElementType.TYPE)
  public @interface ServiceMapped {
      String mappedService();
  }
  

• rpc-api工程需要加注解的类

  /**
   * @ClassName:UserService
   * @Description:
   * @Author:Q-W-W
   * @Date:2019/10/22 22:28
   * @Version:1.0
   **/
  @ServiceMapped(mappedService = "com.qww.rpc.api.impl.UserServiceImpl")
  public interface UserService {
      public UserDto addUser(UserDto userDto);
  }

• 动态工厂：

  /**
   * @ClassName:ProxyFactory
   * @Description: 动态代理工厂
   * @Author:Q-W-W
   * @Date:2019/10/22 23:19
   * @Version:1.0
   **/
  public class ProxyFactory {
  
      public static <T> T getProxyService(Class<T> interfaceClass){
          return (T)Proxy.newProxyInstance(ProxyFactory.class.getClassLoader(),
                  new Class[]{interfaceClass},new RpcInvocationHandler());
      }
  }

• 实现类RpcInvocationHandler

  /**
   * @ClassName:RpcInvocationHandler
   * @Description:
   * @Author:Q-W-W
   * @Date:2019/10/22 23:22
   * @Version:1.0
   **/
  public class RpcInvocationHandler implements InvocationHandler {
      @Override
      public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  
         /* System.out.println("method:"+method.getName());
          System.out.println("args:"+args.length);
          for (int i = 0; i < args.length; i++) {
              System.out.println("args"+i+":"+args[i]);
          }*/
  
          //TODO:在此完成网络交互--invoke会完成方法的调用
          //1、构建rpcTransFormObj对象
          RpcTransformObj rpcTransformObj = new RpcTransformObj();
  
          //根据注解拿到字节码
          String fullClassName = method.getDeclaringClass().getAnnotation(ServiceMapped.class).mappedService();
  
          rpcTransformObj.setFullClassName(fullClassName);
          rpcTransformObj.setMethodName(method.getName());
          rpcTransformObj.setArgs(args);
  
          //2、网络请求
          Object repsObj = BIOSocketClient.callRemoteService(rpcTransformObj, "localhost", 8088);
  
          return repsObj;
      }
  }

• 客户端实现类

  /**
   * @ClassName:BIOSocketClient
   * @Description: 客户端
   * @Author:Q-W-W
   * @Date:2019/10/22 23:43
   * @Version:1.0
   **/
  public class BIOSocketClient {
      public static Object callRemoteService(Object reqObj,String host,int port){
          ObjectInputStream ois = null;
          ObjectOutputStream oos = null;
          Object repsObj = null;
          try {
              Socket socket = new Socket(host,port);
  
              oos = new ObjectOutputStream(socket.getOutputStream());
              oos.writeObject(reqObj);
              oos.flush();
  
              ois = new ObjectInputStream(socket.getInputStream());
              repsObj = ois.readObject();
          }catch (Exception e){
              e.printStackTrace();
          }
          return repsObj;
      }
  }

• 客户端main方法调用

  public class App 
  {
      public static void main( String[] args )
      {
          UserService userService = ProxyFactory.getProxyService(UserService.class);
          UserDto userDto = new UserDto();
          userDto.setUserName("qww");
          userDto.setAge(20);
          System.out.println(userService.addUser(userDto));
      }
  }
  

5、最终运行结果

服务端：

客户端：

 

 

至此，使用 socket+bio+动态代理+反射 的简单rpc实现完成，在此做个记录！！