java实现一个Rpc

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.ServerSocket;
import java.net.Socket;

public class RpcFramework {

	public static void export(final Object service, final Class interfaceClazz, int port) throws Exception {

		System.out.println("Export service " + service.getClass().getName() + " on port " + port);

		ServerSocket server = new ServerSocket(port);
		for (;;) {
			final Socket socket = server.accept();

			new Thread(new Runnable() {
				public void run() {
					try {
						ObjectInputStream input = new ObjectInputStream(socket.getInputStream());
						String interfaceName = input.readUTF();
						String methodName = input.readUTF();
						Class<?>[] parameterTypes = (Class<?>[]) input.readObject();
						Object[] arguments = (Object[]) input.readObject();
						ObjectOutputStream output = new ObjectOutputStream(socket.getOutputStream());
						Method method = service.getClass().getMethod(methodName, parameterTypes);
						Object result = method.invoke(service, arguments);
						output.writeObject(result);

					} catch (Exception e) {
						throw new RuntimeException(e.toString());
					}
				}
			}).start();
		}
	}

	@SuppressWarnings("unchecked")
	public static <T> T refer(final Class<T> interfaceClass, final String host, final int port) throws Exception {

		System.out.println("Get remote service " + interfaceClass.getName() + " from server " + host + ":" + port);
		return (T) Proxy.newProxyInstance(interfaceClass.getClassLoader(), new Class<?>[] { interfaceClass },
				new InvocationHandler() {

					public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
						Socket socket = new Socket(host, port);

						ObjectOutputStream output = new ObjectOutputStream(socket.getOutputStream());

						output.writeUTF(interfaceClass.getName());
						output.writeUTF(method.getName());
						output.writeObject(method.getParameterTypes());
						output.writeObject(args);

						ObjectInputStream input = new ObjectInputStream(socket.getInputStream());

						Object result = input.readObject();
						if (result instanceof Throwable) {
							throw (Throwable) result;
						}
						return result;
					}
				});
	}
}

RpcFramework.java文件是最核心的处理流程，服务端调用其中的export()方法对外暴露服务，客户端调用refer()方法进行远程过程调用，其实就是生成了一个动态代理对象，调用该动态代理对象中的invoke()方法，查看源码可以看到invoke方法中就是使用了java的BIO去连接服务端，并将要调用的接口、方法、参数等传输给服务端；而服务端通过这些参数调用具体的对象就返回结果。

公共接口：

public interface HelloService {

    String hello();

    String hello(String name);

}

服务端实现类：

public class HelloServiceImpl implements HelloService {

    public String hello() {
        return "Hello";
    }

    public String hello(String name) {
        return "Hello," + name;
    }

}

服务端暴露服务类：

public class RpcProvider {

    public static void main(String[] args) throws Exception {
        HelloService service = new HelloServiceImpl();
        RpcFramework.export(service, HelloService.class, 9000);
    }

}

客户端启动类：

public class RpcConsumer {

	public static void main(String[] args) throws Exception {
		HelloService service = RpcFramework.refer(HelloService.class, "127.0.0.1", 9000);
		String result = service.hello("rod");
		System.out.println(result);
	}

}

到此结束，该代码案例可以帮助java开发人员理解rpc调用流程。