使用springboot + activemq 接收硬件传输过来的json字符串

订阅activemq主题

public class MqttReceiveConfig {
    @Value("${spring.mqtt.username}")
    private String username;
 
    @Value("${spring.mqtt.password}")
    private String password;
 
    @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.completionTimeout}")
    private int completionTimeout ;   //连接超时
 
 
    @Bean
    public MqttConnectOptions getMqttConnectOptions(){
        MqttConnectOptions mqttConnectOptions=new MqttConnectOptions();
        mqttConnectOptions.setUserName(username);
        mqttConnectOptions.setPassword(password.toCharArray());
        mqttConnectOptions.setServerURIs(new String[]{hostUrl});
        mqttConnectOptions.setKeepAliveInterval(2);
        return mqttConnectOptions;
    }
    @Bean
    public MqttPahoClientFactory mqttClientFactory() {
        DefaultMqttPahoClientFactory factory = new DefaultMqttPahoClientFactory();
        factory.setConnectionOptions(getMqttConnectOptions());
        return factory;
    }
 
    //接收通道
    @Bean
    public MessageChannel mqttInputChannel() {
        return new DirectChannel();
    }
 
    //配置client,监听的topic 
    @Bean
    public MqttPahoMessageDrivenChannelAdapter inbound() {
        MqttPahoMessageDrivenChannelAdapter adapter =
                //new MqttPahoMessageDrivenChannelAdapter(clientId+"_inbound", mqttClientFactory(),
                new MqttPahoMessageDrivenChannelAdapter(MqttClient.generateClientId(), mqttClientFactory(),        
                        "uav_room_out","rack1");//rack,rack1是topics
        adapter.setCompletionTimeout(completionTimeout);
        adapter.setConverter(new DefaultPahoMessageConverter());
        adapter.setQos(1);
        adapter.setOutputChannel(mqttInputChannel());
        return adapter;
    }
spring.activemq.broker-url=tcp://
# \u5728\u8003\u8651\u7ED3\u675F\u4E4B\u524D\u7B49\u5F85\u7684\u65F6\u95F4
#spring.activemq.close-timeout=15s 
# \u9ED8\u8BA4\u4EE3\u7406URL\u662F\u5426\u5E94\u8BE5\u5728\u5185\u5B58\u4E2D\u3002\u5982\u679C\u6307\u5B9A\u4E86\u663E\u5F0F\u4EE3\u7406\uFF0C\u5219\u5FFD\u7565\u6B64\u503C\u3002
spring.activemq.in-memory=true
# \u662F\u5426\u5728\u56DE\u6EDA\u56DE\u6EDA\u6D88\u606F\u4E4B\u524D\u505C\u6B62\u6D88\u606F\u4F20\u9012\u3002\u8FD9\u610F\u5473\u7740\u5F53\u542F\u7528\u6B64\u547D\u4EE4\u65F6\uFF0C\u6D88\u606F\u987A\u5E8F\u4E0D\u4F1A\u88AB\u4FDD\u7559\u3002
spring.activemq.non-blocking-redelivery=false
# \u5BC6\u7801
spring.activemq.password=123456
# \u7B49\u5F85\u6D88\u606F\u53D1\u9001\u54CD\u5E94\u7684\u65F6\u95F4\u3002\u8BBE\u7F6E\u4E3A0\u7B49\u5F85\u6C38\u8FDC\u3002
spring.activemq.send-timeout=0
spring.activemq.user=haha

你得问题具体说一下

基于最新版ChatGPT4的回答，望采纳！！！有其他问题也可以询问我哦💕（最新版更智能，功能更加强大）:
首先需要在Spring Boot中引入ActiveMQ相关依赖。可以在pom.xml文件中添加以下代码：

xml

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-activemq</artifactId>
</dependency>

然后，在application.properties配置文件中添加ActiveMQ相关的配置信息：

spring.activemq.broker-url=tcp://localhost:61616
spring.activemq.user=admin
spring.activemq.password=admin
其中，broker-url表示ActiveMQ的地址，user和password表示连接ActiveMQ的用户名和密码。

接下来，创建一个消息处理类，用于接收和处理从ActiveMQ接收到的消息。代码如下：

java

@Component
public class MessageHandler {
 
    @JmsListener(destination = "test.topic")
    public void handleMessage(String message) {
        // 处理收到的消息
        System.out.println("Received message: " + message);
    }
 
}

其中，@JmsListener注解用于指定该方法订阅的ActiveMQ主题，并且将接收到的消息转发给该方法进行处理。

