无微不至之RocketMq源码深度讲解(2)-架构分析

源码地址:https://github.com/apache/roc...
基于版本讲解:4.7.1

此内容引用官方介绍

image.png

RocketMQ架构上主要分为四部分,如上图所示:

  • Producer:消息发布的角色,支持分布式集群方式部署。Producer通过MQ的负载均衡模块选择相应的Broker集群队列进行消息投递,投递的过程支持快速失败并且低延迟。
  • Consumer:消息消费的角色,支持分布式集群方式部署。支持以push推,pull拉两种模式对消息进行消费。同时也支持集群方式和广播方式的消费,它提供实时消息订阅机制,可以满足大多数用户的需求。
  • NameServer:NameServer是一个非常简单的Topic路由注册中心,其角色类似Dubbo中的zookeeper,支持Broker的动态注册与发现。主要包括两个功能:Broker管理,NameServer接受Broker集群的注册信息并且保存下来作为路由信息的基本数据。然后提供心跳检测机制,检查Broker是否还存活;路由信息管理,每个NameServer将保存关于Broker集群的整个路由信息和用于客户端查询的队列信息。然后Producer和Conumser通过NameServer就可以知道整个Broker集群的路由信息,从而进行消息的投递和消费。NameServer通常也是集群的方式部署,各实例间相互不进行信息通讯。Broker是向每一台NameServer注册自己的路由信息,所以每一个NameServer实例上面都保存一份完整的路由信息。当某个NameServer因某种原因下线了,Broker仍然可以向其它NameServer同步其路由信息,Producer,Consumer仍然可以动态感知Broker的路由的信息。

RocketMQ 网络部署特点

  • NameServer是一个几乎无状态节点,可集群部署,节点之间无任何信息同步。
  • Broker部署相对复杂,Broker分为Master与Slave,一个Master可以对应多个Slave,但是一个Slave只能对应一个Master,Master与Slave 的对应关系通过指定相同的BrokerName,不同的BrokerId 来定义,BrokerId为0表示Master,非0表示Slave。Master也可以部署多个。每个Broker与NameServer集群中的所有节点建立长连接,定时注册Topic信息到所有NameServer。 注意:当前RocketMQ版本在部署架构上支持一Master多Slave,但只有BrokerId=1的从服务器才会参与消息的读负载。
  • Producer与NameServer集群中的其中一个节点(随机选择)建立长连接,定期从NameServer获取Topic路由信息,并向提供Topic 服务的Master建立长连接,且定时向Master发送心跳。Producer完全无状态,可集群部署。
  • Consumer与NameServer集群中的其中一个节点(随机选择)建立长连接,定期从NameServer获取Topic路由信息,并向提供Topic服务的Master、Slave建立长连接,且定时向Master、Slave发送心跳。Consumer既可以从Master订阅消息,也可以从Slave订阅消息,消费者在向Master拉取消息时,Master服务器会根据拉取偏移量与最大偏移量的距离(判断是否读老消息,产生读I/O),以及从服务器是否可读等因素建议下一次是从Master还是Slave拉取。

结合部署架构图,描述集群工作流程:

  • 启动NameServer,NameServer起来后监听端口,等待Broker、Producer、Consumer连上来,相当于一个路由控制中心。
  • Broker启动,跟所有的NameServer保持长连接,定时发送心跳包。心跳包中包含当前Broker信息(IP+端口等)以及存储所有Topic信息。注册成功后,NameServer集群中就有Topic跟Broker的映射关系。
  • 收发消息前,先创建Topic,创建Topic时需要指定该Topic要存储在哪些Broker上,也可以在发送消息时自动创建Topic。
  • Producer发送消息,启动时先跟NameServer集群中的其中一台建立长连接,并从NameServer中获取当前发送的Topic存在哪些Broker上,轮询从队列列表中选择一个队列,然后与队列所在的Broker建立长连接从而向Broker发消息。
  • Consumer跟Producer类似,跟其中一台NameServer建立长连接,获取当前订阅Topic存在哪些Broker上,然后直接跟Broker建立连接通道,开始消费消息。
    • *

源码艺术

官方对大体架构及主要组件讲解的都已经差不多了,但是细节有些不到位,容易使人产生误解。比如架构图当中RouteInfo具体包含了哪些东西呢?那么由我一步一步的到源码中讲解。

NameServer启动流程

