RabbitMQ快速入门

已于 2023-01-14 15:59:17 修改
阅读量986 收藏 2
点赞数 1
分类专栏： RabbitMQ 文章标签： java-rabbitmq rabbitmq java
于 2023-01-07 22:57:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_54963748/article/details/128548223
版权

RabbitMQ快速入门

RabbitMQ进阶

一、概述

RabbitMQ： 消息队列，是在消息的传输过程中保存消息的容器。
它接受并转发消息。 你可以把它想象成一个邮局：当你把你想要邮寄的邮件放在邮箱里时， 您可以确定，邮递员最终会将邮件递送给您的收件人。 在这个类比中，RabbitMQ是一个邮政信箱，一个邮局和一个信件载体。

1、MQ主要用途

1、流量消峰
在双十一12点时，用户都疯狂的进行购物，进行下单。原本只能处理5000w的订单，但是在双十一要处理高于5000w的订单。这个时候，我们就可以使用MQ来做缓冲，我们把这一时刻的订单，分散到其他时间来进行处理，这样就可以使得每个用户都能下单成功。

2、应用解耦
以电商应用为例，应用中有订单系统、库存系统、物流系统、支付系统。
订单系统需要调用 库存系统、物流系统、支付系统。但是这3个系统，如果任何一个出现故障，都会使订单系统无法完成。当我们在订单和另外3个系统中加入MQ来进行缓存，库存系统、物流系统、支付系统中任何一个出现错误，我们可以把要处理的信息先放在消息队列中，等系统恢复正常后，继续执行，不会影响程序的正常执行，提示了可用性。

在这里插入图片描述

3、异步处理

未使用MQ：订单系统要执行完另外3个系统后才能返回用户数据
使用MQ：用户不用等另外3个系统执行完，就可以返回给用户信息。

在这里插入图片描述
在这里插入图片描述

2、四大核心概念

1、生产者 ： producer
产生数据发送消息的程序是生产者

2、交换机： Exchange
首先接收来自于生产者的消息，message到达的第一站，根据分发规则，将消息推送到队列中。交换机要将消息推送到特定的队列或者推送到多个队列，亦或者吧消息丢失。

3、队列： Queue
消息被推送到的地方，在这里等待消费者取走

4、消费者：
处理消息，从队列中拿到消息。

二、入门开发

RabbitMQ官网示例Java
在这里插入图片描述

1、引入依赖

        <!--rabbitmq 依赖客户端-->
        <dependency>
            <groupId>com.rabbitmq</groupId>
            <artifactId>amqp-client</artifactId>
            <version>5.8.0</version>
        </dependency>

生产者

/**
 * 这个类处理的是生产者的处理
 */
public class Producer {
    // 队列名称
    private static final String QUEUE_NAME = "hello";

    public static void main(String[] args) throws Exception{
        // 1、创建一个连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.92.134");
        factory.setUsername("zww");
        factory.setPassword("自己的密码");

        // 2、创建连接
        Connection connection = factory.newConnection();
        // 3、获取信道
        Channel channel = connection.createChannel();
        //channel 实现了自动 close 接口 自动

        /**
         * queueDeclare(String queue, boolean durable, boolean exclusive,
         * boolean autoDelete, Map<String, Object> arguments)
         * 生成一个队列
         * 1.队列名称
         * 2.队列里面的消息是否持久化,默认消息存储在内存中;不持久化的话，mq重启消息就不存在了
         * 3.独占：该队列是否只供一个消费者进行消费 是否进行共享 true 可以多个消费者消费
         *   当Connection关闭时，是否删除队列
         * 4.是否自动删除
         *   当没有Connection时，最后一个消费者端开连接以后，该队列是否自动删除 true 自动删除
         * 5.其他参数
         */
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);
        String message="hello world";
        /**
         * basicPublish(String exchange, String routingKey, AMQP.BasicProperties props, byte[] body)
         * 发送一个消息
         * 1.发送到那个交换机
         * 2.路由的 key 是哪个
         * 3.其他的参数信息
         * 4.发送消息的消息体
         */
        channel.basicPublish("",QUEUE_NAME,null,message.getBytes());
        System.out.println("消息发送完毕");
        // 释放资源
        channel.close();
        connection.close();
    }
}

消费者

/**
 * 消费者，用来接收消息的
 */
