通过底层技术实现RMI

一 点睛

RMI：远程方法调用（Remote Method Invocation），只适用于 Java 语言。也就是说，各台计算上使用的语言都必须是 Java。

实现机制：在本地（客户端），直接操作的是服务端接口在本地的副本（称为stub），通过stub来充当服务端的接口。例如，如果客户端 L 对象药调用服务端接口 R 中 method() 方法，那么是无法在客户端直接写成L.method()。因此，就必须先将服务端的 method() 的接口 R 在本地复制一份（ 即stub），然后才能写成L.method()。可以发现，在 RMI 通信时，客户端接口借助的是 stub，而服务端为了便于组织管理服务端商的各个接口，以及为了便于和客户端通信，服务端也设置了一个辅助对象 skeleton。即 RMI 通信过程，实际是客户端 stub 和 服务端的 skeleton 在直接交互，如下图所示。

二 具体流程

1 客户端与服务端之间通过 Socket 交互信息。

a 客户端先以字符串的形式定义好需要请求的接口名（"remote.procedure.call.server.RMIService",）然后再将此字符串通过反射，解析出请求的接口名、方法名、方法参数等信息，并将这些信息通过对象流 ObjectOutputStream 发送给服务端。

b 服务端逐个解析这些信息，并通过反射中 invoke() 方法调用服务端上被请求的方法。

2 因为服务端可能存在多个提供方法的接口，因此服务端需要一个“服务注册中心”来统一管理这些接口；当客户端请求某一个接口时，“服务注册中心”就可以立刻获取并提供那个接口。其中，“服务注册中心”可以是一个 Map，其中 Key 存放着接口的名字，value 就是响应方法的接口对象。

3 “服务注册中心”根据客户端请求，找到相应接口后（通过map.get(接口名)），通过该接口的实现类提供方法（即执行实现类中的方法）。

4 服务完毕，服务端再将返回值通过对象流传给客户端。

5 因为不同的服务会返回不同的数据类型给客户端，因此客户端需要通过动态代理来接收服务端的返回值。

三 流程图

四 代码

1 提供服务接口

package rmi.server;
// 服务端上，提供服务的接口
public interface RMIService {
String sayHi(String name);
}

2 提供服务接口的实现类

package rmi.server;
// 服务端上，提供服务接口的实现类
public class RMIServiceImpl implements RMIService {
@Override
public String sayHi(String name) {
return "hi," + name;
}
}

3 服务注册中心接口

package rmi.server;
/**
* @className: ServerCenter
* @description: 服务注册中心接口
* @date: 2022/5/14
* @author: cakin
*/
public interface ServerCenter {
// 启动服务
void start();
// 关闭服务
void stop();
// 注册服务
void register(Class service, Class serviceImpl);
}

4 服务注册中心实现类

