SpringBoot中使用RabbitMQ

已于 2022-01-23 20:10:03 修改
阅读量1.5k 收藏 8
点赞数
分类专栏： RabbitMQ 文章标签： rabbitmq spring boot java
于 2020-10-14 14:38:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_21040559/article/details/109072693
版权

整合

添加RabbitMQ依赖

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

配置application.yml

spring:
  rabbitmq:
    host: 127.0.0.1
    port: 5672
    username: test
    password: 123456
#    virtual-host: /

新建RabbitConfig


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


/**
 * 类功能描述：<br>
 * Broker:它提供一种传输服务,它的角色就是维护一条从生产者到消费者的路线，保证数据能按照指定的方式进行传输,
 * Exchange：消息交换机,它指定消息按什么规则,路由到哪个队列。
 * Queue:消息的载体,每个消息都会被投到一个或多个队列。
 * Binding:绑定，它的作用就是把exchange和queue按照路由规则绑定起来.
 * Routing Key:路由关键字,exchange根据这个关键字进行消息投递。
 * vhost:虚拟主机,一个broker里可以有多个vhost，用作不同用户的权限分离。
 * Producer:消息生产者,就是投递消息的程序.
 * Consumer:消息消费者,就是接受消息的程序.
 * Channel:消息通道,在客户端的每个连接里,可建立多个channel.
 * <ul>
 * <li>类功能描述1<br>
 * <li>类功能描述2<br>
 * <li>类功能描述3<br>
 * </ul>
 * 修改记录：<br>
 * <ul>
 * <li>修改记录描述1<br>
 * <li>修改记录描述2<br>
 * <li>修改记录描述3<br>
 * </ul>
 */
@Configuration
public class RabbitConfig {
    //扇形交换器类型
    public static final String FANOUT_TYPE = "FANOUT";
    //扇形交换器测试队列
    public static final String FANOUT_QUEUE_NAME = "test_fanout_queue";
    public static final String FANOUT_QUEUE_NAME1 = "test_fanout_queue1";
    //扇形交换器
    public static final String TEST_FANOUT_EXCHANGE = "testFanoutExchange";

    //直接交换器类型
    public static final String DIRECT_TYPE = "DIRECT";
    //直接交换器测试队列
    public static final String DIRECT_QUEUE_NAME = "test_direct_queue";
    //直接交换器
    public static final String TEST_DIRECT_EXCHANGE = "testDirectExchange";
    //直接交换器ROUTINGKEY
    public static final String DIRECT_ROUTINGKEY = "test";

    //主题交换器类型
    public static final String TOPIC_TYPE = "TOPIC";
    //主题交换器队列
    public static final String TOPIC_QUEUE_NAME = "test_topic_queue";
    public static final String TOPIC_QUEUE_NAME1 = "test_topic_queue1";
    //主题交换器
    public static final String TEST_TOPIC_EXCHANGE = "testTopicExchange";
    //主题交换器ROUTINGKEY
    public static final String TOPIC_ROUTINGKEY = "test.#";

    //创建扇形交换器测试队列
    @Bean
    public Queue createFanoutQueue() {
        return new Queue(FANOUT_QUEUE_NAME);
    }

    //创建扇形交换器测试队列1
    @Bean
    public Queue createFanoutQueue1() {
        return new Queue(FANOUT_QUEUE_NAME1);
    }

    //创建直接交换器测试队列
    @Bean
    public Queue createDirectQueue() {
        return new Queue(DIRECT_QUEUE_NAME);
    }

    //创建主题交换器测试队列
    @Bean
    public Queue createTopicQueue() {
        return new Queue(TOPIC_QUEUE_NAME);
    }

    //创建主题交换器测试队列1
    @Bean
    public Queue createTopicQueue1() {
        return new Queue(TOPIC_QUEUE_NAME1);
    }

    //创建扇形交换器
    @Bean
    public FanoutExchange defFanoutExchange() {
        return new FanoutExchange(TEST_FANOUT_EXCHANGE);
    }

    //扇形交换器和扇形队列绑定
    @Bean
    Binding bindingFanout() {
        return BindingBuilder.bind(createFanoutQueue()).
                to(defFanoutExchange());
    }

    //扇形交换器和扇形队列绑定
    @Bean
    Binding bindingFanout1() {
        return BindingBuilder.bind(createFanoutQueue1()).
                to(defFanoutExchange());
    }