public class Consumer {
    // 队列名称
    private static final String QUEUE_NAME = "hello";    

    public static void main(String[] args) throws Exception{
        // 1、创建一个连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.92.134");
        factory.setUsername("zww");
        factory.setPassword("njgzydzm9339");

        // 2、创建连接
        Connection connection = factory.newConnection();
        // 3、获取信道
        Channel channel = connection.createChannel();

        // 4、推送的消息如何进行消费的接口回调
        /**
         * (String consumerTag, Delivery message)
         */
        DeliverCallback deliverCallback=(consumerTag, delivery)->{
            String message= new String(delivery.getBody());
            System.out.println(message);
        };
        //取消消费的一个回调接口 如在消费的时候队列被删除掉了
        CancelCallback cancelCallback=(consumerTag)->{
            System.out.println("消息消费被中断");
        };
        /**
         * basicConsume(String queue, boolean autoAck, DeliverCallback deliverCallback, CancelCallback cancelCallback)
         * 消费者消费消息
         * 1.消费哪个队列，队列名称
         * 2.消费成功之后是否要自动应答 true 代表自动应答 false 手动应答
         * 3.消费者成功消费的回调
         * 4、消费者未成功消费的回调处理
         */
        channel.basicConsume(QUEUE_NAME,true,deliverCallback,cancelCallback);
    }
}

三、"Work Queues"模式

Work Queues官网
在这里插入图片描述
应用场景： 轮询来进行处理消息，减小压力。对于任务过重或者任务较多情况使用工作队列可以提高任务处理的速度。

1、首先我们创建一个创建工程，返回Channel的一个工具类

/**
 * 这个是连接工厂创建信道工具类
 */
public class RabbitMqUtils {
    public static Channel getChannel() throws Exception{
        //创建一个连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.92.134");
        factory.setUsername("zww");
        factory.setPassword("123456");

        // 创建连接
        Connection connection = factory.newConnection();
        // 获取信道
        Channel channel = connection.createChannel();
        return channel;
    }
}

2、消费者1

/**
 * 这是一个工作线程的处理(相当于消费者这个是消费者01)
 */
public class Worker01 {
    // 队列名称
    private static final String QUEUE_NAME = "hello";       

    public static void main(String[] args) throws  Exception{
        // 1、初始化,获取信道
        Channel channel = RabbitMqUtils.getChannel();
        // 2、收消息的处理
        DeliverCallback deliverCallback = (s, message) -> System.out.println("接收到的消息为"+new String(message.getBody()));
        // 3、接收被取消的处理
        CancelCallback cancelCallback = con -> System.out.println("消息被取消回调处理了"+con );
        System.out.println("C1等待处理");
        channel.basicConsume(QUEUE_NAME,true,deliverCallback,cancelCallback );
    }
}

2、消费者2

/**
 * 这个是消费者02的处理
 */
public class Worker02 {
    // 队列名称
    private static final String QUEUE_NAME = "hello";       

    public static void main(String[] args) throws  Exception{
        // 初始化
        Channel channel = RabbitMqUtils.getChannel();  
        // 接收消息的处理
        DeliverCallback deliverCallback = (s, message) -> System.out.println("接收到的消息为"+new String(message.getBody()));
        // 接收被取消的处理
        CancelCallback cancelCallback = con -> System.out.println("消息被取消回调处理了"+con );
        System.out.println("C2等待处理的过程");
        channel.basicConsume(QUEUE_NAME,true,deliverCallback,cancelCallback );
    }
}

3、生产者：

/**
 * 生产者的处理
 */
public class Task01 {
    // 队列名称
    private static final String QUEUE_NAME = "hello";       

    // 发送大量消息
    public static void main(String[] args) throws Exception{
        // 工具类，获取信道
        Channel channel = RabbitMqUtils.getChannel();
        /**
         * 生成一个队列
         * 1.队列名称
         * 2.队列里面的消息是否持久化 默认消息存储在内存中
         * 3.该队列是否只供一个消费者进行消费 是否进行共享 true 可以多个消费者消费
         * 4.是否自动删除 最后一个消费者端开连接以后 该队列是否自动删除 true 自动删除
         * 5.其他参数
         */
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);
        // 发送10条消息
        for (int i = 0; i < 10; i++) {
            String message = "消息"+i;
            channel.basicPublish("",QUEUE_NAME,null,message.getBytes());
            System.out.println("发送消息完成："+message);
        }
    }
}

