springBoot 集成 activemq

一、添加 maven 依赖

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

二、修改配置文件

        在 application.properties 配置 activemq 相关配置信息

# activemq config
spring.activemq.user=admin
spring.activemq.password=admin
spring.activemq.broker-url=tcp://127.0.0.1:61616
spring.activemq.pool.enabled=true
spring.activemq.pool.max-connections=10
queueName1=publish1.queue
queueName2=publish2.queue
topicName1=publish1.topic
topicName2=publish2.topic

三、编写 activemq 配置类

@Configuration
public class ActiveMQConfig {

    @Value("${queueName1}")
    private String queueName1;

    @Value("${topicName1}")
    private String topicName1;
    
    @Value("${queueName2}")
    private String queueName2;

    @Value("${topicName2}")
    private String topicName2;

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

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

    @Value("${spring.activemq.broker-url}")
    private  String brokerUrl;
    
    //@Bean会创建一个类型为Queue，对象名为queue1的对象
    @Bean
    public Queue queue1(){
        return new ActiveMQQueue(queueName1);
    }
    @Bean
    public Queue queue2(){
        return new ActiveMQQueue(queueName2);
    }
    @Bean
    public Topic topic1(){
        return new ActiveMQTopic(topicName1);
    }
    @Bean
    public Topic topic2(){
        return new ActiveMQTopic(topicName2);
    }
    
    @Bean
    public ActiveMQConnectionFactory connectionFactory() {
        return new ActiveMQConnectionFactory(usrName, password, brokerUrl);
    }
    
    @Bean
    public JmsListenerContainerFactory<?> jmsListenerContainerQueue(ActiveMQConnectionFactory connectionFactory){
        DefaultJmsListenerContainerFactory bean = new DefaultJmsListenerContainerFactory();
        bean.setConnectionFactory(connectionFactory);
        return bean;
    }
    
    @Bean
    public JmsListenerContainerFactory<?> jmsListenerContainerTopic(ActiveMQConnectionFactory connectionFactory){
        DefaultJmsListenerContainerFactory bean = new DefaultJmsListenerContainerFactory();
        //设置为发布订阅方式, 默认情况下使用的生产消费者方式
        bean.setPubSubDomain(true);
        bean.setConnectionFactory(connectionFactory);
        return bean;
    }
    
}

四、编写消息生产者

@RestController
@RequestMapping("/publish")
public class PublishController {

    @Autowired//也可以使用JmsTemplate,JmsMessagingTemplate是对JmsTemplate进行了封装
    private JmsMessagingTemplate jms;

    @Autowired
    private Queue queue1;

    @Autowired
    private Topic topic1;
    
    @RequestMapping("/queue")
    public String queue(){
	    for (int i = 0; i < 10 ; i++){
	    	User u = new User();
	    	u.setId(i);
	    	u.setName("张"+i);
	    	u.setAge(i);
	    	u.setPassword("密码"+i);
	    	/*jms.convertAndSend第一个参数是目的地，第二个参数是发送的对象，核心方法就是
	    	 * 这个jms.convertAndSend*/
	        jms.convertAndSend(queue1, JSON.toJSON(u).toString());
	    }
        return "queue 发送成功";
    }
    @RequestMapping("/topic")
    public String topic(){
        for (int i = 0; i < 10 ; i++){
        	User u = new User();
	    	u.setId(i);
	    	u.setName("张"+i);
	    	u.setAge(i);
	    	u.setPassword("密码"+i);
            jms.convertAndSend(topic1, JSON.toJSON(u).toString());
        }

        return "topic 发送成功";
    }
    /*这是是测试转发的listener*/
    @JmsListener(destination = "out.queue")
    public void consumerMsg(String msg){
        System.out.println(msg+"....................");
    }
}

五、启动 activemq

       输入 http://localhost:8161/admin 进入管理界面

        启动工程，发现有一个消费者，准备消费队列 out.queue 里面的数据,这个是我们在上面配置的 @JmsListener(destination = "out.queue")

       输入网址创建一个主题和一个队列

       http://localhost:8080/publish/queue 创建队列publish1.queue，我们发现此时队列里有需要消费的数据，但是没有消费者订阅

       http://localhost:8080/publish/topic 创建主题 publish1.topic，我们发现此时队列里有需要消费的数据，但是没有消费者订阅

六、编写消息消费者

       代码结构如下所示，理论是生产者和消费者是不在同一工程里面的，这里只是模拟一下，别较真。

        编写 topicA 和 topicB 两个消费者

@Component
public class TopicAListener {
	
	//不配置containerFactory这个jms就监听不到topic的消息
	@JmsListener(destination = "publish1.topic", containerFactory = "jmsListenerContainerTopic")
    public void receive(String text){
		User user = JSON.parseObject(text,User.class);
        System.out.println("TopicListener: consumer-A 收到一条信息: " + user.toString());
    }
}

@Component
public class TopicBListener {
	
	@JmsListener(destination = "publish1.topic", containerFactory = "jmsListenerContainerTopic")
    public void receive(String text){
		User user = JSON.parseObject(text,User.class);
        System.out.println("TopicListener: consumer-B 收到一条信息: " + user.toString());
    }
}

       当 publish1.topic 这个主题接收到消息时，它的订阅者 topicA 和 topicB 就会接到通知来这取数据，两份数据完全一致。

        编写 queueA 和 queueB 两个消费者

@Component
public class QueueAListener {
	
	/**
	 *@SendTo注解：会将接收到的消息发送到指定的路由目的地，
            所有订阅该消息的用户都能收到，属于广播(针对于下面的方法就是将return后面的字符串发送到路由目的地)
	*/
    @JmsListener(destination = "publish1.queue", containerFactory = "jmsListenerContainerQueue")
    @SendTo("out.queue")
    public String receive(String text){
		User user = JSON.parseObject(text,User.class);
        System.out.println("QueueListener: consumer-a 收到一条信息: " + user.toString());
        return "consumer-a received : " + user.toString();
    } 
}

@Component
public class QueueBListener {
	
    @JmsListener(destination = "publish1.queue", containerFactory = "jmsListenerContainerQueue")
    @SendTo("out.queue")
    public String receive(String text){
	User user = JSON.parseObject(text,User.class);
        System.out.println("QueueListener: consumer-b 收到一条信息: " + user.toString());
        return "consumer-b received : " + user.toString();
    }
}

       当 publish1.queue 这个主题接收到消息时，它的订阅者 queueA 和 queueB 就会来这取数据，但取得数据二者完全随机