一、RMI简介：
说到RMI就不得不说RPC了。
RPC：（Remote Procedure Call），远程过程调用。
RMI（Remote Method Invocation），远程方法调用。
RPC和RMI是有区别的，RPC中是通过网络服务协议向远程主机发送请求，RPC远程主机就去搜索与之相匹配的类和方法，找到后就执行方法并把结果编码，通过网络协议发回。
而RMI是通过客户端的对象作为远程接口进行远程方法的调用。RMI只适用于Java语言。
二、RMI的运行机理：
涉及两个网络端。其核心思想是，一个端可以通过调用另一个端的方法，实现相关功能。
一个端“执行”一个方法，而这个方法的实际执行是在另一端进行的！
当然，两个端都应该有相同的类，自然会拥有相同的方法。
一个端所谓的执行这个方法，其实是通过调用这个类的代理对象的方法，在其中拦截这个方法，在这个方法中
实际上是将执行这个方法的参数和类名称、方法名称，通过网络通讯传输给另一端；另一端根据得到的方法名称、
类名称和参数，实际执行那个方法，再将方法执行结果回传给对端。
要注意的问题：
1、实际执行方法的一端，我们可以认为是RMI服务器端，伪执行一端，自然是RMI客户端；
2、伪执行端不应该自己完成参数、方法名称和类名称的传递工作；也就是说，对于RMI客户端用户而言，他只面对一个类的一个方法，
直接执行就好；
3、RMI服务器端可能接收多个RMI客户端有关这个方法的执行请求，每个客户端的执行当然应该是独立的，应该用线程实现；
4、RMI服务器端在执行了相关方法，并回传方法执行结果后，应该断开与RMI客户端的连接。
下面是我要实现它的一个思路。
上图由于截图原因，给点补充说明：RpcClientExecutor的作用是建立和服务器的连接，并接受消息和发送消息，具体是发送方法的序列号和参数类型。
1.首先：应该是RpcBeanDefinition:
package com.xupt.rpc.core;
import java.lang.reflect.Method;
public class RpcBeanDefination { //将类，类方法，类对象封装在Definition中。
private Class<?> klass;
private Method method;
private Object object;
RpcBeanDefination() {
}
给该类所有的成员都有getter和setter方法就不需要说了，这个类，将执行的哪个类的哪个方法和类的对象封装起来，以后这个类将形成Map
的值，下面来介绍的RpcBeanFactory会重点介绍。
2.RpcBeanFactory
package com.xupt.rpc.core; import java.util.HashMap;
import java.util.Map; public class RpcBeanFactory { private final Map<String, RpcBeanDefination> beanMap; RpcBeanFactory() {
beanMap = new HashMap<>();
} void rpcBeanRegistry(String beanId,RpcBeanDefination defination) {
RpcBeanDefination rbd = beanMap.get(beanId);
if(rbd != null) {
return;
}
beanMap.put(beanId, defination);
} RpcBeanDefination getBean(String beanId) {
return beanMap.get(beanId);
}
}
此类是将序列号作为Map中的键，RpcBeanDeifintion作为值放入Map中，用BeanId来找对应客户端那边序列号相同的方法。
3.下来是RpcBeanRegistry:
package com.xupt.rpc.core;
import java.lang.reflect.Method;
public class RpcBeanRegistry {
RpcBeanRegistry() {
}
//给客户端提供
static void registryInterface(RpcBeanFactory rpcBeanFactory,Class<?> interfaces) {
doregistry(rpcBeanFactory,interfaces,null);
}
//内部使用，注册
private static void doregistry(RpcBeanFactory rpcBeanFactory , Class<?> interfaces ,Object object) {
//得到接口中的所有的方法，行程方法的数组
Method[] methods = interfaces.getDeclaredMethods();
for(Method method : methods) { //遍历这些方法
String beanId = String.valueOf(method.toString().hashCode());//将方法序列化。
RpcBeanDefination rpcBeanDefination = new RpcBeanDefination();
//将得到的实现接口的那个类和它的方法以及对象放进RpcBeanDefination()中。
rpcBeanDefination.setKlass(interfaces);
rpcBeanDefination.setMethod(method);
rpcBeanDefination.setObject(object);
rpcBeanFactory.rpcBeanRegistry(beanId, rpcBeanDefination);
}
}
//服务端使用，知道实现类的对象。
static void registryInterface(RpcBeanFactory rpcBeanFactory,Class<?> interfaces,Object object) {
//判断此类是否实现了这个接口。
if(!interfaces.isAssignableFrom(object.getClass())){
return;
}
doregistry(rpcBeanFactory,interfaces,object);
}
//服务器端使用，知道类，创建一个对象。
static void registryInterface(RpcBeanFactory rpcBeanFactory,Class<?> interfaces,Class<?> klass) {
//判断该类是否实现了接口。
if(!interfaces.isAssignableFrom(klass)){
return;
}
try {
doregistry(rpcBeanFactory, interfaces, klass.newInstance());
} catch (Exception e) {
e.printStackTrace();
}
}
}
这个类是同时给客户端和服务器使用的，所以有一个私有方法来完成类方法的获得和序列号的产生（method.toString().hashcode()）。然后将类、方法、对象放进RpcBeanDefinition中，将得到的序列号作为键和rpcBeanDeifinyion作为值放进Map中，形成键值对，方便客户端和服务器的调用。
4.下来是RpcServer:
package com.xupt.rpc.core;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket; public class RpcServer implements Runnable { private ServerSocket server;
private int port;
private boolean goon;
private final RpcBeanFactory rpcBeanFactory;
private static long executorId; public RpcServer() {
rpcBeanFactory = new RpcBeanFactory();
this.goon = false;
} public void setPort(int port) {
this.port = port;
} public void startRpcServer() throws Exception {
if(this.port == 0) {
return;
}
server = new ServerSocket(port);
this.goon = true;
new Thread(this,"Rpc_Server").start();//启动线程
} public void stopRpcServer() { //关闭服务器
if (this.server != null && !this.server.isClosed()) {
try {
this.server.close();
} catch (IOException e) {
e.printStackTrace();
} finally {
this.server = null;
}
}
} RpcBeanFactory getRpcBeanFactory() {
return rpcBeanFactory;
} //用注册的方法知道类实现的接口，类的对象，通过对象执行类的方法。
public void rpcRegistry(Class<?> interfaces,Object object) {
RpcBeanRegistry.registryInterface(rpcBeanFactory, interfaces, object);
} public void rpcRegistry(Class<?> interfaces, Class<?> imClass) {
RpcBeanRegistry.registryInterface(rpcBeanFactory, interfaces,imClass);
} @Override
public void run() {
while(goon) {
try {
Socket socket = server.accept();//不断的侦听 new RpcServerExecutor(socket, this,++executorId); } catch (Exception e) {
goon = false;
e.printStackTrace();
}
}
stopRpcServer();
}
}
上述服务器端的基本任务已经完成了。
下来我们来看看客户端：
首先还是：RpcClientExecutor，它是建立与服务器端的连接，以及接收，发送消息，具体发送的是方法的序列号和参数类型。
package com.xupt.rpc.core; import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.Socket; public class RpcClientExecutor { private String rpcServerIp; //ip地址
private int rpcServerPort; //端口号 RpcClientExecutor() {
} RpcClientExecutor(String rpcServerIp, int rpcServerPort) {
this.rpcServerIp = rpcServerIp;
this.rpcServerPort = rpcServerPort;
} String getRpcServerIp() {
return rpcServerIp;
} void setRpcServerIp(String rpcServerIp) {
this.rpcServerIp = rpcServerIp;
} int getRpcServerPort() {
return rpcServerPort;
} void setRpcServerPort(int rpcServerPort) {
this.rpcServerPort = rpcServerPort;
} //关闭客户端
private void closeSocket(ObjectInputStream ois, ObjectOutputStream oos, Socket socket) {
try {
if (ois != null) {
ois.close();
}
} catch (IOException e) {
e.printStackTrace();
} finally {
ois = null;
}
try {
if (oos != null) {
oos.close();
}
} catch (IOException e) {
e.printStackTrace();
} finally {
oos = null;
}
try {
if (socket != null && !socket.isClosed()) {
socket.close();
}
} catch (IOException e) {
e.printStackTrace();
} finally {
socket = null;
}
} @SuppressWarnings("unchecked")
<T> T rpExecutor(String beanId,Object[] params) throws Exception {
//连接服务器端
Socket socket = new Socket(rpcServerIp, rpcServerPort);
//发送方法的序列号和参数类型。
ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
oos.writeUTF(beanId);
oos.writeObject(params); //必须将这句放在前面三句的后面。
ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
//接收服务器端返回的结果。
Object result = ois.readObject(); closeSocket(ois,oos,socket); return (T) result; }
}
下来是：RpcClient：这个类是产生代理，用代理对象伪执行相关的方法，然后在真正的来连接服务器。
package com.xupt.rpc.core; import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy; public class RpcClient { private RpcClientExecutor rpcClientExecutor; public RpcClient(String rpcServerIp,int rpcServerport) {
this.rpcClientExecutor = new RpcClientExecutor(rpcServerIp, rpcServerport);
} @SuppressWarnings("unchecked")
public <T> T getProxy(Class<?> klass) {
return (T) Proxy.newProxyInstance(
klass.getClassLoader(),
new Class[] {klass},
new InvocationHandler() { @Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
String BeanId = String.valueOf(method.toString().hashCode());
Object result = rpcClientExecutor.rpExecutor(BeanId, args); return result;
}
}
);
}
}
上述方法产生代理就不多做解释，不明白请看上一篇的代理机制之初见吧。。。。
以上就是我的RMI的简单实现，入如果有错误，请指正！也希望它对你有所帮助。