4、运行结果

我们要先运行两个消费者，让两个消费者先处于等待的状态，然后在运行生产者，这样才可以看到运行的结果。

在这里插入图片描述
在这里插入图片描述

由此可见，C1和C2两个消费者是在轮询进行消费的处理。

四、Publish/Subscribe 发布订阅模式

Publish/Subscribe 发布订阅模式
在这里插入图片描述

  • Exchange： 交换机(X).一方面，介绍生产者发送消息。另一方面，知道如何处理信息，例如递交给某个特别队列
  • 递交给所有队列、将消息丢弃。常见的Exchange有3种类型：
  • Fanout： 广播，将消息交给所有绑定到交换机队列
  • Direct： 定向，将消息交给指定routing key的队列
  • Topic: 通配符，将消息交给符合routing pattern（路由模式）的队列

1、工具类RabbitMqUtils（看上文）

2、生产者（设置交换机类型，绑定队列）

public class PubSub {
    public static void main(String[] args) throws Exception{
        // 1、获取到Channel
        Channel channel = RabbitMqUtils.getChannel();
        // 2、创建交换机
        /**
         1、String exchange,  交换机名称
         2、BuiltinExchangeType type, 交换机类型：
              DIRECT("direct")： 定向方式
              FANOUT("fanout")： 广播方式
              TOPIC("topic")：   通配符
              HEADERS("headers")：参数匹配
         3、boolean durable：  是否持久化
         4、boolean autoDelete： 自动删除
         5、boolean internal:  内部使用 一般是false
         5、Map<String, Object> arguments：参数
         */
        String exchangeName = "test_fanout";
        channel.exchangeDeclare(exchangeName, BuiltinExchangeType.FANOUT,true,false,false,null);
        // 3、创建队列
        String queueName1 = "test_queue1";
        String queueName2 = "test_queue2";
        channel.queueDeclare(queueName1,true,false,false,null);
        channel.queueDeclare(queueName2,true,false,false,null);
        // 4、绑定队列和交换机
        /**
         * queueBind(String queue, String exchange, String routingKey, Map<String, Object> arguments)
         * 1、队列名称
         * 2、交换机名称
         * 3、绑定规则，路由key。如果交换机类型是FANOUT，设置为空就行
         * 4、
         */
        channel.queueBind(queueName1,exchangeName,"");
        channel.queueBind(queueName2,exchangeName,"");
        // 5、发送消息
        String body = "日志信息: update()";
        System.out.println("发送了消息："+body);
        channel.basicPublish(exchangeName,"",null,body.getBytes());
        // 6、释放资源
        channel.close();
    }
}

3、消费者（指定队列）

/**
 * 消费者的处理过程,消费者需要绑定对应的队列名就可以了
 */
public class PubSubConsumer1 {
    private static final String TASK_QUEUE_NAME_1 = "test_queue1";
    public static void main(String[] args) throws Exception{
        Channel channel = RabbitMqUtils.getChannel();
        // 接收消息
        DeliverCallback deliverCallback = (s, delivery) -> {
            System.out.println("队列1打印日志："+new String(delivery.getBody()));

            // 设置不公平分发处理
            int prefetchCount = 2;
            channel.basicQos(prefetchCount);    //  设置的值超过1，那么就是预取值的处理了
            // 采用手动应答
            /**
             * 1.消息标记 tag
             * 2.是否批量应答未应答消息
             */
            channel.basicAck(delivery.getEnvelope().getDeliveryTag(),false);
        };
        boolean autoAck = false;
        channel.basicConsume(TASK_QUEUE_NAME_1, autoAck, deliverCallback, s -> System.out.println(s+"消费者取消接口回调处理"));
    }
}

/**
 * 消费者的处理过程,消费者需要绑定对应的队列名就可以了
 */
public class PubSubConsumer2 {
    private static final String TASK_QUEUE_NAME_2 = "test_queue2";
    public static void main(String[] args) throws Exception{
        Channel channel = RabbitMqUtils.getChannel();

        // 接收消息
        DeliverCallback deliverCallback = (s, delivery) -> {
            System.out.println("队列2保存数据库：："+new String(delivery.getBody()));

            // 设置不公平分发处理
            int prefetchCount = 2;
            channel.basicQos(prefetchCount);    //  设置的值超过1，那么就是预取值的处理了
            // 采用手动应答
            /**
             * 1.消息标记 tag
             * 2.是否批量应答未应答消息
             */
            channel.basicAck(delivery.getEnvelope().getDeliveryTag(),false);
        };
        boolean autoAck = false;
        channel.basicConsume(TASK_QUEUE_NAME_2, autoAck, deliverCallback, s -> System.out.println(s+"消费者取消接口回调处理"));
    }
}

