Spring+Netty+Protostuff+ZooKeeper實現輕量級RPC服務(一)

【轉】Spring+Netty+Protostuff+ZooKeeper實現輕量級RPC服務(一)

轉載地址：https://my.oschina.net/Listening/blog/682124

轉載地址：http://www.jb51.net/article/87079.htm

RPC,即Remote Procedure Call(遠程過程調用)，說得通俗一點就是：調用遠程計算機上的服務，就像調用本地服務一樣。

RPC可基於HTTP 或 TCP 協議，Web Service就是基於HTTP 協議的RPC ，它具有良好的跨平臺性，但其性能卻不如基於 TCP 協議的RPC 。 兩方面會直接影響 RPC 的性能，一是傳輸方式，二是序列化。

衆所周知，TCP是傳輸層協議，HTTP是應用層協議，而傳輸層較應用層更底層，在數據傳輸方面，越底層越快，因此，在一般情況下，TCP一定比 HTTP快。就序列化而言，Java提供了默認的序列化方式，但在高併發的情況下，這種方式將會帶來一些性能上的瓶頸，於是市面上出現了一系列優秀的序列化的框架，比如：Protobuf、Kryo、Hession、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：提供服務註冊與發現功能，開發分佈式系統的必備的選擇，同時它也具備天生的集羣能力。

先介紹本例的大致步驟，相關源碼會在文章後面詳細列出來

本例的步驟介紹

第一步：編寫服務接口

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 配置文件名爲 applicationContext.xml ，內容如下：

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

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

  <!-- 配置服務註冊組件 -->
  <bean id="serviceRegistry" class="com.xxx.registry.ServiceRegistry">
    <constructor-arg name="registryAddress" value="${registry.address}"/>
  </bean>

  <!-- 配置 RPC 服務器 -->
  <bean id="rpcServer" class="com.xxx.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("applicationContext.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 客戶端，applicationContext.xml代碼如下：

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

  <!-- 配置服務發現組件 -->
  <bean id="serviceDiscovery" class="com.xxx.registry.ServiceDiscovery">
    <constructor-arg name="registryAddress" value="${registry.address}"/>
  </bean>

  <!-- 配置 RPC 代理 -->
  <bean id="rpcProxy" class="com.xxx.client.RpcProxy">
    <constructor-arg name="serviceDiscovery" ref="serviceDiscovery"/>
  </bean>
</beans>

其中 config.properties 提供了具體的配置：

# ZooKeeper 服務器
registry.address=127.0.0.1:2181

第八步：實現服務發現

同樣使用 ZooKerper 實現服務發現功能，見如下代碼：

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