Springboot ActiveMQ 集成

ActiveMQ 的安装就不在本篇记录
代码下载地址：https://download.csdn.net/download/jc0803kevin/11464897
maven依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.6.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.kevin.mq</groupId>
    <artifactId>activemqdemo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>activemqdemo</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <!--    springboot 项目入口依赖    -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

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

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

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


        <!--热部署-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
        </dependency>


    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

项目结构：

application.properties配置文件

#服务端口，8080被另一服务占用
server.port=9090
#spring.activemq.broker-url=tcp://127.0.0.1:61616
# 在考虑结束之前等待的时间
#spring.activemq.close-timeout=15s
# 默认代理URL是否应该在内存中。如果指定了显式代理，则忽略此值。
#spring.activemq.in-memory=true
# 是否在回滚回滚消息之前停止消息传递。这意味着当启用此命令时，消息顺序不会被保留。
#spring.activemq.non-blocking-redelivery=false
# 等待消息发送响应的时间。设置为0等待永远。
#spring.activemq.send-timeout=0
#默认情况下activemq提供的是queue模式，若要使用topic模式需要配置下面配置
spring.jms.pub-sub-domain=true
#账号
spring.activemq.user=admin
# 密码
#spring.activemq.password=admin
# 是否信任所有包
#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

项目代码：

生产者：

package com.kevin.mq.activemqdemo.producer;

//import org.apache.activemq.broker.region.Queue;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jms.core.JmsMessagingTemplate;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.jms.Queue;
import javax.jms.Topic;
import java.util.UUID;

@RestController
public class ProducerController{

    @Autowired
    private JmsMessagingTemplate jmsMessagingTemplate;


    @Autowired
    private Queue kevin;

    @Autowired
    private Queue coco;

    @Autowired
    private Topic alibaba;



    @RequestMapping("/send")
      public String sendmsg(String msg){
        msg = msg + "->" + UUID.randomUUID();
        System.out.println("msg-->" + msg );
        return msg;
      }


    @RequestMapping("/kevin")
    public String kevin(String msg){
        msg = msg + "->" + UUID.randomUUID();
         System.out.println("kevin send msg-->" + msg);
         jmsMessagingTemplate.convertAndSend(this.kevin, msg);
        return msg;
     }

    @RequestMapping("/coco")
    public String coco(String msg){
        msg = msg + "->" + UUID.randomUUID();
         System.out.println("coco send msg-->" + msg);
         jmsMessagingTemplate.convertAndSend(this.coco, msg);
        return msg;
     }


    @RequestMapping("/alibaba")
    public String alibaba(String msg){
        msg = msg + "->" + UUID.randomUUID();
         System.out.println("alibaba send msg-->" + msg);
         jmsMessagingTemplate.convertAndSend(this.alibaba, msg);
        return msg;
     }
}

消费者：

package com.kevin.mq.activemqdemo.comsumer;

import com.kevin.mq.activemqdemo.config.ActiveMQConfig;
import org.springframework.jms.annotation.JmsListener;
import org.springframework.stereotype.Component;

/**
 * @Author kevin
 * @Description 消费者
 * @Date Created on 2019/8/1 16:20
 */


@Component
public class ConsumerController {

    /**
     * 点对点模式
     * 生产者发送的消息，只能被一个消费者消费
     *
     *
     * */

    //消费者1
    @JmsListener(destination = ActiveMQConfig.KEVIN_QUEUE_NAME)
    //@JmsListener(destination = ActiveMQConfig.KEVIN_QUEUE_NAME, containerFactory = "jmsListenerContainerQueue")
    public void readActiveQueue(String message) {
        try{
            Thread.sleep(1000);
            //TODO something
        }catch (Exception e){
            e.printStackTrace();
        }

        System.out.println("readActiveQueue kevin  接受到：" + message);

    }
    //消费者2
    @JmsListener(destination = ActiveMQConfig.KEVIN_QUEUE_NAME)
    //@JmsListener(destination = ActiveMQConfig.KEVIN_QUEUE_NAME, containerFactory = "jmsListenerContainerQueue")
    public void readActiveQueue2(String message) {
        try{
            Thread.sleep(1000);
            //TODO something
        }catch (Exception e){
            e.printStackTrace();
        }

        System.err.println("readActiveQueue2 kevin  接受到：" + message );

    }

    //消费者3
    @JmsListener(destination = ActiveMQConfig.KEVIN_QUEUE_NAME)
    //@JmsListener(destination = ActiveMQConfig.KEVIN_QUEUE_NAME, containerFactory = "jmsListenerContainerQueue")
    public void readActiveQueue3(String message) {
        try{
            Thread.sleep(1000);
            //TODO something
        }catch (Exception e){
            e.printStackTrace();
        }

        System.err.println("readActiveQueue3 kevin  接受到：" + message);

    }