4、运行结果

生产者：在这里插入图片描述
消费者1：
在这里插入图片描述

消费者2：
在这里插入图片描述

五、Routing 路由模式

Routing路由模式

在这里插入图片描述
注意：
1、交换机类型要设置成： BuiltinExchangeType.DIRECT
2、生产者在产生消息的时候，发送消息的rotingkey和 交换机与队列的key一样，那么才能发到对应的交换机上

1、生产者

/**
 * Routing模式中： 发送消息的rotingkey和 交换机与队列的key一样，那么才能发到对应的交换机上
 */
public class Producer_Routing {
    public static void main(String[] args) throws Exception{
        // 1、获取到Channel
        Channel channel = RabbitMqUtils.getChannel();
        // 2、创建交换机
        /**
         1、String exchange,  交换机名称
         2、BuiltinExchangeType type, 交换机类型：
              DIRECT("direct")： 定向方式
              FANOUT("fanout")： 广播方式
              TOPIC("topic")：   通配符
              HEADERS("headers")：参数匹配
         3、boolean durable：  是否持久化
         4、boolean autoDelete： 自动删除
         5、boolean internal:  内部使用 一般是false
         5、Map<String, Object> arguments：参数
         */
        String exchangeName = "test_direct";
        // 使用DIRECT的类型
        channel.exchangeDeclare(exchangeName, BuiltinExchangeType.DIRECT,true,false,false,null);
        // 3、创建队列
        String queueName1 = "test_direct_queue1";
        String queueName2 = "test_direct_queue2";
        channel.queueDeclare(queueName1,true,false,false,null);
        channel.queueDeclare(queueName2,true,false,false,null);
        // 4、绑定队列和交换机
        /**
         * queueBind(String queue, String exchange, String routingKey, Map<String, Object> arguments)
         * 1、队列名称
         * 2、交换机名称
         * 3、绑定规则，路由key。如果交换机类型是FANOUT，设置为空就行
         * 4、
         */
        // 第一个queue绑定 error级别的
        channel.queueBind(queueName1,exchangeName,"error");
        channel.queueBind(queueName2,exchangeName,"error");
        channel.queueBind(queueName2,exchangeName,"info");
        channel.queueBind(queueName2,exchangeName,"warning");
        // 5、发送消息
        String body = "日志信息: error级别的()";
        System.out.println("发送了消息："+body);
//        channel.basicPublish(exchangeName,"info",null,body.getBytes());
        // error级别两个都能收到
        channel.basicPublish(exchangeName,"error",null,body.getBytes());
        // 6、释放资源
        channel.close();
    }
}

2、消费者

/**
 * 消费者的处理过程,消费者需要绑定对应的队列名就可以了
 */
public class RoutingConsumer1 {
    private static final String TASK_QUEUE_NAME_1 = "test_direct_queue1";
    public static void main(String[] args) throws Exception{
        Channel channel = RabbitMqUtils.getChannel();
        // 接收消息
        DeliverCallback deliverCallback = (s, delivery) -> {
            System.out.println("队列1打印日志："+new String(delivery.getBody()));

            // 设置不公平分发处理
            int prefetchCount = 2;
            channel.basicQos(prefetchCount);    //  设置的值超过1，那么就是预取值的处理了
            // 采用手动应答
            /**
             * 1.消息标记 tag
             * 2.是否批量应答未应答消息
             */
            channel.basicAck(delivery.getEnvelope().getDeliveryTag(),false);
        };
        boolean autoAck = false;
        channel.basicConsume(TASK_QUEUE_NAME_1, autoAck, deliverCallback, s -> System.out.println(s+"消费者取消接口回调处理"));
    }
}

/**
 * 消费者的处理过程,消费者需要绑定对应的队列名就可以了
 */
