RPC可以提高系统稳定性，比如说，我们的订单服务程序更新出BUG，导致内存溢出，是这台服务器宕机了，但是它只会影响的整个系统的订单业务部分，对于用户注册登录等业务没有影响，同样对于系统的日志记录也没有影响。 RPC远程过程调用(Remote Procedure Call)，调用远程计算机上的服务，就像调用本地服务一样。 java本身也为我们提供一种RPC的实现：RMI，允许运行在一个java 虚拟机的对象调用运行在另一个java虚拟机上对象的方法。RMI***使用的是***JRMP（Java Remote Messageing Protocol）协议, ***JRMP***是专门为java定制的通信协议，所以是纯java的分布式解决方案。这里我就不作详细说明了，简要写一下实现的步骤：
1.创建一个远程接口，并继承java.rmi.Remote接口 2.实现远程接口，并且继承UnicastRemoteObject 3.创建服务器程序，同时使用createRegistry方法注册远程接口对象 4.创建客户端程序，通过Naming类的lookup方法来远程调用接口中的方法 但是RMI接口和实现类不灵活，RMI必须继承和实现Remote接口。
基于socket通信、jdk的动态代理以及java的序列化，我们可以说实现一个简单的RPC服务。
服务端定义服务接口及实现：
//服务接口 public interface TechInterface { String XJ(String name); } //服务的实现 public class TechImpl implements TechInterface { @Override public String XJ(String name) { return "你好 我是Eminem"; } }服务注册中心以及服务处理rpc请求
public class RegisterCenter { //线程池 多线程加快处理请求 private static ExecutorService executor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors()); //一个map模拟注册中心 private static final HashMap<String, Class> serviceRegistry = new HashMap<String, Class>(); private static boolean isRunning = false; //服务端口 private static int port; public RegisterCenter(int port) { this.port = port; } //注册中心启动 public void start() throws IOException { ServerSocket serverSocket = new ServerSocket(); serverSocket.bind(new InetSocketAddress("127.0.0.1",port)); try { while (true) { //serverSocket.accept() 在没有接受到客户端的请求会阻塞在这 //客户端的请求会被包装成任务放到线程池里面执行 executor.execute(new ServiceTask(serverSocket.accept())); System.out.println("11111"); } } finally { serverSocket.close(); } } //map模拟服务注册 public void register(Class serviceInterface, Class impl) { serviceRegistry.put("com.zjx.rpc.service.TechInterface", impl); } //处理客户端请求的任务类 public static class ServiceTask implements Runnable { //客户端client Socket client=null; public ServiceTask(Socket socket){ this.client=socket; } @Override public void run() { ObjectInputStream inputStream=null; ObjectOutputStream outputStream=null; try { inputStream=new ObjectInputStream(client.getInputStream()); //拿到接口名 String serviceName = inputStream.readUTF(); //拿到方法名 String methodName = inputStream.readUTF(); //拿到参数类型 Class<?>[] paramTypes = ( Class<?>[])inputStream.readObject(); //拿到参数值 Object[] arguments = (Object[])inputStream.readObject(); //到注册中心根据接口名获取实现类 Class serviceClass=serviceRegistry.get(serviceName); //反射进行调用 Method method=serviceClass.getMethod(methodName,paramTypes); //执行方法 Object result=method.invoke(serviceClass.newInstance(),arguments); //返回给客户端 outputStream=new ObjectOutputStream(client.getOutputStream()); outputStream.writeObject(result); // outputStream.close(); inputStream.close(); client.close(); }catch (Exception e){ }finally { } } } }服务端启动
public class Server { public static void main(String[] args) throws Exception{ new Thread(new Runnable() { public void run() { try { //起一个服务中心 RegisterCenter serviceServer = new RegisterCenter(8888); //注册服务至注册中心 serviceServer.register(TechInterface.class, TechImpl.class); //运行我们的服务 serviceServer.start(); } catch (Exception e) { e.printStackTrace(); } } }).start(); } }定义一个相同的接口
public interface TechInterface { String XJ(String name); }客户端利用动态代理实现远程服务的调用
public class RpcClientFrame { public static <T> T getRemoteProxyObj(final Class<?> serviceInerface) throws Exception{ //默认端口 InetSocketAddress socketAddress=new InetSocketAddress("127.0.0.1",8888); return (T)Proxy.newProxyInstance(serviceInerface.getClassLoader(),new Class<?>[]{serviceInerface},new DynProxy(serviceInerface,socketAddress)); } private static class DynProxy implements InvocationHandler{ //接口 private final Class<?> serviceInterface; //远程调用的地址 private final InetSocketAddress addr; public DynProxy(Class<?> serviceInterface, InetSocketAddress addr) { this.serviceInterface = serviceInterface; this.addr = addr; } /** * 增强 实现了对远程服务的访问 * @param proxy * @param method * @param args * @return * @throws Throwable */ @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { /** * 网络增强部分 */ Socket socket=null; //因为传递的大部分是 方法、参数，所以我们使用Object流对象 ObjectInputStream objectInputStream=null; ObjectOutputStream objectOutputStream=null; try { socket=new Socket(); System.out.println("3333"); socket.connect(addr); System.out.println("34444"); //往远端发送数据 //拿到输出流 objectOutputStream=new ObjectOutputStream(socket.getOutputStream()); //发送调用方法的类名 使用utf防止乱码 objectOutputStream.writeUTF(serviceInterface.getName()); System.out.println(serviceInterface.getName()); //发送 方法名 objectOutputStream.writeUTF(method.getName()); System.out.println(method.getName()); //发送参数类型 objectOutputStream.writeObject(method.getParameterTypes()); //发送参数值 objectOutputStream.writeObject(args); //刷新缓冲区 使得数据立马发送 objectOutputStream.flush(); //立刻拿到远程执行的结果 objectInputStream=new ObjectInputStream(socket.getInputStream()); //打印调用细节 System.out.println("远程调用成功!"+serviceInterface.getName()); return objectInputStream.readObject(); }finally { socket.close(); objectOutputStream.close(); objectInputStream.close(); } } } }客户端调用远程服务
public static void main(String[] args) { try { TechInterface techInterface= RpcClientFrame.getRemoteProxyObj(TechInterface.class); //进远程调用我们的对象 System.out.println(techInterface.XJ("king")); } catch (Exception e) { e.printStackTrace(); } }调用结果： 注意这边我简单化了，如果传递的参数是实体类，需要序列化。
这里只是简单的写了一下，还有许多可以拓展的地方，例如： 1.通讯效率 2.IO方式 3.序列化速度 4.服务的管理 后面会继续研究阿里的dubbo。