最后，创建一个测试类，通过调用ActiveMQ的JMS API进行消息发送。代码如下：

java

@RunWith(SpringRunner.class)
@SpringBootTest
public class ActiveMqTest {
 
    @Autowired
    private JmsTemplate jmsTemplate;
 
    @Test
    public void sendMessage() {
        String message = "{\"name\":\"张三\",\"age\":18}";
        jmsTemplate.convertAndSend("test.topic", message);
    }
 
}

其中，JmsTemplate是Spring Boot提供的一个方便发送消息的工具类，通过调用其convertAndSend方法即可向指定的ActiveMQ主题发送消息。

以上是使用Spring Boot和ActiveMQ实现订阅主题并接收传输过来的JSON字符串的方法，如果您有任何疑问或需要进一步帮助，请随时告诉我。

文章：springboot 整合activemq 消息发布和订阅中也许有你想要的答案，请看下吧

引用new bing作答：
您可以使用Spring Boot和ActiveMQ来实现订阅MQTT主题并接收传输的JSON字符串。以下是一个简单的示例代码：

1 首先，您需要添加以下依赖关系到您的Maven配置文件中：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-activemq</artifactId>
</dependency>

<dependency>
    <groupId>org.springframework.integration</groupId>
    <artifactId>spring-integration-mqtt</artifactId>
</dependency>

2 在您的应用程序中，创建一个MqttReceiveConfig类，使用@Configuration注释，并定义用于接收消息的MQTT配置。此类应该包括以下属性：

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

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

@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.completionTimeout}")
private int completionTimeout;

3 定义一个用于创建MqttConnectOptions对象的@Bean方法：

@Bean
public MqttConnectOptions getMqttConnectOptions(){
    MqttConnectOptions mqttConnectOptions=new MqttConnectOptions();
    mqttConnectOptions.setUserName(username);
    mqttConnectOptions.setPassword(password.toCharArray());
    mqttConnectOptions.setServerURIs(new String[]{hostUrl});
    mqttConnectOptions.setKeepAliveInterval(2);
    return mqttConnectOptions;
}

4 定义一个用于创建MqttPahoClientFactory对象的@Bean方法：

@Bean
public MqttPahoClientFactory mqttClientFactory() {
    DefaultMqttPahoClientFactory factory = new DefaultMqttPahoClientFactory();
    factory.setConnectionOptions(getMqttConnectOptions());
    return factory;
}

5 定义一个用于创建MessageChannel对象的@Bean方法，该对象将接收来自MQTT主题的消息：

@Bean
public MessageChannel mqttInputChannel() {
    return new DirectChannel();
}

6 最后，定义一个用于创建MqttPahoMessageDrivenChannelAdapter对象的@Bean方法，该对象将订阅MQTT主题，并将接收到的消息发送到mqttInputChannel：

@Bean
public MqttPahoMessageDrivenChannelAdapter inbound() {
    MqttPahoMessageDrivenChannelAdapter adapter =
            new MqttPahoMessageDrivenChannelAdapter(MqttClient.generateClientId(), mqttClientFactory(),
                    "topic_name");
    adapter.setCompletionTimeout(completionTimeout);
    adapter.setConverter(new DefaultPahoMessageConverter());
    adapter.setQos(1);
    adapter.setOutputChannel(mqttInputChannel());
    return adapter;
}

您需要替换上面的"topic_name"为您要订阅的实际主题名称。

现在，您可以在Spring Boot应用程序中使用@Autowired注解注入mqttInputChannel，并将其用作消息处理器。这将使您能够接收来自MQTT主题的消息，并执行所需的操作。

以下内容部分参考ChatGPT模型：

首先，你需要在你的spring boot项目中添加activemq的依赖项。可以使用以下maven依赖项：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-activemq</artifactId>
</dependency>

然后，在你的application.properties文件中添加activemq的配置项：

spring.activemq.broker-url=tcp://localhost:61616
spring.activemq.user=admin
spring.activemq.password=admin

接下来，你需要创建一个消息监听器来接收来自activemq的消息。你可以使用以下代码：

@Component
public class MyMessageListener {
 
    @JmsListener(destination = "my.destination")
    public void onMessage(String message) {
        // 处理接收到的消息
    }
}

在上面的代码中，@JmsListener注解表示这是一个消息监听器，destination属性指定监听的目的地，这里是“my.destination”。当有消息到达这个目的地时，onMessage方法将被调用，并传递消息作为参数。

最后，你需要在你的Spring Boot应用程序中配置一个ActiveMQ连接工厂。你可以使用以下代码：