public class RoutingConsumer2 {
    private static final String TASK_QUEUE_NAME_1 = "test_direct_queue2";
    public static void main(String[] args) throws Exception{
        Channel channel = RabbitMqUtils.getChannel();
        // 接收消息
        DeliverCallback deliverCallback = (s, delivery) -> {
            System.out.println("队列2存入数据库："+new String(delivery.getBody()));

            // 设置不公平分发处理
            int prefetchCount = 2;
            channel.basicQos(prefetchCount);    //  设置的值超过1，那么就是预取值的处理了
            // 采用手动应答
            /**
             * 1.消息标记 tag
             * 2.是否批量应答未应答消息
             */
            channel.basicAck(delivery.getEnvelope().getDeliveryTag(),false);
        };
        boolean autoAck = false;
        channel.basicConsume(TASK_QUEUE_NAME_1, autoAck, deliverCallback, s -> System.out.println(s+"消费者取消接口回调处理"));
    }
}

3、运行结果
info级别：一个队列可以收到，一个队列不能收到

生产者：
在这里插入图片描述
消费者1：(无消息)
在这里插入图片描述
消费者2：(有消息)
在这里插入图片描述

六、Topics 通配符模式

Topices通配符模式

在这里插入图片描述

通配符：

  • ，表示一个单词
  • #，表示0~n个单词
  • Topics：使用的类型 BuiltinExchangeType.TOPIC

1、生产者

/**
 * Topics：使用的类型 BuiltinExchangeType.TOPIC
 */
public class Producer_Topics {
    public static void main(String[] args) throws Exception{
        // 1、获取到Channel
        Channel channel = RabbitMqUtils.getChannel();
        // 2、创建交换机
        /**
         1、String exchange,  交换机名称
         2、BuiltinExchangeType type, 交换机类型：
              DIRECT("direct")： 定向方式
              FANOUT("fanout")： 广播方式
              TOPIC("topic")：   通配符
              HEADERS("headers")：参数匹配
         3、boolean durable：  是否持久化
         4、boolean autoDelete： 自动删除
         5、boolean internal:  内部使用 一般是false
         5、Map<String, Object> arguments：参数
         */
        String exchangeName = "test_topic";
        // 使用DIRECT的类型
        channel.exchangeDeclare(exchangeName, BuiltinExchangeType.TOPIC,true,false,false,null);
        // 3、创建队列
        String queueName1 = "test_topic_queue1";
        String queueName2 = "test_topic_queue2";
        channel.queueDeclare(queueName1,true,false,false,null);
        channel.queueDeclare(queueName2,true,false,false,null);
        // 4、绑定队列和交换机
        /**
         * queueBind(String queue, String exchange, String routingKey, Map<String, Object> arguments)
         * 1、队列名称
         * 2、交换机名称
         * 3、绑定规则，路由key。如果交换机类型是FANOUT，设置为空就行
         * 4、
         */
        // 第一个queue绑定 error级别的
        channel.queueBind(queueName1,exchangeName,"#.error");
        channel.queueBind(queueName1,exchangeName,"order.*");
        channel.queueBind(queueName2,exchangeName,"*.*");
        // 5、发送消息
        String body = "日志信息: 发的是 order.星的";
        System.out.println("发送了消息："+body);
        // error级别两个都能收到
        channel.basicPublish(exchangeName,"order哈.星的",null,body.getBytes());
        // 6、释放资源
        channel.close();
    }
}

2、消费者

/**
 * 消费者的处理过程,消费者需要绑定对应的队列名就可以了
 */
public class TopicConsumer1 {
    private static final String TASK_QUEUE_NAME_1 = "test_topic_queue1";
    public static void main(String[] args) throws Exception{
        Channel channel = RabbitMqUtils.getChannel();
        // 接收消息
        DeliverCallback deliverCallback = (s, delivery) -> {
            System.out.println("队列1的，#.error 和order.*："+new String(delivery.getBody()));

            // 设置不公平分发处理
            int prefetchCount = 2;
            channel.basicQos(prefetchCount);    //  设置的值超过1，那么就是预取值的处理了
            // 采用手动应答
            /**
             * 1.消息标记 tag
             * 2.是否批量应答未应答消息
             */
            channel.basicAck(delivery.getEnvelope().getDeliveryTag(),false);
        };
        boolean autoAck = false;
        channel.basicConsume(TASK_QUEUE_NAME_1, autoAck, deliverCallback, s -> System.out.println(s+"消费者取消接口回调处理"));
    }
}