    //创建直接交换器
    @Bean
    DirectExchange directExchange() {
        return new DirectExchange(TEST_DIRECT_EXCHANGE);
    }

    //直接交换器和直接队列绑定
    @Bean
    Binding bindingDirect() {
        return BindingBuilder.bind(createDirectQueue()).
                to(directExchange()).
                with(DIRECT_ROUTINGKEY);
    }

    //创建主题交换器
    @Bean
    TopicExchange defTopicExchange() {
        return new TopicExchange(TEST_TOPIC_EXCHANGE);
    }

    //主题交换器和主题队列绑定
    @Bean
    Binding bindingTopic() {
        return BindingBuilder.bind(createTopicQueue()).
                to(defTopicExchange()).
                with(TOPIC_ROUTINGKEY);
    }

    //主题交换器和主题队列绑定
    @Bean
    Binding bindingTopic1() {
        return BindingBuilder.bind(createTopicQueue1()).
                to(defTopicExchange()).
                with(TOPIC_ROUTINGKEY);
    }
}

新建生产者(producer)

import com.heima.rabbitmq.config.RabbitConfig;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;


@Component
public class MsgProducer {

    //使用RabbitTemplate进行操作
    @Autowired
    private RabbitTemplate rabbitTemplate;

    /**
     * 向扇形交换器发送数据
     *
     * @param routingKey
     * @param massage
     */
    public void send2FanoutTestQueue(String routingKey, String massage) {
        rabbitTemplate.convertAndSend(RabbitConfig.TEST_FANOUT_EXCHANGE,
                routingKey, massage);
    }

    /**
     * 向直接交换器发送数据
     *
     * @param routingKey
     * @param massage
     */
    public void send2DirectTestQueue(String routingKey, String massage) {
        rabbitTemplate.convertAndSend(RabbitConfig.TEST_DIRECT_EXCHANGE,
                routingKey, massage);
    }

    /**
     * 向主题交换器发送数据
     *
     * @param routingKey
     * @param massage
     */
    public void send2TopicTestAQueue(String routingKey, String massage) {
        rabbitTemplate.convertAndSend(RabbitConfig.TEST_TOPIC_EXCHANGE,
                routingKey, massage);
    }
    
}

新建消费者(consumer)

import com.heima.rabbitmq.config.RabbitConfig;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.*;
import org.springframework.stereotype.Component;

import java.nio.charset.StandardCharsets;

@Component
public class MsgConsumer {

    private static final Logger logger = LoggerFactory.getLogger(MsgConsumer.class);

    /**
     * 监听扇形测试队列数据
     * @param massage
     */
    @RabbitListener(
            bindings =
                    {
                            @QueueBinding(value = @Queue(value = RabbitConfig.FANOUT_QUEUE_NAME, durable = "true"),
                                    exchange = @Exchange(value = RabbitConfig.TEST_FANOUT_EXCHANGE, type = "fanout"))
                    })
    @RabbitHandler
    public void processFanoutMsg(Message massage) {
        String msg = new String(massage.getBody(), StandardCharsets.UTF_8);
        logger.info("接收到FANOUT消息 : " + msg);
    }

    /**
     * 监听扇形测试队列1数据
     * @param massage
     */
    @RabbitListener(
            bindings =
                    {
                            @QueueBinding(value = @Queue(value = RabbitConfig.FANOUT_QUEUE_NAME1, durable = "true"),
                                    exchange = @Exchange(value = RabbitConfig.TEST_FANOUT_EXCHANGE, type = "fanout"))
                    })
    @RabbitHandler
    public void processFanout1Msg(Message massage) {
        String msg = new String(massage.getBody(), StandardCharsets.UTF_8);
        logger.info("接收到FANOUT1消息 : " + msg);
    }

    /**
     * 监听直接测试队列数据
     * @param massage
     */
    @RabbitListener(
            bindings =
                    {
                            @QueueBinding(value = @Queue(value = RabbitConfig.DIRECT_QUEUE_NAME, durable = "true"),
                                    exchange = @Exchange(value = RabbitConfig.TEST_DIRECT_EXCHANGE),
                                    key = RabbitConfig.DIRECT_ROUTINGKEY)
                    })
    @RabbitHandler
    public void processDirectMsg(Message massage) {
        String msg = new String(massage.getBody(), StandardCharsets.UTF_8);
        logger.info("接收到DIRECT消息 : " + msg);
    }