@Configuration
public class ActiveMQConfig {
 
    @Bean
    public ConnectionFactory connectionFactory() {
        ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory();
        connectionFactory.setBrokerURL("tcp://localhost:61616");
        connectionFactory.setPassword("admin");
        connectionFactory.setUserName("admin");
        return connectionFactory;
    }
}

这将创建一个ActiveMQ连接工厂，它将使用你在application.properties文件中配置的连接信息。现在，当你启动你的Spring Boot应用程序时，它将创建一个与ActiveMQ代理的连接，并开始监听来自“my.destination”的消息。

如果我的建议对您有帮助、请点击采纳、祝您生活愉快

要使用Spring Boot和ActiveMQ接收硬件传输的JSON字符串，您可以按照以下步骤操作：

1.在您的Spring Boot应用程序中添加ActiveMQ依赖项，以便可以与ActiveMQ代理通信。您可以在Maven或Gradle构建文件中添加以下依赖项：

Maven：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-activemq</artifactId>
</dependency>

Gradle：
implementation 'org.springframework.boot:spring-boot-starter-activemq'

创建一个JMS消息监听器，以接收来自硬件设备的JSON字符串。您可以使用Spring的@JmsListener注释来创建一个方法，该方法将处理来自队列的消息。例如：

import org.springframework.jms.annotation.JmsListener;
import org.springframework.stereotype.Component;

@Component
public class MyMessageListener {

    @JmsListener(destination = "myQueue")
    public void receiveMessage(String message) {
        // 处理收到的JSON字符串
        System.out.println("Received message: " + message);
    }
}

配置ActiveMQ代理和队列以便将消息发送到您的应用程序。在application.properties或application.yml文件中，添加以下配置：
application.properties:

spring.activemq.broker-url=tcp://localhost:61616
spring.activemq.user=admin
spring.activemq.password=admin
spring.jms.listener.auto-startup=true

application.yml:


spring:
  activemq:
    broker-url: tcp://localhost:61616
    user: admin
    password: admin
  jms:
    listener:
      auto-startup: true
      concurrency: 1

在硬件设备上配置一个消息生产者，以将JSON字符串发送到您的ActiveMQ代理和队列。在这里，您可以使用任何支持JMS的编程语言和库。例如，在Java中，您可以使用ActiveMQ的JMS API：


import org.apache.activemq.ActiveMQConnectionFactory;
import javax.jms.*;

public class MyMessageProducer {

    public static void main(String[] args) throws JMSException {

        ConnectionFactory connectionFactory = new ActiveMQConnectionFactory("tcp://localhost:61616");
        Connection connection = connectionFactory.createConnection("admin", "admin");
        connection.start();

        Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
        Destination destination = session.createQueue("myQueue");

        String json = "{\"sensor\":\"temperature\",\"value\":25.5}";

        TextMessage message = session.createTextMessage(json);
        MessageProducer producer = session.createProducer(destination);
        producer.send(message);

        connection.close();
    }
}

这是一个使用ActiveMQ的JMS API创建消息生产者的简单示例。在这里，我们创建一个连接到ActiveMQ代理的连接，并使用创建的会话和目标发送JSON字符串消息。

总之，您可以使用Spring Boot和ActiveMQ轻松地创建一个接收来自硬件设备的JSON字符串的应用程序。

以下答案由GPT-3.5大模型与博主波罗歌共同编写：
首先需要在springboot项目中添加activemq的依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-activemq</artifactId>
</dependency>

然后配置activemq相关参数，在application.properties中添加以下内容：

spring.activemq.broker-url=tcp://localhost:61616
spring.activemq.user=admin
spring.activemq.password=admin

接下来就可以编写activemq的消费者代码。可以通过注入JmsTemplate对象来实现推拉模式来实现接收activemq传递的消息。

代码示例：

@Service
public class ActivemqConsumer {

    @Autowired
    private JmsTemplate jmsTemplate;

    @JmsListener(destination = "test.queue")
    public void receiveQueue(String message) {
        System.out.println("接收到的消息：" + message);
    }
}

在本示例中，使用了JmsListener注解来对应destination属性，从而监听activemq对应的队列。当activemq中有消息发送到该队列时，就会自动调用receiveQueue方法来进行消费消息的操作。

另外还可以使用activemq的订阅/发布模式来进行消息的传递。

代码示例：

@Service
public class ActivemqSubscriber {

    @Autowired
    private JmsTemplate jmsTemplate;

