paho架构_基于paho springboot集成mqtt实现消息的发布订阅 - 人人都是架构师

1、首先添加pom依赖

org.springframework.boot

spring-boot-starter-integration

org.springframework.integration

spring-integration-stream

org.springframework.integration

spring-integration-mqtt

2、application.yml文件配置

spring:

mqtt:

username: admin

password: password

url: tcp://127.0.0.1:1883

keepAliveInterval: 2

client:

id: mqttId

default:

topic: topic

3、MQTT消息配置类

import org.eclipse.paho.client.mqttv3.MqttConnectOptions;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.beans.factory.annotation.Value;

import org.springframework.context.annotation.Bean;

import org.springframework.integration.annotation.IntegrationComponentScan;

import org.springframework.integration.annotation.ServiceActivator;

import org.springframework.integration.channel.DirectChannel;

import org.springframework.integration.core.MessageProducer;

import org.springframework.integration.mqtt.core.DefaultMqttPahoClientFactory;

import org.springframework.integration.mqtt.core.MqttPahoClientFactory;

import org.springframework.integration.mqtt.inbound.MqttPahoMessageDrivenChannelAdapter;

import org.springframework.integration.mqtt.outbound.MqttPahoMessageHandler;

import org.springframework.integration.mqtt.support.DefaultPahoMessageConverter;

import org.springframework.messaging.Message;

import org.springframework.messaging.MessageChannel;

import org.springframework.messaging.MessageHandler;

import org.springframework.messaging.MessagingException;

import org.springframework.stereotype.Component;

@Component

@IntegrationComponentScan

public class MqttConfig {

private static final Logger logger = LoggerFactory.getLogger(MqttConfig.class);

/**

* 订阅的bean名称

*/

public static final String CHANNEL_NAME_IN = "mqttInboundChannel";

/**

* 发布的bean名称

*/

public static final String CHANNEL_NAME_OUT = "mqttOutboundChannel";

@Value("${spring.mqtt.url}")

private String hostUrl;

@Value("${spring.mqtt.client.id}")

private String clientId;

@Value("${spring.mqtt.default.topic}")

private String defaultTopic;

@Value("${spring.mqtt.username}")

private String userName;

@Value("${spring.mqtt.password}")

private String passWord;

@Value("${spring.mqtt.keepAliveInterval}")

private int keepAliveInterval;

@Bean

public MqttConnectOptions getMqttConnectOptions(){

MqttConnectOptions mqttConnectOptions = new MqttConnectOptions();

mqttConnectOptions.setUserName(userName);

mqttConnectOptions.setPassword(passWord.toCharArray());

mqttConnectOptions.setServerURIs(new String[]{hostUrl});

mqttConnectOptions.setKeepAliveInterval(keepAliveInterval);

return mqttConnectOptions;

}

@Bean

public MqttPahoClientFactory mqttClientFactory(){

DefaultMqttPahoClientFactory factory = new DefaultMqttPahoClientFactory();

factory.setConnectionOptions(getMqttConnectOptions());

return factory;

}

//发送通道

@Bean(name = CHANNEL_NAME_OUT)

public MessageChannel mqttOutboundChannel() {

return new DirectChannel();

}

@Bean

@ServiceActivator(inputChannel = CHANNEL_NAME_OUT)

public MessageHandler MqttOutbound(){

MqttPahoMessageHandler messageHandler = new MqttPahoMessageHandler(clientId+"_Send",mqttClientFactory());

messageHandler.setAsync(true);

messageHandler.setDefaultTopic(defaultTopic);

return messageHandler;

}

//接收通道

@Bean(name = CHANNEL_NAME_IN)

public MessageChannel mqttInboundChannel() {

return new DirectChannel();

}

//配置client,监听的topic

@Bean

public MessageProducer inbound() {

MqttPahoMessageDrivenChannelAdapter adapter =

new MqttPahoMessageDrivenChannelAdapter(clientId + "_inbound",mqttClientFactory(),"hello","hello1");

adapter.setCompletionTimeout(5000);

adapter.setConverter(new DefaultPahoMessageConverter());

adapter.setQos(1);

adapter.setOutputChannel(mqttInboundChannel());

return adapter;

}

@Bean

@ServiceActivator(inputChannel = CHANNEL_NAME_IN)

public MessageHandler handler() {

return new MessageHandler() {

//消息消费

@Override

public void handleMessage(Message> message) throws MessagingException {

logger.error("===================={}============", message.getPayload());

}

};

}

}

4、消息发送接口

import com.mqtt.config.MqttConfig;

import org.springframework.integration.annotation.MessagingGateway;

import org.springframework.integration.mqtt.support.MqttHeaders;

import org.springframework.messaging.handler.annotation.Header;

import org.springframework.stereotype.Component;

@Component

@MessagingGateway(defaultRequestChannel = MqttConfig.CHANNEL_NAME_OUT)

public interface MqttGateway {

/**

* 发送信息到MQTT服务器

*

* @param data 发送的文本

*/

void sendToMqtt(String data);

/**

* 发送信息到MQTT服务器

*

* @param topic 主题

* @param payload 消息主体

*/

void sendToMqtt(@Header(MqttHeaders.TOPIC) String topic,

String payload);

/**

* 发送信息到MQTT服务器

*

* @param topic 主题

* @param qos 对消息处理的几种机制。
0 表示的是订阅者没收到消息不会再次发送，消息会丢失。

* 1 表示的是会尝试重试，一直到接收到消息，但这种情况可能导致订阅者收到多次重复消息。

* 2 多了一次去重的动作，确保订阅者收到的消息有一次。

* @param payload 消息主体

*/

void sendToMqtt(@Header(MqttHeaders.TOPIC) String topic,

@Header(MqttHeaders.QOS) int qos,

String payload);

}

5、启动类

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication

public class MytestApplication {

public static void main(String[] args) {

SpringApplication.run(MytestApplication.class, args);

}

}

6、测试发送消息

import com.mqtt.entity.MqttGateway;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.boot.test.context.SpringBootTest;

import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)

@SpringBootTest

public class DemoApplicationTests {

@Autowired

private MqttGateway mqttGateway;

@Test

public void contextLoads() {

mqttGateway.sendToMqtt("topic", "hello");

}

}

订阅主题后，运行程序，可以接收到发布的消息