    @JmsListener(destination = ActiveMQConfig.COCO_QUEUE_NAME)
    //@JmsListener(destination = ActiveMQConfig.COCO_QUEUE_NAME, containerFactory = "jmsListenerContainerQueue")
    public void coco(String message) {
        try{
            Thread.sleep(2000);
            //TODO something
        }catch (Exception e){
            e.printStackTrace();
        }
        System.out.println("coco  接受到：" + message);

    }

    /**
     *  发布/订阅模式
     *  生产者发送的消息 可以被多个消费者消费
     *
     *
     * **/

    @JmsListener(destination = ActiveMQConfig.ALIBABA_TOPIC_NAME)
    //@JmsListener(destination = ActiveMQConfig.ALIBABA_TOPIC_NAME, containerFactory = "jmsListenerContainerTopic")
    public void alibaba(String message) {
        try{
            Thread.sleep(1500);
            //TODO something
        }catch (Exception e){
            e.printStackTrace();
        }
        System.out.println("alibaba  接受到：" + message );

    }


    @JmsListener(destination = ActiveMQConfig.ALIBABA_TOPIC_NAME)
    //@JmsListener(destination = ActiveMQConfig.ALIBABA_TOPIC_NAME, containerFactory = "jmsListenerContainerTopic")
    public void alibaba2(String message) {
        try{
            Thread.sleep(1500);
            //TODO something
        }catch (Exception e){
            e.printStackTrace();
        }
        System.err.println("alibaba2  接受到：" + message );

    }


    @JmsListener(destination = ActiveMQConfig.ALIBABA_TOPIC_NAME)
    //@JmsListener(destination = ActiveMQConfig.ALIBABA_TOPIC_NAME, containerFactory = "jmsListenerContainerTopic")
    public void alibaba3(String message) {
        try{
            Thread.sleep(1500);
            //TODO something
        }catch (Exception e){
            e.printStackTrace();
        }
        System.err.println("alibaba3  接受到：" + message);

    }

}

消息队列配置

package com.kevin.mq.activemqdemo.config;

import org.apache.activemq.ActiveMQConnectionFactory;
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.jms.config.DefaultJmsListenerContainerFactory;
import org.springframework.jms.config.JmsListenerContainerFactory;
import org.springframework.jms.core.JmsMessagingTemplate;
import org.springframework.stereotype.Component;

import javax.jms.Queue;
import javax.jms.Topic;

/**
 * @Author kevin
 * @Description 消息队列配置
 * @Date Created on 2019/8/1 16:45
 */
@Component
public class ActiveMQConfig {

    public static final String KEVIN_QUEUE_NAME = "activemq.queue.kevin";
    public static final String COCO_QUEUE_NAME = "activemq.queue.coco";
    public static final String ALIBABA_TOPIC_NAME = "activemq.topic.alibaba";
    public static final String BAIDU_TOPIC_NAME = "activemq.topic.baidu";



    /**
     * @Author kevin
     * @Description 声明一个队列 名称为activemq.queue.kevin 点对点模型
     * @Date Created on 2019/8/1 17:49
     * @param
     * @return
     */
    @Bean
    public Queue kevin(){
        return new ActiveMQQueue(ActiveMQConfig.KEVIN_QUEUE_NAME);
    }

    /**
     * @Author kevin
     * @Description 声明一个队列 名称为activemq.queue.coco 点对点模型
     * @Date Created on 2019/8/1 17:49
     * @param
     * @return
     */
    @Bean
    public Queue coco(){
        return new ActiveMQQueue(ActiveMQConfig.COCO_QUEUE_NAME);
    }


    /**
     * @Author kevin
     * @Description 声明一个主题 发布/订阅模式
     * @Date Created on 2019/8/2 10:03
     * @param
     * @return
     */
    @Bean
    public Topic alibaba(){
        return new ActiveMQTopic(ActiveMQConfig.ALIBABA_TOPIC_NAME);
    }

//    @Bean
//    public ActiveMQConnectionFactory connectionFactory() {
//        return new ActiveMQConnectionFactory("admin", "admin", "tcp://localhost:61616");
//    }
//
//    @Bean
//    public JmsListenerContainerFactory<?> jmsListenerContainerTopic(ActiveMQConnectionFactory connectionFactory) {
//        DefaultJmsListenerContainerFactory bean = new DefaultJmsListenerContainerFactory();
//        bean.setPubSubDomain(true);//默认为false queue模式
//        bean.setConnectionFactory(connectionFactory);
//        return bean;
//    }
//
//    @Bean
//    public JmsListenerContainerFactory<?> jmsListenerContainerQueue(ActiveMQConnectionFactory connectionFactory) {
//        DefaultJmsListenerContainerFactory bean = new DefaultJmsListenerContainerFactory();
//        bean.setConnectionFactory(connectionFactory);
//        return bean;
//    }
//
//    @Bean
//    public JmsMessagingTemplate jmsMessagingTemplate(ActiveMQConnectionFactory connectionFactory){
//        return new JmsMessagingTemplate(connectionFactory);
//    }
}

启动类：

package com.kevin.mq.activemqdemo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class ActivemqdemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(ActivemqdemoApplication.class, args);
    }

}