转载请注明出处:http://blog.csdn.net/l1028386804/article/details/62284352
今天,我们一起来实现一个轻量级的RPC框架。
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:提供服务注册与发现功能,开发分布式系统的必备选择,同时它也具备天生的集群能力。
1 第一步:编写服务接口
- package com.lyz.zkrpc;
- /**
- * 定义服务接口
- * @author liuyazhuang
- */
- public interface HelloService {
- String hello(String name);
- }
将该接口放在独立的客户端 jar 包中,以供应用使用
2 第二步:编写服务接口的实现类
- package com.lyz.zkrpc;
- /**
- * 实现服务接口
- * @author liuyazhuang
- */
- @RpcService(HelloService.class) // 指定远程接口
- public class HelloServiceImpl implements HelloService {
- @Override
- public String hello(String name) {
- return "Hello! " + name;
- }
- }
使用RpcService注解定义在服务接口的实现类上,需要对该实现类指定远程接口,因为实现类可能会实现多个接口,一定要告诉框架哪个才是远程接口。
RpcService代码如下:
- package com.lyz.zkrpc;
- import org.springframework.stereotype.Component;
- import java.lang.annotation.ElementType;
- import java.lang.annotation.Retention;
- import java.lang.annotation.RetentionPolicy;
- import java.lang.annotation.Target;
- /**
- * RPC接口注解
- * @author liuyazhuang
- */
- @Target({ElementType.TYPE})
- @Retention(RetentionPolicy.RUNTIME)
- @Component // 标明可被 Spring 扫描
- public @interface RpcService {
- Class<?> value();
- }
该注解具备 Spring 的Component注解的特性,可被 Spring 扫描。
该实现类放在服务端 jar 包中,该 jar 包还提供了一些服务端的配置文件与启动服务的引导程序。
3 第三步:配置服务端
服务端 Spring 配置文件名为spring-zk-rpc-server.xml,内容如下:
- <?xml version="1.0" encoding="UTF-8"?>
- <beans xmlns="http://www.springframework.org/schema/beans"
- xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
- xmlns:context="http://www.springframework.org/schema/context"
- xsi:schemaLocation="http://www.springframework.org/schema/beans
- http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
- http://www.springframework.org/schema/context
- http://www.springframework.org/schema/context/spring-context-3.0.xsd">
- <!-- 配置自动扫包 -->
- <context:component-scan base-package="com.lyz.zkrpc"/>
- <context:property-placeholder location="classpath:rpc-server-config.properties"/>
- <!-- 配置服务注册组件 -->
- <bean id="serviceRegistry" class="com.lyz.zkrpc.ServiceRegistry">
- <constructor-arg name="registryAddress" value="${registry.address}"/>
- </bean>
- <!-- 配置 RPC 服务器 -->
- <bean id="rpcServer" class="com.lyz.zkrpc.RpcServer">
- <constructor-arg name="serverAddress" value="${server.address}"/>
- <constructor-arg name="serviceRegistry" ref="serviceRegistry"/>
- </bean>
- </beans>
具体的配置参数在rpc-server-config.properties文件中,内容如下:
- <!-- lang: java -->
- # ZooKeeper 服务器
- registry.address=127.0.0.1:2181
- # RPC 服务器
- server.address=127.0.0.1:8000
以上配置表明:连接本地的 ZooKeeper 服务器,并在 8000 端口上发布 RPC 服务。
4 第四步:启动服务器并发布服务
为了加载 Spring 配置文件来发布服务,只需编写一个引导程序即可:
- package com.lyz.zkrpc;
- import org.springframework.context.support.ClassPathXmlApplicationContext;
- /**
- * RPC服务启动入口
- * @author liuyazhuang
- */
- public class RpcBootstrap {
- public static void main(String[] args) {
- new ClassPathXmlApplicationContext("spring-zk-rpc-server.xml");
- }
- }
运行RpcBootstrap类的main方法即可启动服务端,但还有两个重要的组件尚未实现,它们分别是:ServiceRegistry与RpcServer
,下文会给出具体实现细节。
5 第五步:实现服务注册
使用 ZooKeeper 客户端可轻松实现服务注册功能,ServiceRegistry代码如下:
- package com.lyz.zkrpc;
- import org.apache.zookeeper.*;
- import org.slf4j.Logger;
- import org.slf4j.LoggerFactory;
- import java.io.IOException;
- import java.util.concurrent.CountDownLatch;
- /**
- * 连接ZK注册中心,创建服务注册目录
- * @author liuyazhuang
- */
- 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) {
- // 判断是否已连接ZK,连接后计数器递减.
- if (event.getState() == Event.KeeperState.SyncConnected) {
- latch.countDown();
- }
- }
- });
- // 若计数器不为0,则等待.
- 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配置了所有的常量:
- package com.lyz.zkrpc;
- /**
- * ZK相关常量
- * @author liuyazhuang
- */
- public interface Constant {
- int ZK_SESSION_TIMEOUT = 5000;
- String ZK_REGISTRY_PATH = "/registry";
- String ZK_DATA_PATH = ZK_REGISTRY_PATH + "/data";
- }
注意:首先需要使用 ZooKeeper 客户端命令行创建/registry永久节点,用于存放所有的服务临时节点。
6 第六步:实现 RPC 服务器
使用 Netty 可实现一个支持 NIO 的 RPC 服务器,需要使用ServiceRegistry注册服务地址,RpcServer代码如下:
- package com.lyz.zkrpc;
- import io.netty.bootstrap.ServerBootstrap;
- import io.netty.channel.ChannelFuture;
- import io.netty.channel.ChannelInitializer;
- import io.netty.channel.ChannelOption;
- import io.netty.channel.EventLoopGroup;
- import io.netty.channel.nio.NioEventLoopGroup;
- import io.netty.channel.socket.SocketChannel;
- import io.netty.channel.socket.nio.NioServerSocketChannel;
- import org.apache.commons.collections4.MapUtils;
- import org.slf4j.Logger;
- import org.slf4j.LoggerFactory;
- import org.springframework.beans.BeansException;
- import org.springframework.beans.factory.InitializingBean;
- import org.springframework.context.ApplicationContext;
- import org.springframework.context.ApplicationContextAware;
- import java.util.HashMap;
- import java.util.Map;
- /**
- * 启动并注册服务
- * @author liuyazhuang
- */
- public class RpcServer implements ApplicationContextAware, InitializingBean {
- private static final Logger LOGGER = LoggerFactory.getLogger(RpcServer.class);
- private String serverAddress;
- private ServiceRegistry serviceRegistry;
- private Map<String, Object> handlerMap = new HashMap<String, Object>(); // 存放接口名与服务对象之间的映射关系
- 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, Object> serviceBeanMap = ctx.getBeansWithAnnotation(RpcService.class); // 获取所有带有 RpcService 注解的 Spring Bean
- 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>() {
- @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 请求,代码如下:
- package com.lyz.zkrpc;
- /**
- * RPC请求
- * @author liuyazhuang
- */
- public class RpcRequest {
- private String requestId;
- private String className;
- private String methodName;
- private Class<?>[] parameterTypes;
- private Object[] parameters;
- public String getRequestId() {
- return requestId;
- }
- public void setRequestId(String requestId) {
- this.requestId = requestId;
- }
- public String getClassName() {
- return className;
- }
- public void setClassName(String className) {
- this.className = className;
- }
- public String getMethodName() {
- return methodName;
- }
- public void setMethodName(String methodName) {
- this.methodName = methodName;
- }
- public Class<?>[] getParameterTypes() {
- return parameterTypes;
- }
- public void setParameterTypes(Class<?>[] parameterTypes) {
- this.parameterTypes = parameterTypes;
- }
- public Object[] getParameters() {
- return parameters;
- }
- public void setParameters(Object[] parameters) {
- this.parameters = parameters;
- }
- }
使用RpcResponse封装 RPC 响应,代码如下:
- package com.lyz.zkrpc;
- import io.netty.buffer.ByteBuf;
- import io.netty.channel.ChannelHandlerContext;
- import io.netty.handler.codec.ByteToMessageDecoder;
- import java.util.List;
- /**
- * RPC解码
- * @author liuyazhuang
- */
- 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 {
- 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方法即可,代码如下:
- package com.lyz.zkrpc;
- import io.netty.buffer.ByteBuf;
- import io.netty.channel.ChannelHandlerContext;
- import io.netty.handler.codec.MessageToByteEncoder;
- /**
- * RPC编码
- * @author liuyazhuang
- */
- 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实现序列化:
- package com.lyz.zkrpc;
- import com.dyuproject.protostuff.LinkedBuffer;
- import com.dyuproject.protostuff.ProtostuffIOUtil;
- import com.dyuproject.protostuff.Schema;
- import com.dyuproject.protostuff.runtime.RuntimeSchema;
- import org.objenesis.Objenesis;
- import org.objenesis.ObjenesisStd;
- import java.util.Map;
- import java.util.concurrent.ConcurrentHashMap;
- /**
- * Protostuff序列化与反序列化工具
- * @author liuyazhuang
- */
- public class SerializationUtil {
- private static Map<Class<?>, Schema<?>> cachedSchema = new ConcurrentHashMap<>();
- private static Objenesis objenesis = new ObjenesisStd(true);
- private SerializationUtil() {
- }
- @SuppressWarnings("unchecked")
- private static <T> Schema<T> getSchema(Class<T> cls) {
- Schema<T> schema = (Schema<T>) cachedSchema.get(cls);
- if (schema == null) {
- schema = RuntimeSchema.createFrom(cls);
- if (schema != null) {
- cachedSchema.put(cls, schema);
- }
- }
- return schema;
- }
- @SuppressWarnings("unchecked")
- public static <T> byte[] serialize(T obj) {
- Class<T> cls = (Class<T>) obj.getClass();
- LinkedBuffer buffer = LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE);
- try {
- Schema<T> schema = getSchema(cls);
- return ProtostuffIOUtil.toByteArray(obj, schema, buffer);
- } catch (Exception e) {
- throw new IllegalStateException(e.getMessage(), e);
- } finally {
- buffer.clear();
- }
- }
- public static <T> T deserialize(byte[] data, Class<T> cls) {
- try {
- T message = (T) objenesis.newInstance(cls);
- Schema<T> schema = getSchema(cls);
- ProtostuffIOUtil.mergeFrom(data, message, schema);
- return message;
- } catch (Exception e) {
- throw new IllegalStateException(e.getMessage(), e);
- }
- }
- }
以上了使用 Objenesis 来实例化对象,它是比 Java 反射更加强大。
注意:如需要替换其它序列化框架,只需修改SerializationUtil即可。当然,更好的实现方式是提供配置项来决定使用哪种序列化方式。
使用RpcHandler中处理 RPC 请求,只需扩展 Netty 的SimpleChannelInboundHandler抽象类即可,代码如下:
- package com.lyz.zkrpc;
- import io.netty.channel.ChannelFutureListener;
- import io.netty.channel.ChannelHandlerContext;
- import io.netty.channel.SimpleChannelInboundHandler;
- import net.sf.cglib.reflect.FastClass;
- import net.sf.cglib.reflect.FastMethod;
- import org.slf4j.Logger;
- import org.slf4j.LoggerFactory;
- import java.util.Map;
- /**
- * RPC服务端:请求处理过程
- * @author liuyazhuang
- */
- public class RpcHandler extends SimpleChannelInboundHandler<RpcRequest> {
- private static final Logger LOGGER = LoggerFactory.getLogger(RpcHandler.class);
- private final Map<String, Object> handlerMap;
- public RpcHandler(Map<String, Object> handlerMap) {
- 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。
7 第七步:配置客户端
同样使用 Spring 配置文件来配置 RPC 客户端,spring-zk-rpc-client.xml代码如下:
- <?xml version="1.0" encoding="UTF-8"?>
- <beans xmlns="http://www.springframework.org/schema/beans"
- xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
- xmlns:context="http://www.springframework.org/schema/context"
- xsi:schemaLocation="http://www.springframework.org/schema/beans
- http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
- http://www.springframework.org/schema/context
- http://www.springframework.org/schema/context/spring-context-3.0.xsd">
- <context:component-scan base-package="com.lyz.zkrpc"/>
- <context:property-placeholder location="classpath:rpc-client-config.properties"/>
- <!-- 配置服务发现组件 -->
- <bean id="serviceDiscovery" class="com.lyz.zkrpc.ServiceDiscovery">
- <constructor-arg name="registryAddress" value="${registry.address}"/>
- </bean>
- <!-- 配置 RPC 代理 -->
- <bean id="rpcProxy" class="com.lyz.zkrpc.RpcProxy">
- <constructor-arg name="serviceDiscovery" ref="serviceDiscovery"/>
- </bean>
- </beans>
其中rpc-client-config.properties提供了具体的配置:
- <!-- lang: java -->
- # ZooKeeper 服务器
- registry.address=127.0.0.1:2181
8 第八步:实现服务发现
同样使用 ZooKeeper 实现服务发现功能,见如下代码:
- package com.lyz.zkrpc;
- import org.apache.zookeeper.KeeperException;
- import org.apache.zookeeper.WatchedEvent;
- import org.apache.zookeeper.Watcher;
- import org.apache.zookeeper.ZooKeeper;
- import org.slf4j.Logger;
- import org.slf4j.LoggerFactory;
- import java.io.IOException;
- import java.util.ArrayList;
- import java.util.List;
- import java.util.concurrent.CountDownLatch;
- import java.util.concurrent.ThreadLocalRandom;
- /**
- * 服务发现:连接ZK,添加watch事件
- * @author liuyazhuang
- */
- 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<>();
- 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() {
- @Override
- public void process(WatchedEvent event) {
- if (event.getType() == Event.EventType.NodeChildrenChanged) {
- watchNode(zk);
- }
- }
- });
- List<String> dataList = new ArrayList<>();
- 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);
- }
- }
- }
9 第九步:实现 RPC 代理
这里使用 Java 提供的动态代理技术实现 RPC 代理(当然也可以使用 CGLib 来实现),具体代码如下:
- package com.lyz.zkrpc;
- import net.sf.cglib.proxy.InvocationHandler;
- import net.sf.cglib.proxy.Proxy;
- import java.lang.reflect.Method;
- import java.util.UUID;
- /**
- * 客户端RPC调用代理
- * @author liuyazhuang
- */
- 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 <T> T create(Class<?> interfaceClass) {
- 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.getError() != null) {
- throw response.getError();
- } else {
- return response.getResult();
- }
- }
- }
- );
- }
- }
使用RpcClient类实现 RPC 客户端,只需扩展 Netty 提供的SimpleChannelInboundHandler抽象类即可,代码如下:
- package com.lyz.zkrpc;
- import io.netty.bootstrap.Bootstrap;
- import io.netty.channel.*;
- import io.netty.channel.nio.NioEventLoopGroup;
- import io.netty.channel.socket.SocketChannel;
- import io.netty.channel.socket.nio.NioSocketChannel;
- import org.slf4j.Logger;
- import org.slf4j.LoggerFactory;
- /**
- * RPC真正调用客户端
- * @author liuyazhuang
- */
- public class RpcClient extends SimpleChannelInboundHandler<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>() {
- @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();
- }
- }
- }
10 第十步:发送 RPC 请求
使用 JUnit 结合 Spring 编写一个单元测试,代码如下:
- <!-- lang: java -->
- @RunWith(SpringJUnit4ClassRunner.class)
- @ContextConfiguration(locations = "classpath:spring.xml")
- /**
- * 测试RPC服务
- * @author liuyazhuang
- */
- 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);
- }
- }
11 最后,总结
本文通过 Spring + Netty + Protostuff + ZooKeeper 实现了一个轻量级 RPC 框架,使用 Spring 提供依赖注入与参数配置,使用 Netty 实现 NIO 方式的数据传输,使用 Protostuff 实现对象序列化,使用 ZooKeeper 实现服务注册与发现。使用该框架,可将服务部署到分布式环境中的任意节点上,客户端通过远程接口来调用服务端的具体实现,让服务端与客户端的开发完全分离,为实现大规模分布式应用提供了基础支持。
12 附录:Maven 依赖
- <!-- lang: xml -->
- <!-- JUnit -->
- <dependency>
- <groupId>junit</groupId>
- <artifactId>junit</artifactId>
- <version>4.11</version>
- <scope>test</scope>
- </dependency>
- <!-- SLF4J -->
- <dependency>
- <groupId>org.slf4j</groupId>
- <artifactId>slf4j-log4j12</artifactId>
- <version>1.7.7</version>
- </dependency>
- <!-- Spring -->
- <dependency>
- <groupId>org.springframework</groupId>
- <artifactId>spring-context</artifactId>
- <version>3.2.12.RELEASE</version>
- </dependency>
- <dependency>
- <groupId>org.springframework</groupId>
- <artifactId>spring-test</artifactId>
- <version>3.2.12.RELEASE</version>
- <scope>test</scope>
- </dependency>
- <!-- Netty -->
- <dependency>
- <groupId>io.netty</groupId>
- <artifactId>netty-all</artifactId>
- <version>4.0.24.Final</version>
- </dependency>
- <!-- Protostuff -->
- <dependency>
- <groupId>com.dyuproject.protostuff</groupId>
- <artifactId>protostuff-core</artifactId>
- <version>1.0.8</version>
- </dependency>
- <dependency>
- <groupId>com.dyuproject.protostuff</groupId>
- <artifactId>protostuff-runtime</artifactId>
- <version>1.0.8</version>
- </dependency>
- <!-- ZooKeeper -->
- <dependency>
- <groupId>org.apache.zookeeper</groupId>
- <artifactId>zookeeper</artifactId>
- <version>3.4.6</version>
- </dependency>
- <!-- Apache Commons Collections -->
- <dependency>
- <groupId>org.apache.commons</groupId>
- <artifactId>commons-collections4</artifactId>
- <version>4.0</version>
- </dependency>
- <!-- Objenesis -->
- <dependency>
- <groupId>org.objenesis</groupId>
- <artifactId>objenesis</artifactId>
- <version>2.1</version>
- </dependency>
- <!-- CGLib -->
- <dependency>
- <groupId>cglib</groupId>
- <artifactId>cglib</artifactId>
- <version>3.1</version>
- </dependency>
相关推荐
分布式数据库30讲 分布式数据库是指使用分布式架构实现的关系型数据库。它可以解决许多问题,如性能和可靠性问题。由于各种原因,大型机已经不再是多数企业的可选项,而采用 x86 架构的通用设备在单机性能和可靠性...
本文来自于csdn,本文主要从分布式的原因,事务特性,和解决方案中深入理解了分布式事务,希望对您的学习有所帮助。 分布式事务就是指事务的参与者、支持事务的服务器、资源服务器以及事务管理器分别位于不同的...
南理工 魏松杰 对应他的英文版本PPT复习可用,同时是学习分布式系统的很好的PPT,分布式系统ppt对应分布式系统第五版英文版ppt,复习,自学可用,了解分布式系统,共10章,01-概述,02-系统模型,03-进程间通信,04-...
分布式存储系统主要经历了四个阶段:第一代分布式存储系统(1980 到 1990),第二代分布式存储系统(1990 到 1995),第三代分布式存储系统(1995 到 2000),第四代分布式存储系统(2000 至今)。 第一代分布式...
本报告主要对分布式存储市场进行调研,涵盖了分布式存储的定义与分类、分布式存储与其他相关技术的关系、分布式存储市场状况、分布式存储行业典型应用场景等多个方面。 一、分布式存储的定义与分类 分布式存储是指...
分布式系统理论体系非常庞大,涉及知识面也非常广博,本文精心选择了部分在工程实践中应用广泛、简单有效的分布式理论、算法、协议加以介绍。全文分为两大部分,第一部分介绍了分布式系统的一些基本概念并框定了本文...
【Maven构建的分布式demo】 在现代软件开发中,分布式系统已经成为主流,它能提高系统的可扩展性、容错性和性能。Maven作为Java项目管理工具,为构建分布式应用程序提供了强大的支持。本篇将深入探讨如何利用Maven...
分布式系统及应用是计算机科学中的一个关键领域,尤其在当今大数据和云计算的时代背景下,其重要性日益凸显。东北大学的研究生课程"分布式系统及应用"显然涵盖了这一领域的核心概念和实践技能。以下是对该课程相关...
本书分为三大部分,即分布式系统基础理论、分布式系统常用技术以及经典的分布式系统案例分析。第一部分主要介绍分布式系统基础理论知识,总结一些在设计分布式系统时需要考虑的范式、知识点以及可能会面临的问题,...
Java开发基于SpringBoot+WebSocket+Redis分布式即时通讯群聊系统。一个基于Spring Boot + WebSocket + Redis,可快速开发的分布式即时通讯群聊系统。适用于直播间聊天、游戏内聊天、客服聊天等临时性群聊场景。 ...
范型篇——介绍谷歌、亚马逊、微软、阿里巴巴等著名互联网公司的大规模分布式存储系统架构,涉及分布式文件系统、分布式键值系统、分布式表格系统以及分布式数据库技术等。实践篇——以阿里巴巴的分布式数据库Ocean...
《分布式系统原理与范型》作为一本系统介绍分布式系统基本原理与实践应用的书籍,涵盖了分布式系统设计与实现的核心理念。分布式系统指的是由多个可以独立运行的计算单元构成的系统,这些计算单元通过通信网络相互...
分布式系统是计算机科学中的一个重要领域,它涉及到多个独立的计算节点通过网络进行协作,共同完成一个任务或提供服务。这份“分布式系统 概念与设计 习题答案(完整版)”涵盖了该领域的核心概念、设计原则以及常见...
简介:《分布式服务框架:原理与实践》创作者具有丰富的分布式服务框架、平台中间件的架构设计和实践经验,主导设计的华为分布式服务框架已经在全球数十个国家成功商用。《分布式服务框架:原理与实践》依托工作实践...
《凤凰架构:构建可靠的大型分布式系统》是一本开源文档,其核心在于为技术人员提供一个构建可信赖的大型分布式软件系统的框架和方法论。分布式系统是一类由多个组件构成的系统,这些组件分散在不同的网络节点上,...
《大规模分布式系统架构与设计实战》写到,分布式并行计算的基本原理解剖;分布式协调的实现,包括如何实现公共配置管理,如何实现分布式锁,如何实现集群管理等;分布式缓存的实现,包括如何提供完整的分布式缓存来...
大型分布式网站架构设计与实践.pdf <br/>《大型分布式网站架构设计与实践》主要介绍了大型分布式网站架构所涉及的一些技术细节,包括SOA架构的实现、互联网安全架构、构建分布式网站所依赖的基础设施、系统稳定...
本书是著名作者Tanenbaum关于分布式系统的最新力作,是分布式系统的权威教材。本书分成了两大部分。第2~9章讨论的是分布式系统的的原理、概念和技术,包括通信、进程、命名、同步化、一致性和复制、容错性以及安全...