    @JmsListener(destination = "test.topic", containerFactory = "topicListenerContainerFactory")
    public void receiveTopic(String message) {
        System.out.println("接收到的消息：" + message);
    }
}

在本示例中，使用了JmsListener注解来对应destination属性，从而监听activemq对应的主题。当activemq中有消息发送到该主题时，就会自动调用receiveTopic方法来进行消费消息的操作。需要注意的是，使用订阅/发布模式时需要在配置文件中加上以下代码：

spring.jms.pub-sub-domain=true

这样才能开启订阅/发布模式。
如果我的回答解决了您的问题，请采纳！

引用chatGPT作答，似乎提供的代码正在配置消息驱动的通道适配器以接收 MQTT 消息并将它们传送到 Spring Integration 通道。但是，配置似乎是针对 MQTT 而不是 ActiveMQ。

要使用 Spring Boot 和 ActiveMQ 从 ActiveMQ 接收消息，您可以使用以下配置：

1.将以下依赖项添加到您的 pom.xml 文件中：

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-activemq</artifactId>
</dependency>
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-integration</artifactId>
</dependency>

2.将以下属性添加到您的 application.properties 文件中：

spring.activemq.broker-url=tcp://localhost:61616
spring.activemq.user=admin
spring.activemq.password=admin

3.创建一个将从 ActiveMQ 队列接收消息的消息接收器类：

import org.springframework.jms.annotation.JmsListener;
import org.springframework.stereotype.Component;

@Component
public class MessageReceiver {

    @JmsListener(destination = "myQueue")
    public void receiveMessage(String message) {
        System.out.println("Received message: " + message);
    }

}

4.@JmsListener 注释用于指示应该使用此方法从 myQueue 队列接收消息。

通过上述配置，任何发送到 ActiveMQ 上的 myQueue 队列的消息都将被 MessageReceiver 类接收并打印到控制台。

SpringBoot接收前端传来的json数据
可以借鉴下
https://blog.csdn.net/qq_41512902/article/details/126060344

1，服务端，订阅所有的主题，类似监听的功能，监听所有。
2，硬件端，发布硬件相关的主题，如deviceType/deviceId
3，硬件端发送消息到此主题，服务端就可以收到消息了

当使用Spring Boot和ActiveMQ接收硬件传输过来的Json字符串時，可以按照以下步骤进行：

1.在你的Spring Boot项目中添加ActiveMQ的依赖。你可以在你的build.gradle 或 pom.xml中加入以下代码：

Gradle:

implementation 'org.springframework.boot:spring-boot-starter-activemq'

Maven：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-activemq</artifactId>
</dependency>

2.创建一个Spring Bean，用于监听ActiveMQ队列中的消息并处理。你可以创建一个JavaClass，并使用注释@Component标记该类为Spring Bean。

@Component
public class MyMessageListener {
    
    @JmsListener(destination = "myQueue")
    public void processMessage(String message) {
        // 处理收到的消息
    }
}

3.在processMessage()方法中添加对收到的Json数据的解析和处理逻辑

@Component
public class MyMessageListener {
    
    @JmsListener(destination = "myQueue")
    public void processMessage(String message) {
        // 处理收到的消息
        ObjectMapper mapper = new ObjectMapper();
        try {
            MyModel myModel = mapper.readValue(message, MyModel.class);
            // 处理 MyModel 类型的数据
        } catch (JsonProcessingException e) {
            // json解析错误
            e.printStackTrace();
        }
    }
}

在这里，MyModel是你定义的一个Java对象，用来表示收到的Json数据。你可以使用像Jackson这样的Json解析库将收到的Json字符串转换为Java对象。

4.在application.properties文件中添加ActiveMQ连接参数，用于连接到ActiveMQ。

spring.activemq.broker-url=tcp://localhost:61616
spring.activemq.user=admin
spring.activemq.password=admin

5.最后，你可以使用使用ActiveMQ的JmsTemplate将消息从硬件传递到你的Spring Boot应用程序中，例如：

@Autowired
private JmsTemplate jmsTemplate;

public void sendMessage(MyModel myModel) throws JmsException {
    ObjectMapper mapper = new ObjectMapper();
    String jsonMessage = mapper.writeValueAsString(myModel);
    jmsTemplate.convertAndSend("myQueue", jsonMessage);
}

这里，你可以注入JmsTemplate对象，并使用convertAndSend()方法将Json转换为字符串并发送到ActiveMQ队列上。

以上就是使用Spring Boot和ActiveMQ接收硬件传输过来的Json字符串的基本步骤，希望对你有所帮助。