自己用 Netty 實現一個簡單的 RPC

莫那·魯道發表於2018-03-26
NettyRPC

自己用 Netty 實現一個簡單的 RPC

目錄：

  1. 需求
  2. 設計
  3. 實現
    1. 建立 maven 專案，匯入 Netty 4.1.16。
    2. 專案目錄結構
    3. 設計介面
    4. 提供者相關實現
    5. 消費者相關實現
    6. 測試結果
  4. 總結

原始碼地址：github 原始碼地址

前言

眾所周知，dubbo 底層使用了 Netty 作為網路通訊框架，而 Netty 的高效能我們之前也分析過原始碼，對他也算還是比較瞭解了。今天我們就自己用 Netty 實現一個簡單的 RPC 框架。

1. 需求

模仿 dubbo，消費者和提供者約定介面和協議，消費者遠端呼叫提供者，提供者返回一個字串，消費者列印提供者返回的資料。底層網路通訊使用 Netty 4.1.16。

2. 設計

  1. 建立一個介面，定義抽象方法。用於消費者和提供者之間的約定。
  2. 建立一個提供者，該類需要監聽消費者的請求，並按照約定返回資料。
  3. 建立一個消費者，該類需要透明的呼叫自己不存在的方法，內部需要使用 Netty 請求提供者返回資料。

3. 實現

1. 建立 maven 專案，匯入 Netty 4.1.16。

  <groupId>cn.thinkinjava</groupId>
  <artifactId>rpc-demo</artifactId>
  <version>1.0-SNAPSHOT</version>

  <dependencies>
    <dependency>
      <groupId>io.netty</groupId>
      <artifactId>netty-all</artifactId>
      <version>4.1.16.Final</version>
    </dependency>
複製程式碼

2. 專案目錄結構如下：

自己用 Netty 實現一個簡單的 RPC

3. 設計介面

一個簡單的 hello world：

public interface HelloService {
  String hello(String msg);
}
複製程式碼

4. 提供者相關實現

4.1. 首先實現約定介面，用於返回客戶端資料：

/**
 * 實現類
 */
public class HelloServiceImpl implements HelloService {
  public String hello(String msg) {
    return msg != null ? msg + " -----> I am fine." : "I am fine.";
  }
}
複製程式碼

4.2. 實現 Netty 服務端和自定義 handler

