4、RocketMQ 源码解析之网络通信 Netty

最新推荐文章于 2024-06-20 23:00:46 发布

carl-zhao

最新推荐文章于 2024-06-20 23:00:46 发布

阅读量1k

点赞数 1

分类专栏： RocketMQ Architecture Message Queue 文章标签： java 分布式网络

本文链接：https://blog.csdn.net/u012410733/article/details/122152780

版权

Architecture 同时被 3 个专栏收录

71 篇文章 5 订阅

订阅专栏

Message Queue

21 篇文章 0 订阅

订阅专栏

RocketMQ

8 篇文章 3 订阅

订阅专栏

RocketMQ 的架构图如下所示：

在这里插入图片描述
可以看到 RocketMQ 里面有消息发送方(Producer)、配置中心(NameServer)、消息存储中心(Broker) 以及消息消费方(Consumer)。而且它们之间也需要相互通信的，那么它们是怎么通信的呢？因为 RocketMQ 是通过 Java 语言编写的，对于网络通信它就选择了 Netty 并且通过自定义协议来完成各个角色之间的高效的网络通信。

1、为什么选择 Netty？

在网络编码领域，Netty 是 Java 的卓越框架。它封装了 Java NIO 操作的复杂性，使得开发者能够使用其提供的简易 API 就能够开发出高效的网络程序。

设计：统一的 API ，支持多种传输类型，阻塞和非阻塞的简单，简单而强大的线程模型，真正的无连接数据报套接字支持。链接逻辑组件以支持复用
易于使用：详实的 javadoc 和大量的示例集，不需要超过 JDK 1.6 的依赖
性能：拥有比 Java 核心 API 更高的吞吐量以及更低的延迟，得益于池化和复用，拥有更低的资源消耗，最少的内存复制
健壮性：不会因为慢速、快速或者超载的连接而导致 OutOfMemoryError。消除在高速网络中 NIO 应用程序常见的不公平读/写比率
安全性：完整的 SSL/TLS 以及 StartTLS 支持，可用于受限环境下，如 Applet 和 OSGI
社区驱动：发布快速而频繁

很多公司包含：Apple、Twitter、Facebook、Google 都在使用 Netty，并且很多流行的开源项目也在使用 Netty如：Vert.x 、Apache Cassandra 和 Elasticsearch，它们所有的核心代码都是利用了 Netty 强大的网络抽象。

2、Netty 使用 Demo

要编写 Netty 服务端以及客户端通信特别简单。下面我们来写一个简单的 Demo。

2.1 Netty Server

编写 Server 端业务处理类，因为需要响应客户端传入的信息，所以需要实现 ChannelInboundHandler 接口。作为一个简单的 hello world 程序，我们可以继承 ChannelInboundHandlerAdapter 它提供了 ChannelInboundHandler 的默认实现，我们只需要重写需要关注的方法就行了。

EchoServerHandler

@ChannelHandler.Sharable
public class EchoServerHandler extends ChannelInboundHandlerAdapter {

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        // 将接收到的消息写给发送者，而不冲刷出站消息
        ByteBuf in = (ByteBuf) msg;
        System.out.println("Server received : " + in.toString(CharsetUtil.UTF_8));
        ctx.write(in);
    }

    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        // 将未决消息冲刷到远程节点，并且关闭该 Channel
        ctx.writeAndFlush(Unpooled.EMPTY_BUFFER).addListener(ChannelFutureListener.CLOSE);
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        // 打印异常堆栈
        cause.printStackTrace();
        // 关闭该 Channel
        ctx.close();
}

下面就需要创建引导服务器，绑定服务器并且监听并且接收传入连接请求的端口，配置 Channel ，用来将传入的入站消息通知给 EchoServerHandler 实例。

EchoServer.java

public class EchoServer {
    
    private final int port;

    public EchoServer(int port) {
        this.port = port;
    }

    public static void main(String[] args) throws Exception {
        new EchoServer(8080).start();
    }