用过RocketMq的大概都知道,在windows或者linux下rocketmq的bin文件目录下有个mqnamesrv可执行文件,在这个文件使用了shell编程,然后间接的调用到了NamesrvStartup类的main方法中,在main方法中可以看到首先经过一系列的参数解析,然后通过反射将参数付给NamesrvConfig和NettyServerConfig实例,最终将配置参数传入NameServerController的构造方法中,创建出一个NameServerController实例,然后调用NameServerController.initialize方法进行一系列准备操作,最终调用NameServerController.start方法正式开启端口监听。等待Broker,Producer,Consumer的连接及业务请求。所以我们这里需要着重理解的是NameServerController.initialize及start方法。

initialize方法

image.png
1.从磁盘中kvConfig.json文件中加载kv配置到内存中,说白了就是维护了一个Map结构
2.实例化NettyRemotingServer,这个类其实也是broker服务的实现类。只是注册的具体的RequestProcessor不同。

public NettyRemotingServer(final NettyServerConfig nettyServerConfig,
 final ChannelEventListener channelEventListener) {
    super(nettyServerConfig.getServerOnewaySemaphoreValue(), nettyServerConfig.getServerAsyncSemaphoreValue());
 this.serverBootstrap = new ServerBootstrap();
 this.nettyServerConfig = nettyServerConfig;
 this.channelEventListener = channelEventListener;
 int publicThreadNums = nettyServerConfig.getServerCallbackExecutorThreads();
 if (publicThreadNums <= 0) {
        publicThreadNums = 4;
 }
    this.publicExecutor = Executors.newFixedThreadPool(publicThreadNums, new ThreadFactory() {
        private AtomicInteger threadIndex = new AtomicInteger(0);
 @Override
 public Thread newThread(Runnable r) {
            return new Thread(r, "NettyServerPublicExecutor_" + this.threadIndex.incrementAndGet());
 }
    });
 if (useEpoll()) {
        this.eventLoopGroupBoss = new EpollEventLoopGroup(1, new ThreadFactory() {
            private AtomicInteger threadIndex = new AtomicInteger(0);
 @Override
 public Thread newThread(Runnable r) {
                return new Thread(r, String.format("NettyEPOLLBoss_%d", this.threadIndex.incrementAndGet()));
 }
        });
 this.eventLoopGroupSelector = new EpollEventLoopGroup(nettyServerConfig.getServerSelectorThreads(), new ThreadFactory() {
            private AtomicInteger threadIndex = new AtomicInteger(0);
 private int threadTotal = nettyServerConfig.getServerSelectorThreads();
 @Override
 public Thread newThread(Runnable r) {
                return new Thread(r, String.format("NettyServerEPOLLSelector_%d_%d", threadTotal, this.threadIndex.incrementAndGet()));
 }
        });
 } else {
        this.eventLoopGroupBoss = new NioEventLoopGroup(1, new ThreadFactory() {
            private AtomicInteger threadIndex = new AtomicInteger(0);
 @Override
 public Thread newThread(Runnable r) {
                return new Thread(r, String.format("NettyNIOBoss_%d", this.threadIndex.incrementAndGet()));
 }
        });
 this.eventLoopGroupSelector = new NioEventLoopGroup(nettyServerConfig.getServerSelectorThreads(), new ThreadFactory() {
            private AtomicInteger threadIndex = new AtomicInteger(0);
 private int threadTotal = nettyServerConfig.getServerSelectorThreads();
 @Override
 public Thread newThread(Runnable r) {
                return new Thread(r, String.format("NettyServerNIOSelector_%d_%d", threadTotal, this.threadIndex.incrementAndGet()));
 }
        });
 }
    loadSslContext();
}

从构造方法中可以看到内部使用的netty框架,那么首先需要创建出一个ServerBootStrap启动类,然后分别创建出bossGroup(用来接受请求)和workerGroup两个线程组(用来处理IO事件,比如读,写,连接等事件)(简单说就是线程池)。BossGroup线程数一般设为1,WorkerGroup在此默认值为3。从代码中还可以看到,在创建bossGroup和workerGroup的时候进行了判断useEpoll。Epool线程组在linux系统下,性能表现更加。具体原理可以自己找找关于Epool的文章。

3.实例化一个线程池(具体请求到来时交由这个线程池处理)

4.注册业务处理器()