    /**
     * 监听主题测试队列数据
     * @param massage
     */
    @RabbitListener(
            bindings =
                    {
                            @QueueBinding(value = @Queue(value = RabbitConfig.TOPIC_QUEUE_NAME, durable = "true"),
                                    exchange = @Exchange(value = RabbitConfig.TEST_TOPIC_EXCHANGE, type = "topic"),
                                    key = RabbitConfig.TOPIC_ROUTINGKEY)
                    })
    @RabbitHandler
    public void processTopicMsg(Message massage) {
        String msg = new String(massage.getBody(), StandardCharsets.UTF_8);
        logger.info("接收到TOPIC消息 : " + msg);
    }

    /**
     * 监听主题测试1队列数据
     * @param massage
     */
    @RabbitListener(
            bindings =
                    {
                            @QueueBinding(value = @Queue(value = RabbitConfig.TOPIC_QUEUE_NAME1, durable = "true"),
                                    exchange = @Exchange(value = RabbitConfig.TEST_TOPIC_EXCHANGE, type = "topic"),
                                    key = RabbitConfig.TOPIC_ROUTINGKEY)
                    })
    @RabbitHandler
    public void processTopic1Msg(Message massage) {
        String msg = new String(massage.getBody(), StandardCharsets.UTF_8);
        logger.info("接收到TOPIC1消息 : " + msg);
    }

}

编写controller测试

@RestController
@RequestMapping("/rabbitmq")
public class RabbitmqController {

    @Autowired
    private MsgProducer msgProducer;

    /**
     * 发送测试数据
     *
     * @param type       交换器类型
     * @param routingKey
     * @param message
     * @return
     */
    @RequestMapping("/send")
    public String send(String type, String routingKey, String message) {

        if (RabbitConfig.DIRECT_TYPE.equals(type)) {
            //发送直接交换器
            msgProducer.send2DirectTestQueue(routingKey, message);
        } else if (RabbitConfig.TOPIC_TYPE.equals(type)) {
            //发送主题交换器
            msgProducer.send2TopicTestAQueue(routingKey, message);
        } else if (RabbitConfig.FANOUT_TYPE.equals(type)) {
            //发送扇形交换器
            msgProducer.send2FanoutTestQueue(routingKey, message);
        }
        return "OK";
    }
}

测试

直接交换器测试

单队列绑定

绑定代码(在RabbitConfig中写的)

//创建直接交换器测试队列
@Bean
public Queue createDirectQueue() {
    return new Queue("test_direct_queue");
}
//创建直接交换器
@Bean
DirectExchange directExchange() {
    return new DirectExchange("testDirectExchange");
}
//直接交换器和直接队列绑定
@Bean
Binding bindingDirect() {
    return BindingBuilder.bind(createDirectQueue()).
        to(directExchange()).
        with("test");
}

postman发送测试请求

http://127.0.0.1:8080/rabbitmq/send?type=DIRECT&routingKey=test&message=测试直接交换器

在这里插入图片描述

