springboot整合rabbitmq

rabbitmq简介

路由模式：
	交换机：1个交换机接受生产者数据
	队列：多个队列提供消息给多个消费者
	路由key：交换机和队列的绑定key

POM添加rabbitmq

<!--rabbitmq-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

maven import导入包

交换机配置

新建ExchangeConfig.java文件，配置1个交换机

import org.springframework.amqp.core.DirectExchange;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @packageName：  
 * @description：
 * @author： xumiaofeng
 * @date： 2019/3/20 0020 17:36
 */
@Configuration
public class ExchangeConfig {

    /**
     * 消息交换机的名字
     */
    public static final String EXCHANGE = "exchangeTest";

    /**
     * 1.定义direct exchange，绑定queueTest
     * 2.durable="true" rabbitmq重启的时候不需要创建新的交换机
     * 3.direct交换器相对来说比较简单，匹配规则为：如果路由键匹配，消息就被投送到相关的队列
     * fanout交换器中没有路由键的概念，他会把消息发送到所有绑定在此交换器上面的队列中。
     * topic交换器你采用模糊匹配路由键的原则进行转发消息到队列中
     * key: queue在该direct-exchange中的key值，当消息发送给direct-exchange中指定key为设置值时，
     * 消息将会转发给queue参数指定的消息队列
     */
    @Bean
    public DirectExchange directExchange() {
        DirectExchange directExchange = new DirectExchange(EXCHANGE, true, false);
        return directExchange;
    }
}

队列配置

新建QueueConfig.java 文件，配置2个队列

import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @packageName： 
 * @description：
 * @author： xumiaofeng
 * @date： 2019/3/20 0020 17:35
 */
@Configuration
public class QueueConfig {

    @Bean
    public Queue firstQueue() {
        /**
         durable="true" 持久化 rabbitmq重启的时候不需要创建新的队列
         auto-delete 表示消息队列没有在使用时将被自动删除 默认是false
         exclusive  表示该消息队列是否只在当前connection生效,默认是false
         */
        return new Queue("first-queue", true, false, false);
    }

    @Bean
    public Queue secondQueue() {
        return new Queue("second-queue", true, false, false);
    }
}

RabbitConfig配置

新建RabbitConfig配置文件，交换机和队列之间，绑定key

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.core.RabbitAdmin;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @packageName：
 * @description：
 * @author： xumiaofeng
 * @date： 2019/3/20 0020 16:34
 */

/**
 * Broker:它提供一种传输服务,它的角色就是维护一条从生产者到消费者的路线，保证数据能按照指定的方式进行传输,
 * Exchange：消息交换机,它指定消息按什么规则,路由到哪个队列。
 * Queue:消息的载体,每个消息都会被投到一个或多个队列。
 * Binding:绑定，它的作用就是把exchange和queue按照路由规则绑定起来.
 * Routing Key:路由关键字,exchange根据这个关键字进行消息投递。
 * vhost:虚拟主机,一个broker里可以有多个vhost，用作不同用户的权限分离。
 * Producer:消息生产者,就是投递消息的程序.
 * Consumer:消息消费者,就是接受消息的程序.
 * Channel:消息通道,在客户端的每个连接里,可建立多个channel.
 */

@Configuration
public class RabbitConfig {


    /**
     * 队列key1
     */
    public static final String ROUTINGKEY1 = "queue_one_key1";
    /**
     * 队列key2
     */
    public static final String ROUTINGKEY2 = "queue_one_key2";

    @Autowired
    private QueueConfig queueConfig;
    @Autowired
    private ExchangeConfig exchangeConfig;

    /**
     * 连接工厂
     */
    @Autowired
    private ConnectionFactory connectionFactory;

    /**
     * 将消息队列1和交换机进行绑定
     */
    @Bean
    public Binding binding_one() {
        return BindingBuilder.bind(queueConfig.firstQueue()).to(exchangeConfig.directExchange()).with(RabbitConfig.ROUTINGKEY1);
    }

