RPC，即 Remote Procedure Call（遠程過程調用），說得通俗一點就是：調用遠程計算機上的服務，就像調用本地服務一樣。
RPC 可基於 HTTP 或 TCP 協議，Web Service 就是基於 HTTP 協議的 RPC，它具有良好的跨平臺性，但其性能卻不如基於 TCP 協議的 RPC。會兩方面會直接影響 RPC 的性能，一是傳輸方式，二是序列化。
眾所周知，TCP 是傳輸層協議，HTTP 是應用層協議，而傳輸層較應用層更加底層，在數據傳輸方面，越底層越快，因此，在一般情況下，TCP 一定比 HTTP 快。就序列化而言，Java 提供了默認的序列化方式，但在高併發的情況下，這種方式將會帶來一些性能上的瓶頸，於是市面上出現了一系列優秀的序列化框架，比如：Protobuf、Kryo、Hessian、Jackson 等，它們可以取代 Java 默認的序列化，從而提供更高效的性能。
為了支持高併發，傳統的阻塞式 IO 顯然不太合適，因此我們需要異步的 IO，即 NIO。Java 提供了 NIO 的解決方案，Java 7 也提供了更優秀的 NIO.2 支持，用 Java 實現 NIO 並不是遙不可及的事情，只是需要我們熟悉 NIO 的技術細節。
我們需要將服務部署在分佈式環境下的不同節點上，通過服務註冊的方式，讓客戶端來自動發現當前可用的服務，並調用這些服務。這需要一種服務註冊表（Service Registry）的組件，讓它來註冊分佈式環境下所有的服務地址（包括：主機名與端口號）。
應用、服務、服務註冊表之間的關係見下圖：
每臺 Server 上可發佈多個 Service，這些 Service 共用一個 host 與 port，在分佈式環境下會提供 Server 共同對外提供 Service。此外，為防止 Service Registry 出現單點故障，因此需要將其搭建為集群環境。
本文將為您揭曉開發輕量級分佈式 RPC 框架的具體過程，該框架基於 TCP 協議，提供了 NIO 特性，提供高效的序列化方式，同時也具備服務註冊與發現的能力。
根據以上技術需求，我們可使用如下技術選型：
- Spring：它是最強大的依賴注入框架，也是業界的權威標準。
- Netty：它使 NIO 編程更加容易，屏蔽了 Java 底層的 NIO 細節。
- Protostuff：它基於 Protobuf 序列化框架，面向 POJO，無需編寫 .proto 文件。
- ZooKeeper：提供服務註冊與發現功能，開發分佈式系統的必備選擇，同時它也具備天生的集群能力。
相關 Maven 依賴請見附錄。
第一步：編寫服務接口
public interface HelloService {
String hello(String name);
}
將該接口放在獨立的客戶端 jar 包中，以供應用使用。
第二步：編寫服務接口的實現類
@RpcService(HelloService.class) // 指定遠程接口
public class HelloServiceImpl implements HelloService {
@Override
public String hello(String name) {
return "Hello! " + name;
}
}
使用RpcService註解定義在服務接口的實現類上，需要對該實現類指定遠程接口，因為實現類可能會實現多個接口，一定要告訴框架哪個才是遠程接口。
RpcService代碼如下：
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Component // 表明可被 Spring 掃描
public @interface RpcService {
Class> value();
}
該註解具備 Spring 的Component註解的特性，可被 Spring 掃描。
該實現類放在服務端 jar 包中，該 jar 包還提供了一些服務端的配置文件與啟動服務的引導程序。
第三步：配置服務端
服務端 Spring 配置文件名為spring.xml，內容如下：
<beans>
<component-scan>
<property-placeholder>
<bean>
<constructor-arg>
<bean>
<constructor-arg>
<constructor-arg>
具體的配置參數在config.properties文件中，內容如下：
# ZooKeeper 服務器
registry.address=127.0.0.1:2181
# RPC 服務器
server.address=127.0.0.1:8000
以上配置表明：連接本地的 ZooKeeper 服務器，並在 8000 端口上發佈 RPC 服務。
第四步：啟動服務器併發布服務
為了加載 Spring 配置文件來發布服務，只需編寫一個引導程序即可：
public class RpcBootstrap {
public static void main(String[] args) {
new ClassPathXmlApplicationContext("spring.xml");
}
}
運行RpcBootstrap類的main方法即可啟動服務端，但還有兩個重要的組件尚未實現，它們分別是：ServiceRegistry與RpcServer，下文會給出具體實現細節。
第五步：實現服務註冊
使用 ZooKeeper 客戶端可輕鬆實現服務註冊功能，ServiceRegistry代碼如下：
public class ServiceRegistry {
private static final Logger LOGGER = LoggerFactory.getLogger(ServiceRegistry.class);
private CountDownLatch latch = new CountDownLatch(1);
private String registryAddress;
public ServiceRegistry(String registryAddress) {
this.registryAddress = registryAddress;
}
public void register(String data) {
if (data != null) {
ZooKeeper zk = connectServer();
if (zk != null) {
createNode(zk, data);
}
}
}
private ZooKeeper connectServer() {
ZooKeeper zk = null;
try {
zk = new ZooKeeper(registryAddress, Constant.ZK_SESSION_TIMEOUT, new Watcher() {
@Override
public void process(WatchedEvent event) {
if (event.getState() == Event.KeeperState.SyncConnected) {
latch.countDown();
}
}
});
latch.await();
} catch (IOException | InterruptedException e) {
LOGGER.error("", e);
}
return zk;
}
private void createNode(ZooKeeper zk, String data) {
try {
byte[] bytes = data.getBytes();
String path = zk.create(Constant.ZK_DATA_PATH, bytes, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
LOGGER.debug("create zookeeper node ({} => {})", path, data);
} catch (KeeperException | InterruptedException e) {
LOGGER.error("", e);
}
}
}
其中，通過Constant配置了所有的常量：
public interface Constant {
int ZK_SESSION_TIMEOUT = 5000;
String ZK_REGISTRY_PATH = "/registry";
String ZK_DATA_PATH = ZK_REGISTRY_PATH + "/data";
}
注意：首先需要使用 ZooKeeper 客戶端命令行創建/registry永久節點，用於存放所有的服務臨時節點。
第六步：實現 RPC 服務器
使用 Netty 可實現一個支持 NIO 的 RPC 服務器，需要使用ServiceRegistry註冊服務地址，RpcServer代碼如下：
public class RpcServer implements ApplicationContextAware, InitializingBean {
private static final Logger LOGGER = LoggerFactory.getLogger(RpcServer.class);
private String serverAddress;
private ServiceRegistry serviceRegistry;
private Map<string> handlerMap = new HashMap<>(); // 存放接口名與服務對象之間的映射關係/<string>
public RpcServer(String serverAddress) {
this.serverAddress = serverAddress;
}
public RpcServer(String serverAddress, ServiceRegistry serviceRegistry) {
this.serverAddress = serverAddress;
this.serviceRegistry = serviceRegistry;
}
@Override
public void setApplicationContext(ApplicationContext ctx) throws BeansException {
Map<string> serviceBeanMap = ctx.getBeansWithAnnotation(RpcService.class); // 獲取所有帶有 RpcService 註解的 Spring Bean/<string>
if (MapUtils.isNotEmpty(serviceBeanMap)) {
for (Object serviceBean : serviceBeanMap.values()) {
String interfaceName = serviceBean.getClass().getAnnotation(RpcService.class).value().getName();
handlerMap.put(interfaceName, serviceBean);
}
}
}
@Override
public void afterPropertiesSet() throws Exception {
EventLoopGroup bossGroup = new NioEventLoopGroup();
EventLoopGroup workerGroup = new NioEventLoopGroup();
try {
ServerBootstrap bootstrap = new ServerBootstrap();
bootstrap.group(bossGroup, workerGroup).channel(NioServerSocketChannel.class)
.childHandler(new ChannelInitializer<socketchannel>() {/<socketchannel>
@Override
public void initChannel(SocketChannel channel) throws Exception {
channel.pipeline()
.addLast(new RpcDecoder(RpcRequest.class)) // 將 RPC 請求進行解碼（為了處理請求）
.addLast(new RpcEncoder(RpcResponse.class)) // 將 RPC 響應進行編碼（為了返回響應）
.addLast(new RpcHandler(handlerMap)); // 處理 RPC 請求
}
})
.option(ChannelOption.SO_BACKLOG, 128)
.childOption(ChannelOption.SO_KEEPALIVE, true);
String[] array = serverAddress.split(":");
String host = array[0];
int port = Integer.parseInt(array[1]);
ChannelFuture future = bootstrap.bind(host, port).sync();
LOGGER.debug("server started on port {}", port);
if (serviceRegistry != null) {
serviceRegistry.register(serverAddress); // 註冊服務地址
}
future.channel().closeFuture().sync();
} finally {
workerGroup.shutdownGracefully();
bossGroup.shutdownGracefully();
}
}
}
以上代碼中，有兩個重要的 POJO 需要描述一下，它們分別是RpcRequest與RpcResponse。
使用RpcRequest封裝 RPC 請求，代碼如下：
public class RpcRequest {
private String requestId;
private String className;
private String methodName;
private Class>[] parameterTypes;
private Object[] parameters;
// getter/setter...
}
使用RpcResponse封裝 RPC 響應，代碼如下：
public class RpcResponse {
private String requestId;
private Throwable error;
private Object result;
// getter/setter...
}
使用RpcDecoder提供 RPC 解碼，只需擴展 Netty 的ByteToMessageDecoder抽象類的decode方法即可，代碼如下：
public class RpcDecoder extends ByteToMessageDecoder {
private Class> genericClass;
public RpcDecoder(Class> genericClass) {
this.genericClass = genericClass;
}
@Override
public void decode(ChannelHandlerContext ctx, ByteBuf in, List<object> out) throws Exception {/<object>
if (in.readableBytes() < 4) {
return;
}
in.markReaderIndex();
int dataLength = in.readInt();
if (dataLength < 0) {
ctx.close();
}
if (in.readableBytes() < dataLength) {
in.resetReaderIndex();
return;
}
byte[] data = new byte[dataLength];
in.readBytes(data);
Object obj = SerializationUtil.deserialize(data, genericClass);
out.add(obj);
}
}
使用RpcEncoder提供 RPC 編碼，只需擴展 Netty 的MessageToByteEncoder抽象類的encode方法即可，代碼如下：
public class RpcEncoder extends MessageToByteEncoder {
private Class> genericClass;
public RpcEncoder(Class> genericClass) {
this.genericClass = genericClass;
}
@Override
public void encode(ChannelHandlerContext ctx, Object in, ByteBuf out) throws Exception {
if (genericClass.isInstance(in)) {
byte[] data = SerializationUtil.serialize(in);
out.writeInt(data.length);
out.writeBytes(data);
}
}
}
編寫一個SerializationUtil工具類，使用Protostuff實現序列化：
public class SerializationUtil {
private static Map<class>, Schema>> cachedSchema = new ConcurrentHashMap<>();/<class>
private static Objenesis objenesis = new ObjenesisStd(true);
private SerializationUtil() {
}
@SuppressWarnings("unchecked")
private static
Schema
if (schema == null) {
schema = RuntimeSchema.createFrom(cls);
if (schema != null) {
cachedSchema.put(cls, schema);
}
}
return schema;
}
@SuppressWarnings("unchecked")
public static
Class
LinkedBuffer buffer = LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE);
try {
Schema
return ProtostuffIOUtil.toByteArray(obj, schema, buffer);
} catch (Exception e) {
throw new IllegalStateException(e.getMessage(), e);
} finally {
buffer.clear();
}
}
public static
try {
T message = (T) objenesis.newInstance(cls);
Schema
ProtostuffIOUtil.mergeFrom(data, message, schema);
return message;
} catch (Exception e) {
throw new IllegalStateException(e.getMessage(), e);
}
}
}
以上了使用 Objenesis 來實例化對象，它是比 Java 反射更加強大。
注意：如需要替換其它序列化框架，只需修改SerializationUtil即可。當然，更好的實現方式是提供配置項來決定使用哪種序列化方式。
使用RpcHandler中處理 RPC 請求，只需擴展 Netty 的SimpleChannelInboundHandler抽象類即可，代碼如下：
public class RpcHandler extends SimpleChannelInboundHandler<rpcrequest> {/<rpcrequest>
private static final Logger LOGGER = LoggerFactory.getLogger(RpcHandler.class);
private final Map<string> handlerMap;/<string>
public RpcHandler(Map<string> handlerMap) {/<string>
this.handlerMap = handlerMap;
}
@Override
public void channelRead0(final ChannelHandlerContext ctx, RpcRequest request) throws Exception {
RpcResponse response = new RpcResponse();
response.setRequestId(request.getRequestId());
try {
Object result = handle(request);
response.setResult(result);
} catch (Throwable t) {
response.setError(t);
}
ctx.writeAndFlush(response).addListener(ChannelFutureListener.CLOSE);
}
private Object handle(RpcRequest request) throws Throwable {
String className = request.getClassName();
Object serviceBean = handlerMap.get(className);
Class> serviceClass = serviceBean.getClass();
String methodName = request.getMethodName();
Class>[] parameterTypes = request.getParameterTypes();
Object[] parameters = request.getParameters();
/*Method method = serviceClass.getMethod(methodName, parameterTypes);
method.setAccessible(true);
return method.invoke(serviceBean, parameters);*/
FastClass serviceFastClass = FastClass.create(serviceClass);
FastMethod serviceFastMethod = serviceFastClass.getMethod(methodName, parameterTypes);
return serviceFastMethod.invoke(serviceBean, parameters);
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
LOGGER.error("server caught exception", cause);
ctx.close();
}
}
為了避免使用 Java 反射帶來的性能問題，我們可以使用 CGLib 提供的反射 API，如上面用到的FastClass與FastMethod。
第七步：配置客戶端
同樣使用 Spring 配置文件來配置 RPC 客戶端，spring.xml代碼如下：
<beans>
<property-placeholder>
<bean>
<constructor-arg>
<bean>
<constructor-arg>
其中config.properties提供了具體的配置：
# ZooKeeper 服務器
registry.address=127.0.0.1:2181
第八步：實現服務發現
同樣使用 ZooKeeper 實現服務發現功能，見如下代碼：
public class ServiceDiscovery {
private static final Logger LOGGER = LoggerFactory.getLogger(ServiceDiscovery.class);
private CountDownLatch latch = new CountDownLatch(1);
private volatile List<string> dataList = new ArrayList<>();/<string>
private String registryAddress;
public ServiceDiscovery(String registryAddress) {
this.registryAddress = registryAddress;
ZooKeeper zk = connectServer();
if (zk != null) {
watchNode(zk);
}
}
public String discover() {
String data = null;
int size = dataList.size();
if (size > 0) {
if (size == 1) {
data = dataList.get(0);
LOGGER.debug("using only data: {}", data);
} else {
data = dataList.get(ThreadLocalRandom.current().nextInt(size));
LOGGER.debug("using random data: {}", data);
}
}
return data;
}
private ZooKeeper connectServer() {
ZooKeeper zk = null;
try {
zk = new ZooKeeper(registryAddress, Constant.ZK_SESSION_TIMEOUT, new Watcher() {
@Override
public void process(WatchedEvent event) {
if (event.getState() == Event.KeeperState.SyncConnected) {
latch.countDown();
}
}
});
latch.await();
} catch (IOException | InterruptedException e) {
LOGGER.error("", e);
}
return zk;
}
private void watchNode(final ZooKeeper zk) {
try {
List<string> nodeList = zk.getChildren(Constant.ZK_REGISTRY_PATH, new Watcher() {/<string>
@Override
public void process(WatchedEvent event) {
if (event.getType() == Event.EventType.NodeChildrenChanged) {
watchNode(zk);
}
}
});
List<string> dataList = new ArrayList<>();/<string>
for (String node : nodeList) {
byte[] bytes = zk.getData(Constant.ZK_REGISTRY_PATH + "/" + node, false, null);
dataList.add(new String(bytes));
}
LOGGER.debug("node data: {}", dataList);
this.dataList = dataList;
} catch (KeeperException | InterruptedException e) {
LOGGER.error("", e);
}
}
}
第九步：實現 RPC 代理
這裡使用 Java 提供的動態代理技術實現 RPC 代理（當然也可以使用 CGLib 來實現），具體代碼如下：
public class RpcProxy {
private String serverAddress;
private ServiceDiscovery serviceDiscovery;
public RpcProxy(String serverAddress) {
this.serverAddress = serverAddress;
}
public RpcProxy(ServiceDiscovery serviceDiscovery) {
this.serviceDiscovery = serviceDiscovery;
}
@SuppressWarnings("unchecked")
public
return (T) Proxy.newProxyInstance(
interfaceClass.getClassLoader(),
new Class>[]{interfaceClass},
new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
RpcRequest request = new RpcRequest(); // 創建並初始化 RPC 請求
request.setRequestId(UUID.randomUUID().toString());
request.setClassName(method.getDeclaringClass().getName());
request.setMethodName(method.getName());
request.setParameterTypes(method.getParameterTypes());
request.setParameters(args);
if (serviceDiscovery != null) {
serverAddress = serviceDiscovery.discover(); // 發現服務
}
String[] array = serverAddress.split(":");
String host = array[0];
int port = Integer.parseInt(array[1]);
RpcClient client = new RpcClient(host, port); // 初始化 RPC 客戶端
RpcResponse response = client.send(request); // 通過 RPC 客戶端發送 RPC 請求並獲取 RPC 響應
if (response.isError()) {
throw response.getError();
} else {
return response.getResult();
}
}
}
);
}
}
使用RpcClient類實現 RPC 客戶端，只需擴展 Netty 提供的SimpleChannelInboundHandler抽象類即可，代碼如下：
public class RpcClient extends SimpleChannelInboundHandler<rpcresponse> {/<rpcresponse>
private static final Logger LOGGER = LoggerFactory.getLogger(RpcClient.class);
private String host;
private int port;
private RpcResponse response;
private final Object obj = new Object();
public RpcClient(String host, int port) {
this.host = host;
this.port = port;
}
@Override
public void channelRead0(ChannelHandlerContext ctx, RpcResponse response) throws Exception {
this.response = response;
synchronized (obj) {
obj.notifyAll(); // 收到響應，喚醒線程
}
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
LOGGER.error("client caught exception", cause);
ctx.close();
}
public RpcResponse send(RpcRequest request) throws Exception {
EventLoopGroup group = new NioEventLoopGroup();
try {
Bootstrap bootstrap = new Bootstrap();
bootstrap.group(group).channel(NioSocketChannel.class)
.handler(new ChannelInitializer<socketchannel>() {/<socketchannel>
@Override
public void initChannel(SocketChannel channel) throws Exception {
channel.pipeline()
.addLast(new RpcEncoder(RpcRequest.class)) // 將 RPC 請求進行編碼（為了發送請求）
.addLast(new RpcDecoder(RpcResponse.class)) // 將 RPC 響應進行解碼（為了處理響應）
.addLast(RpcClient.this); // 使用 RpcClient 發送 RPC 請求
}
})
.option(ChannelOption.SO_KEEPALIVE, true);
ChannelFuture future = bootstrap.connect(host, port).sync();
future.channel().writeAndFlush(request).sync();
synchronized (obj) {
obj.wait(); // 未收到響應，使線程等待
}
if (response != null) {
future.channel().closeFuture().sync();
}
return response;
} finally {
group.shutdownGracefully();
}
}
}
第十步：發送 RPC 請求
使用 JUnit 結合 Spring 編寫一個單元測試，代碼如下：
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:spring.xml")
public class HelloServiceTest {
@Autowired
private RpcProxy rpcProxy;
@Test
public void helloTest() {
HelloService helloService = rpcProxy.create(HelloService.class);
String result = helloService.hello("World");
Assert.assertEquals("Hello! World", result);
}
}
運行以上單元測試，如果不出意外的話，您應該會看到綠條。
總結
本文通過 Spring + Netty + Protostuff + ZooKeeper 實現了一個輕量級 RPC 框架，使用 Spring 提供依賴注入與參數配置，使用 Netty 實現 NIO 方式的數據傳輸，使用 Protostuff 實現對象序列化，使用 ZooKeeper 實現服務註冊與發現。使用該框架，可將服務部署到分佈式環境中的任意節點上，客戶端通過遠程接口來調用服務端的具體實現，讓服務端與客戶端的開發完全分離，為實現大規模分佈式應用提供了基礎支持。
https://my.oschina.net/huangyong/blog/361751
閱讀更多 架構師的修煉之路 的文章
