时隔多日，终于又开始写博客了。之前的多线程篇才刚起了个头就因为面试搁浅了，非常不好意思，一方面也是因为经验不足，这一块难度很大，所以，等以后有经验了再更吧。
最近在看李林峰老师的《分布式服务框架》，也是刚需吧，其实老早就想系统的学习一下分布式的知识，之前都是迷迷糊糊在用，很多基本的概念都不通。当然我不是去学分布式的底层原理，只是学学服务框架罢了。初学者，基本的概念还在搭建当中，希望大佬不吝赐教。
很早之前就知道RPC这个东西了，也好像知道他是干什么的，但就是不明白它怎么用，像之前听过的Thrift以及grpc。今天尝试梳理一下rpc的知识，并带上书上的一个例子帮助大家理解。
从IPC(Inter Process Comunication)到RPC：
RPC(Remote Procedure Call)远程过程调用，说白了就是调用远程服务器上的服务，该服务不在本地。 那么第一个问题：为什么会出现远程的服务呢？
传统的垂直架构的弊病：(垂直架构简单来说就是当增加系统功能的时候，一个系统的复杂性不断地纵向加深，系统会变得越来越庞大。）这会带来很多的问题，比如代码重复率高，维护和部署时间长，耦合性不断增强，牵一发而动全身，可靠性变差等等。所以我们这种传统的架构可能就只会应用在小型的系统上了。
我们要做的就是把原来一个臃肿的系统给分开，比如我们将核心业务，拥有公共能力的API抽离出来。说白了，解耦是一个一直追求的目标。那么现在我们有了不同的服务模块，我们就可以把他们部署在不同的机器上了。因此接口调用本地API变成了跨进程远程调用，RPC框架应运而生。
那么自然而然地就出现了我们第一问题的答案：因为应用服务已经遍及各地，我不能再像调用本地服务那样调用它了，所以自然而然就出现了远程过程调用。
那么第二个问题来了，RPC需要解决哪些问题呢？包括但不仅限于：
1.远程服务提供者需要以某种形式提供服务定义文件。例如Thrift的IDL，WS-RPC的WSDL文件，甚至可以是接口说明文档。IDL(Interface Description Language)，说白了他可以屏蔽不同编程语言的差异。因为你部署在不同的机器上的服务，根据业务需求你可能使用不同的环境不同的语言编写的程序，那么我们要解决这种异构性。(但SOA好像是统一的技术栈)
2.远程代理对象：Java里面的代理真的是非常重要的思想，也符合我们的现实生活的习惯，通过代理来简化你的请求嘛。也就是说调用者调用远程服务的时候其实只需要调用本地的服务代理就可以。
3.通信协议：不同的服务可你的那个需要在网络上传输吧，那么我们采用什么协议呢?其实RPC是与协议无关的。
4.序列化：远程传输信息的时候，我们需要将对象转化为二进制码流，不同的RPC框架的序列化细节都是不同的。
这张图基本能说明这个调用的过程了，网上扒的，很想自己画一个，但画得太丑。
好了，下面进入今天的正题，我们如何自己来编写一个简单的rpc调用呢？原料：
Java socket, Java自带的序列化方式(只适用于Java)，你还需要知道：
Java动态代理， Java反射。
按照我们讲得那样，需要实现三部分：
1.服务提供者，运行在服务端，负责提供服务接口和服务实现类。
2.服务发布者，运行在RPC服务端，负责将本地服务发布成远程服务，供消费者调用。
3.本地服务代理，运行在该RPC客户端。通过代理调用远程服务提供者，然后将结果封装后返回给消费者。
嗯开始吧，首先是服务端接口和实现：
public interface EchoService {
String echo(String ping);
}
public class EchoServiceImpl implements EchoService {
@Override
public String echo(String ping) {
return ping != null?ping + "-->I am ok." : "I am ok.";
}
}
只是一个Demo，当然算不上服务，只是打印一个简单的语句。注意一定要定义一个接口，这是Java动态代理里面的知识，可以自己去看看。
下面是服务端服务发布者代码：
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;
public class RpcExporter {
static Executor executor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
public static void exporter(String hostName, int port) throws Exception{
ServerSocket serverSocket = new ServerSocket();
serverSocket.bind(new InetSocketAddress(hostName,port));
try{
while (true){
executor.execute(new ExporterTask(serverSocket.accept()));
}
}finally {
serverSocket.close();
}
}
private static class ExporterTask implements Runnable{
Socket client = null;
public ExporterTask(Socket client){
this.client = client;
}
@Override
public void run() {
ObjectInputStream input = null;
ObjectOutputStream output = null;
try {
input = new ObjectInputStream(client.getInputStream());
String interfaceName = input.readUTF();
try {
Class<?> service = Class.forName(interfaceName);
String methodName = input.readUTF();
Class<?>[] parametersTypes = (Class<?>[])input.readObject();
Object[] arguments = (Object[]) input.readObject();
try {
Method method = service.getMethod(methodName,parametersTypes);
output = new ObjectOutputStream(client.getOutputStream());
try {
Object result = null;
try {
result = method.invoke(service.newInstance(),arguments);
} catch (InstantiationException e) {
e.printStackTrace();
}
output.writeObject(result);
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}finally {
try {
output.close();
input.close();
} catch (IOException e) {
e.printStackTrace();
}
}
} catch (NoSuchMethodException e) {
e.printStackTrace();
}
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
服务发布者做了如下几件事情：
1.作为服务端，监听客户端的TCP连接，接收到新的客户端连接后将其封装成Task，由线程池执行。
2.将客户端发送的码流反序列化成对象，反射调用服务实现者，获取执行结果。顺便提一句，表明Java对象可序列的方式是实现Serializable接口，但真正起作用的其实是ObjectInputStream和ObjectOutputStream的ObjectStreamClass对象，具体的方法便是readObject()和writeObject()。有兴趣的可以自己去研究下。
3.将执行结果对象反序列化，通过Socket发送给客户端。
4.远程服务调用完成以后，释放Socket等连接资源，防止句柄泄露。
下面是RPC客户端代码：
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 RpcImporter<S> {
public S importer(final Class<?> serviceClass, final InetSocketAddress addr){
return (S) Proxy.newProxyInstance(serviceClass.getClassLoader(), new Class<?>[]{serviceClass.getInterfaces()[0]}, new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Socket socket = null;
ObjectOutputStream output = null;
ObjectInputStream input = null;
try {
socket = new Socket();
socket.connect(addr);
output = new ObjectOutputStream(socket.getOutputStream());
output.writeUTF(serviceClass.getName());
output.writeUTF(method.getName());
output.writeObject(method.getParameterTypes());
output.writeObject(args);
input = new ObjectInputStream(socket.getInputStream());
return input.readObject();
}finally {
if(input != null){
input.close();
}
if(output != null){
output.close();
}
if(socket != null){
socket.close();
}
}
}
});
}
}
本地代理做的事情如下：
1.将本地的接口调用转换成JDK动态代理，在动态接口中实现接口的远程调用。
2.创建Socket刻划断，根据指定地址连接远程服务提供者。
3.将远程服务所需要的接口类，方法名，参数列表等编码后发给服务提供者。
4.同步阻塞等待服务端返回应答，获取应答后返回。
下面是测试代码：
public class Test
{
public static void main(String[] args) {
new Thread(new Runnable() {
@Override
public void run() {
try {
RpcExporter.exporter("localhost",8088);
} catch (Exception e) {
e.printStackTrace();
}
}
}).start();
RpcImporter<EchoService> importer = new RpcImporter<>();
EchoService echoService = importer.importer(EchoServiceImpl.class, new InetSocketAddress("localhost",8088));
System.out.println(echoService.echo("Are you ok?"));
}
}
首先创建一个异步的发布服务端的线程并启动，用于接收RPC客户端的请求，根据请求参数带哦用实现类，返回结果给客户端。
随后，创建客户端服务代理类，构建RPC请求参数。发起RPC调用，将调用结果输出到控制台。
执行结果如下：
好啦，这篇文章就写完了。感觉写的很基础也很片面，跟网上其他介绍rpc的文章根本没法比，就当作入门了解一下吧。