    public void start() throws Exception {
        final EchoServerHandler serverHandler = new EchoServerHandler();
        EventLoopGroup boss = new NioEventLoopGroup();
        EventLoopGroup worker = new NioEventLoopGroup();
        try {
            ServerBootstrap bootstrap = new ServerBootstrap();
            bootstrap.group(boss, worker)
                        .channel(NioServerSocketChannel.class)
                        .localAddress(new InetSocketAddress(port))
                        .childHandler(new ChannelInitializer<SocketChannel>() {
                            @Override
                            protected void initChannel(SocketChannel socketChannel) throws Exception {
                                socketChannel.pipeline().addLast(serverHandler);
                            }
                        });
            ChannelFuture future = bootstrap.bind().sync();
            future.channel().closeFuture().sync();
        } finally {
            boss.shutdownGracefully().sync();
            worker.shutdownGracefully().sync();
        }
    }
}

上面的服务主要做了以下几件事：

main() 方法引导了服务器，引导过程中所需要以下步骤
创建一个 ServerBootstrap 的实例用于引导和绑定服务
创建两个 EventLoopGroup 实例，boss 用于接收请求，而 worker 用于真正的请求处理
指定服务器绑定到本地的 InetSocketAddress
使用一个 EventLoopGroup 的实例初始化每一个新的 Channel
调用 ServerBootstrap.bind() 方法绑定服务器

这个时候服务器已经初始化好了，可以接收客户端发送过来的请求了。

2.2 Netty Client

首先编码客户端处理类，客户端处理类需要发送一个或者多个消息到服务器。并且在发送消息之后接收服务器发回的响应，最后关闭连接。

EchoClientHandler.java

@ChannelHandler.Sharable
public class EchoClientHandler extends ChannelInboundHandlerAdapter {

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        // 当被通知 Channel 活跃的时候,发送消息
        ctx.writeAndFlush(Unpooled.copiedBuffer("Hello RocketMQ!", CharsetUtil.UTF_8));
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        // 打印服务端响应的信息
        ByteBuf in = (ByteBuf) msg;
        System.out.println("Client received : " + in.toString(CharsetUtil.UTF_8));
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        // 打印异常，并关闭 Channel
        cause.printStackTrace();
        ctx.close();
    }
}

下面我们就需要编写客户端引导类，用于连接服务端并且与服务端进行通信。

EchoClient.java

public class EchoClient {
    
    private final String host;
    
    private final int prot;

    public EchoClient(String host, int prot) {
        this.host = host;
        this.prot = prot;
    }

    public static void main(String[] args) throws Exception {
        new EchoClient("localhost", 8080).start();
    }
    
    public void start() throws Exception {
        EventLoopGroup group = new NioEventLoopGroup();
        try {
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(group)
                        .channel(NioSocketChannel.class)
                        .remoteAddress(new InetSocketAddress(host, prot))
                        .handler(new ChannelInitializer<SocketChannel>() {
                            @Override
                            protected void initChannel(SocketChannel ch) throws Exception {
                                ch.pipeline().addLast(new EchoClientHandler());
                            }
                        });
            ChannelFuture future = bootstrap.connect().sync();
            future.channel().closeFuture().sync();
        } finally {
            group.shutdownGracefully().sync();
        }
    }

}

以上代码做的事如下：

创建一个 Bootstrap 实例以初始化客户端
创建一个 EventLoopGroup 实例处理创建新的连接以及处理入站和出站数据
为连接服务器创建一个 InetSocketAddress 实例
当连接被建立时，一个 EchoClientHandler 实例会被安装到 ChannelPipeline 中
一切设置完成后，调用 Bootstrap.connect() 方法连接到远程节点

下面我们就可以测试程序的正确性了。

2.3 Test

运行服务端引导类 EchoServer，然后运行客户端引导类 EchoClient。此时在服务端的控制台打印以下结果：

在这里插入图片描述
接着在客户端的控制台打印以下结果：

3、RocketMQ 中的 Netty

在 RocketMQ 对于网络通信抽象成了 RemotingService，它的类继承结构如下：
在这里插入图片描述
这个类负责客户端、服务端的启动、关闭并且扩展类 RPCHook。

