昨天去巡检线上环境的时候，偶然发现了某个服务报了一个错误，而且是每隔90秒报一次，错误信息如下：
意思是内部错误，没有新的messageid可以使用了。
消息队列就不多说了。正常的情况就是一个消息会有一个消息id，如果不了解mqtt的消息id的话，我们正常人的思维就是这个消息id是个随机数，因为消息的id是int类型，所以最大值是2^31-1，大概是21亿，对于一个庞大的系统而且是持续运行的系统，消息肯定会满天飞，数量级可能是百亿甚至千亿，那这个id能装得下么。结合着这个疑问和这个报错，捋了一下这块的代码。
对于消息队列来讲，就是生产者、消费者两个角色。 生产者很简单，生产消息，简单的可以理解为建立连接、发送消息、关闭连接。 消费者是监听某个队列，如果有消息就去接收，并做处理，那么对于消费者来讲就是一个持续连接的状态。
下面先贴下伪代码：
1、相关依赖：
<!--lmq-mqtt-->
<dependency>
<groupId>org.eclipse.paho</groupId>
<artifactId>org.eclipse.paho.client.mqttv3</artifactId>
<version>1.1.0</version>
</dependency>
<dependency>
<groupId>com.aliyun.openservices</groupId>
<artifactId>ons-client</artifactId>
<version>1.3.2.Final</version>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.32</version>
</dependency>2、消费者，采用的是异步监听的方式
@Component
public class MQTTAsyncClientFactory implements ApplicationRunner {
private static MqttAsyncClient mqttAsyncClient;
private MQTTAsyncClientFactory() {
}
public static MqttAsyncClient getMqttAsyncProducerClient() throws MqttException {
return mqttAsyncClient;
}
@Override
public void run(ApplicationArguments args) throws Exception {
LMQProperties lmqProperties = LMQProperties.getInstance();
String clientId = lmqProperties.getGroupId() + "@@@" + lmqProperties.getDeviceId() + InetAddress.getLocalHost().getHostAddress().toString().replaceAll("\\.", "");
final MemoryPersistence memoryPersistence = new MemoryPersistence();
mqttAsyncClient = new MqttAsyncClient(lmqProperties.getBrokerUrl(), clientId, memoryPersistence);
MqttConnectOptions connOpts = new MqttConnectOptions();
connOpts.setUserName(lmqProperties.getUserName());
connOpts.setPassword(lmqProperties.getPassWord().toCharArray());
connOpts.setCleanSession(lmqProperties.getCleanSession());
connOpts.setKeepAliveInterval(10);
connOpts.setAutomaticReconnect(true);
connOpts.setMaxInflight(lmqProperties.getMaxInflight());
mqttAsyncClient.setCallback(new MqttCallbackExtended() {
@Override
public void connectComplete(boolean reconnect, String serverURI) {
try {
//订阅Topic,可以订阅多个
final String topicFilter[] = {lmqProperties.getTopic() + "/" + lmqProperties.getRecieveTopic2() + "/" + lmqProperties.getTopic3()};
//设置QoS级别
final int[] qos = {lmqProperties.getQos()};
Thread.sleep(2000);
System.out.println("连接成功，订阅消息");
IMqttToken subscribe = mqttAsyncClient.subscribe(topicFilter, qos);
System.out.println("消息ID:"+subscribe.getMessageId()+" Thread="+Thread.currentThread().getName());
} catch (MqttException e) {
e.printStackTrace();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
@Override
public void connectionLost(Throwable throwable) {
throwable.printStackTrace();
}
@Override
public void messageArrived(String s, MqttMessage mqttMessage) throws Exception {
//处理pos返回消息
rececive(new String(mqttMessage.getPayload()));
}
@Override
public void deliveryComplete(IMqttDeliveryToken iMqttDeliveryToken) {
//this notice make sense when qos >0
int serialid = iMqttDeliveryToken.getMessageId();
System.out.println("消息id是"+serialid+" Thread="+Thread.currentThread().getName());
}
});
mqttAsyncClient.connect(connOpts).waitForCompletion();
System.out.println("mqtt连接成功");
}
public static boolean rececive(String msg){
//TODO 处理pos返回消息
return true;
}
}消费者其实实现起来也很简单，就是实现接口
ApplicationRunner，并且把类注册到spring容器中就行了。
ApplicationRunner接口很简单：
public interface ApplicationRunner {
/**
* Callback used to run the bean.
* @param args incoming application arguments
* @throws Exception on error
*/
void run(ApplicationArguments args) throws Exception;
}这个接口的注释说的也很明确：
Interface used to indicate that a bean should <em>run</em> when it is contained within a {@link SpringApplication}.
Multiple {@link ApplicationRunner} beans can be defined within the same application context and
can be ordered using the {@link Ordered} interface or {@link Order @Order} annotation.意思是只要你这个bean实现了这个接口，并且包含在spring容器中，就会执行实现的run方法。多个bean可以在同一个spring上下文中，并且可以通过order接口或注解来进行指定执行顺序。
run方法会在spring容器启动之后进行执行，
这里面有一个对象MqttAsyncClient，是在spring容器启动之后进行实例化而且实例化了一次。
正常同步的话，我们可以在
mqttAsyncClient.connect(connOpts)之后，进行订阅
mqttAsyncClient.subscribe(topicFilter, qos);
但是在这个demo里面，我们是在连接成功之后，回调确认连接成功的时候进行的监听，应该是一样的。因为确认连接的过程实际上也是发送了一条消息。
LMQProperties这个类是一个单例，封装了mqtt连接的信息，具体配置的值我已经去掉了。
@Component
public class LMQProperties {
//服务地址
private String brokerUrl;
//一级topic
private String topic;
//二级发送消息topic 商户ID_标识符 标识符：用1/0标记，1：消息从云平台到POS，0：消息从POS到云平台
private String sendTopic2;
//二级接收消息topic
private String recieveTopic2;
//三级topic
private String topic3;
//服务系统用户名
private String userName;
//
private String passWord;
//客户端配置分组id 在控制台创建后使用
private String groupId;
//Device ID: 每个设备独一无二的标识，由业务方自己指定。需要保证全局唯一，例如每个传感器设备的序列号。
//与groupId 一起生成 clientID = groupId+@@@+deviceId
private String deviceId;
//QoS级别
private Integer qos;
//设置客户端是否使用持久化模式
private Boolean cleanSession;
//允许未能及时收到broker回复的ack时的MQ消息最大数量
private int maxInflight;
//老版本队列的企业号白名单
private String companyIdsWhite;
private LMQProperties(){
brokerUrl = "";
topic = "";
sendTopic2 = "test";
recieveTopic2 = "";
topic3 = "";
userName="";
passWord="";
groupId="";
deviceId="";
qos=1;
cleanSession= false;
maxInflight=100000;
}
private static LMQProperties INSTANCE = new LMQProperties();
public static LMQProperties getInstance(){
return INSTANCE;
}
public String getBrokerUrl() {
return brokerUrl;
}
public void setBrokerUrl(String brokerUrl) {
this.brokerUrl = brokerUrl;
}
public String getTopic() {
return topic;
}
public void setTopic(String topic) {
this.topic = topic;
}
public String getSendTopic2() {
return sendTopic2;
}
public void setSendTopic2(String sendTopic2) {
this.sendTopic2 = sendTopic2;
}
public String getRecieveTopic2() {
return recieveTopic2;
}
public void setRecieveTopic2(String recieveTopic2) {
this.recieveTopic2 = recieveTopic2;
}
public String getTopic3() {
return topic3;
}
public void setTopic3(String topic3) {
this.topic3 = topic3;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public String getPassWord() {
return passWord;
}
public void setPassWord(String passWord) {
this.passWord = passWord;
}
public String getGroupId() {
return groupId;
}
public void setGroupId(String groupId) {
this.groupId = groupId;
}
public String getDeviceId() {
return deviceId;
}
public void setDeviceId(String deviceId) {
this.deviceId = deviceId;
}
public Integer getQos() {
return qos;
}
public void setQos(Integer qos) {
this.qos = qos;
}
public Boolean getCleanSession() {
return cleanSession;
}
public void setCleanSession(Boolean cleanSession) {
this.cleanSession = cleanSession;
}
public int getMaxInflight() {
return maxInflight;
}
public void setMaxInflight(int maxInflight) {
this.maxInflight = maxInflight;
}
public String getCompanyIdsWhite() {
return companyIdsWhite;
}
public void setCompanyIdsWhite(String companyIdsWhite) {
this.companyIdsWhite = companyIdsWhite;
}3、生产者
public static void publishMsg(int cnt) throws Exception {
MqttAsyncClient mqttClient = MQTTAsyncClientFactory.getMqttAsyncProducerClient();
LMQProperties lmqProperties = LMQProperties.getInstance();
//拼接topic
final String mqttSendTopic = lmqProperties.getTopic() + "/" + lmqProperties.getRecieveTopic2() + "/" + lmqProperties.getTopic3();
MqttMessage message = new MqttMessage("我是消息内容".getBytes());
//设置QoS级别
message.setQos(lmqProperties.getQos());
mqttClient.publish(mqttSendTopic, message);
if(cnt%1000==0)
System.out.println("这是第"+cnt+"次发送消息");
}生产者很简单，就是执行一下publish就可以了。
消息想产生一定是会在发消息的时候生成，所以接下来就可以跟下publish方法是怎么生成消息id的。
publish调用的是
ClientComms的sendNoWait，
最终调用的是ClientState的send方法
getNextMessageId（）方法就是生成新消息id的方法：
private synchronized int getNextMessageId() throws MqttException {
int startingMessageId = nextMsgId;
// Allow two complete passes of the message ID range. This gives
// any asynchronous releases a chance to occur
int loopCount = 0;
do {
nextMsgId++;
if ( nextMsgId > MAX_MSG_ID ) {
nextMsgId = MIN_MSG_ID;
}
if (nextMsgId == startingMessageId) {
loopCount++;
if (loopCount == 2) {
throw ExceptionHelper.createMqttException(MqttException.REASON_CODE_NO_MESSAGE_IDS_AVAILABLE);
}
}
} while( inUseMsgIds.containsKey( new Integer(nextMsgId) ) );
Integer id = new Integer(nextMsgId);
inUseMsgIds.put(id, id);
return nextMsgId;
}这个方法是个同步方法，说的就是给消息获取新的消息id，并且把它存到一个已经在使用的集合里面作为标记。
而这个方法里面的这个异常便是我们的那个异常了
在这个方法里面，涉及到这几个变量：
nextMsgId默认是0， 最小消息id是1，最大消息id是65535。inUseMsgIds这个标记已经使用的消息id的集合是个hashtable。
这个方法大致解释一下，就是进入这个方法之后，会将当前nextMsgId的值存到startingMessageId这个变量上。
定义一个循环数量的变量loopCount，如果循环了达到两次，就抛出那个异常。
进入循环的判断条件就是nextMsgId在inUseMsgIds的集合里面。
循环里面，如果nextMsgId大于最大消息id的时候，会被设置为最小消息id。 所以从这里可以看出，这里的消息id是循环重复使用的。那么什么情况下会出现那个异常呢，就是当从1~65535的消息id都放到了inUseMsgIds里面，并且nextMsgId达到了最大值65535的时候，nextMsgId会被重置为1，会重新再跑一遍1~65535的while循环，就会报那个错了。
inUseMsgIds是记录已经使用的消息id。那么他里面的内容什么时候被清理的呢，ClientState里面提供了
clearState(),close()方法，进行inUseMsgIds.clear()。 而clearState()是在
shutdownConnection的时候执行的。 也就是说在mqtt的client失去连接或者关闭的时候，就会清理inUseMsgIds。
如果只有这个机制才能清理，那么如果一直不失去连接或者不关闭连接，岂不是就会报那个错误，设计一定不会这么傻。所以ClientState还提供了以下方法：
private synchronized void releaseMessageId(int msgId) { inUseMsgIds.remove(new Integer(msgId)); }
这个方法总共有三个调用者：
CommsSender，CommsReceiver，CommsCallback
CommsSender在发送成功之后，会调用ClientState.notifySend()方法，进而调用releaseMssageId()。
CommsReceiver在收到ack的消息的时候，会调用ClientState.notifyReceivedAck()方法，进而调用releaseMssageId()。
CommsCallback当等待者和回调处理完消息后调用，会调用ClientState.notifyComplete()方法，进而调用releaseMssageId()。
所以正常情况下，只要消息发送成功，消息成功消费，基本就不存在报那个错。因为消息的id产生了，只要不用了就会被释放。
所以非常遗憾，线上服务重启后就没有再出现这个问题，所以也没有排查到当时为啥会出现那个错误。