/**
 * 消费者的处理过程,消费者需要绑定对应的队列名就可以了
 */
public class TopicConsumer2 {
    private static final String TASK_QUEUE_NAME_1 = "test_topic_queue2";
    public static void main(String[] args) throws Exception{
        Channel channel = RabbitMqUtils.getChannel();
        // 接收消息
        DeliverCallback deliverCallback = (s, delivery) -> {
            System.out.println("队列2 *.*的："+new String(delivery.getBody()));

            // 设置不公平分发处理
            int prefetchCount = 2;
            channel.basicQos(prefetchCount);    //  设置的值超过1，那么就是预取值的处理了
            // 采用手动应答
            /**
             * 1.消息标记 tag
             * 2.是否批量应答未应答消息
             */
            channel.basicAck(delivery.getEnvelope().getDeliveryTag(),false);
        };
        boolean autoAck = false;
        channel.basicConsume(TASK_QUEUE_NAME_1, autoAck, deliverCallback, s -> System.out.println(s+"消费者取消接口回调处理"));
    }
}

3、运行结果

发送的key为： “order哈.星的”,按照道理，*.*的是可以接收到的，另外一个消费者是不能接收到的。

生产者：
在这里插入图片描述
消费者：
在这里插入图片描述
另外一个无消息

七、SpringBoot整合RabbitMQ

**1、依赖添加

    <dependencies>
        <dependency>
<!--            MQ的依赖-->
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>

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

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
        </dependency>
    </dependencies>

2、添加配置文件

spring:
  rabbitmq:
    host: 192.168.92.134
    port: 5672
    username: mycat
    password: 123456
    virtual-host: /

3、编写生产者的处理(配置类)

@Configuration
public class RabbitMQConfig {
    public static final String QUEUE_NAME = "boot_queue";
    public static final String EXCHANGE_NAME="boot_topic_exchange";

    // 1、交换机的配置
    @Bean("bootExchange")
    public Exchange exchange(){
        //durable(true) 持久化，mq重启之后交换机还在
        return ExchangeBuilder.topicExchange(EXCHANGE_NAME).durable(true).build();
    }
    // 2、队列的配置
    @Bean("bootQueue")
    public Queue bootQueue(){
        return QueueBuilder.durable(QUEUE_NAME).build();
    }

    // 3、绑定关系  Binging
    /**
     * 1、知道哪个队列
     * 2、知道哪个交换机
     * 3、设置对应的 routing key
     */

    @Bean
    public Binding bindQueueExchange(@Qualifier("bootQueue") Queue queue,@Qualifier("bootExchange") Exchange exchange){
        return BindingBuilder.bind(queue).to(exchange).with("boot.#").noargs();
    }
}

启动类：

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

4、进行生产者的测试处理


@SpringBootTest
@RunWith(SpringRunner.class)
public class MQTest {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void testSend(){
        /**
         * 交换机的名称，key，消息
         */
        rabbitTemplate.convertAndSend(EXCHANGE_NAME,"boot.hhh","传的消息啊！！！！！！");
    }
}

5、进行消费者的处理(消费者监听类)

@Component
public class RabbitListener {

    @org.springframework.amqp.rabbit.annotation.RabbitListener(queues = "boot_queue")
    public void ListenerQueque(Message message){
        System.out.println("返回的message："+message);
        System.out.println("产生的消息："+message.getBody().toString());
    }
}

6、进行整体的测试处理
-1：先运行生产者的测试类
-2：运行消费者模块，然后查看运行结果
在这里插入图片描述

进阶请查看： RabbitMQ进阶