private void registerProcessor() {
    if (namesrvConfig.isClusterTest()) {
        this.remotingServer.registerDefaultProcessor(new ClusterTestRequestProcessor(this, namesrvConfig.getProductEnvName()),
 this.remotingExecutor);
 } else {
//默认走此实现
        this.remotingServer.registerDefaultProcessor(new DefaultRequestProcessor(this), this.remotingExecutor);
 }
}

在方法中将一个默认请求处理器DefaultRequestProcessor注册到NettyRemotingServer实例中。

5.定期清理不合格的broker,并将其剔除,以至于producer和consumer不会请求到此broker中。

start方法
在start方法中,间接的调用NettyRemotingServer.start方法。那么我们直接进入到此方法中进行讲解。
public void start() {
    this.defaultEventExecutorGroup = new DefaultEventExecutorGroup(
        nettyServerConfig.getServerWorkerThreads(),
 new ThreadFactory() {
            private AtomicInteger threadIndex = new AtomicInteger(0);
 @Override
 public Thread newThread(Runnable r) {
                return new Thread(r, "NettyServerCodecThread_" + this.threadIndex.incrementAndGet());
 }
        });
 //准备一系列NettyHandler
 prepareSharableHandlers();
 ServerBootstrap childHandler =
        this.serverBootstrap.group(this.eventLoopGroupBoss, this.eventLoopGroupSelector)
            .channel(useEpoll() ? EpollServerSocketChannel.class : NioServerSocketChannel.class)
            .option(ChannelOption.SO_BACKLOG, 1024)
            .option(ChannelOption.SO_REUSEADDR, true)
            .option(ChannelOption.SO_KEEPALIVE, false)
            .childOption(ChannelOption.TCP_NODELAY, true)
            .childOption(ChannelOption.SO_SNDBUF, nettyServerConfig.getServerSocketSndBufSize())
            .childOption(ChannelOption.SO_RCVBUF, nettyServerConfig.getServerSocketRcvBufSize())
            .localAddress(new InetSocketAddress(this.nettyServerConfig.getListenPort()))
            .childHandler(new ChannelInitializer<SocketChannel>() {
                @Override
 public void initChannel(SocketChannel ch) throws Exception {
                    ch.pipeline()
                        .addLast(defaultEventExecutorGroup, HANDSHAKE_HANDLER_NAME, handshakeHandler)
                        .addLast(defaultEventExecutorGroup,
 encoder,
 new NettyDecoder(),
 new IdleStateHandler(0, 0, nettyServerConfig.getServerChannelMaxIdleTimeSeconds()),
 connectionManageHandler,
 serverHandler
 );
 }
            });
 if (nettyServerConfig.isServerPooledByteBufAllocatorEnable()) {
        childHandler.childOption(ChannelOption.ALLOCATOR, PooledByteBufAllocator.DEFAULT);
 }
    try {
        ChannelFuture sync = this.serverBootstrap.bind().sync();
 InetSocketAddress addr = (InetSocketAddress) sync.channel().localAddress();
 this.port = addr.getPort();
 } catch (InterruptedException e1) {
        throw new RuntimeException("this.serverBootstrap.bind().sync() InterruptedException", e1);
 }
    if (this.channelEventListener != null) {
        this.nettyEventExecutor.start();
 }
    this.timer.scheduleAtFixedRate(new TimerTask() {
        @Override
 public void run() {
            try {
                NettyRemotingServer.this.scanResponseTable();
 } catch (Throwable e) {
                log.error("scanResponseTable exception", e);
 }
        }
    }, 1000 * 3, 1000);
}

在这些代码中其实核心代码就那么几行:
prepareSharableHandlers();实例化一系列netty的请求处理handler

