通过java原生的序列化，Socket通信，动态代理和反射机制，实现一个简单的RPC框架，由三部分组成：

1、服务提供者，运行再服务端，负责提供服务接口定义和服务实现类

2、服务发布者，运行再RPC服务端，负责将本地服务发布成远程服务，供其他消费者调用

3、本地服务代理，运行再RPC客户端，通过代理调用远程服务提供者，然后将结果进行封装返回给本地消费者

服务端接口定义和实现，如下：

代码清单 1-1 接口定义

public interface EchoService {    String echo(String ping);}

代码清单1-2

public class EchoServiceImpl implements EchoService {    public String echo(String ping) {        return ping != null ? ping + " -- I am ok." : "I am ok";    }}

代码清单1-3

import java.io.ObjectInputStream;import java.io.ObjectOutputStream;import java.lang.reflect.Method;import java.net.InetSocketAddress;import java.net.ServerSocket;import java.net.Socket;import java.util.concurrent.Executor;import java.util.concurrent.Executors;/** *  */public class RpcExporter {    static Executor executor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());    public static void exporter(String hostName , int port) throws  Exception{        ServerSocket serverSocket = new ServerSocket();        serverSocket.bind(new InetSocketAddress(hostName,port));        try {            while (true){                executor.execute(new ExporterTask(serverSocket.accept()));            }        }finally {            serverSocket.close();        }    }    private static class ExporterTask implements Runnable{        Socket client = null;        public ExporterTask(Socket client) {            this.client = client;        }        public void run() {            ObjectInputStream inputStream = null;            ObjectOutputStream outputStream = null;            try {                inputStream = new ObjectInputStream(client.getInputStream());                String interfaceName = inputStream.readUTF();                Class
      service = Class.forName(interfaceName);                String methodName = inputStream.readUTF();                Class
      [] parameterTypes = (Class
      [])inputStream.readObject();                Object [] arguments = (Object [])inputStream.readObject();                Method method = service.getMethod(methodName,parameterTypes);                Object result = method.invoke(service.newInstance(),arguments);                outputStream = new ObjectOutputStream(client.getOutputStream());                outputStream.writeObject(result);            }catch (Exception e){                e.printStackTrace();            }finally {                if(outputStream != null){                    try {                        outputStream.close();                    }catch (Exception e){                        e.printStackTrace();                    }                }                if(inputStream != null){                    try {                        inputStream.close();                    }catch (Exception e){                        e.printStackTrace();                    }                }                if(client != null){                    try {                        client.close();                    }catch (Exception e){                        e.printStackTrace();                    }                }            }        }    }}

服务发布者的主要职责如下：

1、作为服务端，监控客户端的TCP连接，接收到新的客户端连接之后，将其封装成Task，由线程池执行

2、将客户端发送的码流反序列化成对象，反射调用实现者，获取执行结果

3、将执行结果对象序列化，通过socket发送给客户端

4、远程服务调用完成之后，释放Socket等连接字段，防止句柄泄露

RPC客户端本地服务代理源码如下：

代码清单1-4

package com.habit;import com.sun.org.apache.xml.internal.serializer.OutputPropertiesFactory;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.InetSocketAddress;import java.net.Socket;/** *  */public class RpcImporter {    public S importer(final Class
       serviceClass, final InetSocketAddress address) {        return (S) Proxy.newProxyInstance(serviceClass.getClassLoader(), new Class
      []{serviceClass.getInterfaces()[0]},                new InvocationHandler() {                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {                        Socket socket = null;                        ObjectOutputStream outputStream = null;                        ObjectInputStream inputStream = null;                        try {                            socket = new Socket();                            socket.connect(address);                            outputStream = new ObjectOutputStream(socket.getOutputStream());                            outputStream.writeUTF(serviceClass.getName());                            outputStream.writeUTF(method.getName());                            outputStream.writeObject(method.getParameterTypes());                            outputStream.writeObject(args);                            inputStream = new ObjectInputStream(socket.getInputStream());                            return inputStream.readObject();                        } finally {                            if (socket != null) {                                socket.close();                            }                            if (outputStream != null) {                                outputStream.close();                            }                            if (inputStream != null) {                                inputStream.close();                            }                        }                    }                });    }}

本地服务代理的主要功能：

1、将本地的接口调用转成JDK的动态代理，再动态代理中实现接口的远程调用

2、创建Socket客户端，根据指定地址链接远程服务提供者

3、将远程服务调用所需的接口类、方法名、参数列表等编码后发送给服务提供者

4、同步阻塞等待服务端返回应答，获取应答之后返回

测试代码：

代码清单1-5

package com.habit;import java.net.InetSocketAddress;/** *  */public class RpcTest {    public static void main(String[] args) {        new Thread(new Runnable() {            public void run() {                try {                    RpcExporter.exporter("localhost",8088);                }catch (Exception e){                    e.printStackTrace();                }            }        }).start();        RpcImporter
     
       importer = new RpcImporter
      
       ();        EchoService echo = importer.importer(EchoServiceImpl.class,new InetSocketAddress("localhost",8088));        System.out.println(echo.echo("Are you ok?"));    }}
      
     

创建一个异步发布服务端的线程并启动，用于接口rpc客户端的请求，根据请求参数调用服务实现类，返回结果给客户端

随后，创建客户端服务代理类，构建rpc请求参数，发起rpc请求，将调用结果输出到控制台，执行结果如下：

Are you ok? -- I am ok.