RPC（Remote Procedure Call）：远程过程调用。客户端能够像调用本地方法一样去调用服务器的服务。
常见的RPC框架有阿里的Dubbo、Google的gRPC、Twitter 的Finagle，Facebook 的 Thrift，等等。
那么RPC中有一些什么技术呢？
框架：Netty
通信协议：Socket、RMI。
服务发布与订阅：Zookeeper
Spring：使用Spring配置服务，加载Bean,扫描注解
消息编码与解码：使用Protostuff序列化与反序列化消息。
实现的流程图：
核心流程：
1、服务消费方（client）调用以本地调用方式调用服务；
2、client stub接收到调用后负责将方法、参数等组装成能够进行网络传输的消息体；
3、client stub 找到服务地址，并将消息发送给服务端；
4、server stub收到消息后进行解码；
5、server stub 根据解码结果调用本地服务；
6、本地服务执行并将结果返回给serverstub;
7、server stub 将返回的结果打包成消息发送至消费方；
8、client stub 接收到消息，并进行解码；
9、服务消费方得到最终结果
RPC的目标就是将2~8这些步骤封装起来，让用户不需要了解这些细节。Java一般使用动态代理的方式实现远程调用。
RMI（Java Remote Method Invocation）实现方式
是Java编程语言里面，一种用于实现远程调用的应用程序编程接口。它使客户机上运行的程序可以调用远程服务器上的对象。远程方法调用特性使Java编程人员能够在网络环境中分布操作。RMI全部的宗旨就是尽可能简化远程接口对象的使用。
实现步骤：
1、编写远程服务接口，该接口必须继承java.rmi.Remote接口，方法必须抛出java.rmi.RemoteException异常；
2、编写远程接口实现类，该类必须继承java.rmi.server.UnicastRemoteObject类。
3、运行RMI编译器，创建客户端stub类和服务端skeleton类；
4、启动一个RMI注册表，以便驻留这些服务；
5、在RMI注册表中注册服务；
6、客服端查找远程对象，并调用远程方法；
1:创建远程接口，继承java.rmi.Remote接口
public interface GreetServer extends java.rmi.Remote{
String sayHello(String name) throws RemoteException;
}
2：实现远程接口，继承java.rmi.server.UnicastRemoteObject类
public class GreeServerImpl extends java.rmi.UnicastRemoteObject
implements GreetServer{
private static final long serilVersionUID = 343406015238720004l;
public GreetServer() throws RemoteException{
super();
}
@Override
public String sayHello(String name) throws RemoteException{
return "Hello"+name;
}
}
3、生成Stub和Skeleton;
4、执行rmiregistry命令注册服务
5、启动服务
LocateRegistry.createRegistry(1098);
Naming.bind("rmi://10.108.1.1.138:1098/GreetServer",New GreetServerImpl());
6、客服端调用
GreetServer greetServer = (GreetServer)Naming.out.println(greetServer.sayHello("Jobs"));Zookeeper
Zookeeper是一个分布式协调服务，可用于服务发现，分布式锁，分布式领导选举，配置管理等。Zookeeper提供了类似于Linux文件系统的树形结构（可认为是轻量级的内存文件系统，但只适合存少量信息，完全不适合存储大量文件或者大文件），同时提供了对于每个节点的监控与通知机制。
Zookeeper角色
Zookeeper集群是一个基于主从复制的高可用集群，每个服务器承担如下三种角色的一种
Leader：
1、一个Zookeeper集群同一时间只会只有一个实际工作的leader，它会发起并维护与各Follwer及Observer间的心跳。
2、所有的写操作必须通过Leader完成再由Leader将写操作广播给其他服务器。只要有超过半数节点（不包括observeer节点）写入成功。该请求就会被提交。
Follower：
1、一个Zookeeper集群可能同时存在多个Follower，它会响应Leader的心跳
2、Follower可直接处理并返回客户端的读请求，同时会将写请求转发给Leader处理
3、并且负责在Leader处理写请求时对请求进行投票。
Netty架构：
服务端通讯流程
1、ServerSocketChannel
2、绑定InetSocketAdress
3、创建Selector，启动线程
4、将ServerSocketChannel注册到Selector监听
5、Selector轮询就绪的Key
6、handleAccept()处理新的客户端接入
7、设置新建客户连接的Socket
8、向selector注册监听读操作SelectionKey.OP_READ
9、handleRead()异步读请求消息到ByteBuffer
10、decode请求
11、异步写ByteBuffer到SocketChannel
package NettyTest;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.ByteChannel;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
//服务器端（端口号为63932，192.168.1.4）
public class NIOServer {
private Selector selector;
/*
* 获得一个ServerSocket通道，并对通道进行一些初始化的工作
* @param port 绑定端口号
* @Throws IOException
*/
public void initServer(int port) throws IOException{
//获得一个ServerSocket的通道
ServerSocketChannel serverChannel = ServerSocketChannel.open();
//设置通道为非阻塞
serverChannel.configureBlocking(false);
//将对应的ServerSocket绑定到port端口
serverChannel.socket().bind(new InetSocketAddress(port));
//获得一个管道处理器
this.selector = Selector.open();
//将通道管理器与该通道绑定，并为该通道注册SelectorKey.OP_ACCEPT事件，注册该事件后
//当该事件到达时，selector.select()会返回，如果事件没有到达，则selector.select()会一直阻塞
serverChannel.register(selector, SelectionKey.OP_ACCEPT);
/*
* 采用轮询的方式监听selector上是否有需要处理的事件，如果有则进行处理
* @throws IOException
*/
}
public void listen() throws IOException{
System.out.println("服务端启动成功！");
//轮询selector
while(true){
//当注册事件到来时返回方法，否则一直阻塞
selector.select();
//获得selector中的迭代器，选中的项为注册事件
Iterator ite = this.selector.selectedKeys().iterator();
while(ite.hasNext()){
SelectionKey key = (SelectionKey) ite.next();
//删除已选用的Key,防止重复处理
ite.remove();
//客户端连接请求事件
if(key.isAcceptable()){
ServerSocketChannel server = (ServerSocketChannel) key.channel();
//获得和客户端连接通道
SocketChannel channel = server.accept();
//设置成非阻塞
channel.configureBlocking(false);
//在这可以给客户端发送消息
channel.write(ByteBuffer.wrap(new String("向客户端发送的一条消息").getBytes()));
//在和客户端连接成功后，为了可以接收客户端的信息，需要给通道设置成读的权限。
channel.register(this.selector, SelectionKey.OP_READ);
//获得可读事件
}else if(key.isReadable()){
read(key);
}
}
}
}
private void read(SelectionKey key)throws IOException {
//服务器可读取消息：得到的消息发生的socket通道
SocketChannel channel = (SocketChannel) key.channel();
//创建读取缓冲区
ByteBuffer buffer = ByteBuffer.allocate(10);
channel.read(buffer);
byte[] data = buffer.array();
String msg = new String(data).trim();
System.out.println("服务器端收到的消息"+msg);
ByteBuffer outbuffer = ByteBuffer.wrap(msg.getBytes());
channel.write(outbuffer);//将消息送回给客户端
}
//启动服务端测试
public static void main(String[] args) throws IOException{
NIOServer server = new NIOServer();
server.initServer(63932);
server.listen();
}
}代码中缺少handle的处理
客户端通信
1、打开SocketChannel
2、设置SocketChannel为非阻塞模式，同时设置TCP参数
3、异步连接服务端
4、判断连接结果，如果连接成功，则调到步骤10，否则执行步骤5
5、向Reactor线程多路复用器注册OP CONNECT事件
6、创建Selector启动线程
7、Selector轮询就绪的Key
8、handerConnect()
9、判断连接完成，则执行步骤10
10、向多路复用器注册读事件OP_READ
11、handerConnect()
12、decode请求
13、异步写ByteBuffer到SocketChannel
package NettyTest;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
public class NIOClient {
//通道管理器
private Selector selector;
/*
* 获得一个Socket通道，并对通道进行一些初始化工作
* @param ip 连接客户端IP
* @param port 连接服务器的端口
* @throws IOException
*/
public void initClient(String ip,int port) throws IOException{
//获取一个socket通道
SocketChannel channel = SocketChannel.open();
//设置通道位非阻塞
channel.configureBlocking(false);
//获取一个通道管理器
this.selector=Selector.open();
//客户端连接服务器，其实方法执行并没有连接服务器，需要在listen()方法中调用
//用channel.finishConnet();才能完成连接
channel.connect(new InetSocketAddress(port));
//将通道管理器与通道绑定，并为该通道注册SelectionKey.OP_CONNET事件。
channel.register(selector, SelectionKey.OP_CONNECT);
}
/*
* 采用轮询的方式监听selector上是否有需要处理的事件，如果有则进行处理
* @throws IOException
*/
public void listen() throws IOException{
//轮询访问selector
selector.select();
Iterator ite = this.selector.selectedKeys().iterator();
while(ite.hasNext()){
SelectionKey key = (SelectionKey) ite.next();
ite.remove();
//连接该事件发生
if(key.isConnectable()){
SocketChannel channel = (SocketChannel) key.channel();
if(channel.isConnectionPending()){
channel.finishConnect();
}
//设置成非阻塞
channel.configureBlocking(false);
channel.write(ByteBuffer.wrap(new String("向服务器发送了一条消息").getBytes()));
//在服务器连接成功后，为了可以接收到服务端消息，需要设置管道的读取权限
channel.register(this.selector, SelectionKey.OP_READ);
//获取可读事件
}else if(key.isReadable()){
read(key);
}
}
}
private void read(SelectionKey key) throws IOException {
SocketChannel channel = (SocketChannel) key.channel();
//创建读取缓冲区
ByteBuffer buffer = ByteBuffer.allocate(1024);
channel.read(buffer);
byte[] data = buffer.array();
String msg = new String(data).trim();
System.out.println("服务器端收到的消息"+msg);
ByteBuffer outbuffer = ByteBuffer.wrap(msg.getBytes());
channel.write(outbuffer);//将消息送回给客户端
}
//启动客户端测试
public static void main(String[] args) throws IOException{
NIOClient client = new NIOClient();
client.initClient("localhost", 63932);
client.listen();
}
}Netty的IO线程由于聚合了 多路复用器Selector，可以同时并发处理成百上千个客户端Channel，由于读写操作都是非阻塞的，这就可以充分提升IO的运行效率，避免频繁的IO阻塞导致线程的挂起。
零拷贝：
1、Netty的接收和发送ByteBuffer采用DIRECT BUFFERS，使用堆外直接内存进行Socket读写，不需要进行字节缓冲区的二次拷贝。如果使用传统的堆内存（HEAP BUFFER）进行Socket的读写，JVM会将堆内存Buffer拷贝一份到直接内存中，然后才写入Socket中。相比于堆外直接内存，消息在发送过程中多了一次缓冲区的内存拷贝。
2、Netty提供了组合Buffer对象，可以聚合多个ByteBuffer对象，用户可以像操作一个Buffer那样方便对组合buffer进行操作，避免了传统通过内存拷贝的方式将几个小的Buffer合并成一个大的Buffer。
3、Netty的文件传输采用了transferTo的方法，它可以直接将文件缓冲区的数据发送到目标Channel，避免了传统通过write方式导致内存拷贝问题。