基于Netty打造RPC服务器设计经验谈

　　自从在园子里，发表了两篇如何基于Netty构建RPC服务器的文章：谈谈如何使用Netty开发实现高性能的RPC服务器、Netty实现高性能RPC服务器优化篇之消息序列化 之后，收到了很多同行、园友们热情的反馈和若干个优化建议，于是利用闲暇时间，打算对原来NettyRPC中不合理的模块进行重构，并且增强了一些特性，主要的优化点如下：

1. 在原来编码解码器：JDK原生的对象序列化方式、kryo、hessian，新增了：protostuff。
2. 优化了NettyRPC服务端的线程池模型，支持LinkedBlockingQueue、ArrayBlockingQueue、SynchronousQueue，并扩展了多个线程池任务处理策略。
3. RPC服务启动、注册、卸载支持，通过Spring中自定义的nettyrpc标签进行统一管理。

　　现在重点整理一下重构思路、经验，记录下来。对应源代码代码，大家可以查看我的开源github：https://github.com/tang-jie/NettyRPC 项目中的NettyRPC 2.0目录。

　　在最早的NettyRPC消息编解码插件中，我使用的是：JDK原生的对象序列化（ObjectOutputStream/ObjectInputStream）、Kryo、Hessian这三种方式，后续有园友向我提议，可以引入Protostuff序列化方式。经过查阅网络的相关资料，Protostuff基于Google protobuf，但是提供了更多的功能和更简易的用法。原生的protobuff是需要数据结构的预编译过程，需要编写.proto格式的配置文件，再通过protobuf提供的工具翻译成目标语言代码，而Protostuff则省略了这个预编译的过程。以下是Java主流序列化框架的性能测试结果（图片来自网络）：

　　

　　可以发现，Protostuff序列化确实是一种很高效的序列化框架，相比起其他主流的序列化、反序列化框架，其序列化性能可见一斑。如果用它来进行RPC消息的编码、解码工作，再合适不过了。现在贴出具体的Protostuff序列化编解码器的实现代码。

　　首先是定义Schema，这个是因为Protostuff-Runtime实现了无需预编译对java bean进行protobuf序列化/反序列化的能力。我们可以把运行时的Schema缓存起来，提高序列化性能。具体实现类SchemaCache代码如下：

package com.newlandframework.rpc.serialize.protostuff;

import com.dyuproject.protostuff.Schema;
import com.dyuproject.protostuff.runtime.RuntimeSchema;

import com.google.common.cache.Cache;
import com.google.common.cache.CacheBuilder;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;

/**
 * @author tangjie<https://github.com/tang-jie>
 * @filename:SchemaCache.java
 * @description:SchemaCache功能模块
 * @blogs http://www.cnblogs.com/jietang/
 * @since 2016/10/7
 */
public class SchemaCache {
    private static class SchemaCacheHolder {
        private static SchemaCache cache = new SchemaCache();
    }

    public static SchemaCache getInstance() {
        return SchemaCacheHolder.cache;
    }

    private Cache, Schema> cache = CacheBuilder.newBuilder()
            .maximumSize(1024).expireAfterWrite(1, TimeUnit.HOURS)
            .build();

    private Schema get(final Class cls, Cache, Schema> cache) {
        try {
            return cache.get(cls, new Callable>() {
                public RuntimeSchema call() throws Exception {
                    return RuntimeSchema.createFrom(cls);
                }
            });
        } catch (ExecutionException e) {
            return null;
        }
    }

    public Schema get(final Class cls) {
        return get(cls, cache);
    }
}

　　然后定义真正的Protostuff序列化、反序列化类，它实现了RpcSerialize接口的方法：

package com.newlandframework.rpc.serialize.protostuff;

import com.dyuproject.protostuff.LinkedBuffer;
import com.dyuproject.protostuff.ProtostuffIOUtil;
import com.dyuproject.protostuff.Schema;

import java.io.InputStream;
import java.io.OutputStream;

import com.newlandframework.rpc.model.MessageRequest;
import com.newlandframework.rpc.model.MessageResponse;
import com.newlandframework.rpc.serialize.RpcSerialize;

import org.objenesis.Objenesis;
import org.objenesis.ObjenesisStd;

/**
 * @author tangjie<https://github.com/tang-jie>
 * @filename:ProtostuffSerialize.java
 * @description:ProtostuffSerialize功能模块
 * @blogs http://www.cnblogs.com/jietang/
 * @since 2016/10/7
 */
public class ProtostuffSerialize implements RpcSerialize {
    private static SchemaCache cachedSchema = SchemaCache.getInstance();
    private static Objenesis objenesis = new ObjenesisStd(true);
    private boolean rpcDirect = false;

    public boolean isRpcDirect() {
        return rpcDirect;
    }

    public void setRpcDirect(boolean rpcDirect) {
        this.rpcDirect = rpcDirect;
    }

    private static  Schema getSchema(Class cls) {
        return (Schema) cachedSchema.get(cls);
    }

    public Object deserialize(InputStream input) {
        try {
            Class cls = isRpcDirect() ? MessageRequest.class : MessageResponse.class;
            Object message = (Object) objenesis.newInstance(cls);
            Schema