Java简单的RPC实现（一）

RPC使用java最基本的，传输层使用Socket，序列化使用Serializable，java 动态代理模式，但是未实现消息注册等相关信息

大道至简

server端

 package com.rpc.entity;

 import java.io.Serializable;

 public class RpcObject implements Serializable{

     private static final long serialVersionUID = 1L;
     private Class<?> c;
     private String methodName;
     private Object[] args;

     public RpcObject() {

     }

     public RpcObject(Class<?> c, String methodName, Object[] args) {
         this.c = c;
         this.methodName = methodName;
         this.args = args;
     }

     public Class<?> getC() {
         return c;
     }

     public void setC(Class<?> c) {
         this.c = c;
     }

     public String getMethodName() {
         return methodName;
     }

     public void setMethodName(String methodName) {
         this.methodName = methodName;
     }

     public Object[] getArgs() {
         return args;
     }

     public void setArgs(Object[] args) {
         this.args = args;
     }
 }

ConfMonitor

 package com.rpc.server;

 import java.util.HashMap;
 import java.util.Map;

 import com.rpc.service.impl.HelloImpl;

 /**
  * 模拟配置，实际的框架中大部分都是使用xml进行配置的，比如Hessian是配置在web.xml的servlet属性里的
  * @author cdwangzijian
  *
  */
 public class ConfMonitor {
     @SuppressWarnings("rawtypes")
     public static Map<String, Class> conf = new HashMap<String, Class>();

     static {
         conf.put("com.rpc.service.IHello", HelloImpl.class);
     }
 }

RpcThread

 package com.rpc.server;

 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.Socket;

 import com.rpc.entity.RpcObject;

 public class RpcThread extends Thread {

     private Socket s;

     public RpcThread(Socket s) {
         this.s = s;
     }

     @Override
     public void run() {

         ObjectInputStream is = null;
         ObjectOutputStream os = null;

         try {

             is = new ObjectInputStream(s.getInputStream());

             // 得到远程调用参数，包含了接口名，调用方法，方法参数
             RpcObject rpcObject = (RpcObject) is.readObject();

             System.out.println("Method:"+rpcObject.getMethodName());

             // 构建接口的实现类，然后通过反射调用方法
             Object o = getObject(rpcObject.getC());
             System.out.println("class:"+rpcObject.getC());

             Object reO = executeMethod(o, rpcObject.getMethodName(), rpcObject.getArgs());

             // 输出返回值
             os = new ObjectOutputStream(s.getOutputStream());
             os.writeObject(reO);
             os.flush();
         } catch (IOException e) {
             e.printStackTrace();
         } catch (ClassNotFoundException e) {
             e.printStackTrace();
         } finally {
             try {
                 if(is!=null){
                     is.close();
                 }

                 if(os!=null){
                     os.close();
                 }
             } catch (IOException e) {
                 e.printStackTrace();
             }
         }
     }

     /**
      * 通过反射技术执行方法，并返回返回值
      * @param o
      * @param methodName
      * @param args
      * @return
      */
     private Object executeMethod(Object o, String methodName, Object[] args) {
         Object objR = null;
         Class<?>[] cs = new Class[args.length];
         for (int i = 0; i < args.length; i++) {
             Object arg = args[i];
             cs[i] = arg.getClass();
         }
         try {
             Method m = o.getClass().getMethod(methodName, cs);
             objR = m.invoke(o, args);
         } catch (SecurityException e) {
             e.printStackTrace();
         } catch (NoSuchMethodException e) {
             e.printStackTrace();
         } catch (IllegalArgumentException e) {
             e.printStackTrace();
         } catch (IllegalAccessException e) {
             e.printStackTrace();
         } catch (InvocationTargetException e) {
             e.printStackTrace();
         }
         return objR;
     }

     /**
      * 根据接口名得到实例
      * @param c
      * @return
      */
     private Object getObject(Class<?> c) {
         Object o = null;
         try {

             System.out.println("c.getName:"+c.getName());

             o = ConfMonitor.conf.get(c.getName()).newInstance();
         } catch (InstantiationException e) {
             e.printStackTrace();
         } catch (IllegalAccessException e) {
             e.printStackTrace();
         }
         return o;
     }
 }

