简单RPC之Socket实现

最近看到Dubbo大神写得使用Socket实现的简单的RPC调用，对RPC的理解更简单了，然后根据大神的代码自己也重构了一下。

RPC Server端代码，主要是使用ServerSocket获得rpc调用客户端发送过来的类信息，方法信息及方法参数信息，通过反射在RPCServer端进行代码执行，最后将执行结果发送给Socket，第一步需要首先执行RPCServer。

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ConcurrentHashMap;
/**
 * 服务端
 * @author tianjunwei
 */
public class RPCServer {

  public static ConcurrentHashMap<String, Object> classMap = new ConcurrentHashMap<String,Object>();
  
  public static void main(String [] args) throws Exception{
    System.err.println("server start");
    RPCServer.invoker(8080);
  }
  public static void invoker(int port) throws Exception{
    
    ServerSocket server = new ServerSocket(port);
    for(;;){
        try{
          final Socket socket = server.accept();
          new Thread(new Runnable() {
            ObjectOutputStream output =  null;
            @Override
            public void run() {
              try{
                try {
                  output = new ObjectOutputStream(socket.getOutputStream()); 
                  ObjectInputStream input = new ObjectInputStream(socket.getInputStream());
                  String className = input.readUTF();
                  String methodName = input.readUTF();
                  Class<?>[] parameterTypes = (Class<?>[])input.readObject();  
                              Object[] arguments = (Object[])input.readObject();  
                  Object claszz = null;
                  if(!classMap.containsKey(className)){
                    try {
                      claszz = Class.forName(className).newInstance();
                      classMap.put(className, claszz);
                    } catch (InstantiationException | IllegalAccessException | ClassNotFoundException e) {
                      e.printStackTrace();
                    }
                  }else {
                    claszz = classMap.get(className);
                  }
                  Method method = claszz.getClass().getMethod(methodName, parameterTypes);  
                              Object result = method.invoke(claszz, arguments);  
                              output.writeObject(result);  
                } catch (IOException | ClassNotFoundException | IllegalAccessException | IllegalArgumentException | InvocationTargetException | NoSuchMethodException | SecurityException e) {
                  output.writeObject(e);
                }finally {
                  output.close();
                }
              }catch(Exception e){
                e.printStackTrace();
              }finally {
                try {
                  socket.close();
                } catch (IOException e) {
                  e.printStackTrace();
                }
              }
            }
          }).start();
      }catch (Exception e) {
        e.printStackTrace();
      }
    }
  }
}

RPC 客户端代码，这里利用了代理机制的特性，在执行具体的方法时执行远程调用，执行方法时会调用invoke方法，这样就可以通过Socket向RPCServer发送需要执行的方法的信息，并且获取执行后的结果并返回。

public class RPCProxy {
  
   @SuppressWarnings("unchecked")
  public static <T> T create(Object target){
     
     return (T) Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(), new InvocationHandler(){

      @SuppressWarnings("resource")
      @Override
      public Object invoke(Object proxy, Method method, Object[] args)
          throws Throwable {
         Socket socket = new Socket("localhost", 8080);
         ObjectOutputStream output = new ObjectOutputStream(socket.getOutputStream());  
                 try {  
                   output.writeUTF(target.getClass().getName());
                     output.writeUTF(method.getName());  
                     output.writeObject(method.getParameterTypes());  
                     output.writeObject(args);  
                     ObjectInputStream input = new ObjectInputStream(socket.getInputStream());  
                     try {  
                         Object result = input.readObject();  
                         if (result instanceof Throwable) {  
                             throw (Throwable) result;  
                         }  
                         return result;  
                     } finally {  
                         input.close();  
                     }  
                 } finally {  
                     output.close();  
                     socket.close();
                 }  
      }
       
     });
   }
}

HelloRpc接口：

public interface HelloRpc {
  String hello(String name);
}

HelloRpcImpl实现类：

public class HelloRpcImpl implements HelloRpc {

  @Override
  public String hello(String name) {
    return "hello "+name;
  }

}

Main函数操作：

public class Main {

  public static void main(String [] args){
    HelloRpc helloRpc = new HelloRpcImpl();
    helloRpc = RPCProxy.create(helloRpc);
    System.err.println(helloRpc.hello("rpc"));
  }
}

执行结果：

hello rpc

通过以上这个示例我们可能会对一些RPC框架的实现原理有一定的了解，比如和我之前发表的​​Hessian源码分析​​​有一些相似的地方。示例源码地址​​github​​，当然这个实现只是作为一些简单的原理说明，还有很多不足的地方。