SpringBoot整合ActiveMQ的详细步骤
pom文件引入activemq依赖
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
<!--activeMq配置--> < dependency > < groupId >org.springframework.boot</ groupId > < artifactId >spring-boot-starter-activemq</ artifactId > </ dependency > < dependency > < groupId >org.apache.activemq</ groupId > < artifactId >activemq-pool</ artifactId > < version >5.15.3</ version > </ dependency > < dependency > < groupId >org.projectlombok</ groupId > < artifactId >lombok</ artifactId > </ dependency > < dependency > < groupId >org.springframework.boot</ groupId > < artifactId >spring-boot-starter-web</ artifactId > </ dependency > < dependency > < groupId >com.alibaba</ groupId > < artifactId >fastjson</ artifactId > < version >2.0.7</ version > </ dependency > |
2. 配置文件
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
|
spring: activemq: user: admin password: admin broker-url: failover:(tcp: //192.168.43.666:61616) #是否信任所有包(如果传递的是对象则需要设置为 true ,默认是传字符串) packages: trust-all: true #连接池 pool: enabled: true max-connections: 5 idle-timeout: 30000 # expiry-timeout: 0 jms: #默认使用queue模式,使用topic则需要设置为 true pub-sub-domain: true # 是否信任所有包 #spring.activemq.packages.trust-all= # 要信任的特定包的逗号分隔列表(当不信任所有包时) #spring.activemq.packages.trusted= # 当连接请求和池满时是否阻塞。设置 false 会抛“JMSException异常”。 #spring.activemq.pool.block- if -full= true # 如果池仍然满,则在抛出异常前阻塞时间。 #spring.activemq.pool.block- if -full-timeout=-1ms # 是否在启动时创建连接。可以在启动时用于加热池。 #spring.activemq.pool.create-connection-on-startup= true # 是否用Pooledconnectionfactory代替普通的ConnectionFactory。 #spring.activemq.pool.enabled= false # 连接过期超时。 #spring.activemq.pool.expiry-timeout=0ms # 连接空闲超时 #spring.activemq.pool.idle-timeout=30s # 连接池最大连接数 #spring.activemq.pool.max-connections= 1 # 每个连接的有效会话的最大数目。 #spring.activemq.pool.maximum-active-session-per-connection= 500 # 当有 "JMSException" 时尝试重新连接 #spring.activemq.pool.reconnect-on-exception= true # 在空闲连接清除线程之间运行的时间。当为负数时,没有空闲连接驱逐线程运行。 #spring.activemq.pool.time-between-expiration-check=-1ms # 是否只使用一个MessageProducer #spring.activemq.pool.use-anonymous-producers= true |
3. 生产者
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
|
package com.gblfy.producer; import org.apache.activemq.ScheduledMessage; import org.apache.activemq.command.ActiveMQQueue; import org.apache.activemq.command.ActiveMQTopic; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.autoconfigure.jms.JmsProperties; import org.springframework.jms.core.JmsMessagingTemplate; import org.springframework.web.bind.annotation.PathVariable; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController; import javax.jms.*; import java.io.Serializable; /** * 发送消息 * * @author gblfy * @date 2022-11-02 */ @RestController @RequestMapping (value = "/active" ) public class SendController { //也可以注入JmsTemplate,JmsMessagingTemplate对JmsTemplate进行了封装 @Autowired private JmsMessagingTemplate jmsMessagingTemplate; /** * 发送消息接口 * 发送queue消息 :http://127.0.0.1:8080/active/send?msg=ceshi1234 * 发送topic 消息: http://127.0.0.1:8080/active/topic/send?msg=ceshi1234 * 发送queue消息(延迟time毫秒) :http://127.0.0.1:8080/active/send?msg=ceshi1234&time=5000 * * @param msg 消息 * @param type url中参数,非必须 * @param time * @return */ @RequestMapping ({ "/send" , "/{type}/send" }) public String send( @PathVariable (value = "type" , required = false ) String type, String msg, Long time) { Destination destination = null ; if (type == null ) { type = "" ; } switch (type) { case "topic" : //发送广播消息 destination = new ActiveMQTopic( "active.topic" ); break ; default : //发送 队列消息 destination = new ActiveMQQueue( "active.queue" ); break ; } // System.out.println("开始请求发送:"+DateUtil.getStringDate(new Date(),"yyyy-MM-dd HH:mm:ss")); if (time != null && time > 0 ) { //延迟队列,延迟time毫秒 //延迟队列需要在 <broker>标签上增加属性 schedulerSupport="true" delaySend(destination, msg, time); } else { jmsMessagingTemplate.convertAndSend(destination, msg); //无序 //jmsMessagingTemplate.convertSendAndReceive();//有序 } return "activemq消息发送成功 队列消息:" + msg; } /** * 延时发送 * 说明:延迟队列需要在 <broker>标签上增加属性 schedulerSupport="true" * * @param destination 发送的队列 * @param data 发送的消息 * @param time 延迟时间 /毫秒 */ public <T extends Serializable> void delaySend(Destination destination, T data, Long time) { Connection connection = null ; Session session = null ; MessageProducer producer = null ; // 获取连接工厂 ConnectionFactory connectionFactory = jmsMessagingTemplate.getConnectionFactory(); try { // 获取连接 connection = connectionFactory.createConnection(); connection.start(); // 获取session,true开启事务,false关闭事务 session = connection.createSession(Boolean.TRUE, Session.AUTO_ACKNOWLEDGE); // 创建一个消息队列 producer = session.createProducer(destination); producer.setDeliveryMode(JmsProperties.DeliveryMode.PERSISTENT.getValue()); ObjectMessage message = session.createObjectMessage(data); //设置延迟时间 message.setLongProperty(ScheduledMessage.AMQ_SCHEDULED_DELAY, time); // 发送消息 producer.send(message); session.commit(); } catch (Exception e) { e.printStackTrace(); } finally { try { if (producer != null ) { producer.close(); } if (session != null ) { session.close(); } if (connection != null ) { connection.close(); } } catch (Exception e) { e.printStackTrace(); } } } } |
4. 配置config
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
|
package com.gblfy.config; 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.annotation.EnableJms; import org.springframework.jms.config.DefaultJmsListenerContainerFactory; import org.springframework.jms.config.JmsListenerContainerFactory; import javax.jms.Queue; import javax.jms.Topic; /** * 描述: * activemq 有两种模式 queue 和 topic * queue 模式是单对单,有多个消费者的情况下则是使用轮询监听 * topic 模式/广播模式/发布订阅模式 是一对多,发送消息所有的消费者都能够监听到 * * @author gblfy * @date 2022-11-02 */ @EnableJms @Configuration public class ActiveMQConfig { //队列名 private static final String queueName = "active.queue" ; //主题名 private static final String topicName = "active.topic" ; @Value ( "${spring.activemq.user:}" ) private String username; @Value ( "${spring.activemq.password:}" ) private String password; @Value ( "${spring.activemq.broker-url:}" ) private String brokerUrl; @Bean public Queue acQueue() { return new ActiveMQQueue(queueName); } @Bean public Topic acTopic() { return new ActiveMQTopic(topicName); } @Bean public ActiveMQConnectionFactory connectionFactory() { return new ActiveMQConnectionFactory(username, password, brokerUrl); } @Bean public JmsListenerContainerFactory<?> jmsListenerContainerQueue(ActiveMQConnectionFactory connectionFactory) { DefaultJmsListenerContainerFactory bean = new DefaultJmsListenerContainerFactory(); // 关闭Session事务,手动确认与事务冲突 bean.setSessionTransacted( false ); // 设置消息的签收模式(自己签收) /** * AUTO_ACKNOWLEDGE = 1 :自动确认 * CLIENT_ACKNOWLEDGE = 2:客户端手动确认 * DUPS_OK_ACKNOWLEDGE = 3: 自动批量确认 * SESSION_TRANSACTED = 0:事务提交并确认 * 但是在activemq补充了一个自定义的ACK模式: * INDIVIDUAL_ACKNOWLEDGE = 4:单条消息确认 **/ bean.setSessionAcknowledgeMode( 4 ); //此处设置消息重发规则,redeliveryPolicy() 中定义 connectionFactory.setRedeliveryPolicy(redeliveryPolicy()); bean.setConnectionFactory(connectionFactory); return bean; } @Bean public JmsListenerContainerFactory<?> jmsListenerContainerTopic(ActiveMQConnectionFactory connectionFactory) { DefaultJmsListenerContainerFactory bean = new DefaultJmsListenerContainerFactory(); // 关闭Session事务,手动确认与事务冲突 bean.setSessionTransacted( false ); bean.setSessionAcknowledgeMode( 4 ); //设置为发布订阅方式, 默认情况下使用的生产消费者方式 bean.setPubSubDomain( true ); bean.setConnectionFactory(connectionFactory); return bean; } /** * 消息的重发规则配置 */ @Bean public RedeliveryPolicy redeliveryPolicy() { RedeliveryPolicy redeliveryPolicy = new RedeliveryPolicy(); // 是否在每次尝试重新发送失败后,增长这个等待时间 redeliveryPolicy.setUseExponentialBackOff( true ); // 重发次数五次, 总共六次 redeliveryPolicy.setMaximumRedeliveries( 5 ); // 重发时间间隔,默认为1000ms(1秒) redeliveryPolicy.setInitialRedeliveryDelay( 1000 ); // 重发时长递增的时间倍数2 redeliveryPolicy.setBackOffMultiplier( 2 ); // 是否避免消息碰撞 redeliveryPolicy.setUseCollisionAvoidance( false ); // 设置重发最大拖延时间-1表示无延迟限制 redeliveryPolicy.setMaximumRedeliveryDelay(- 1 ); return redeliveryPolicy; } } |
5. queue消费者
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
|
package com.gblfy.listener; import org.apache.activemq.command.ActiveMQMessage; import org.springframework.jms.annotation.JmsListener; import org.springframework.stereotype.Component; import javax.jms.JMSException; import javax.jms.Session; /** * TODO * * @author gblfy * @Date 2022-11-02 **/ @Component public class QueueListener { /** * queue 模式 单对单,两个消费者监听同一个队列则通过轮询接收消息 * containerFactory属性的值关联config类中的声明 * * @param msg */ @JmsListener (destination = "active.queue" , containerFactory = "jmsListenerContainerQueue" ) public void queueListener(ActiveMQMessage message, Session session, String msg) throws JMSException { try { System.out.println( "active queue 接收到消息 " + msg); //手动签收 message.acknowledge(); } catch (Exception e) { //重新发送 session.recover(); } } } |
6. topic消费者
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
|
package com.gblfy.listener; import org.apache.activemq.command.ActiveMQMessage; import org.springframework.jms.annotation.JmsListener; import org.springframework.stereotype.Component; import javax.jms.JMSException; import javax.jms.Session; /** * TODO * * @author gblfy * @Date 2022-11-02 **/ @Component public class TopicListener { /** * topic 模式/广播模式/发布订阅模式 一对多,多个消费者可同时接收到消息 * topic 模式无死信队列,死信队列是queue模式 * containerFactory属性的值关联config类中的声明 * * @param msg */ @JmsListener (destination = "active.topic" , containerFactory = "jmsListenerContainerTopic" ) public void topicListener(ActiveMQMessage message, Session session, String msg) throws JMSException { try { // System.out.println("接收到消息:" + DateUtil.getStringDate(new Date(), "yyyy-MM-dd HH:mm:ss")); System.out.println( "active topic 接收到消息 " + msg); System.out.println( "" ); //手动签收 message.acknowledge(); } catch (Exception e) { //重新发送 session.recover(); } } @JmsListener (destination = "active.topic" , containerFactory = "jmsListenerContainerTopic" ) public void topicListener2(ActiveMQMessage message, Session session, String msg) throws JMSException { try { // System.out.println("接收到消息:" + DateUtil.getStringDate(new Date(), "yyyy-MM-dd HH:mm:ss")); System.out.println( "active topic2 接收到消息 " + msg); System.out.println( "" ); //手动签收 message.acknowledge(); } catch (Exception e) { //重新发送 session.recover(); } } } |
6. ActiveMQ 消息存储规则
QUEUE 点对点:
特点:消息遵循先到先得,消息只能被一个消费者消费。
消息存储规则:消费者消费消息成功,MQ服务端消息删除
TOPIC订阅模式: 消息属于广播(订阅)模式,消息会被所有的topic消费者消费消息。
消息存储规则:所有消费者消费成功,MQ服务端消息删除,有一个消息没有没有消费完成,消息也会存储在MQ服务端。
举例:
已经处于运行topic消费者5个,5个消费者消费完成后,MQ服务端消息删除。
扩展点补充:如果想额外添加topic消费者,如果MQ服务端消息没有被消费完毕,新增topic消费者可以消费以前未被消费的消息,
正常新增的只会消费新的topic消息。