《分布式服务框架原理与实践》
一、RPC架构
rpc，全称remote procedure call，即远程过程调用。它是一种进程间的通信方式，允许像调用本地服务一样，调用远程的服务。有很多的具体实现，如spring的http invoker、facebook的thrift二进制私有协议通信。
rpc在80s，由bruce jay nelson提出，他在论文中做了如下定义：
1）简单：rpc概念的语义十分清晰以及简单，这样建立分布式计算就更容易。
2）高效：过程调用看起来十分简单，而且高效。
3）通用：在单机计算中往往是算法和api，跨进程最重要的是通用的通信机制。
2006年后，随着互联网移动的发展以及智能终端的普及，远程分布式调用已经成为主流，开源和自研的rpc框架的普及标志
着传统垂直应用架构的终结。
二、原理
rpc框架的目标是让远程过程（服务），调用更加简单透明，rpc负责屏蔽底层传输方式（tcp udp）、序列化方式（xml json 二进制）以及通信细节。框架的使用者，只需要了解谁在什么位置，提供了什么样的远程服务即可，开发者不用关系底层的调用过程和通信细节。
框架原理图：
核心技术点：
1）远程服务提供者需要以某种形式提供 服务调用 的相关信息，包括但不限于接口定义、数据结构、或者中间态的服务定义文件，例如thrift的IDL文件，WS-RPC的WSDL文件定义，甚至也可以是服务端接口的说明文档。服务调用者需要通过一定的途径获取远程服务的调用的相关信息，例如服务端接口定义jar包导入，获取服务端IDL文件等。
2）远程代理对象：服务调用者调用的服务实际上是远程服务的本地代理，对于java语言，它的实现就是jdk动态代理，通过动态代理的拦截机制，将本地调用封装成远程服务调用。
3）通信：rpc与具体的协议无关，例如spring远程调用支持http invoker、rmi invoke，MessagePack使用的是私有的二进制压缩协议。
4）序列化：远程通信，需要将对象转换成二进制码流进行传输，不同的框架支持的数据类型，数据包大小，异常类型，以及性能都不同，不同的rpc框架应用场景不同，因此技术选择会存在很大差异，一些比较好的rpc框架，支持多种序列化方式，甚至支持用户自定义序列化框架（hadoop avro）。
三、简单实现一个rpc框架
分析：
分为三个部分：
1）服务提供者：运行在服务端，负责提供接口的定义以及服务具体实现类
2）服务发布者：运行在rpc服务端，负责将本地服务发布成远程服务，供消费者使用
主要职责：作为服务端，监听客户端的socket连接，接收到新的连接后，将其封装成task，由线程池执行；
将客户端发送的码流，反序列化成对象，反射调用服务提供者，获取执行结果；
将执行结果序列化，通过socket发送给客户端；
远程服务执行完毕后，关闭socket等资源，防止句柄泄露；
3）本地服务代理：运行在客户端，通过代理调用远程服务 提供者，然后将结果封装返回给本地消费者
主要职责：将本地的接口调用转换成jdk动态代理，在动态代理中实现接口的远程调用；
创建socket客户端，根据ip地址，连接远程服务提供者；
将远程服务调用所需要的接口类，方法名，参数列表等编码后，发送给服务提供者；
同步阻塞，等待服务端响应，获取响应结果后返回
代码结构：
代码：
1）服务提供者：
package me.ele.remoteServiceProvider;
/**
* 远程服务_接口
*
* @author LZJ
* @create 2018-08-03 14:06
**/
public interface DemoService {
String demo(String ping);
}
package me.ele.remoteServiceProvider;
/**
* 远程服务_具体实现
*
* @author LZJ
* @create 2018-08-03 14:08
**/
public class DemoServiceImpl implements DemoService {
public String demo(String ping) {
return ping !=null ? ping + "---->i am ok" : "i am ok";
}
}
2）服务发布者：
package me.ele.remoteServicePublisher;
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.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* 服务发布者
*
* @author LZJ
* @create 2018-08-03 14:10
**/
public class RpcPublisher {
//返回到虚拟机的最大可用的处理器数量
static ExecutorService executorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
public static void publish(String hostName, int port) throws IOException {
ServerSocket server = new ServerSocket();
server.bind(new InetSocketAddress(hostName,port));
try {
while (true){
//server监听客户端请求连接，由线程池执行
executorService.execute(new SupportTask(server.accept()));
}
}finally {
server.close();
}
}
private static class SupportTask implements Runnable{
Socket socket = null;
public SupportTask(Socket socket){
this.socket = socket;
}
public void run() {
ObjectInputStream inputStream = null;
ObjectOutputStream outputStream = null;
try {
inputStream = new ObjectInputStream(socket.getInputStream());
//获取客户端发送的类名
String interfaceName = inputStream.readUTF();
Class<?> service = Class.forName(interfaceName);
//获取客户端发送的方法名
String methodName = inputStream.readUTF();
//获取客户端发送的参数类型
Class<?>[] parameterTypes = (Class<?>[]) inputStream.readObject();
//获取参数
Object[] args = (Object[]) inputStream.readObject();
//invoke调用对应的方法
Method method = service.getMethod(methodName, parameterTypes);
Object result = method.invoke(service.newInstance(), args);
//返回执行结果给客户端
outputStream = new ObjectOutputStream(socket.getOutputStream());
outputStream.writeObject(result);
} catch (Exception e) {
e.printStackTrace();
} finally {
if(inputStream != null){
try {
inputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(outputStream != null){
try {
outputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (socket != null){
try {
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
}
3）本地服务代理：
package me.ele.localServiceProxy;
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;
/**
* 本地服务代理
*
* @author LZJ
* @create 2018-08-03 14:34
**/
public class RpcImporter<S> {
public S importer(final Class<?> serviceClass , final InetSocketAddress address){
return (S) Proxy.newProxyInstance(serviceClass.getClassLoader(),
new Class<?>[]{serviceClass.getInterfaces()[0]},
new InvocationHandler() {
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Socket socket = null;
ObjectOutputStream outputStream = null;
ObjectInputStream inputStream = null;
try {
socket = new Socket();
socket.connect(address);
//向远程发布者提供远程服务的信息
outputStream = new ObjectOutputStream(socket.getOutputStream());
outputStream.writeUTF(serviceClass.getName());
outputStream.writeUTF(method.getName());
outputStream.writeObject(method.getParameterTypes());
outputStream.writeObject(args);
//接收远程服务的返回
inputStream = new ObjectInputStream(socket.getInputStream());
return inputStream.readObject();
}finally {
if(socket != null){
socket.close();
}
if(inputStream != null){
inputStream.close();
}
if(outputStream != null){
outputStream.close();
}
}
}
});
}
}
4）测试：
package me.ele;
import me.ele.localServiceProxy.RpcImporter;
import me.ele.remoteServiceProvider.DemoService;
import me.ele.remoteServiceProvider.DemoServiceImpl;
import me.ele.remoteServicePublisher.RpcPublisher;
import java.io.IOException;
import java.net.InetSocketAddress;
/**
* @author LZJ
* @create 2018-08-03 14:01
**/
public class Test {
public static void main(String[] args) {
//异步启动服务
new Thread(new Runnable() {
public void run() {
try {
RpcPublisher.publish("localhost",9999);
} catch (IOException e) {
e.printStackTrace();
}
}
}).start();
//创建rpc客户端代理
RpcImporter<DemoService> importer = new RpcImporter<DemoService>();
//构建rpc请求参数，发起rpc调用
DemoService localhost = importer.importer(DemoServiceImpl.class, new InetSocketAddress("localhost", 9999));
//将调用结果输出到控制台
String result = localhost.demo("are you ok???");
System.out.println(result);
}
}
5）运行结果：