啟動 Netty Server 程式碼：

  private static void startServer0(String hostName, int port) {
    try {
      ServerBootstrap bootstrap = new ServerBootstrap();
      NioEventLoopGroup eventLoopGroup = new NioEventLoopGroup();
      bootstrap.group(eventLoopGroup)
          .channel(NioServerSocketChannel.class)
          .childHandler(new ChannelInitializer<SocketChannel>() {
            @Override
            protected void initChannel(SocketChannel ch) throws Exception {
              ChannelPipeline p = ch.pipeline();
              p.addLast(new StringDecoder());
              p.addLast(new StringEncoder());
              p.addLast(new HelloServerHandler());
            }
          });
      bootstrap.bind(hostName, port).sync();
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
  }
複製程式碼

上面的程式碼中新增了 String型別的編解碼 handler，新增了一個自定義 handler。

自定義 handler 邏輯如下：

/**
 * 用於處理請求資料
 */
public class HelloServerHandler extends ChannelInboundHandlerAdapter {
  @Override
  public void channelRead(ChannelHandlerContext ctx, Object msg) {

    // 如何符合約定，則呼叫本地方法，返回資料
    if (msg.toString().startsWith(ClientBootstrap.providerName)) {
      String result = new HelloServiceImpl()
          .hello(msg.toString().substring(msg.toString().lastIndexOf("#") + 1));
      ctx.writeAndFlush(result);
    }
  }
}
複製程式碼

這裡顯示判斷了是否符合約定（並沒有使用複雜的協議，只是一個字串判斷），然後建立一個具體實現類，並呼叫方法寫回客戶端。

還需要一個啟動類：

public class ServerBootstrap {
  public static void main(String[] args) {
    NettyServer.startServer("localhost", 8088);
  }
}
複製程式碼

好，關於提供者的程式碼就寫完了，主要就是建立一個 netty 服務端，實現一個自定義的 handler，自定義 handler 判斷是否符合之間的約定（算是協議吧），如果符合，就建立一個介面的實現類，並呼叫他的方法返回字串。

5. 消費者相關實現

消費者有一個需要注意的地方，就是呼叫需要透明，也就是說，框架使用者不用關心底層的網路實現。這裡我們可以使用 JDK 的動態代理來實現這個目的。

思路：客戶端呼叫代理方法，返回一個實現了 HelloService 介面的代理物件，呼叫代理物件的方法，返回結果。

我們需要在代理中做手腳，當呼叫代理方法的時候，我們需要初始化 Netty 客戶端，還需要向服務端請求資料，並返回資料。

5.1. 首先建立代理相關的類

public class RpcConsumer {

  private static ExecutorService executor = Executors
      .newFixedThreadPool(Runtime.getRuntime().availableProcessors());

  private static HelloClientHandler client;

  /**
   * 建立一個代理物件
   */
  public Object createProxy(final Class<?> serviceClass,
      final String providerName) {
    return Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
        new Class<?>[]{serviceClass}, (proxy, method, args) -> {
          if (client == null) {
            initClient();
          }
          // 設定引數
          client.setPara(providerName + args[0]);
          return executor.submit(client).get();
        });
  }

  /**
   * 初始化客戶端
   */
  private static void initClient() {
    client = new HelloClientHandler();
    EventLoopGroup group = new NioEventLoopGroup();
    Bootstrap b = new Bootstrap();
    b.group(group)
        .channel(NioSocketChannel.class)
        .option(ChannelOption.TCP_NODELAY, true)
        .handler(new ChannelInitializer<SocketChannel>() {
          @Override
          public void initChannel(SocketChannel ch) throws Exception {
            ChannelPipeline p = ch.pipeline();
            p.addLast(new StringDecoder());
            p.addLast(new StringEncoder());
            p.addLast(client);
          }
        });
    try {
      b.connect("localhost", 8088).sync();
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
  }
}

複製程式碼

該類有 2 個方法，建立代理和初始化客戶端。

初始化客戶端邏輯： 建立一個 Netty 的客戶端，並連線提供者，並設定一個自定義 handler，和一些 String 型別的編解碼器。

建立代理邏輯：使用 JDK 的動態代理技術，代理物件中的 invoke 方法實現如下： 如果 client 沒有初始化，則初始化 client，這個 client 既是 handler ，也是一個 Callback。將引數設定進 client ，使用執行緒池呼叫 client 的 call 方法並阻塞等待資料返回。

看看 HelloClientHandler 的實現：

public class HelloClientHandler extends ChannelInboundHandlerAdapter implements Callable {

  private ChannelHandlerContext context;
  private String result;
  private String para;

  @Override
  public void channelActive(ChannelHandlerContext ctx) {
    context = ctx;
  }

  /**
   * 收到服務端資料，喚醒等待執行緒
   */
  @Override
  public synchronized void channelRead(ChannelHandlerContext ctx, Object msg) {
    result = msg.toString();
    notify();
  }

  /**
   * 寫出資料，開始等待喚醒
   */
  @Override
  public synchronized Object call() throws InterruptedException {
    context.writeAndFlush(para);
    wait();
    return result;
  }

  void setPara(String para) {
    this.para = para;
  }
}

複製程式碼

該類快取了 ChannelHandlerContext，用於下次使用，有兩個屬性：返回結果和請求引數。

當成功連線後，快取 ChannelHandlerContext，當呼叫 call 方法的時候，將請求引數傳送到服務端，等待。當服務端收到並返回資料後，呼叫 channelRead 方法，將返回值賦值個 result，並喚醒等待在 call 方法上的執行緒。此時，代理物件返回資料。

再看看設計的測試類：

public class ClientBootstrap {

  public static final String providerName = "HelloService#hello#";

  public static void main(String[] args) throws InterruptedException {

    RpcConsumer consumer = new RpcConsumer();
    // 建立一個代理物件
    HelloService service = (HelloService) consumer
        .createProxy(HelloService.class, providerName);
    for (; ; ) {
      Thread.sleep(1000);
      System.out.println(service.hello("are you ok ?"));
    }
  }
}

複製程式碼

測試類首先建立了一個代理物件，然後每隔一秒鐘呼叫代理的 hello 方法，並列印服務端返回的結果。

測試結果

自己用 Netty 實現一個簡單的 RPC

成功列印。

總結

看了這麼久的 Netty 原始碼，我們終於實現了一個自己的 Netty 應用，雖然這個應用很簡單，甚至程式碼寫的有些粗糙，但功能還是實現了，RPC 的目的就是允許像呼叫本地服務一樣呼叫遠端服務，需要對使用者透明，於是我們使用了動態代理。並使用 Netty 的 handler 傳送資料和響應資料，完成了一次簡單的 RPC 呼叫。

當然，還是那句話，程式碼比較簡單，主要是思路，以及瞭解 RPC 底層的實現。

好吧。good luck！！！！

相關文章