StartUp

 package com.rpc.server;

 import java.io.IOException;
 import java.net.ServerSocket;
 import java.net.Socket;

 /**
  * RPC服务器启动
  * @author cdwangzijian
  *
  */
 public class StartUp {

     public static final int port = 9001;

     public static void main(String[] args) {
             exportRpc();
     }

     /**
      * 导出RPC接口
      */
     private static void exportRpc() {
         try {
             ServerSocket ss = new ServerSocket(port);
             while(true){
                 Socket s = ss.accept();
                 if(s!=null){
                     new RpcThread(s).start();
                 }
             }
         } catch (IOException e) {
             e.printStackTrace();
         }
     }
 }

HelloImpl

 package com.rpc.service.impl;

 import com.rpc.service.IHello;

 public class HelloImpl implements IHello {
     @Override
     public String sayHello(String name) {
         return "hello:" + name;
     }
 }

IHello

 package com.rpc.service;

 public interface IHello {
     String sayHello(String name);
 }

客户端实现：

 ProxyFactory

 package com.zhy.proxy;

 import java.lang.reflect.InvocationHandler;
 import java.lang.reflect.Proxy;

 public class ProxyFactory {

     @SuppressWarnings("unchecked")
     public static <T> T create(Class<T> c, String ip, int port) {

         InvocationHandler handler = new RpcProxy(ip, port, c);

         return (T) Proxy.newProxyInstance(c.getClassLoader(),new Class[] {c},handler);
     }
 }

RpcProxy

 package com.zhy.proxy;

 import java.io.ObjectInputStream;
 import java.io.ObjectOutputStream;
 import java.io.Serializable;
 import java.lang.reflect.InvocationHandler;
 import java.lang.reflect.Method;
 import java.net.Socket;

 import com.rpc.entity.RpcObject;

 /**
  * 客户端接口代理
  * 当客户端接口方法被调用的时候，把方法名，方法参数作为参数。
  * 传送给远程服务执行，然后获取返回值
  * @author cdwangzijian
  *
  */
 public class RpcProxy implements InvocationHandler, Serializable{

     private String ip;
     private int port;
     private Class<?> c;

     private static final long serialVersionUID = 1L;

     public RpcProxy(String ip, int port, Class<?> c) {
         this.ip = ip;
         this.port = port;
         this.c = c;
     }

     /**
      * 动态代理类，当调用接口方法的时候转为调用此方法
      */
     @Override
     public Object invoke(Object proxy, Method method, Object[] args)throws Throwable {

         // 用作返回值
         Object o = null;
         // 通过socket调用远程服务
         Socket s = new Socket(ip, port);

         // 组装为一个保留了要调用的类，方法名及参数的对象，然后序列化之后传给远程
         RpcObject rpcObject = new RpcObject(c, method.getName(), args);

         ObjectOutputStream os = null;
         ObjectInputStream is = null;

         try{
             os = new ObjectOutputStream(s.getOutputStream());
             os.writeObject(rpcObject);
             os.flush();

             // 从远程得到返回结果
             is = new ObjectInputStream(s.getInputStream());
             o = is.readObject();

         } catch (Exception e) {
             e.printStackTrace();

         } finally{

             if(os!=null){
                 os.close();
             }

             if(is!=null){
                 is.close();
             }

         }

         return o;
     }

 }

RpcClient

 package com.zhy;

 import com.rpc.service.IHello;
 import com.zhy.proxy.ProxyFactory;

 public class RpcClient {
     public static void main(String[] args) {

         String ip = "localhost";
         int port = 9001;

         IHello hello = ProxyFactory.create(IHello.class, ip, port);

         System.out.println(hello.sayHello("小明"));

     }
 }

输出结果：