智慧的猪-
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
RabbitMQ快速入门及API介绍（401M）
04-11
RabbitMQ快速入门及API介绍(401M) QQ截图 20191220230107.png?x-oss-process=style/pnp8 (42.73KB, 下载次数：227) 下载附件 2019-12-2023 :01 上传【课程介绍】：第一章 : RabbitMQ介绍：消息中间件概念、RabbitMQ安装、RabbitMq客户端调用的Java实现。 第 2 章：RabbitMQ 概念：生产者、消费者、Broken、交换、路由密钥、绑定密钥、交换类型。 第三章：RabbitMQ的几个API：连接、通道、交换、队列、发送消息、消费消息。 【课程目录】：---第一章：RabbitMQ介绍----1-什么是消息中间件.mp4----2-RabbitMQ消息队列安装：window环境.mp4----3-RabbitMQ消息队列安装 ：Linux环境.mp4----4-Rabbitmq入口示例：server.mp4----5-rabbitmq入口示例：client.mp4---第二章：RabbitMQ的几个概念----1-生产者和消费者 concept.mp4--- -2-Broke
RabbitMQ 学习笔记
qq_43670559的博客
05-26 222
Broker：接收和分发消息的应用，RabbitMQ Server 就是 Message BrokerVirtual host：出于多租户和安全因素设计的，把 AMQP 的基本组件划分到一个虚拟的分组中，类似于网络中的 namespace 概念。当多个不同的用户使用同一个 RabbitMQ server 提供的服务时，可以划分出多个 vhost，不同的 vhost 对应不同的交换机和队列，每个用户在自己的 vhost 创建 exchange／queue 等。
RabbitMQ之消费者可靠性
最新发布
Lyhdreamer的博客
02-19 1247
RabbitMQ消费者可靠性的实现
十六、RabbitMQ快速入门
11-21
十六、RabbitMQ快速入门
RabbitMQ消息中间件快速入门
欢迎来到编程小栈
07-19 2166
文章目录一、同步和异步通讯1. 同步通讯2. 异步通讯二、RabbitMQ1. MessageQueue对比2. RabbitMQ快速入门【1】安装与启动【2】基本结构3. 五种消息模型介绍【1】入门案例1）publisher实现2）consumer实现4. SpringAMQP实现【1】Basic Queue 基本消息队列1）消息发送2）消息接收3）测试【2】WorkQueue工作消息队列1）消息发送2）消息接收3）测试4）prefetch提前获取【3】发布订阅三种模式1）Fanout[1] 声明队列和交
懵了，Kafka、RabbitMQ到底选哪个？
m0_65618219的博客
01-04 6139
经常有人问我 有个 xx 需求，我应该用 Kafka 还是 RabbitMQ ？ 这个问题很常见，而且很多人对二者的选择也把握不好。 所以我决定写篇文章来详细说一下：Kafka 和 RabbitMQ 的区别，适用于什么场景？ 同时，这个问题在面试中也经常问到。 下面我会通过 6 个场景，来对比分析一下 Kafka 和 RabbitMQ 的优劣。 一、消息的顺序 有这样一个需求：当订单状态变化的时候，把订单状态变化的消息发送给所有关心订单变化的系统。 订单会有创建成功、待付款、已支付、已发
RabbitMQ入门
qq_45179408的博客
12-20 148
RabbitMQ简介 各大主流中间件对比 ActiveMQ 是 Apache 出品，最流行的，能力强劲的开源消息总线，并且它一 个完全支持 J M S 规范的消息中间件。 其丰富的 API 、多种集群构建模式使得他成为业界老牌消息中间件，在中 小型企业中应用广泛！ MQ 衡量指标：服务性能、数据存储、集群架构 Kafka RocketMQ是阿里开源的消息中间件，目前也已经孵化为Apache顶级...
RabbitMQ（一）：RabbitMQ快速入门
LoveSummer
06-18 862
RabbitMQ（一）：RabbitMQ快速入门 RabbitMQ是目前非常热门的一款消息中间件，不管是互联网大厂还是中小企业都在大量使用。作为一名合格的开发者，有必要对RabbitMQ有所了解，本文是RabbitMQ快速入门文章，主要内容包括RabbitMQ是什么、RabbitMQ核心概念、常用交换器类型、用Docker安装RabbitMQ等。 RabbitMQ简介 以熟悉的电商场景为例，如果商品服务和订单服务是两个不同的微服务，在下单的过程中订单服务需要调用商品服务进行扣库存操作。按照传统的方式，下单过
超简单的RabbitMQ快速入门
学哥斌的博客
05-23 676
文章目录1、基本介绍1.1 什么是MQ？1.2 什么是AMQP？1.3 什么是JMS？2、RabbitMQ的安装2.1 说明2.2 启动相关服务2.3 管理页面3、RabbitMQ工作原理3.1 基本结构3.2 组成说明3.3 消息发布和接收流程4、HelloWorld4.1 环境依赖4.2 生产者代码4.3 消费者代码4.4 测试5、RabbitMQ的工作模式5.1 Work queues5.2 Publish/subscribe 1、基本介绍 1.1 什么是MQ？   MQ全称为Message Queu
RabbitMQ安装及配置步骤（windows10实测顺利安装）
weixin_30641465的博客
09-15 331
1、安装Erlang 下载地址：https://www.erlang.org/downloads，本文选择OTP 21.0.1 Windows 64-bit Binary File (91707927) 设置环境变量，新建ERLANG_HOME 修改环境变量path，增加Erlang变量至path，%ERLANG_HOME%\bin; 打开cmd命令框，输入erl 至此，Erl...
RabbitMQ 快速入门(简单模式)
weixin_42947972的博客
03-11 196
RabbitMQ 快速入门(简单模式) 步骤 创建工程(生产者、消费者) 分别添加依赖 编写生产者发布消息 编写消费者接受消息 一. 创建工程(生产者、消费者)
Linux中安装RabbitMQ急速入门.md
11-26
Linux中安装RabbitMQ急速入门，快速安装，纯小白可直接上手，内容详细步骤明确，只要按照文档中来操作，成功率100%
ApacheCamel快速入门（上）
01-27
在这个专题中，我们介绍了相当数量技术组件：Flume、Kafka、ActiveMQ、Rabbitmq、Zookeeper、Thrift、Netty、DUBBO等等，还包括本文要进行介绍的ApacheCamel。有的技术组件讲得比较深入，有的技术组件则是点到为止。...
RabbitMQ小Demo
10-19
学习RabbitMQ的小Demo； 快速入门RabbitMQ。
rabbitMQ介绍.docx
05-25
rabbitmq重要概念入门，可以为面试快速了解下mq的机制，大概几分钟看完，可以临阵磨枪下，但想深入了解实战没有用哦
RabbitMQ基础.pptx
01-10
MQ 的基本概念 RabbitMQ 的安装和配置 RabbitMQ 快速入门 RabbitMQ 的工作模式
mq-消息队列的 使用场景、常见问题及解决方法
梦~'
04-12 2183
前言 最近mq越来越火，很多公司在用，很多人在用，其重要性不言而喻。但是如果我让你回答下面的这些问题： 我们为什么要用mq？ 引入mq会多哪些问题？ 如何解决这些问题？ 你心中是否有答案了呢？本文将会一一为你解答，这些看似平常却很有意义的问题。 1 传统模式有哪些痛点？ 1.1 痛点1 有些复杂的业务系统，一次用户请求可能会同步调用N个系统的接口，需要等待所有的接口都返回了，才能真正的获取执行结果。 这种同步接口调用的方式总耗时比较长，非常影响用户的体验，特别是在
MQ的使用场景
u013733643的博客
04-08 7894
转自：http://www.cnblogs.com/linjiqin/p/5720865.html 一、消息队列概述 消息队列中间件是分布式系统中重要的组件，主要解决应用解耦，异步消息，流量削锋等问题，实现高性能，高可用，可伸缩和最终一致性架构。目前使用较多的消息队列有ActiveMQ，RabbitMQ，ZeroMQ，Kafka，MetaMQ，RocketMQ 二、消息队列应用场景 以下介绍消息队列在实际应用中常用的使用场景。异步处理，应用解耦，流量削锋和消息通讯四个场景。 2.1异步处理 场景说明：
Springboot----项目整合微信支付与RabbitMQ（使用RabbitMQ延迟插件实现订单管理）
赵四司机的博客
07-03 3637
主要介绍如何在Springboot项目支付模块中使用RabbitMQ实现延迟队列，采用的是RabbitMQ的延迟插件实现，文章中主要涉及RabbitMQ的相关配置、消息队列的创建与绑定以及生产者消费者的代码实现。
rabbitmq快速入门
03-11
你好，关于rabbitmq快速入门，我可以为您提供一些基本的信息和指导。首先，RabbitMQ是一个开源的消息代理软件，它实现了高级消息队列协议（AMQP）标准，可以用于实现异步消息传递和解耦。如果您想快速入门，可以先了解RabbitMQ的基本概念和架构，例如消息生产者、消息消费者、交换机、队列等等。同时，您还需要安装RabbitMQ并配置好环境，然后使用RabbitMQ提供的客户端API进行编程。当然，如果您需要更详细的指导和帮助，可以参考RabbitMQ官方文档或者相关的教程和书籍。希望这些信息对您有所帮助。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值