一、基本原理
1、RPC模型
流程：当 User 想发起一个远程调用时，它实际是通过本地调用 User-stub。 User-stub 负责将调用的接口、方法和参数通过约定的协议规范进行编码并通过本地的 RPCRuntime 实例传输到远端的实例。 远端 RPCRuntime 实例收到请求后交给 Server-stub 进行解码后发起向本地端 Server 的调用，调用结果再返回给 User 端。
2、RPC组件细化
1、RpcServer:负责暴露（export）远程接口
2、RpcClient：负责导入（import）远程接口的代理实现
3、RpcProxy：远程接口的代理实现
4、RpcInvoker：客户端：负责编码调用信息和发送调用请求到服务端并等待调用结果返回；服务端：负责调用服务端接口的具体实现并返回调用结果
5:、RpcProtocol：负责协议编/解码
6、RpcConnector：负责维持客户端和服务端的连接通道和发送数据到服务端
7、RpcAcceptor：负责接收客户端请求并返回请求结果
8、RpcProcessor：负责在服务端控制调用过程，包括管理调用线程池、超时时间等
9、RpcChannel：数据传输通道
二、RPC简易实现
1、项目结构
2、公共服务接口
public interface HelloService {
String sayHello(String name);
}
3、服务端实现
（1）实现类
public class HelloServiceImpl implements HelloService {
public String sayHello(String name) {
return "hello " + name;
}
}
（2）服务端Rpc服务类实现
其主要逻辑
1、注册服务类
2、启动服务socket，循环等待客户端连接
3、获取客户端传送的信息
4、根据信息解析并调用本地实现，并回传调用值
public class RpcServer {
private static final HashMap<String, Class<?>> serviceRegistry = new HashMap<String, Class<?>>();
private int port;
public RpcServer(int port) {
this.port = port;
}
public RpcServer register(Class serviceInterface, Class impClass) {
//注册服务（接口名:实现类名）
serviceRegistry.put(serviceInterface.getName(), impClass);
return this;
}
public void run() throws IOException {
//1、启动服务
ServerSocket serverSocket = new ServerSocket();
serverSocket.bind(new InetSocketAddress(port));
System.out.println("start server！");
ObjectInputStream input = null;
ObjectOutputStream output = null;
Socket socket = null;
try {
//2、循环等待连接
for (; ; ) {
//3、获取客户端的请求数据
socket = serverSocket.accept();
input = new ObjectInputStream(socket.getInputStream());
String serviceName = input.readUTF();//客户端传过来的接口名
String methodName = input.readUTF();//客户端传过来的方法名
Class<?>[] parameterTypes = (Class<?>[]) input.readObject();//客户端传过来的方法参数类型
Object[] args = (Object[]) input.readObject();//客户端传过来的参数值
System.out.println("接受到客户端的请求：serviceName：" + serviceName + ",methodName:" + methodName);
//4、根据客户端传过信息获取注册的服务端接口,并调用
Class<?> serviceClass = serviceRegistry.get(serviceName);
if (serviceClass == null) {
throw new ClassNotFoundException(serviceName + " not found!");
}
Method method = serviceClass.getMethod(methodName, parameterTypes);
Object invokeResult = method.invoke(serviceClass.newInstance(), args);
//5、返回调用的方法
output = new ObjectOutputStream(socket.getOutputStream());
output.writeObject(invokeResult);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
close(input, output, socket);
}
}
private void close(ObjectInputStream input, ObjectOutputStream output, Socket socket) {
if (output != null) {
try {
output.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (input != null) {
try {
input.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (socket != null) {
try {
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
（3）服务端启动类
public class ServerMain {
public static void main(String[] args) throws IOException {
RpcServer rpcServer = new RpcServer(8888);
rpcServer.register(HelloService.class, HelloServiceImpl.class);
rpcServer.run();
}
}
3、客户端实现
主要逻辑
1、获取ip和port，通过jdk代理远程调用服务端
2、向服务端传递服务接口相关信息，并获取服务端返回的信息
（1）客户端代理类实现
public class RpcClientProxy<T> implements InvocationHandler {
/**
* 服务端代理接口
*/
private Class<T> serverInstance;
/**
* 服务端地址
*/
private InetSocketAddress address;
public RpcClientProxy(Class<T> serverInstance, String ip, Integer port) {
this.address = new InetSocketAddress(ip, port);
this.serverInstance = serverInstance;
}
/**
* 获取客户端代理对象
*
* @return
*/
public T getClientInstance() {
return (T) Proxy.newProxyInstance(serverInstance.getClassLoader(), new Class<?>[]{serverInstance}, this);
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Socket socket = null;
ObjectOutputStream outputStream = null;
ObjectInputStream inputStream = null;
try {
// 1.创建Socket客户端，根据指定地址连接远程服务提供者
socket = new Socket();
socket.connect(address);
//2、将远程服务调用所需的接口类、方法名、参数列表等编码后发送给服务提供者
outputStream = new ObjectOutputStream(socket.getOutputStream());
outputStream.writeUTF(serverInstance.getName());//接口名
outputStream.writeUTF(method.getName());//方法名
outputStream.writeObject(method.getParameterTypes());//方法参数类型,数组
outputStream.writeObject(args);//具体方法参数值
//3、同步阻塞等待服务器返回应答，获取应答后返回
inputStream = new ObjectInputStream(socket.getInputStream());
return inputStream.readObject();
} finally {
if (socket != null) {
socket.close();
}
if (outputStream != null) {
outputStream.close();
}
if (inputStream != null) {
inputStream.close();
}
}
}
}
（2）客户端启动类
public class ClientMain {
public static void main(String[] args) {
RpcClientProxy clientProxy = new RpcClientProxy(HelloService.class, "127.0.0.1", 8888);
HelloService helloService = (HelloService) clientProxy.getClientInstance();
String result = helloService.sayHello("中国");
System.out.println(result);
}
}
