Spring Boot集成ActiveMQ

Spring Boot集成ActiveMQ

本文主要说明，如何在Spring Boot中，使用JMS，集成ActiveMQ。

添加依赖

首先添加依赖：

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

添加配置

在Spring Boot的bootstrap.properties添加如下配置

spring.activemq.broker-url=tcp://127.0.0.1:61616
spring.activemq.user=admin
spring.activemq.password=admin
spring.activemq.in-memory=false
spring.activemq.pool.enabled=false
spring.activemq.pool.max-connections=5
spring.activemq.pool.idle-timeout=30000
spring.activemq.pool.expiry-timeout=0
spring.activemq.send-timeout=1000

上面配置的意思是：

1. spring.activemq.broker-url=tcp://127.0.0.1:61616:

   • 这是ActiveMQ消息代理（broker）的连接URL。它指定了连接到ActiveMQ服务的地址和端口。在这里，它连接到IP地址为本地127.0.0.1的ActiveMQ服务器的61616端口。可根据自己环境的情况修改。

2. spring.activemq.user=admin:

   • 这是连接到ActiveMQ代理所使用的用户名。在这个示例中，用户名是"admin"。根据自己环境的情况修改。

3. spring.activemq.password=admin:

   • 这是连接到ActiveMQ代理所使用的密码。在这个示例中，密码是"admin"。根据自己环境的情况修改。

4. spring.activemq.in-memory=false:

   • 这个属性指定是否使用内存模式，如果设置为false，则表示不使用内存模式，数据将持久化到磁盘。

5. spring.activemq.pool.enabled=true:

   • 这个属性控制是否启用连接池。如果设置为false，则不会使用连接池来管理JMS连接。如果设置为true，则会启用连接池。

6. spring.activemq.pool.max-connections=5:

   • 如果连接池已启用，这个属性指定连接池的最大连接数，表示可以同时建立的最大连接数。

7. spring.activemq.pool.idle-timeout=30000:

   • 如果连接池已启用，这个属性指定连接的最大空闲时间（以毫秒为单位）。如果连接在此时间内处于空闲状态，它将被关闭并从连接池中移除。

8. spring.activemq.pool.expiry-timeout=0:

   • 如果连接池已启用，这个属性指定连接的过期时间（以毫秒为单位）。如果设置为0，连接永不过期。

9. spring.activemq.send-timeout=1000:

   • 这个属性表示发送消息的超时时间，以毫秒为单位。如果发送消息时超过此时间，将会引发超时异常。

编写配置类

该配置类包括ActiveMQ的连接信息、队列信息等，如下：

import javax.jms.Queue;
import javax.jms.Topic;
import org.apache.activemq.ActiveMQConnectionFactory;
import org.apache.activemq.RedeliveryPolicy;
import org.apache.activemq.command.ActiveMQQueue;
import org.apache.activemq.command.ActiveMQTopic;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jms.config.DefaultJmsListenerContainerFactory;
import org.springframework.jms.core.JmsTemplate;

@Configuration
public class MQConfig {
	
	@Value("${spring.activemq.user}")
    private String usrName;

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

    @Value("${spring.activemq.broker-url}")
    private  String brokerUrl;
    
	/*
	 * 队列1
	 */
	@Bean
	public Queue queue() {
		return new ActiveMQQueue("test/queue1");
	}
	
	/*
	 * 队列2
	 */
	@Bean
	public Queue queueShellPublished() {
		return new ActiveMQQueue("test/queue2");
	}

	@Bean
	public Topic topicMonitorShellExecutedResult() {
		return new ActiveMQTopic("monitorShellExecutedResult");
	}

	@Bean
	public ActiveMQConnectionFactory activeMQConnectionFactory() {
		ActiveMQConnectionFactory activeMQConnectionFactory = new ActiveMQConnectionFactory(usrName, password,
				brokerUrl);
		activeMQConnectionFactory.setRedeliveryPolicy(redeliveryPolicy());
		return activeMQConnectionFactory;
	}

	@Bean
	public JmsTemplate jmsTemplate(ActiveMQConnectionFactory connectionFactory) {
		JmsTemplate jmsTemplate=new JmsTemplate();
        //进行持久化配置 1表示非持久化，2表示持久化
        jmsTemplate.setDeliveryMode(2);
        jmsTemplate.setConnectionFactory(connectionFactory); 
        //客户端签收模式
        jmsTemplate.setSessionAcknowledgeMode(4);
        return jmsTemplate;
	}
	
	//定义一个消息监听器连接工厂，这里定义的是点对点模式的监听器连接工厂
    @Bean(name = "jmsQueueListener")
    public DefaultJmsListenerContainerFactory jmsQueueListenerContainerFactory(ActiveMQConnectionFactory activeMQConnectionFactory) {
        DefaultJmsListenerContainerFactory factory =
                new DefaultJmsListenerContainerFactory();
        factory.setConnectionFactory(activeMQConnectionFactory);
        //设置连接数
        factory.setConcurrency("1-10");
        //重连间隔时间
        factory.setRecoveryInterval(1000L);
        factory.setSessionAcknowledgeMode(4);
        return factory;
    }

    @Bean
	public RedeliveryPolicy redeliveryPolicy() {
		RedeliveryPolicy redeliveryPolicy = new RedeliveryPolicy();
		// 是否在每次尝试重新发送失败后,增长这个等待时间
		redeliveryPolicy.setUseExponentialBackOff(true);
		// 重发次数,默认为6次 这里设置为10次
		redeliveryPolicy.setMaximumRedeliveries(6);
		// 重发时间间隔,默认为1秒
		redeliveryPolicy.setInitialRedeliveryDelay(1000);
		// 第一次失败后重新发送之前等待1000毫秒,第二次失败再等待1000 * 2毫秒,这里的2就是value
		redeliveryPolicy.setBackOffMultiplier(2);
		// 是否避免消息碰撞
		redeliveryPolicy.setUseCollisionAvoidance(false);
		// 设置重发最大拖延时间-1 表示没有拖延只有UseExponentialBackOff(true)为true时生效
		redeliveryPolicy.setMaximumRedeliveryDelay(-1);
		return redeliveryPolicy;
	}
}

向队列发送数据

使用上面的队列，向队列发送数据：

import org.springframework.jms.core.JmsTemplate;
import org.springframework.stereotype.Service;

@Service
public class JmsProducerService {
    @Autowired
	private JmsTemplate jmsTemplate;
    
    /**
     * 队列1。注意，此处queue的名称必须和上面配置类的队列1相同。否则要使用@Qualifier("queue")指定
     */
    @Autowired
	private Queue queue;

    public void sendMessage(String message) {
        jmsTemplate.convertAndSend(queue, message);
    }
}

创建消费者

创建消费者，消费队列1中的数据。

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

@Service
public class JmsConsumerService {

    @JmsListener(destination = "test/queue1",, containerFactory = "jmsQueueListener")
    public void receiveMessage(String message, Session session) {
        try{
            // 处理接收到的消息
        	System.out.println("Received message: " + message);
        	// 使用手动签收模式，需要手动的调用
        	text.acknowledge();
        }catch (Exception e) {
            session.recover();
        }
    }
}