RocketMQ高手之路系列之二：RocketMQ之消息通信

result.putInt(length);

// header length

result.put(markProtocolType(headerData.length, serializeTypeCurrentRPC));

// header data

result.put(headerData);

// body data;

if (this.body != null) {

result.put(this.body);

}

result.flip(); //将缓冲区翻转，用于将ByteBuffer放到网络通道中进行传输

return result;

}

我们再看下消息的解码操作，源码中的实现如下所示：

//解码操作

public static RemotingCommand decode(final byte[] array) {

ByteBuffer byteBuffer = ByteBuffer.wrap(array);

return decode(byteBuffer);

}

//

public static RemotingCommand decode(final ByteBuffer byteBuffer) {

int length = byteBuffer.limit();

int oriHeaderLen = byteBuffer.getInt();

int headerLength = getHeaderLength(oriHeaderLen);

byte[] headerData = new byte[headerLength];

byteBuffer.get(headerData);

RemotingCommand cmd = headerDecode(headerData, getProtocolType(oriHeaderLen));

int bodyLength = length - 4 - headerLength;

byte[] bodyData = null;

if (bodyLength > 0) {

bodyData = new byte[bodyLength];

byteBuffer.get(bodyData);

}

cmd.body = bodyData;

return cmd;

}

（2）消息传输方式

在RocketMQ系统中，消息的通信方式主要有三种：

1、可靠的同步传输；

2、可靠的异步传输；

3、单向传输；

二、消息如何流转

---

我们知道RocketMQ底层的通信是通过Netty实现。其中NettyRemotingClient与NettyRemotingServer是RemotingClient和RemotingServer这两个接口的实现类，也是比较重要的实现类。NettyRemotingClient与NettyRemotingServer也同时继承了NettyRemotingAbstract抽象类，该类抽象了invokeSync、invokeOneway等公用的方法实现。

（1）客户端请求发送

首先我们来看下 NettyRemotingClient中的重要源码分析，如下所示：

public class NettyRemotingClient extends NettyRemotingAbstract implements RemotingClient {

…

}

我们可以看出客户端继承了NettyRemotingAbstract抽象类同时实现了RemotingClient接口。其中比较重要的方法包括同步调用、异步调用以及单向调用。我么通过异步调用的方式来举例，NettyRemotingClient 根据地址信息获取或者创建channel，接着会进行invokeAsyncImpl方法的调用，此时客户端会将数据流转给公共的抽象类NettyRemotingAbstract 进行统一处理，在此类中完成真正的请求发送动作。发送消息的源码如下所示：

public void invokeAsyncImpl(final Channel channel, final RemotingCommand request, final long timeoutMillis,

final InvokeCallback invokeCallback)

throws InterruptedException, RemotingTooMuchRequestException, RemotingTimeoutException, RemotingSendRequestException {

long beginStartTime = System.currentTimeMillis();

//请求的ID

final int opaque = request.getOpaque();

boolean acquired = this.semaphoreAsync.tryAcquire(timeoutMillis, TimeUnit.MILLISECONDS);

if (acquired) {

final SemaphoreReleaseOnlyOnce once = new SemaphoreReleaseOnlyOnce(this.semaphoreAsync);

long costTime = System.currentTimeMillis() - beginStartTime;

if (timeoutMillis < costTime) {

once.release();

throw new RemotingTimeoutException(“invokeAsyncImpl call timeout”);

}

//构建ResponseFuture

final ResponseFuture responseFuture = new ResponseFuture(channel, opaque, timeoutMillis - costTime, invokeCallback, once);

//将ResponseFuture放入responseTable

this.responseTable.put(opaque, responseFuture);

try {

//使用Netty的channel进行请求数据的发送

channel.writeAndFlush(request).addListener(new ChannelFutureListener() {

//消息发送后执行动作

@Override

public void operationComplete(ChannelFuture f) throws Exception {

if (f.isSuccess()) {

//如果消息发送成功，则直接将属性置为true，同时返回

responseFuture.setSendRequestOK(true);

return;

}

//如果失败

requestFail(opaque);

log.warn(“send a request command to channel <{}> failed.”, RemotingHelper.parseChannelRemoteAddr(channel));

}

});

} catch (Exception e) {

//异常处理过程

responseFuture.release();

log.warn(“send a request command to channel <” + RemotingHelper.parseChannelRemoteAddr(channel) + “> Exception”, e);

throw new RemotingSendRequestException(RemotingHelper.parseChannelRemoteAddr(channel), e);

}

} else {

if (timeoutMillis <= 0) {

throw new RemotingTooMuchRequestException(“invokeAsyncImpl invoke too fast”);

} else {

String info =

String.format(“invokeAsyncImpl tryAcquire semaphore timeout, %dms, waiting thread nums: %d semaphoreAsyncValue: %d”,

timeoutMillis,

this.semaphoreAsync.getQueueLength(),

this.semaphoreAsync.availablePermits()

);

log.warn(info);

throw new RemotingTimeoutException(info);

}

}

}

此处有需要留意的部分，如下：

protected final ConcurrentMap<Integer /* opaque */, ResponseFuture> responseTable =

new ConcurrentHashMap<Integer, ResponseFuture>(256);

opaque 表示请求码，用来标识不同的请求。这个请求码会与ResponseFuture映射在一起。

（2）服务端响应流程

服务端代码如下，继承了NettyRemotingAbstract同时实现了RemotingServer。

public class NettyRemotingServer extends NettyRemotingAbstract implements RemotingServer {

…

}

在该类中的start方法如下所示，它的主要作用是启动Netty服务器

@Override

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());

}

});

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)

言尽于此，完结

无论是一个初级的 coder，高级的程序员，还是顶级的系统架构师，应该都有深刻的领会到设计模式的重要性。

• 第一，设计模式能让专业人之间交流方便，如下：

程序员A：这里我用了XXX设计模式

程序员B：那我大致了解你程序的设计思路了

• 第二，易维护

项目经理：今天客户有这样一个需求…

程序员：明白了，这里我使用了XXX设计模式，所以改起来很快

• 第三，设计模式是编程经验的总结

程序员A：B，你怎么想到要这样去构建你的代码

程序员B：在我学习了XXX设计模式之后，好像自然而然就感觉这样写能避免一些问题

• 第四，学习设计模式并不是必须的

程序员A：B，你这段代码使用的是XXX设计模式对吗？

程序员B：不好意思，我没有学习过设计模式，但是我的经验告诉我是这样写的

从设计思想解读开源框架，一步一步到Spring、Spring5、SpringMVC、MyBatis等源码解读，我都已收集整理全套，篇幅有限，这块只是详细的解说了23种设计模式，整理的文件如下图一览无余！

搜集费时费力，能看到此处的都是真爱！

三，设计模式是编程经验的总结

程序员A：B，你怎么想到要这样去构建你的代码

程序员B：在我学习了XXX设计模式之后，好像自然而然就感觉这样写能避免一些问题

• 第四，学习设计模式并不是必须的

程序员A：B，你这段代码使用的是XXX设计模式对吗？

程序员B：不好意思，我没有学习过设计模式，但是我的经验告诉我是这样写的

[外链图片转存中…(img-ZlaQWxVh-1714443826514)]

从设计思想解读开源框架，一步一步到Spring、Spring5、SpringMVC、MyBatis等源码解读，我都已收集整理全套，篇幅有限，这块只是详细的解说了23种设计模式，整理的文件如下图一览无余！

[外链图片转存中…(img-HAanWJKC-1714443826515)]

搜集费时费力，能看到此处的都是真爱！

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录