2020-08-28 10:36:27.014  INFO 16164 --- [ntContainer#0-1] com.heima.rabbitmq.consumer.MsgConsumer  : 接收到DIRECT消息 : 测试直接交换器

多队列绑定不同主题

我们正在用的广播模式的交换器并不够灵活，它只是不加思索地进行广播。因此，需要使用direct exchange来代替。直连交换器的路由算法非常简单：将消息推送到binding key与该消息的routing key相同的队列。
在这里插入图片描述
在该图中，直连交换器X上绑定了两个队列。第一个队列绑定了绑定键orange，第二个队列有两个绑定键：black和green。在这种场景下，一个消息在布时指定了路由键为orange将会只被路由到队列Q1，路由键为black和green的消息都将被路由到队列Q2。其他的消息都将被丢失。

绑定代码

//创建直接交换器测试队列
@Bean
public Queue createDirectQueue() {
    return new Queue("test_direct_queue");
}

//创建直接交换器测试队列1
@Bean
public Queue createDirectQueue1() {
    return new Queue("test_direct_queue1");
}

//创建直接交换器
@Bean
DirectExchange directExchange() {
    return new DirectExchange("testDirectExchange");
}

//直接交换器和直接队列绑定
@Bean
Binding bindingDirectOrange() {
    return BindingBuilder.bind(createDirectQueue()).
        to(directExchange()).
        with("orange");
}

//直接交换器和直接队列绑定
@Bean
Binding bindingDirectBlack() {
    return BindingBuilder.bind(createDirectQueue1()).
        to(directExchange()).
        with("black");
}

//直接交换器和直接队列绑定
@Bean
Binding bindingDirectGreen() {
    return BindingBuilder.bind(createDirectQueue1()).
        to(directExchange()).
        with("green");
}

/**
 * 监听直接测试队列数据
 *
 * @param massage
 */
@RabbitListener(
    bindings =
    {
        @QueueBinding(value = @Queue(value = "test_direct_queue", durable = "true"),
                      exchange = @Exchange(value = "testDirectExchange"))
    })
@RabbitHandler
public void processDirectMsg(Message massage) {
    String routingkey = massage.getMessageProperties().getReceivedRoutingKey();
    String msg = new String(massage.getBody(), StandardCharsets.UTF_8);
    logger.info("接收到direct消息,ROUTINGKEY:{},message: {}", routingkey, msg);
}


/**
 * 监听直接测试队列数据
 *
 * @param massage
 */
@RabbitListener(
    bindings =
    {
        @QueueBinding(value = @Queue(value = "test_direct_queue1", durable = "true"),
                      exchange = @Exchange(value = "testDirectExchange"))
    })
@RabbitHandler
public void processDirectMsg1(Message massage) {
    String routingkey = massage.getMessageProperties().getReceivedRoutingKey();
    String msg = new String(massage.getBody(), StandardCharsets.UTF_8);
    logger.info("接收到direct1消息,ROUTINGKEY:{},message: {}", routingkey, msg);
}

postman测试

http://127.0.0.1:8080/rabbitmq/send?type=DIRECT&routingKey=orange&message=测试直接交换器orange
http://127.0.0.1:8080/rabbitmq/send?type=DIRECT&routingKey=black&message=测试直接交换器black
http://127.0.0.1:8080/rabbitmq/send?type=DIRECT&routingKey=green&message=测试直接交换器green

2020-08-28 11:10:28.684  INFO 8284 --- [ntContainer#3-1] com.heima.rabbitmq.consumer.MsgConsumer  : 接收到direct消息,ROUTINGKEY:orange,message: 测试直接交换器orange
2020-08-28 11:10:52.903  INFO 8284 --- [ntContainer#5-1] com.heima.rabbitmq.consumer.MsgConsumer  : 接收到direct1消息,ROUTINGKEY:black,message: 测试直接交换器black
2020-08-28 11:11:14.820  INFO 8284 --- [ntContainer#5-1] com.heima.rabbitmq.consumer.MsgConsumer  : 接收到direct1消息,ROUTINGKEY:green,message: 测试直接交换器green

多队列绑定相同主题

同一个绑定键可以绑定到不同的队列上去，在下图中，我们也可以增加一个交换器X与队列Q2的绑定键，在这种情况下，直连交换器将会和广播交换器有着相同的行为，将消息推送到所有匹配的队列。一个路由键为black的消息将会同时被推送到队列Q1和Q2。
在这里插入图片描述
绑定代码

//创建直接交换器测试队列
@Bean
public Queue createDirectQueue() {
    return new Queue("test_direct_queue");
}

//创建直接交换器测试队列1
@Bean
public Queue createDirectQueue1() {
    return new Queue("test_direct_queue1");
}

//创建直接交换器
@Bean
DirectExchange directExchange() {
    return new DirectExchange("testDirectExchange");
}
//直接交换器和直接队列绑定
@Bean
Binding bindingDirectBlack() {
    return BindingBuilder.bind(createDirectQueue()).
        to(directExchange()).
        with("black");
}

//直接交换器和直接队列绑定
@Bean
Binding bindingDirectBlack1() {
    return BindingBuilder.bind(createDirectQueue1()).
        to(directExchange()).
        with("black");
}


/**
 * 监听直接测试队列数据
 *
 * @param massage
 */
@RabbitListener(
    bindings =
    {
        @QueueBinding(value = @Queue(value = "test_direct_queue", durable = "true"),
                      exchange = @Exchange(value = "testDirectExchange"))
    })
@RabbitHandler
public void processDirectMsg(Message massage) {
    String routingkey = massage.getMessageProperties().getReceivedRoutingKey();
    String msg = new String(massage.getBody(), StandardCharsets.UTF_8);
    logger.info("接收到direct消息,ROUTINGKEY:{},message: {}", routingkey, msg);
}


/**
 * 监听直接测试队列数据
 *
 * @param massage
 */
@RabbitListener(
    bindings =
    {
        @QueueBinding(value = @Queue(value = "test_direct_queue1", durable = "true"),
                      exchange = @Exchange(value = "testDirectExchange"))
    })
@RabbitHandler
public void processDirectMsg1(Message massage) {
    String routingkey = massage.getMessageProperties().getReceivedRoutingKey();
    String msg = new String(massage.getBody(), StandardCharsets.UTF_8);
    logger.info("接收到direct1消息,ROUTINGKEY:{},message: {}", routingkey, msg);
}

postman测试

http://127.0.0.1:8080/rabbitmq/send?type=DIRECT&routingKey=black&message=测试直接交换器black

2020-08-28 11:18:00.069  INFO 5904 --- [ntContainer#2-1] com.heima.rabbitmq.consumer.MsgConsumer  : 接收到direct消息,ROUTINGKEY:black,message: 测试直接交换器black
2020-08-28 11:18:00.069  INFO 5904 --- [ntContainer#1-1] com.heima.rabbitmq.consumer.MsgConsumer  : 接收到direct1消息,ROUTINGKEY:black,message: 测试直接交换器black

扇形交换器测试

​ 扇形交换机是最基本的交换机类型，它所能做的事情非常简单———广播消息。扇形交换机会把能接收到的消息全部发送给绑定在自己身上的队列。因为广播不需要“思考”，所以扇形交换机处理消息的速度也是所有的交换机类型里面最快的。

绑定代码

//创建扇形交换器测试队列
@Bean
public Queue createFanoutQueue() {
    return new Queue("test_fanout_queue");
}

//创建扇形交换器测试队列1
@Bean
public Queue createFanoutQueue1() {
    return new Queue("test_fanout_queue1");
}

//创建扇形交换器
@Bean
public FanoutExchange defFanoutExchange() {
    return new FanoutExchange("testFanoutExchange");
}

//扇形交换器和扇形队列绑定
@Bean
Binding bindingFanout() {
    return BindingBuilder.bind(createFanoutQueue()).
        to(defFanoutExchange());
}

//扇形交换器和扇形队列绑定
@Bean
Binding bindingFanout1() {
    return BindingBuilder.bind(createFanoutQueue1()).
        to(defFanoutExchange());
}

/**
 * 监听扇形测试队列数据
 *
 * @param massage
 */
@RabbitListener(
    bindings =
    {
        @QueueBinding(value = @Queue(value = "test_fanout_queue", durable = "true"),
                      exchange = @Exchange(value = "testFanoutExchange", type = "fanout"))
    })
@RabbitHandler
public void processFanoutMsg(Message massage) {
    String msg = new String(massage.getBody(), StandardCharsets.UTF_8);
    logger.info("接收到FANOUT消息 : " + msg);
}

/**
 * 监听扇形测试队列1数据
 *
 * @param massage
 */
@RabbitListener(
    bindings =
    {
        @QueueBinding(value = @Queue(value = "test_fanout_queue1", durable = "true"),
                      exchange = @Exchange(value = "testFanoutExchange", type = "fanout"))
    })
@RabbitHandler
public void processFanout1Msg(Message massage) {
    String msg = new String(massage.getBody(), StandardCharsets.UTF_8);
    logger.info("接收到FANOUT1消息 : " + msg);
}

postman测试

http://127.0.0.1:8080/rabbitmq/send?type=FANOUT&routingKey=anykey&message=测试扇形交换器

2020-08-28 13:46:54.391  INFO 17556 --- [ntContainer#1-1] com.heima.rabbitmq.consumer.MsgConsumer  : 接收到FANOUT1消息 : 测试扇形交换器
2020-08-28 13:46:54.391  INFO 17556 --- [ntContainer#5-1] com.heima.rabbitmq.consumer.MsgConsumer  : 接收到FANOUT消息 : 测试扇形交换器

主题交换器测试

发送到主题交换器的消息不能有任意的routing key，必须是由点号分开的一串单词，这些单词可以是任意的，但通常是与消息相关的一些特征。比如以下是几个有效的routing key： “stock.usd.nyse”, “nyse.vmw”,“quick.orange.rabbit”，routing key的单词可以有很多，最大限制是255 bytes。

binding key必须与routing key模式一样。Topic交换器的逻辑与direct交换器有点相似：使用特定路由键发送的消息将被发送到所有使用匹配绑定键绑定的队列，然而，绑定键有两个特殊的情况，如下：

  1. *表示匹配任意一个单词
  2. #表示匹配任意一个或多个单词

在这里插入图片描述
在这个例子中，我们将发送所有跟动物有关的消息，这些消息将会发送到由三个单词，两个点号组成的routing key，第一个单词了表示的是速度，第二个单词表示颜色，第三个单词表示种类：

“<speed>.<colour>.<species>”。

我们创建三个绑定关系：队列Q1绑定到绑定键*.orange.* ，队列Q2绑定到*.*.rabbit和lazy.#。

绑定代码

//创建主题交换器测试队列
@Bean
public Queue createTopicQueue() {
    return new Queue("test_topic_queue");
}

//创建主题交换器测试队列1
@Bean
public Queue createTopicQueue1() {
    return new Queue("test_topic_queue1");
}

//创建主题交换器
@Bean
TopicExchange defTopicExchange() {
    return new TopicExchange("testTopicExchange");
}

//主题交换器和主题队列绑定
@Bean
Binding bindingTopic() {
    return BindingBuilder.bind(createTopicQueue()).
        to(defTopicExchange()).
        with("*.orange.*");
}

//主题交换器和主题队列绑定
@Bean
Binding bindingTopic1() {
    return BindingBuilder.bind(createTopicQueue1()).
        to(defTopicExchange()).
        with("*.*.rabbit");
}

//主题交换器和主题队列绑定
@Bean
Binding bindingTopic2() {
    return BindingBuilder.bind(createTopicQueue1()).
        to(defTopicExchange()).
        with("lazy.#");
}

/**
 * 监听主题测试队列数据
 *
 * @param massage
 */
@RabbitListener(
    bindings =
    {
        @QueueBinding(value = @Queue(value = "test_topic_queue", durable = "true"),
                      exchange = @Exchange(value = "testTopicExchange", type = "topic"))
    })
@RabbitHandler
public void processTopicMsg(Message massage) {
    String routingkey = massage.getMessageProperties().getReceivedRoutingKey();
    String msg = new String(massage.getBody(), StandardCharsets.UTF_8);
    logger.info("接收到TOPIC消息,ROUTINGKEY:{},message: {}", routingkey, msg);
}

/**
 * 监听主题测试1队列数据
 *
 * @param massage
 */
@RabbitListener(
    bindings =
    {
        @QueueBinding(value = @Queue(value = "test_topic_queue1", durable = "true"),
                      exchange = @Exchange(value = "testTopicExchange", type = "topic"))
    })
@RabbitHandler
public void processTopic1Msg(Message massage) {
    String routingkey = massage.getMessageProperties().getReceivedRoutingKey();
    String msg = new String(massage.getBody(), StandardCharsets.UTF_8);
    logger.info("接收到TOPIC1消息,ROUTINGKEY:{},message: {}", routingkey, msg);
}

postman测试

http://127.0.0.1:8080/rabbitmq/send?type=TOPIC&routingKey=quick.orange.rabbit&message=测试主题交换器
http://127.0.0.1:8080/rabbitmq/send?type=TOPIC&routingKey=lazy.orange.elephant&message=测试主题交换器
http://127.0.0.1:8080/rabbitmq/send?type=TOPIC&routingKey=quick.orange.fox&message=测试主题交换器
http://127.0.0.1:8080/rabbitmq/send?type=TOPIC&routingKey=lazy.brown.fox&message=测试主题交换器
http://127.0.0.1:8080/rabbitmq/send?type=TOPIC&routingKey=lazy.pink.rabbit&message=测试主题交换器
http://127.0.0.1:8080/rabbitmq/send?type=TOPIC&routingKey=quick.orangle.male.rabbit&message=测试主题交换器

2020-08-28 11:53:31.585  INFO 5624 --- [ntContainer#3-1] com.heima.rabbitmq.consumer.MsgConsumer  : 接收到TOPIC1消息,ROUTINGKEY:quick.orange.rabbit,message: 测试主题交换器
2020-08-28 11:53:31.585  INFO 5624 --- [ntContainer#2-1] com.heima.rabbitmq.consumer.MsgConsumer  : 接收到TOPIC消息,ROUTINGKEY:quick.orange.rabbit,message: 测试主题交换器
2020-08-28 11:56:07.981  INFO 5624 --- [ntContainer#3-1] com.heima.rabbitmq.consumer.MsgConsumer  : 接收到TOPIC1消息,ROUTINGKEY:lazy.orange.elephant,message: 测试主题交换器
2020-08-28 11:56:07.981  INFO 5624 --- [ntContainer#2-1] com.heima.rabbitmq.consumer.MsgConsumer  : 接收到TOPIC消息,ROUTINGKEY:lazy.orange.elephant,message: 测试主题交换器
2020-08-28 11:56:34.729  INFO 5624 --- [ntContainer#2-1] com.heima.rabbitmq.consumer.MsgConsumer  : 接收到TOPIC消息,ROUTINGKEY:quick.orange.fox,message: 测试主题交换器
2020-08-28 11:57:14.123  INFO 5624 --- [ntContainer#3-1] com.heima.rabbitmq.consumer.MsgConsumer  : 接收到TOPIC1消息,ROUTINGKEY:lazy.brown.fox,message: 测试主题交换器
2020-08-28 12:46:00.455  INFO 5624 --- [ntContainer#3-1] com.heima.rabbitmq.consumer.MsgConsumer  : 接收到TOPIC1消息,ROUTINGKEY:lazy.pink.rabbit,message: 测试主题交换器
fFee-ops
关注
专栏目录
【SpringBoot】43、SpringBoot中整合RabbitMQ实现延时队列（延时插件篇）
Asurplus
02-21 21万+
一、介绍 1、什么是延时队列？ 延时队列即就是放置在该队列里面的消息是不需要立即消费的，而是等待一段时间之后取出消费 2、适用场景 （1）商城订单超时未支付，取消订单 （2）使用权限到期前十分钟提醒用户 （3）收益项目，投入后一段时间后产生收益 二、实现方式 从以上场景中，我们可以看出，延时队列的主要功能就是在指定的时间之后做指定的事情，那么，我们思考有哪些工具我们可以使用？ 1、Redis 监听过期 Key 可以参考我的博客【SpringBoot】三十五、SpringBoot整合Redis监听Ke
RabbitMq 虚拟主机 virtual-host ，Springboot 中使用 RabbitMq 虚拟主机 virtual-host
热门推荐
简简单单Onlinezuozuo
12-20 2万+
文章目录RabbitMq 虚拟主机 virtual-host ，Springboot 中使用 RabbitMq 虚拟主机 virtual-host1、在RabbitMQ 控制台中创建虚拟主机2、创建一个用户3、把用户分配给虚拟主机4、在Springboot 项目中指定连接时，连接到指定的虚拟主机5、虚拟主机在Springboot 中取值的源码 RabbitMq 虚拟主机 virtual-host ...
在SpringBoot中使用RabbitMQ
好记性不如烂笔头
07-28 557
开始之前 RabbitMQ涉及的重要的概念 Channel 信道。消息的读写操作在信道中进行，客户端可以建立多个信道，每个信道代表一个会话。 Message 消息。应用程序和MQ服务之间传送的数据，消息可以非常简单，也可以很复杂。有Properties和body组成。Properties为外包装，可以对消息进行修饰，比如消息的优先级、延迟等高级特性；body就是消息体内容。 Exchange 交换器,一个MQ服务器可以有一个或多个交换器。应用程序通过交换器，按照一定路由规则将消
Spring Boot中使用RabbitMQ
JavaAlliance
07-08 4446
Message Broker与AMQP简介 Message Broker是一种消息验证、传输、路由的架构模式，其设计目标主要应用于下面这些场景： 消息路由到一个或多个目的地 消息转化为其他的表现方式 执行消息的聚集、消息的分解，并将结果发送到他们的目的地，然后重新组合成相应的结果返回给消息用户 调用Web服务来检索数据 响应事件或错误 使用发布-订阅模式来提供内容或基于主题的消息路由 AMQP...
SpringBoot 使用 RabbitMQ
最新发布
2302_82270778的博客
08-06 1202
RabbitListener(queues = "order.create") 可以加在类上，也可以加在方法上，加在类上，如果消息是 String 类型就会执行 String 类型的方法，如果是对象类型，就会执行对象类型的方法。@RabbitListener 是 Spring 框架中用于监听 RabbitMQ 队列的注解，通过使用这个注解，可以定义一个方法，以便从 RabbitMQ 队列中接收消息，该注解支持多种参数类型。声明两个队列和一个交换机，然后绑定队列和交换机。声明队列和交换机，并绑定。
Spring Boot 中使用 RabbitMQ
good7ob的博客
07-31 1828
通过本文的介绍，你已经学习了如何在 Spring Boot 中使用 RabbitMQ 实现异步消息的发送和接收。你了解了如何配置 RabbitMQ 连接信息，并使用 Spring Boot 提供的和注解进行消息的发送和接收。通过实际的案例，我们展示了如何使用 RabbitMQ 实现任务队列，以邮件发送服务为例。你学习了如何创建消息发送者和消息接收者，并使用队列来实现任务的异步处理。使用 RabbitMQ 可以帮助我们实现解耦和异步处理，提高系统的可靠性和性能。
springboot中使用rabbitmq
10-27
Spring Boot中使用RabbitMQ需要引入spring-boot-starter-amqp依赖，然后通过配置文件配置RabbitMQ的连接信息。在代码中，我们可以通过RabbitTemplate来发送消息，也可以通过@RabbitListener注解来监听队列并消费消息...
rabbitMQ学习笔记(八)——应用场景
sam的博客
05-11 444
MQ的应用场景 1 异步处理 场景说明：用户注册后，需要发注册邮件和注册短信,传统的做法有两种 1.串行的方式 2.并行的方式 串行方式: 将注册信息写入数据库后,发送注册邮件,再发送注册短信,以上三个任务全部完成后才返回给客户端。 这有一个问题是,邮件,短信并不是必须的,它只是一个通知,而这种做法让客户端等待没有必要等待的东西. 并行方式:将注册信息写入数据库后,发送邮件的同时,发送短信,以上三个任务完成后,返回给客户端,并行的方式能提高处理的时间。 消息队列:假设三个业务节点分别使用50
springboot使用rabbitmq工具类
03-29
springboot使用rabbitmq工具类,里面包含比较原生的方法,还有一套是我结合springboot框架写的一套方法,里面有两个方法,看情况使用,一般使用框架的方法比较好,因为框架方法时前辈们封装好经过检验的没有问题的方法,自己写的方法比较简陋,参考下原理即可.
spring boot mq
myself8202的博客
07-27 378
brew更新到最新版本，执行：brew update 安装Erlang，执行：brew install erlang 安装RabbitMQ Server，执行：brew install rabbitmq.bash_profile或.profile文件中增加下面内容： PATH=$PATH:/usr/local/sbin通过rabbitmq-server命令来启动RabbitMQ的服务端 打开
Springboot中使用RabbitMQ
Jessie
06-24 209
RabbitAdmin主要用于对队列进行管理，用于创建，绑定，删除队列与交换机，发送消息等。 1.RabbitMq配置类，配置连接工厂和对象
springboot使用rabbitmq
aichun8580的博客
07-25 75
话不多少 上来就是干 如果你想直接可以使用，可以直接参考项目代码 github源代码 首先引入依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp<...
Springboot使用rabbitmq
森森的博客
01-17 243
这里写目录标题配置文件配置开启rabbitmq创建队列 配置文件 1.打开Rabbitmq的配置类，发现默认配置为本地，所以若你是没有改变，不用配置文件中配置 配置开启rabbitmq 创建队列 1.可以选择配置页面**http://localhost:15672/#/**配置交换器，路由规则，消息队列 2.我这里代码配置了 测试类中 @Autowired AmqpAdmin amqpAdmin; @Test public void bind() { amq
SpringBoot之rabbitmq使用
菜菜程序员
04-19 175
消息队列中间件是分布式系统中重要的组件，主要解决应用耦合，异步消息，流量削锋等问题实现高性能，高可用，可伸缩和最终一致性架构 使用较多的消息队列有ActiveMQ，RabbitMQ，ZeroMQ，Kafka，MetaMQ，RocketMQ。 今天我们将会了解到在SpringBoot中使用rabbitmq 实现 1.1 rabbitmq简介 RabbitMQ是由Erlang语言编写的实现了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值