使用Netty構建Rpc中介軟體（一）

徐家三少發表於2017-06-11
NettyRPC

Rpc中介軟體是目前網際網路企業用的最多的中介軟體，是實現分散式系統最基礎的中介軟體系統。在國內，用的最多的就是Dubbo以及Thrift。在國外，包括grpc，以及Finagle。Rpc的原理大同小異，都是利用TCP/IP協議將要本地要呼叫的類，方法，引數按照某種協議傳輸到遠端主機，遠端主機執行完畢以後再返回到本地主機。
當然其真正的實現非常複雜，涉及到IO，網路，多執行緒以及整個框架的架構設計。那麼接下來的幾篇文章（包括這篇文章）就來實現一個簡單的基本的RPC框架，NIO框架使用的是Netty，原因你懂得。

定義一個簡單的服務

假設有一個叫做IDemoService的簡單服務。這個服務放在了contract包中間：

public interface IDemoService 
{
    public   int  sum(int a,int  b);

}複製程式碼

本地機器只有介面，實現是在遠端實現的。
那麼在本地呼叫的時候肯定是通過代理走網路傳送到遠端主機。如果使用靜態代理，那麼每個介面都必須實現一個代理類，所以一般來說沒有哪個RPC框架使用靜態代理，都是使用動態代理：

public class JDKDynamicService<T> implements InvocationHandler {

    private Class<T> clazz;

    private RpcClient client = new RpcClient("127.0.0.1", 6666);

    public void setClass(Class<T> clazz) {
        this.clazz = clazz;

    }

    @SuppressWarnings("unchecked")
    public T get() {

        return (T) Proxy.newProxyInstance(this.getClass().getClassLoader(), new Class<?>[] { this.clazz }, this);

    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        return client.sendCommand(clazz, method, args);

    }

}複製程式碼

使用動態代理，呼叫被代理類的每一個方法都會呼叫invoke方法。在invoke方法內部，呼叫RpcClient來傳輸協議和返回結果。

構建一個簡單的傳輸協議

本地主機要呼叫遠端介面，肯定要告訴遠端主機呼叫哪個類的哪個介面，引數是什麼。這裡就簡單的定一個傳輸的協議類：

public class MethodInvoker implements Serializable {
    private static final long serialVersionUID = 6644047311439601478L;
    private Class clazz;
    private String method;
    private Object[] args;
    public MethodInvoker(String method, Object[] args, Class clazz) {
        super();
        this.method = method;
        this.args = args;
        this.clazz = clazz;
    }

    public String getMethod() {
        return method;
    }

    public void setMethod(String method) {
        this.method = method;
    }

    public Object[] getArgs() {
        return args;
    }

    public void setArgs(Object[] args) {
        this.args = args;
    }

    public Class getClazz() {
        return clazz;
    }
    public void setClazz(Class clazz) {
        this.clazz = clazz;
    }

}複製程式碼

這個類就不具體分析了，原因你懂得，繼承Serializable介面是為了使用JAVA自帶的序列化協議。

使用RPCClient實際傳送資料

public class RpcClient {
    private String host;

    private int port;

    public RpcClient(String host, int port) {
        super();
        this.host = host;
        this.port = port;
    }

    public Object sendCommand(Class clazz, Method method, Object[] args) {

        MethodInvoker invoker = new MethodInvoker(method.getName(), args, clazz);
        final ClientHandler clientHandler = new ClientHandler(invoker);
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            Bootstrap b = new Bootstrap();
            b.group(workerGroup);
            b.channel(NioSocketChannel.class);
            b.option(ChannelOption.SO_KEEPALIVE, true);
            b.handler(new ChannelInitializer<SocketChannel>() {
                @Override
                public void initChannel(SocketChannel ch) throws Exception {
                    ch.pipeline().addLast(new ObjectDecoder(1024 * 1024,
                            ClassResolvers.weakCachingConcurrentResolver(this.getClass().getClassLoader())));
                    ch.pipeline().addLast(new ObjectEncoder());
                    ch.pipeline().addLast(clientHandler);

                }
            });

            // Start the client.
            ChannelFuture f = b.connect(new InetSocketAddress(host, port)).sync();
            // Wait until the connection is closed. 當一個任務完成的時候會繼續執行。
        f.channel().closeFuture().sync();
            return clientHandler.getResponse();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            workerGroup.shutdownGracefully();
        }
        return null;

    }

}複製程式碼