	 /**
     * 将消息队列2和交换机1进行绑定
     */
    @Bean
    public Binding binding_one_two() {
        return BindingBuilder.bind(queueConfig.firstQueue()).to(exchangeConfig.directExchange()).with(RabbitConfig.ROUTINGKEY2);
    }

    /**
     * 将消息队列2和交换机2进行绑定
     */
    @Bean
    public Binding binding_two() {
        return BindingBuilder.bind(queueConfig.secondQueue()).to(exchangeConfig.directExchange()).with(RabbitConfig.ROUTINGKEY2);
    }

    /**
     * 定义rabbit template用于数据的接收和发送
     *
     * @return
     */
    @Bean
    public RabbitTemplate rabbitTemplate() {
        RabbitTemplate template = new RabbitTemplate(connectionFactory);
        return template;
    }

    /**
     * 定义rabbitAdmin用于动态新建交换机和队列
     *
     * @return
     */
    @Bean
    RabbitAdmin rabbitAdmin(ConnectionFactory connectionFactory) {
        return new RabbitAdmin(connectionFactory);
    }
}

消息生产者

import com.ruoyi.framework.config.rabbitmq.ExchangeConfig;
import com.ruoyi.framework.config.rabbitmq.RabbitConfig;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.DirectExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitAdmin;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * @packageName： 
 * @description：
 * @author： xumiaofeng
 * @date： 2019/3/20 0020 17:02
 */

@Component
public class MsgProducer {

    private final Logger logger = LoggerFactory.getLogger(this.getClass());

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Autowired
    private RabbitAdmin rabbitAdmin;

    /**
     * 发送消息
     *
     * @param uuid
     * @param message 消息
     */
    public void send(String uuid, Object message) {
        CorrelationData correlationId = new CorrelationData(uuid);
        rabbitTemplate.convertAndSend(ExchangeConfig.EXCHANGE, RabbitConfig.ROUTINGKEY2,
                message, correlationId);
    }

    /**
     * 发送消息
     *
     * @param uuid
     * @param message 消息
     */
    public void sendAdmin(String uuid, Object message) {

        DirectExchange directExchange = new DirectExchange(ExchangeConfig.EXCHANGE, true, false);
        rabbitAdmin.declareExchange(directExchange);

        Queue queue = new Queue("testQueue", true, false, false);
        rabbitAdmin.declareQueue(queue);

        Binding binding = BindingBuilder.bind(queue).to(directExchange).with("testKey");
        rabbitAdmin.declareBinding(binding);

        CorrelationData correlationId = new CorrelationData(uuid);
        rabbitTemplate.convertAndSend(ExchangeConfig.EXCHANGE, "testKey", message, correlationId);

        String testQueue = (String) rabbitTemplate.receiveAndConvert("testQueue");
        System.out.println(testQueue);

    }

}

消息消费者

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

/**
 * @packageName：
 * @description：
 * @author： xumiaofeng
 * @date： 2019/3/20 0020 17:04
 */
@Component
public class MsgReceiver {

    private final Logger logger = LoggerFactory.getLogger(this.getClass());

    @RabbitListener(queues = {"first-queue"}, containerFactory = "rabbitListenerContainerFactory")
    public void handleMessage(String message) throws Exception {
        // 处理消息
        System.out.println("FirstConsumer {} handleMessage :" + message);
    }

    @RabbitListener(queues = {"second-queue"}, containerFactory = "rabbitListenerContainerFactory")
    public void handleMessage2(String message) throws Exception {
        // 处理消息
        System.out.println("SecondConsumer {} handleMessage :" + message);
    }
}

controller测试

import com.ruoyi.framework.rabbitmq.MsgProducer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.UUID;

/**
 * @packageName： 
 * @description：
 * @author： xumiaofeng
 * @date： 2019/3/20 0020 17:43
 */

@RestController
public class SendController {

    @Autowired
    private MsgProducer firstSender;

    @GetMapping("/send")
    public String send(String message) {
        String uuid = UUID.randomUUID().toString();
//        firstSender.send(uuid, message);
        firstSender.sendAdmin(uuid, message);
        return uuid;
    }
}