public interface RemotingService {
    void start();

    void shutdown();

    void registerRPCHook(RPCHook rpcHook);
}

3.1 RemotingServer

这个是远程服务的网络抽象，它提供了对于客户端请求的处理，以及对客户端的调用。

public interface RemotingServer extends RemotingService {

	// 注册处理器，处理不同的请求
    void registerProcessor(final int requestCode, final NettyRequestProcessor processor,
        final ExecutorService executor);

	// 注册默认处理器，处理 NameServer 和 对Admin 自身操作
    void registerDefaultProcessor(final NettyRequestProcessor processor, final ExecutorService executor);

	// 本地监听端口
    int localListenPort();

	// 根据请求码获取处理类
    Pair<NettyRequestProcessor, ExecutorService> getProcessorPair(final int requestCode);

	// 同步调用远程服务
    RemotingCommand invokeSync(final Channel channel, final RemotingCommand request,
        final long timeoutMillis) throws InterruptedException, RemotingSendRequestException,
        RemotingTimeoutException;

	// 异常调用远程服务
    void invokeAsync(final Channel channel, final RemotingCommand request, final long timeoutMillis,
        final InvokeCallback invokeCallback) throws InterruptedException,
        RemotingTooMuchRequestException, RemotingTimeoutException, RemotingSendRequestException;

	// Oneway 模式调用
    void invokeOneway(final Channel channel, final RemotingCommand request, final long timeoutMillis)
        throws InterruptedException, RemotingTooMuchRequestException, RemotingTimeoutException,
        RemotingSendRequestException;

}

在 RemotingServer 的实现类NettyRemotingServer#start 方法中会通过 Netty 启动服务，类似于我们第二章节的 EchoServer#start 的启动。

3.2 RemotingClient

这个是客户端服务的网络抽象，它提供了对于远程服务的调用：包含 NameServer 以及 Broker。因为 Netty 网络通信是异步的，当调用其它服务处理的时候，需要把对应的 Channel 保存到本地。等到远程处理完毕之后从本地找到对应的调用然后进行处理，所以提供了一个 registerProcessor 当调用远程服务的时候把就请求注册到本地 Map 当中

public interface RemotingClient extends RemotingService {

	// 更新 NameServer 列表地址
    void updateNameServerAddressList(final List<String> addrs);

	// 获取 NameServer 列表地址
    List<String> getNameServerAddressList();

	// 同步远程调用
    RemotingCommand invokeSync(final String addr, final RemotingCommand request,
        final long timeoutMillis) throws InterruptedException, RemotingConnectException,
        RemotingSendRequestException, RemotingTimeoutException;

	// 异步远程调用
    void invokeAsync(final String addr, final RemotingCommand request, final long timeoutMillis,
        final InvokeCallback invokeCallback) throws InterruptedException, RemotingConnectException,
        RemotingTooMuchRequestException, RemotingTimeoutException, RemotingSendRequestException;

	// Oneway 模式调用(不需要返回)
    void invokeOneway(final String addr, final RemotingCommand request, final long timeoutMillis)
        throws InterruptedException, RemotingConnectException, RemotingTooMuchRequestException,
        RemotingTimeoutException, RemotingSendRequestException;

	// 注册请求处理到本地，等待远程服务异步响应处理
    void registerProcessor(final int requestCode, final NettyRequestProcessor processor,
        final ExecutorService executor);

	// 设置异步回调线程池处理
    void setCallbackExecutor(final ExecutorService callbackExecutor);

	// 获取异步回调线程池处理
    ExecutorService getCallbackExecutor();

	// 是否可写
    boolean isChannelWritable(final String addr);
}

在 RemotingClient的实现类NettyRemotingClient#start 方法中会通过 Netty 启动服务，类似于我们第二章节的 EchoClient#start 的启动。

3.3 NettyRemotingAbstract

不管是 NettyRemotingServer 还是 NettyRemotingClient 它们都继承了 NettyRemotingAbstract 这个类。它主要提供了以下几个功能点：

