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

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

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

為了更好的理解，參考了兩個博文，所以就把兩個博文的地址都貼出來

為了避免文章篇幅過長，我把完整源碼部分寫在下一篇文章中了，Spring+Netty+Protostuff+ZooKeeper實現輕量級RPC服務 (二)

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: {}&quo