ch.pipeline()
                        .addLast(defaultEventExecutorGroup, HANDSHAKE_HANDLER_NAME, handshakeHandler)
                        .addLast(defaultEventExecutorGroup,
 encoder,
 new NettyDecoder(),
 new IdleStateHandler(0, 0, nettyServerConfig.getServerChannelMaxIdleTimeSeconds()),
 connectionManageHandler,
 serverHandler

如果不懂netty的话,可以直接看这行代码,在代码块中可以看到添加了几个Handler。
当客户端请求到来时:经过的handler处理器顺序为:
NettyDecoder(解码器,将字节节码成java具体的数据结构,在此为RemotingCommond)->IdleStateHandler(心跳检测处理器,当读写空闲某个时间阈值时,会触发一个IdleEvent事件)->connectionManageHandler(连接事件转发)->serverHandler(核心,prepareSharableHandlers()方法中NettyServerHandler的实例,处理真正的业务)
当响应数据写回给客户端时经过的handler链为:
serverHandler->connectionManageHandler->IdleStateHandler->NettyEecoder

我们重点要看的时NettyEncoder和NettDecoder和NettyServerHandler。
1.NettyServerDecoder,将字节码转换为RemotingCommond结构,主要由请求头+请求体。具体通信协议格式为:
image.png
其中后两部分是通讯的实际数据。前两段都是四个字节的整形,分别表示两段实际数据的长度。

  • header: 协议的头,数据是序列化后的json。json的每个key字段都是固定的,不同的通讯请求字段不一样。后面解释
  • body: 请求的二进制实际数据。例如发送消息的网络请求中,body中传输实际的消息内容。
  • length:2 3 4 端整体的长度。四个字节整数。
  • header length: header的长度。四个字节整数。

将客户端请求的数据转换成RemotingCommond之后(具体转换细节忽略),请求头里面里面有几个核心参数:
(1)opaque(标记此次请求的唯一标识,和zookeeper的xid和dubbo的requestId作用一样),全局唯一自增长。
(2)type标记此请求时Request还是Reponse
(3)isOneWay 标记此请求是否是单边请求即是否需要响应,true不需要,false则需要相应
(4)code 不同的业务请求对应不同的code
2.NettyEcoder(NettyDecoder的相反逻辑,将RemotingCommond根据协议,转换成字节码,最后通过网络发给其他网络通道)

3.NettyServerHandler(真正的业务处理Handler)

@ChannelHandler.Sharable
class NettyServerHandler extends SimpleChannelInboundHandler<RemotingCommand> {

@Override

protected void channelRead0(ChannelHandlerContext ctx, RemotingCommand msg) throws Exception {
//当请求到来并经过NettyDecoder解码时

    processMessageReceived(ctx, msg);

}
}
在processMessageReceived方法中根据请求的type,确定当前请求时request还是response,分别走不同的逻辑。

1.processRequestCommand(处理request类型逻辑)

public void processRequestCommand(final ChannelHandlerContext ctx, final RemotingCommand cmd) {
    //1.根据业务code获取我们之前注册的NettyRequestProcessor
 final Pair<NettyRequestProcessor, ExecutorService> matched = this.processorTable.get(cmd.getCode());
 //2.如果当前业务code对应的RequestProcessor,则采用默认的
 final Pair<NettyRequestProcessor, ExecutorService> pair = null == matched ? this.defaultRequestProcessor : matched;
 final int opaque = cmd.getOpaque();
 if (pair != null) {
        //线程池任务
 Runnable run = new Runnable() {
            @Override
 public void run() {
                try {
                    doBeforeRpcHooks(RemotingHelper.parseChannelRemoteAddr(ctx.channel()), cmd);
 final RemotingResponseCallback callback = new RemotingResponseCallback() {
                        @Override
 public void callback(RemotingCommand response) {
                            doAfterRpcHooks(RemotingHelper.parseChannelRemoteAddr(ctx.channel()), cmd, response);
 if (!cmd.isOnewayRPC()) {
                                if (response != null) {
                                    response.setOpaque(opaque);
 response.markResponseType();
 try {
                                        ctx.writeAndFlush(response);
 } catch (Throwable e) {
                                        log.error("process request over, but response failed", e);
 log.error(cmd.toString());
 log.error(response.toString());
 }
                                } else {
                                }
                            }
                        }
                    };
 if (pair.getObject1() instanceof AsyncNettyRequestProcessor) {
                        AsyncNettyRequestProcessor processor = (AsyncNettyRequestProcessor)pair.getObject1();
 processor.asyncProcessRequest(ctx, cmd, callback);
 } else {
                        NettyRequestProcessor processor = pair.getObject1();
 RemotingCommand response = processor.processRequest(ctx, cmd);
 callback.callback(response);
 }
                } catch (Throwable e) {
                    log.error("process request exception", e);
 log.error(cmd.toString());
 if (!cmd.isOnewayRPC()) {
                        final RemotingCommand response = RemotingCommand.createResponseCommand(RemotingSysResponseCode.SYSTEM_ERROR,
 RemotingHelper.exceptionSimpleDesc(e));
 response.setOpaque(opaque);
 ctx.writeAndFlush(response);
 }
                }
            }
        };
 //拦截一些请求,每个RequestProcessor拦截的逻辑不同
 if (pair.getObject1().rejectRequest()) {
            final RemotingCommand response = RemotingCommand.createResponseCommand(RemotingSysResponseCode.SYSTEM_BUSY,
 "[REJECTREQUEST]system busy, start flow control for a while");
 response.setOpaque(opaque);
 ctx.writeAndFlush(response);
 return; }
        try {
            final RequestTask requestTask = new RequestTask(run, ctx.channel(), cmd);
 //交由线程池处理
 pair.getObject2().submit(requestTask);
 } catch (RejectedExecutionException e) {
            if ((System.currentTimeMillis() % 10000) == 0) {
                log.warn(RemotingHelper.parseChannelRemoteAddr(ctx.channel())
                    + ", too many requests and system thread pool busy, RejectedExecutionException "
 + pair.getObject2().toString()
                    + " request code: " + cmd.getCode());
 }
            if (!cmd.isOnewayRPC()) {
                final RemotingCommand response = RemotingCommand.createResponseCommand(RemotingSysResponseCode.SYSTEM_BUSY,
 "[OVERLOAD]system busy, start flow control for a while");
 response.setOpaque(opaque);
 ctx.writeAndFlush(response);
 }
        }
    } else {
 String error = " request type " + cmd.getCode() + " not supported";
 final RemotingCommand response =
            RemotingCommand.createResponseCommand(RemotingSysResponseCode.REQUEST_CODE_NOT_SUPPORTED, error);
 response.setOpaque(opaque);
 ctx.writeAndFlush(response);
 log.error(RemotingHelper.parseChannelRemoteAddr(ctx.channel()) + error);
 }
}

该代码块大致逻辑为,首先根据请求的业务code,获取对应的RequestProcessor,如果没有注册,则采用注册了的DefaultRequestProcessor处理,也就是我们之前讲到的在NettyRemotingServer的构造方法中注册进去的。然后提交线程池进行处理,最终会调用到RequestProcessor.processRequest方法,经过processRequest方法处理后,最终返回RemotingCommon,然后设置opaque,最终调用ctx.writeAndFlush通过netty框架经过一系列的handler链(上面提到的)写回给请求端。

2.processResponseCommand(处理响应端)
public void processResponseCommand(ChannelHandlerContext ctx, RemotingCommand cmd) {

//获取请求标识,具体是哪个请求得到了相应

final int opaque = cmd.getOpaque();
//请求时,会创建一个ResponseFuture放到map中,待请求到来时,通过opaque唯一标识获取结果
final ResponseFuture responseFuture = responseTable.get(opaque);
if (responseFuture != null) {

    responseFuture.setResponseCommand(cmd);

responseTable.remove(opaque);
if (responseFuture.getInvokeCallback() != null) {

        executeInvokeCallback(responseFuture);

} else {

        responseFuture.putResponse(cmd);

responseFuture.release();
}

} else {
    log.warn("receive response, but not matched any request, " + RemotingHelper.parseChannelRemoteAddr(ctx.channel()));

log.warn(cmd.toString());
}
}
根据标识,获取到请求到创建的ResponseFuture实例,然后将RemotingCommond结果,放入到ResponseFuture中,在一个请求发出之后,客户端拿到ResponseFuture实例,然后调用ResponseFuture#waitResponse方法,进行阻塞等待(实现原理采用CountDownLatch#await方法)。
public RemotingCommand waitResponse(final long timeoutMillis) throws InterruptedException {

this.countDownLatch.await(timeoutMillis, TimeUnit.MILLISECONDS);

return this.responseCommand;
}
当客户端接受到响应后,调用processResponseCommand,在里面可以看到调用了ResponseFuture#putResponse方法。
public void putResponse(final RemotingCommand responseCommand) {

this.responseCommand = responseCommand;

this.countDownLatch.countDown();
},该方法被调用后,唤醒之前阻塞的线程,然后客户端拿到RemotingCommond结果。然后进行响应的处理。

大概的一个网络请求流程就是这样的一个过程。具体的业务场景后面会讲到,也就是不同的业务请求交由不同的RequestProcessor去实现。核心还是RequestProcessor。

评论

暂无评论