最近晚上沒事，加上工作上要使用，所以開始自己學習RPC框架，目前寫了一個基本的，便於理解，後續往裡面新增內容。

**

服務提供方：

**

服務介面程式碼：

package zhm.rpc.server;

public interface IServer {
    public String testMethod(String arg);
}

介面實現類：

/**
 * rpcServerImpl.java
 * zhm.rpc.server
 * 2017年10月9日下午8:44:06
 *
 */
package zhm.rpc.server;

/**
 * @author
 
 zhuheming
 * rpcServerImpl
 * 2017年10月9日下午8:44:06
 */
public class rpcServerImpl implements IServer {

    /* (non-Javadoc)
     * @see zhm.rpc.server.IServer#testMethod(java.lang.String)
     */
    @Override
    public String testMethod(String arg) {
        // TODO Auto-generated method stub
        return
 
 "hello, "+arg;
    }

}

反射類：
主要用於接收服務消費方發起的遠端呼叫請求，得到method和args，就是方法和引數，再利用反射方式執行該方法，返回執行結果。

這裡反射使用了commons.lang3包中的MethodUtils工具類實現。

/**
 * serverReflect.java
 * zhu.rpc.reflect
 * 2017年10月9日下午9:24:47
 *
 */
package zhu.rpc.reflect;

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

import org.apache.commons.lang3.reflect.MethodUtils;


/**
 * @author zhuheming
 * serverReflect
 * 2017年10月9日下午9:24:47
 */
public class ServerReflect implements Runnable{

    private Object object;
    private int port;

    public ServerReflect(Object object,int port){
        this.object=object;
        this.port=port;
    }
    /* (non-Javadoc)
     * @see java.lang.Runnable#run()
     */
    @Override
    public void run() {
        // TODO Auto-generated method stub
        //新建連線
            //SocketConnect sc=new SocketConnect();         
            //Socket socket=sc.connect("127.0.0.1", port);
            try {
                ServerSocket ss=new ServerSocket(port);

            while(true){
                try {
                    final Socket socket=ss.accept();
                    //建立輸入
                    ObjectInputStream ois=new ObjectInputStream(socket.getInputStream());
                    try{
                        //得到方法名和引數列表
                        String method=ois.readUTF();
                        Object[] args=(Object[])ois.readObject(); 
                        System.out.print(method+"  "+args.toString());
                        //反射得到對應方法的執行結果 
                        Object resultObject=MethodUtils.invokeExactMethod(object, method, args);
                        ObjectOutputStream oos=new ObjectOutputStream(socket.getOutputStream());
                        try{
                            //返回結果
                            oos.writeObject(resultObject);
                        }catch(Exception e){
                            oos.writeObject(e);
                            e.printStackTrace();
                        }finally{
                            oos.close();
                        }
                    } catch (Exception e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }finally{
                        ois.close();
                    }
                }catch(Exception e){
                    e.printStackTrace();
                }
            }
        } catch (IOException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }
    }
    //private static Thread serverThread=new Thread();

    //public void waittingServer(Class<T> serverClass,int port)

}

測試入口：
省得麻煩，直接使用8081埠，用一個Thread來執行等待服務消費端的呼叫。

/**
 * test.java
 * zhm.rpc.test
 * 2017年10月9日下午10:18:33
 *
 */
package zhm.rpc.test;

import zhm.rpc.server.IServer;
import zhm.rpc.server.rpcServerImpl;
import zhu.rpc.reflect.ServerReflect;

/**
 * @author zhuheming
 * test
 * 2017年10月9日下午10:18:33
 */
public class testServer {
    public static void main(String args[]) throws InterruptedException{
        IServer is=new rpcServerImpl();
        Thread serverThread=new Thread(new ServerReflect(is,8081));
        serverThread.start();
        serverThread.join();
    }

}

**

服務消費方：

**

socket聯結器，這裡使用了一個連線介面IConnect，方便以後如果使用多種連線方式可以抽象

package zhm.rpc.connect;

import java.net.Socket;


/**
 * socket聯結器
 * @author zhuheming
 * socketConnet
 * 2017年9月28日下午11:29:24
 */
public class SocketConnect implements IConnect {

    @Override
    public Socket connect(String host, int port) {
        // TODO Auto-generated method stub
        //判斷輸入引數
        if(!"".equalsIgnoreCase(host)&&port!=0){
            Socket socket=null;
            try{
                socket=new Socket(host,port);

            }catch(Exception e){
                e.getStackTrace();
            }
            return socket;
        }else{
            return null;
        }

    }

    public void close(Object connectObject){
        if(connectObject!=null){
            try{
                Socket socket=(Socket)connectObject;
                socket.close();
            }catch(Exception e){
                e.getStackTrace();
            }
        }
    }


}

服務消費方的動態代理實現：
思路是將服務提供方的IServer介面生成動態代理類，使用動態代理類執行執行IServer的介面方法時，會呼叫invoke方法，在invoke方法中，遠端連線消費提供方，將方法名稱和引數傳送給服務提供方，由服務提供方返回執行結果。

/**
 * cosumeProxy.java
 * zhm.rpc.proxy
 * 2017年9月29日上午12:03:30
 *
 */
package zhm.rpc.proxy;

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

import zhm.rpc.connect.SocketConnect;

/**
 * @author zhuheming
 * cosumeProxy
 * 2017年9月29日上午12:03:30
 */
public class ConsumeProxy {
    //匿名內部類方法實現需要呼叫，所以host和port需要為final
    @SuppressWarnings("unchecked")
    public static <T> T consume(Class<T> interfaceClass,final String host,final int port){

        //先建立一個InvocationHandler介面的物件（實現內部方法）
        //InvocationHandler invocationHandler=;

        return (T) Proxy.newProxyInstance(interfaceClass.getClassLoader(), new Class<?>[]{interfaceClass},new InvocationHandler(){

            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable{
                //建立連線
                SocketConnect sc=new SocketConnect();
                Socket socket=sc.connect(host, port);
                //傳送方法和引數
                ObjectOutputStream ops=new ObjectOutputStream(socket.getOutputStream());
                ops.writeUTF(method.getName());
                ops.writeObject(args);
                //接收返回
                ObjectInputStream ois=new ObjectInputStream(socket.getInputStream());
                Object getObject=ois.readObject();
                return getObject;
            }
    });
        //return null;

    }
}

服務提供方給的服務介面
注意，實現是在服務提供方，消費方只有介面

package zhm.rpc.server;

public interface IServer {
    public String testMethod(String arg);
}

服務消費方入口：

先生成代理類，再遠端執行方法。

package zhm.rpc.test;

import zhm.rpc.proxy.ConsumeProxy;
import zhm.rpc.server.IServer;

public class Test {

    //遠端呼叫服務端的testMethod方法，客戶端只有介面，沒有方法實現。
    public static void main(String args[]) throws InterruptedException{
        Object obj= ConsumeProxy.consume(IServer.class, "127.0.0.1", 8081);
        if(obj!=null){
            System.out.println(obj.getClass().getInterfaces().toString());
            //System.out.println(obj.toString());
            System.out.println("not null!");
        }else{
            System.out.println("null!");
        }
        IServer rpc=(IServer)obj;

        for(int i=0;i<100;i++){

            System.out.println(rpc.testMethod(""+i));
            Thread.sleep(1000);
        }
    }

}

好了，以上就是最簡單的RPC遠端執行框架，要想豐滿起來，後續還要考慮很多，如自己實現序列化反序列化，軟負載均衡，高可用NIO通訊方式，服務的解耦合IOC方式，以及服務治理，類似zk的服務釋出等。

繼續努力吧。