package rmi.server;
import java.io.IOException;
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.HashMap;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
// 服务注册中心实现类
public class ServerCenterImpl implements ServerCenter {
// map：服务端的所有可供客户端访问的接口，都注册到该 map 中
// key: 接口的名字（如"RMIService"），value:真正的提供服务的类（如RMIServiceImpl类）
private static HashMap serviceRegiser = new HashMap<>();
// 服务端的端口号
private static int port;
// 线程池：线程池中存在多个线程对象，每个线程对象都可以处理一个客户请求
private static ExecutorService executor
= Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
// 是否开启服务
private static volatile boolean isRunning = false;
public ServerCenterImpl(int port) {
this.port = port;
}
// 开启服务端服务
@Override
public void start() {
ServerSocket server = null;
try {
server = new ServerSocket();
server.bind(new InetSocketAddress(port));
} catch (IOException e1) {
e1.printStackTrace();
}
isRunning = true;
// 客户端每次请求一次请求，服务端从线程池中启动一个线程对象去处理
while (true) {
// 具体的服务内容：接收客户端请求，处理请求，并返回结果
System.out.println("服务已启动...");
Socket socket = null;
try {
socket = server.accept(); // 等待客户端连接
} catch (IOException e) {
e.printStackTrace();
}
// 启动一个线程 去处理客户请求
executor.execute(new ServiceTask(socket));
}
}
// 关闭服务
@Override
public void stop() {
isRunning = false;
executor.shutdown();
}
// 将接口名和接口实现类一一对应，以便于接收到请求时，能及时获取到对应的服务实现类
@Override
public void register(Class service, Class serviceImpl) {
serviceRegiser.put(service.getName(), serviceImpl);
}
// 处理请求的线程
private static class ServiceTask implements Runnable {
private Socket socket;
public ServiceTask() {
}
public ServiceTask(Socket socket) {
this.socket = socket;
}
// 具体的处理逻辑
@Override
public void run() {
ObjectOutputStream output = null;
ObjectInputStream input = null;
try {
// 接收到客户端的各个请求参数（接口名、方法名、参数类型、参数值）
input = new ObjectInputStream(socket.getInputStream());
// 因为 ObjectInputStream 对发送数据的顺序有严格要求，因此必须按照发送的顺序逐个接收
// 请求的接口名
String serviceName = input.readUTF();
// 请求的方法名
String methodName = input.readUTF();
// 请求方法的参数类型
Class[] parameterTypes = (Class[]) input.readObject();
// 请求方法的参数名
Object[] arguments = (Object[]) input.readObject();
// 根据客户请求，到服务注册中心 map 中找到与之对应的具体接口（即RMIService）
Class ServiceClass = serviceRegiser.get(serviceName);
// 构建请求的方法
Method method = ServiceClass.getMethod(methodName, parameterTypes);
// 执行该方法
Object result = method.invoke(ServiceClass.newInstance(), arguments);
// 将执行完毕的返回值，返回给客户端
output = new ObjectOutputStream(socket.getOutputStream());
output.writeObject(result);
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (output != null)
output.close();
if (input != null)
input.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
}

5 客户端

package rmi.client;
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 RMIClient {
/**
* 功能描述：获取代表服务端接口的动态代理对象（RMIService）
*
* @param serviceInterface:请求的接口名
* @param addr:待请求服务端的ip:端口
* @author cakin
* @date 2022/5/14
*/
@SuppressWarnings("unchecked")
public static T getRemoteProxyObj(Class serviceInterface,
InetSocketAddress addr) {
/*
newProxyInstance(a,b,c)中,前两个参数的含义如下：
a:类加载器 ：需要代理那个对象的类加载器
b:用于表示需要代理的对象提供了哪些方法。Java是单继承、多实现，
因此，如果某一个对象实现了多个接口，那么该对象就拥有其全部接口的所有方法，因此是一个接口数组。
例如，如果有A implements B接口,c接口，并且B接口中有3个方法，C接口中有2个方法，那么A的对象就拥有5个方法（暂不考虑A自身提供的方法）
*/
return (T) Proxy.newProxyInstance(serviceInterface.getClassLoader(),
new Class[]{serviceInterface}, new InvocationHandler() {
/**
* 功能描述：
*
* @author cakin
* @date 2022/5/14
* @param proxy:代理的对象
* @param method：哪个方法（sayHi(参数列表)）
* @param args:参数列表
* @return T
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) {
// 客户端向服务端发送请求：请求某一个具体的接口
Socket socket = new Socket();
ObjectOutputStream output = null;
ObjectInputStream input = null;
try {
// addr包含了要访问的服务端的Ip和端口
socket.connect(addr);
// 通过序列化流（对象流）向服务端发送请求
output = new ObjectOutputStream(socket.getOutputStream());
// 发送请求的接口名
output.writeUTF(serviceInterface.getName());
// 发送请求的方法名
output.writeUTF(method.getName());
// 发送请求的方法的参数的类型
output.writeObject(method.getParameterTypes());
// 发送请求的方法的参数值
output.writeObject(args);
// 等待服务端处理...
// 接收服务端处理后的返回值
input = new ObjectInputStream(socket.getInputStream());
return input.readObject();
} catch (Exception e) {
e.printStackTrace();
return null;
} finally {
try {
if (output != null) output.close();
if (input != null) input.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
});
}
}

6 服务端启动类

package rmi.test;
import rmi.server.RMIService;
import rmi.server.RMIServiceImpl;
import rmi.server.ServerCenter;
import rmi.server.ServerCenterImpl;
public class TestRMIServer {
public static void main(String[] args) {
// 用线程的形式启动服务
new Thread(() -> {
// 服务中心
ServerCenter server = new ServerCenterImpl(9999);
// 将 RMIService 接口及实现类，注册到服务中心
server.register(RMIService.class, RMIServiceImpl.class);
server.start();
}).start();
}
}

7 客户端启动类

package rmi.test;
import rmi.client.RMIClient;
import rmi.server.RMIService;
import java.net.InetSocketAddress;
// 先启动服务端，再启动客户端，就能看到客户端成功的调用了服务端上的 sayHi() 方法。
public class TestRMIClient {
public static void main(String[] args) throws ClassNotFoundException {
// 调用远程的 rmi.server.RMIService 接口，并执行接口中的 sayHi() 方法
RMIService service = RMIClient.getRemoteProxyObj(
Class.forName("rmi.server.RMIService" ) ,
new InetSocketAddress("127.0.0.1", 9999)) ;
System.out.println( service.sayHi("zs") ) ;
}
}

五 测试结果

hi,zs