ClientHandler 用來向服務端傳送資料：

public class ClientHandler extends ChannelInboundHandlerAdapter {
    private Object response;
    private MethodInvoker methodInvoker;

    public ClientHandler(MethodInvoker methodInvoker) {

        this.methodInvoker = methodInvoker;

    }

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {

        ctx.writeAndFlush(this.methodInvoker); // 傳送到下一個Handler。input處理完，就輸出，然後output。
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {

        System.out.println("channelRead:"+msg);
        response = msg;
        ctx.close();
    }

    public Object getResponse() {
        return response;
    }

}複製程式碼

值得注意的是,被傳輸物件的編碼和解碼使用了Netty自帶的編碼與解碼器。此外，一定要呼叫ctx.close()方法來關閉這個連結。

server端業務的實現

假設server端實現了IDemoService,並且使用Spring來管理bean物件：

public class DemoServiceImpl implements  IDemoService
{

    public int sum(int a, int b) {
        return a+b;
    }

}複製程式碼
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
    http://www.springframework.org/schema/beans/spring-beans.xsd">


<bean  id="demoService"  class="com.slowlizard.rpc.server.business.DemoServiceImpl"></bean>

</beans>複製程式碼

server端接受傳過來的資料

public class ServerHandler extends ChannelInboundHandlerAdapter {
    private static ApplicationContext springApplicationContext;
    static {
        springApplicationContext = new ClassPathXmlApplicationContext("context.xml");
    }
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        System.out.println("server come here:channelRead");
        MethodInvoker methodInvoker = (MethodInvoker) msg;
         Object service = springApplicationContext.getBean(methodInvoker.getClazz());
        Method[] methods = service.getClass().getDeclaredMethods();
        for (Method method : methods) {
            if (method.getName().equals(methodInvoker.getMethod())) {
                Object result = method.invoke(service, methodInvoker.getArgs());
                ctx.writeAndFlush(result);
            }

        }

    }
@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
    System.out.println("server come here:channelActive");
}
}複製程式碼

啟動server

public class Server {
    private static int port = 6666;
    public static void main(String[] args) {
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap bootstrap = new ServerBootstrap().group(bossGroup, workGroup)
                    .channel(NioServerSocketChannel.class).localAddress(new InetSocketAddress(port))
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel arg0) throws Exception {
                            arg0.pipeline().addLast(new ObjectDecoder(1024*1024,
                                    ClassResolvers.weakCachingConcurrentResolver(this.getClass().getClassLoader())) );
                            arg0.pipeline().addLast(new ObjectEncoder());
                            arg0.pipeline().addLast(new ServerHandler());
                        }
                    }

                    ).option(ChannelOption.SO_BACKLOG, 1024)
                    .childOption(ChannelOption.TCP_NODELAY, true).childOption(ChannelOption.SO_KEEPALIVE, true); // 保持長連線狀態
            // 繫結埠，開始接收進來的連線
            ChannelFuture future = bootstrap.bind(port).sync();
            future.channel().closeFuture().sync();// 子執行緒開始監聽
        } catch (Exception e) {
            bossGroup.shutdownGracefully();
            workGroup.shutdownGracefully();
        }
    }
}複製程式碼

測試

public class App {
    public static void main(String[] args) {

        JDKDynamicService<IDemoService> proxy = new JDKDynamicService<IDemoService>();
        proxy.setClass(IDemoService.class);
        IDemoService service = proxy.get();
        System.out.println("result" + service.sum(1, 2));
    }
}複製程式碼

很快，我們就是實現了一個簡單的RPC遠端呼叫。但是它只是一個原理性的示範，離真正的RPC框架還非常遠。

首先，它的效能怎麼樣？

RpcClient每次傳送協議到服務端，都會建立一個新的連線，能否優化它？
Server端能更快的查詢到Bean並更快執行嗎？

客戶端能否與Spring整合？

Server端 Netty傳輸能否與Spring分離？

在下一章，我們將著手優化這個“框架”，來解決目前遇到的問題。

差點忘了附上Github地址：
github.com/slowlizard/…

相關文章