輕量級分布式 RPC 框架

1、每套服務需搭配一個RPCSERVER
2、RPCSERVER作為SPRING 容器的一個BEAN
3、在SPRING啟動的時候，RPCSERVER會啟動一個NETTY服務器端，然后將SPRING容器中含RPCSERVICE注釋的BEAN緩存起來，將來會根據傳進來的類名
方法名等參數來找到相應的BEAN后執行；同時以類名作為KEY值，IP:PORT作為VALUE值在ZOOKEEPER中注冊，以方便客戶端根據類名查找到本機的IP
而被調用
4、客戶端如果要進行遠程調用的時候不需NEW一個對象，也不需從SPRING中獲取服務對象，而是從動態代理中創建對象而獲得
5、動態代理創建對象時，會對所有方法時行攔截，向ZOOKEEPER進行查找，根據方法名獲得RPCSERVER的IP:PORT，
調用RPCCLIENT，對方法名、參數、類名進行封裝，對遠程RPCSERVER進行通訊獲取返回

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

>
    <context:component-scan base-package="com.xxx.rpc.sample.server"/>

    <context:property-placeholder location="classpath:config.properties"/>

    
    <bean id="serviceRegistry" class="com.xxx.rpc.registry.ServiceRegistry">
        <constructor-arg name="registryAddress" value="${registry.address}"/>
    </bean>

    
    <bean id="rpcServer" class="com.xxx.rpc.server.RpcServer">
        <constructor-arg name="serverAddress" value="${server.address}"/>
        <constructor-arg name="serviceRegistry" ref="serviceRegistry"/>
    </bean>
</beans>

具體的配置參數在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, Object> handlerMap = new HashMap<>(); // 存放接口名與服務對象之間的映射關系

    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 請求，代碼如下：

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 {
        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<>();

    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抽象類即可，代碼如下：

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。

第七步：配置客戶端

同樣使用 Spring 配置文件來配置 RPC 客戶端，spring.xml代碼如下：

<beans

>
    <context:property-placeholder location="classpath:config.properties"/>

    
    <bean id="serviceDiscovery" class="com.xxx.rpc.registry.ServiceDiscovery">
        <constructor-arg name="registryAddress" value="${registry.address}"/>
    </bean>

    
    <bean id="rpcProxy" class="com.xxx.rpc.client.RpcProxy">
        <constructor-arg name="serviceDiscovery" ref="serviceDiscovery"/>
    </bean>
</beans>

其中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<>();

    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);
        }
    }
}

第九步：實現 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 <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.isError()) {
                        throw response.getError();
                    } else {
                        return response.getResult();
                    }
                }
            }
        );
    }
}

使用RpcClient類實現 RPC 客戶端，只需擴展 Netty 提供的SimpleChannelInboundHandler抽象類即可，代碼如下：

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();
        }
    }
}

第十步：發送 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 實現服務注冊與發現。使用該框架，可將服務部署到分布式環境中的任意節點上，客戶端通過遠程接口來調用服務端的具體實現，讓服務端與客戶端的開發完全分離，為實現大規模分布式應用提供了基礎支持。

附錄：Maven 依賴

<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.11</version>
    <scope>test</scope>
</dependency>


<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-log4j12</artifactId>
    <version>1.7.7</version>
</dependency>


<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>


<dependency>
    <groupId>io.netty</groupId>
    <artifactId>netty-all</artifactId>
    <version>4.0.24.Final</version>
</dependency>


<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>


<dependency>
    <groupId>org.apache.zookeeper</groupId>
    <artifactId>zookeeper</artifactId>
    <version>3.4.6</version>
</dependency>


<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-collections4</artifactId>
    <version>4.0</version>
</dependency>


<dependency>
    <groupId>org.objenesis</groupId>
    <artifactId>objenesis</artifactId>
    <version>2.1</version>
</dependency>


<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>3.1</version>
</dependency>

源碼地址：http://git.oschina.net/huangyong/rpc

翻譯

朗讀

復制

朗讀

譯

posted on 2016-04-12 13:44 paulwong 閱讀(951) 評論(0) 編輯收藏所屬分類: NETTY 、RPC

新用戶注冊刷新評論列表


只有注冊用戶登錄后才能發表評論。




網站導航: 博客園 IT新聞 Chat2DB C++博客博問管理
相關文章: 史上最通俗Netty入門長文：基本介紹、環境搭建、動手實戰 SPRING MVC整合NETTY Netty是什么？輕量級分布式 RPC 框架 Reactor模式詳解 Netty3架構解析 100萬并發連接服務器筆記之Java Netty處理1M連接會怎么樣輕量級、高性能NIO網絡通訊框架（around 60K）-zbus commonrpc 0.1 發布，高性能分布式 RPC 框架 NETTY資源

paulwong

My Links

Blog Stats

常用鏈接

留言簿(66)

隨筆分類(1388)

隨筆檔案(1146)

文章分類(7)

文章檔案(10)

相冊

收藏夾(2)

AI

Develop

E-BOOK

Other

養生

微服務

搜索

最新評論

閱讀排行榜

評論排行榜

60天內閱讀排行