processMessageReceived ：处理消息，包含请求消息以及响应消息。
invokeSyncImpl：同步调用网络请求
invokeAsyncImpl：异步调用网络请求
invokeOnewayImpl：Oneway 模式进行网络请求

下面我们来看一下对于消息请求的处理，它主要的逻辑就是根据请求码找到对应的 NettyRequestProcessor 处理类进行处理。处理完成之后然后把请求响应给请求方 Channel。

所有的请求码都在 org.apache.rocketmq.common.protocol.RequestCode 类中，里面包含了 Producer、NameServer、Broker 以及 Consumer 之间的所有请求。具体代码我就不贴出来了，大家可以自行查看，后续我们在源码分析当中遇到场景在具体分析。
NettyRequestProcessor 这个接口定义了不同的请求码的具体处理。

首先我们来看一下NettyRequestProcessor 这个接口的类体系结构：

在这里插入图片描述
其实根据类名称都大体可以猜出这个处理类的具体作用了。

3.4 MQClientInstance

在 RocketMQ 中如果是需要主动发送消息的话，就会通过 MQClientInstance 进行网络请求。这个类里面比较核心的字段为：

MQClientAPIImpl mQClientAPIImpl：封装了与NameServer 的网络连接
ConcurrentMap<String/* Broker Name */, HashMap<Long/* brokerId */, String/* address */>> brokerAddrTable：客户端(Producer 或者 Consumer) 在连接 NameServer 可以获取到 Broker 相关的信息

当然还有其它比较核心的字段，这里就不一一介绍了。我们只需要知道，不管是 Producer 或者 Consumer 都可以通过它建立与 NameServer 的连接获取到 Broker 保存到 NameServer 的元数据信息。

在 MQClientAPIImpl 类当中包含了 Producer 或者 Consumer 关心的核心功能：从 NameServer更新元数据信息、Producer发送消息到 Broker、Consumer 从 Broker拉取消息等。

在 MQClientAPIImpl 初始化的时候，还会注册一些默认需要的请求码的处理类到本地内存映射当中：

    public MQClientAPIImpl(final NettyClientConfig nettyClientConfig,
        final ClientRemotingProcessor clientRemotingProcessor,
        RPCHook rpcHook, final ClientConfig clientConfig) {
        this.clientConfig = clientConfig;
        topAddressing = new TopAddressing(MixAll.getWSAddr(), clientConfig.getUnitName());
        this.remotingClient = new NettyRemotingClient(nettyClientConfig, null);
        this.clientRemotingProcessor = clientRemotingProcessor;

        this.remotingClient.registerRPCHook(rpcHook);
        // 检查事务消息状态
        this.remotingClient.registerProcessor(RequestCode.CHECK_TRANSACTION_STATE, this.clientRemotingProcessor, null);
        // 通知 Consumer ID 变更
        this.remotingClient.registerProcessor(RequestCode.NOTIFY_CONSUMER_IDS_CHANGED, this.clientRemotingProcessor, null);
        // 重置 Consumer 的 Offset
        this.remotingClient.registerProcessor(RequestCode.RESET_CONSUMER_CLIENT_OFFSET, this.clientRemotingProcessor, null);
        // 获取 Consumer 的客户端状态
        this.remotingClient.registerProcessor(RequestCode.GET_CONSUMER_STATUS_FROM_CLIENT, this.clientRemotingProcessor, null);
        // 获取 Consumer 的运行信息
        this.remotingClient.registerProcessor(RequestCode.GET_CONSUMER_RUNNING_INFO, this.clientRemotingProcessor, null);
        // 直接消费消息
        this.remotingClient.registerProcessor(RequestCode.CONSUME_MESSAGE_DIRECTLY, this.clientRemotingProcessor, null);
        // 发送应答消息给客户端
        this.remotingClient.registerProcessor(RequestCode.PUSH_REPLY_MESSAGE_TO_CLIENT, this.clientRemotingProcessor, null);
    }