RabbitMQ简介以及在Spring Boot中使用

最新推荐文章于 2024-05-05 11:15:31 发布
最新推荐文章于 2024-05-05 11:15:31 发布
阅读量1.5k 收藏
点赞数 1
分类专栏： Java # 中间件、工具 文章标签： java rabbitmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/IT_10/article/details/81270654
版权

文章目录

消息队列

RabbitMQ是由erlang语言开发，基于AMQP（Advanced Message Queue 高级消息队列协议，应用层协议）协议实现的消息队列，它是一种应用程序之间的通信方法，消息队列在分布式系统开发中应用非常广泛。

通常，消息队列的应用场景为：

  • 处理异步任务
    将不需要同步处理的并且耗时长的操作由消息队列通知消息接收方进行异步处理。提高应用程序的响应速度。
  • 解耦合
    生产者通过MQ与消费者交换，将应用程序解耦合。

常用消息队列有：ActiveMQ，RabbitMQ，ZeroMQ，Kafka，MetaMQ，RocketMQ、Redis等

JMS

JMS（Java Message Service，Java消息服务）应用程序接口是一个Java平台中关于面向消息中间件的API，用于在两个应用程序之间，或分布式系统中发送消息，进行异步通信。

JMS是java提供的一套消息服务API标准，其目的是为所有的java应用程序提供统一的消息通信的标准，只要遵循JMS标准的应用程序之间都可以进行消息通信。它和AMQP有什么 不同，JMS是java语言专属的消息服务标准，它是在api层定义标准，并且只能用于java应用；而AMQP是在协议层定义的标准，是跨语言的 。

RabbitMQ消息投递模型

在这里插入图片描述
说明：

  • 一个TCP长连接中，有多个虚拟链路（信道），生产者有可能是个多线程的，那么每个线程就可以占用一个信道
  • Exchange：消息队列交换机，不具备持久化消息的特性，只是按一定的路由规则将消息转发到特定的队列
  • Broker：消息队列服务进程，此进程包括两个部分：Exchange和Queue
  • Queue：消息队列，存储消息的队列，消息到达队列并转发给指定的消费方
  • Producer：消息生产者，即生产方客户端，生产方客户端将消息发送到MQ
  • Consumer：消息消费者，即消费方客户端，接收MQ转发的消息

消息发送流程：

  1. 生产者和Broker建立TCP连接
  2. 生产者和Broker建立通道
  3. 生产者通过通道将消息发送给Broker，有Exchange将消息进行转发
  4. Exchange将消息转发到指定的Queue

消息接受流程：

  1. 消费者和Broker建立TCP连接
  2. 消费者和Broker建立通道
  3. 消费者监听指定的队列
  4. 当有消息到达队列时，Broker默认将消息推送给消费者
  5. 消费者接受消息

RabbitMQ的第一个示例

需要的依赖：

<dependency>
    <groupId>com.rabbitmq</groupId>
    <artifactId>amqp-client</artifactId>
    <version>4.0.3</version>
</dependency>

生产者程序：

public class Producer01 {
    //队列名称
    private static final String QUEUE = "test";

    public static void main(String[] args) {
        //通过连接工厂创建新的连接和mq建立连接
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("127.0.0.1");
        connectionFactory.setPort(5672); //默认端口
        connectionFactory.setUsername("guest"); //默认用户名
        connectionFactory.setPassword("guest"); //默认密码
        //设置虚拟机，一个mq服务可以设置多个相互隔离的虚拟机，每个虚拟机就相当于一个独立的mq
        connectionFactory.setVirtualHost("/");

        Connection connection = null;
        Channel channel = null;
        try {
            //建立新连接
            connection = connectionFactory.newConnection();
            //创建会话通道,生产者和mq服务所有通信都在channel通道中完成
            channel = connection.createChannel();
            //声明队列，如果队列没有在mq中则要创建
            /**
             * 参数说明
             * String queue, boolean durable, boolean exclusive,
             * boolean autoDelete, Map<String, Object> arguments
             *
             * 1、queue 队列名称
             * 2、durable 是否持久化，如果持久化，mq重启后队列还存在
             * 3、exclusive 是否独占连接，队列只允许在该连接中访问，如果connection连接关闭，队列则自动删除,如果将此参数设置true可用于临时队列的创建
             * 4、autoDelete 自动删除，队列不再使用时是否自动删除此队列，如果将此参数和exclusive参数设置为true就可以实现临时队列（队列不用了就自动删除）
             * 5、arguments 参数，可以设置一个队列的扩展参数，比如：可设置存活时间
             */
            channel.queueDeclare(QUEUE,true,false,false,null);
            //发送消息
            /**
             * 参数说明
             * String exchange, String routingKey, BasicProperties props, byte[] body
             *
             * 1、exchange，交换机，如果不指定将使用mq的默认交换机（设置为""）
             * 2、routingKey，路由key，交换机根据路由key来将消息转发到指定的队列，如果使用默认交换机，routingKey设置为队列的名称
             * 3、props，消息的属性
             * 4、body，消息内容
             */
            //消息内容
            String message = "Hello RabbitMQ！";
            channel.basicPublish("",QUEUE,null,message.getBytes());
            System.out.println("发送消息："+message);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //关闭通道
            try {
                channel.close();
            } catch (IOException e) {
                e.printStackTrace();
            } catch (TimeoutException e) {
                e.printStackTrace();
            }
            //关闭连接
            try {
                connection.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

通过浏览器登录进入RabbitMQ管理系统，运行程序，可以看到这个消息队列：
在这里插入图片描述
消费者程序：

public class Consumer01 {
    //队列
    private static final String QUEUE = "test";

    public static void main(String[] args) throws IOException, TimeoutException {
        //通过连接工厂创建新的连接和mq建立连接
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("127.0.0.1");
        connectionFactory.setPort(5672);//端口
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");
        //设置虚拟机，一个mq服务可以设置多个虚拟机，每个虚拟机就相当于一个独立的mq
        connectionFactory.setVirtualHost("/");

        //建立新连接
        Connection connection = connectionFactory.newConnection();
        //创建会话通道,生产者和mq服务所有通信都在channel通道中完成
        Channel channel = connection.createChannel();

        //监听队列
        //声明队列，如果队列没有在mq中则要创建
        channel.queueDeclare(QUEUE,true,false,false,null);

        //实现消费方法
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel){
            /**
             * 当接收到消息后此方法将被调用
             * @param consumerTag  消费者标签，用来标识消费者的，在监听队列时设置channel.basicConsume
             * @param envelope 信封，通过envelope可以获取得到交换机、消息id等消息
             * @param properties 消息属性
             * @param body 消息内容
             * @throws IOException
             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //交换机
                //String exchange = envelope.getExchange();
                //消息id，mq在channel中用来标识消息的id，可用于确认消息已接收
                //long deliveryTag = envelope.getDeliveryTag();
                //消息内容
                String message= new String(body,"utf-8");
                System.out.println("收到消息："+message);
            }
        };

        //监听队列
        /**
         * 参数说明
         * String queue, boolean autoAck, Consumer callback
         *
         * 1、queue 队列名称
         * 2、autoAck 如果将此参数设置为tru表示会自动回复mq，当消费者接收到消息后要告诉mq消息已接收；如果设置为false要通过编程实现回复
         * 3、callback 消费者接收到消息要执行的方法
         */
        channel.basicConsume(QUEUE,true,defaultConsumer);
    }
}

RabbitMQ的工作模式

  • Work queues 工作队列模式
  • Publish/Subscribe 发布/订阅模式
  • Routing 路由模式
  • Topics 通配符模式
  • Header
  • RPC
Work queues

在这里插入图片描述
一个生产者发送消息到队列，多个消费者共同监听该队列，并且，消息不能被重复消费，RabbitMQ中采用轮询的方式将消息发送给其中一个消费者。

应用场景：多个消费者可以轮询消费消息，提高任务的处理速度

代码示例同上面的例子，只是运行多个消费者程序，运行一个生产者程序。

Publish/Subscribe

在这里插入图片描述
每个消费者监听自己的队列，生产者将消息发送给broker，由交换机将消息转发到绑定此交换机的每个队列，每个绑定交换机的队列都将接受到消息。
如果一个队列有多个监听者，则和工作队列模式一样，轮询地发送消息给消费者。

应用场景：如用户支付成功，同时需要发送短信通知和邮件通知

发布者查询：

public class Producer02_publish {
    //队列名称
    private static final String QUEUE_INFORM_EMAIL = "queue_inform_email";
    private static final String QUEUE_INFORM_SMS = "queue_inform_sms";
    private static final String EXCHANGE_FANOUT_INFORM="exchange_fanout_inform";

    public static void main(String[] args) {
        //通过连接工厂创建新的连接和mq建立连接
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("127.0.0.1");
        connectionFactory.setPort(5672);//端口
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");
        //设置虚拟机，一个mq服务可以设置多个虚拟机，每个虚拟机就相当于一个独立的mq
        connectionFactory.setVirtualHost("/");

        Connection connection = null;
        Channel channel = null;
        try {
            //建立新连接
            connection = connectionFactory.newConnection();
            //创建会话通道,生产者和mq服务所有通信都在channel通道中完成
            channel = connection.createChannel();
            //声明队列，如果队列没有在mq中则要创建
            channel.queueDeclare(QUEUE_INFORM_EMAIL,true,false,false,null);
            channel.queueDeclare(QUEUE_INFORM_SMS,true,false,false,null);
            //声明一个交换机
            channel.exchangeDeclare(EXCHANGE_FANOUT_INFORM, BuiltinExchangeType.FANOUT);

            //进行交换机和队列绑定
            /**
             * 参数说明
             * String queue, String exchange, String routingKey
             * 1、queue 队列名称
             * 2、exchange 交换机名称
             * 3、routingKey 路由key，作用是交换机根据路由key的值将消息转发到指定的队列中，在发布订阅模式中为空字符串
             */
            channel.queueBind(QUEUE_INFORM_EMAIL,EXCHANGE_FANOUT_INFORM,"");
            channel.queueBind(QUEUE_INFORM_SMS,EXCHANGE_FANOUT_INFORM,"");

            //发送消息
            for(int i=0;i<5;i++){
                //消息内容
                String message = "支付成功";
                channel.basicPublish(EXCHANGE_FANOUT_INFORM,"",null,message.getBytes());
                System.out.println("发送消息："+message);
            }

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //关闭通道
            try {
                channel.close();
            } catch (IOException e) {
                e.printStackTrace();
            } catch (TimeoutException e) {
                e.printStackTrace();
            }
            //关闭连接
            try {
                connection.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

邮件订阅者程序：

public class Consumer02_subscribe_email {
    //队列名称
    private static final String QUEUE_INFORM_EMAIL = "queue_inform_email";
    private static final String EXCHANGE_FANOUT_INFORM="exchange_fanout_inform";

    public static void main(String[] args) throws IOException, TimeoutException {
        //通过连接工厂创建新的连接和mq建立连接
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("127.0.0.1");
        connectionFactory.setPort(5672);//端口
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");
        //设置虚拟机，一个mq服务可以设置多个虚拟机，每个虚拟机就相当于一个独立的mq
        connectionFactory.setVirtualHost("/");

        //建立新连接
        Connection connection = connectionFactory.newConnection();
        //创建会话通道,生产者和mq服务所有通信都在channel通道中完成
        Channel channel = connection.createChannel();

        channel.queueDeclare(QUEUE_INFORM_EMAIL,true,false,false,null);
        //声明一个交换机
        channel.exchangeDeclare(EXCHANGE_FANOUT_INFORM, BuiltinExchangeType.FANOUT);

        //进行交换机和队列绑定
        channel.queueBind(QUEUE_INFORM_EMAIL, EXCHANGE_FANOUT_INFORM, "");

        //实现消费方法
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //交换机
                String exchange = envelope.getExchange();
                //消息id，mq在channel中用来标识消息的id，可用于确认消息已接收
                long deliveryTag = envelope.getDeliveryTag();
                //消息内容
                String message= new String(body,"utf-8");
                System.out.println("receive message:"+message);
            }
        };

        //监听队列
        channel.basicConsume(QUEUE_INFORM_EMAIL,true,defaultConsumer);

    }
}

在这里插入图片描述
短信订阅者程序：

public class Consumer02_subscribe_sms {
    //队列名称
    private static final String QUEUE_INFORM_SMS = "queue_inform_sms";
    private static final String EXCHANGE_FANOUT_INFORM="exchange_fanout_inform";


    public static void main(String[] args) throws IOException, TimeoutException {
        //通过连接工厂创建新的连接和mq建立连接
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("127.0.0.1");
        connectionFactory.setPort(5672);//端口
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");
        //设置虚拟机，一个mq服务可以设置多个虚拟机，每个虚拟机就相当于一个独立的mq
        connectionFactory.setVirtualHost("/");

        //建立新连接
        Connection connection = connectionFactory.newConnection();
        //创建会话通道,生产者和mq服务所有通信都在channel通道中完成
        Channel channel = connection.createChannel();

        channel.queueDeclare(QUEUE_INFORM_SMS,true,false,false,null);
        //声明一个交换机
        channel.exchangeDeclare(EXCHANGE_FANOUT_INFORM, BuiltinExchangeType.FANOUT);
        //进行交换机和队列绑定
        channel.queueBind(QUEUE_INFORM_SMS, EXCHANGE_FANOUT_INFORM, "");

        //实现消费方法
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //交换机
                String exchange = envelope.getExchange();
                //消息id，mq在channel中用来标识消息的id，可用于确认消息已接收
                long deliveryTag = envelope.getDeliveryTag();
                //消息内容
                String message= new String(body,"utf-8");
                System.out.println("receive message:"+message);
            }
        };

        //监听队列
        channel.basicConsume(QUEUE_INFORM_SMS,true,defaultConsumer);
    }
}

交换机种类：

  • fanout：对应publish/subscribe工作模式
  • direct：Routing工作模式
  • topic：topics工作模式
  • handlers：handler是工作模式
Routing

在这里插入图片描述
每个消费者监听自己的队列，并且设置routingkey。生产者将消息发给交换机，由交换机根据routingkey来转发消息到指定的队列。

发送者程序：

public class Producer03_routing {
    //队列名称
    private static final String QUEUE_INFORM_EMAIL = "queue_inform_email";
    private static final String QUEUE_INFORM_SMS = "queue_inform_sms";

    //交换机名称
    private static final String EXCHANGE_ROUTING_INFORM="exchange_routing_inform";

    //路由key
    private static final String ROUTINGKEY_EMAIL="inform_email";
    private static final String ROUTINGKEY_SMS="inform_sms";

    public static void main(String[] args) {
        //通过连接工厂创建新的连接和mq建立连接
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("127.0.0.1");
        connectionFactory.setPort(5672);//端口
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");
        //设置虚拟机，一个mq服务可以设置多个虚拟机，每个虚拟机就相当于一个独立的mq
        connectionFactory.setVirtualHost("/");

        Connection connection = null;
        Channel channel = null;
        try {
            //建立新连接
            connection = connectionFactory.newConnection();
            //创建会话通道,生产者和mq服务所有通信都在channel通道中完成
            channel = connection.createChannel();
            //声明队列，如果队列没在mq中则要创建
            channel.queueDeclare(QUEUE_INFORM_EMAIL,true,false,false,null);
            channel.queueDeclare(QUEUE_INFORM_SMS,true,false,false,null);
            //声明一个交换机
            channel.exchangeDeclare(EXCHANGE_ROUTING_INFORM, BuiltinExchangeType.DIRECT);

            //进行交换机和队列绑定
            channel.queueBind(QUEUE_INFORM_EMAIL,EXCHANGE_ROUTING_INFORM,ROUTINGKEY_EMAIL);
            channel.queueBind(QUEUE_INFORM_SMS,EXCHANGE_ROUTING_INFORM,ROUTINGKEY_SMS);

            //发送消息
            for(int i=0;i<5;i++){
                //发送消息的时候指定routingKey
                String message = "支付成功";
                channel.basicPublish(EXCHANGE_ROUTING_INFORM,ROUTINGKEY_SMS,null,message.getBytes());
                System.out.println("发送消息："+message);
            }

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //关闭通道
            try {
                channel.close();
            } catch (IOException e) {
                e.printStackTrace();
            } catch (TimeoutException e) {
                e.printStackTrace();
            }
            //关闭连接
            try {
                connection.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

邮件接收者程序：

public class Consumer03_routing_email {
    //队列名称
    private static final String QUEUE_INFORM_EMAIL = "queue_inform_email";
    private static final String EXCHANGE_ROUTING_INFORM="exchange_routing_inform";
    private static final String ROUTINGKEY_EMAIL="inform_email";

    public static void main(String[] args) throws IOException, TimeoutException {
        //通过连接工厂创建新的连接和mq建立连接
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("127.0.0.1");
        connectionFactory.setPort(5672);//端口
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");
        //设置虚拟机，一个mq服务可以设置多个虚拟机，每个虚拟机就相当于一个独立的mq
        connectionFactory.setVirtualHost("/");

        //建立新连接
        Connection connection = connectionFactory.newConnection();
        //创建会话通道,生产者和mq服务所有通信都在channel通道中完成
        Channel channel = connection.createChannel();

        channel.queueDeclare(QUEUE_INFORM_EMAIL,true,false,false,null);
        //声明一个交换机
        channel.exchangeDeclare(EXCHANGE_ROUTING_INFORM, BuiltinExchangeType.DIRECT);
        //进行交换机和队列绑定
        channel.queueBind(QUEUE_INFORM_EMAIL, EXCHANGE_ROUTING_INFORM,ROUTINGKEY_EMAIL);

        //实现消费方法
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //交换机
                String exchange = envelope.getExchange();
                //消息id，mq在channel中用来标识消息的id，可用于确认消息已接收
                long deliveryTag = envelope.getDeliveryTag();
                //消息内容
                String message= new String(body,"utf-8");
                System.out.println("接收消息"+message);
            }
        };

        //监听队列
        channel.basicConsume(QUEUE_INFORM_EMAIL,true,defaultConsumer);

    }
}

短信接收者程序：

public class Consumer03_routing_sms {
    //队列名称
    private static final String QUEUE_INFORM_SMS = "queue_inform_sms";
    private static final String EXCHANGE_ROUTING_INFORM="exchange_routing_inform";
    private static final String ROUTINGKEY_SMS="inform_sms";

    public static void main(String[] args) throws IOException, TimeoutException {
        //通过连接工厂创建新的连接和mq建立连接
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("127.0.0.1");
        connectionFactory.setPort(5672);//端口
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");
        //设置虚拟机，一个mq服务可以设置多个虚拟机，每个虚拟机就相当于一个独立的mq
        connectionFactory.setVirtualHost("/");

        //建立新连接
        Connection connection = connectionFactory.newConnection();
        //创建会话通道,生产者和mq服务所有通信都在channel通道中完成
        Channel channel = connection.createChannel();

        channel.queueDeclare(QUEUE_INFORM_SMS,true,false,false,null);
        //声明一个交换机
        channel.exchangeDeclare(EXCHANGE_ROUTING_INFORM, BuiltinExchangeType.DIRECT);
        //进行交换机和队列绑定
        channel.queueBind(QUEUE_INFORM_SMS, EXCHANGE_ROUTING_INFORM,ROUTINGKEY_SMS);

        //实现消费方法
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //交换机
                String exchange = envelope.getExchange();
                //消息id，mq在channel中用来标识消息的id，可用于确认消息已接收
                long deliveryTag = envelope.getDeliveryTag();
                //消息内容
                String message= new String(body,"utf-8");
                System.out.println("接受消息："+message);
            }
        };

        //监听队列
        channel.basicConsume(QUEUE_INFORM_SMS,true,defaultConsumer);
    }
}

由于发送消息的时候，routingkey设置的是ROUTINGKEY_SMS，短信接收者的routingkey也设置的是ROUTINGKEY_SMS，因此只有短信接收者程序才能接收到消息。

Topics

在这里插入图片描述
每个消费者监听自己的队列，并且设置带统配符的routingkey。生产者将消息发给broker，由交换机根据routingkey来转发消息到指定的队列。
符号#可以匹配多个词，符号*可以匹配一个词语
实例代码和上面的一样，只是将routingkey设置为通配符模式，进行交换机和队列绑定的时候指定routingkey，交换机根据匹配规则将消息发送到不同的消息队列中。监听者接进行交换机和队列绑定的时候同样指定routingkey。

Header

header模式与routing不同的地方在于，header模式取消routingkey，使用header中的key/value（键值对）匹配队列。

应用场景：根据用户的通知设置去通知用户，设置接收Email的用户只接收Email，设置接收sms的用户只接收sms，设置两种通知类型都接收的则两种通知都有效。

RPC

RPC即客户端远程调用服务端的方法，使用MQ可以实现RPC的异步调用，基于Direct交换机实现，流程如下：

  • 客户端既是生产者也是消费者，向RPC请求队列发送RPC调用消息，同时监听RPC响应队列。
  • 服务端监听RPC请求队列的消息，收到消息后执行服务端的方法，得到方法返回的结果
  • 服务端将RPC方法的结果发送到RPC响应队列
  • 客户端（RPC调用方）监听RPC响应队列，接收到RPC调用结果

Spring Boot整合RabbitMQ

添加依赖：

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

配置application.yml：

spring:
  application:
    name: test-rabbitmq-producer
  rabbitmq:
    host: 127.0.0.1
    port: 5672
    username: guest
    password: guest
    virtualHost: /

这里以Topics工作模式举例，ROUTINGKEY_EMAIL队列绑定交换机，指定routingKey
为inform.#.email.#，QUEUE_INFORM_SMS队列绑定交换机，指定routingKey为inform.#.sms.#，发送方指定的routingkey为inform.sms，因此只有QUEUE_INFORM_SMS队列能接收到消息。

RabbitmqConfig配置文件，放在包下即可，生产者和发送者都需要这个配置文件：

@Configuration
public class RabbitmqConfig {
    public static final String QUEUE_INFORM_EMAIL = "queue_inform_email";
    public static final String QUEUE_INFORM_SMS = "queue_inform_sms";
    public static final String EXCHANGE_TOPICS_INFORM="exchange_topics_inform";
    public static final String ROUTINGKEY_EMAIL="inform.#.email.#";
    public static final String ROUTINGKEY_SMS="inform.#.sms.#";

    //声明交换机
    @Bean(EXCHANGE_TOPICS_INFORM)
    public Exchange EXCHANGE_TOPICS_INFORM(){
        //durable(true) 持久化，mq重启之后交换机还在
        return ExchangeBuilder.topicExchange(EXCHANGE_TOPICS_INFORM).durable(true).build();
    }

    //声明QUEUE_INFORM_EMAIL队列
    @Bean(QUEUE_INFORM_EMAIL)
    public Queue QUEUE_INFORM_EMAIL(){
        return new Queue(QUEUE_INFORM_EMAIL);
    }
    //声明QUEUE_INFORM_SMS队列
    @Bean(QUEUE_INFORM_SMS)
    public Queue QUEUE_INFORM_SMS(){
        return new Queue(QUEUE_INFORM_SMS);
    }

    //ROUTINGKEY_EMAIL队列绑定交换机，指定routingKey
    @Bean
    public Binding BINDING_QUEUE_INFORM_EMAIL(@Qualifier(QUEUE_INFORM_EMAIL) Queue queue,
                                              @Qualifier(EXCHANGE_TOPICS_INFORM) Exchange exchange){
        return BindingBuilder.bind(queue).to(exchange).with(ROUTINGKEY_EMAIL).noargs();
    }
    //ROUTINGKEY_SMS队列绑定交换机，指定routingKey
    @Bean
    public Binding BINDING_ROUTINGKEY_SMS(@Qualifier(QUEUE_INFORM_SMS) Queue queue,
                                              @Qualifier(EXCHANGE_TOPICS_INFORM) Exchange exchange){
        return BindingBuilder.bind(queue).to(exchange).with(ROUTINGKEY_SMS).noargs();
    }
}

发送方程序，这里写在一个测试类中即可：

@Autowired
RabbitTemplate rabbitTemplate;

//使用rabbitTemplate发送消息
@Test
public void testSendEmail(){

    String message = "send email message to user";
    /**
     * 参数：
     * 1、交换机名称
     * 2、routingKey
     * 3、消息内容
     */
    rabbitTemplate.convertAndSend(RabbitmqConfig.EXCHANGE_TOPICS_INFORM,"inform.email",message);

}

接收方程序，这里写在包下的某个类中（打上@Component注解）即可，只要打上RabbitListener注解，当Sbring Boot程序启动的时候就会执行该方法从消息队里中取消息：

@RabbitListener(queues = {RabbitmqConfig.QUEUE_INFORM_EMAIL})
public void getEmail(String msg,Message message,Channel channel){
    System.out.println("receive message is:"+msg);
}
IT_10-
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringBoot集成RabbitMQ
qixiang_chen的博客
11-15 1577
配置POM 配置application.properties 发送RabbitMQ消息分为两种，第一种是同步调用(RPC)，也就是发送完消息后需要等待消息处理结果，第二种是异步消息，发送者发消息后可以处理其他业务，不等待消息处理结果。 同步消息 消息发送类 package com.test; import java.io.ByteArrayOutputStream; import java....
python中true+false的值,python中的true和false
yang0728y的博客
01-04 460
大家好，给大家分享一下python中true+false的值，很多人还不知道这一点。在python中，bool的True和False是数值1和0的字符串表示格式，实际上bool类型是int类型的一个子类。，所以可以直接在布尔测试的表达式中使用，而并非一定要去大小比较、通过函数测试等等。因为True/False是数值1和0的另一种表示方式，它们可以直接参与数值运算。那么，哪些类型的数据是True，哪些类型的数据是False？实际上，一个数据对象是真还是假，是根据这个类型的。的返回值(为0则为假)来决定的。
13、Python：布尔值类型（True False）
最新发布
一名全栈开发工程师
05-05 421
Python中的布尔值是编程中的基础概念，用于表示逻辑上的“真”或“假”。True和False。
RabbitMq的学习和Springboot结合（基础）
m0_51340928的博客
02-11 987
多个消费者绑定到一个队列，同一条消息只会被一个消费者处理通过设置prefetch来控制消费者预取的消息数量交换机的作用是什么？接收publisher发送的消息将消息按照规则路由到与之绑定的队列不能缓存消息，路由失败，消息丢失FanoutExchange的会将消息路由到每个绑定的队列描述下Direct交换机与Fanout交换机的差异？Fanout交换机将消息路由给每一个与之绑定的队列Direct交换机根据RoutingKey判断路由给哪个队列。
python中有哪些类型的布尔值是False？
Kwoky的博客
04-28 4252
问题不大，你能肯定的说上来吗？ 1.None 2. False 3.所有的值为零的数 4."" 5.[] 6.() 7.{}
RabbitMQ+SpringBoot
Pratik_shiku的博客
09-23 1394
RabbitMQ 文章目录`RabbitMQ`一、简介1. 是什么2. 消息模型3. 应用场景二、`Docker`部署和配置1. 拉取镜像2. 跑3. 访问4. 创建新用户5. 创建`virtual host`三、`Springboot`整合`rabbitMQ`1. `Hello World`① 编写一个消息提供者`Provider`：② 编写一个消息消费者`Consumer`：2. `Work`队列① 编写一个消息提供者`WorkProvider`② 编写两个消息消费者`WorkConsumer1和Wor
Spring Boot中使用RabbitMQ的示例代码
08-27
本篇文章主要介绍了Spring Boot中使用RabbitMQ的示例代码，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
spring boot中使用RabbitMQ routing路由详解
08-27
本篇文章主要介绍了spring boot中使用RabbitMQ routing路由详解，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
详解Spring Boot 配置多个RabbitMQ
08-30
本篇文章主要介绍了Spring Boot 配置多个RabbitMQ，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Spring Boot RabbitMQ常用配置
04-21
RabbitMQ 是一个开源的消息代理中间件，广泛用于构建分布式应用程序中的消息系统。在 Spring Boot 项目中，通过集成 RabbitMQ，可以实现异步消息传递、消息队列等功能，提高系统的可靠性和扩展性。
spring boot整合RabbitMQ（Direct模式）
08-30
springboot集成RabbitMQ非常简单，如果只是简单的使用配置非常少，springboot提供了spring-boot-starter-amqp项目对消息各种支持。下面通过本文给大家介绍下spring boot整合RabbitMQ（Direct模式）,需要的朋友可以...
javascript布尔值_JavaScript中的布尔值
07-28 3245
javascript布尔值 JavaScript布尔值 (JavaScript Boolean) Boolean is a data type that stores only two values: true and false. 布尔值是仅存储两个值的数据类型： true和false 。 Alternately, true is represented by 1 and false by ...
Springboot RabbitMq源码解析之配置类
翻身已碰头的博客
12-07 2971
1. RabbitAutoConfiguration类 RabbitAutoConfiguration类是springboot的自动配置类。 @Configuration @ConditionalOnClass({ RabbitTemplate.class, Channel.class }) @EnableConfigurationProperties(RabbitProperties.class...
python 去除列表空值_Python中的布尔值（bool）与空值（None）
weixin_39586235的博客
12-04 477
# 空值：# python中一种特殊的值，用None表示，空值的类型也是一种特殊数据类型# None不能理解为0，因为0是有意义的，而None是一个特殊值。# 空值通常用作默认值使用# 创建一个空值a = Noneprint(a)print(type(a))# 布尔：# 用来存储一个真或假的数值，只有真 True或者假 False两种值# True 和 False 是 Python 中的...
python中什么的布尔值不是false_不是python中的布尔值
weixin_39639622的博客
01-13 3733
我从1989年的K&R书中学习了去年夏天的C。我现在正在学习Python3。在我有点困惑。在如果我做测试的话如果！(……)那个“！”将“()”中的值更改为相反的值，因此如果为true，则变为false，反之亦然。在所以我要做的是，把它从C改成python。在int card(long long number, int size){if(!(size == 13 || size == 15 ...
#Python3中布尔类型False和True
weixin_43097301的博客
10-01 2万+
Python中布尔类型 布尔类型只有True（正确）和False（错误）两种值，但是布尔类型有以下几种运算： True：一个条件正确 False：一个条件错误 1.与运算：只有两个布尔值都为 True 时，计算结果才为 True。 print(True and True) #(输出)True print(True and False) #(输出)False print(False and ...
Python总复习——选择题篇
热门推荐
昕昕子的博客
06-21 2万+
1、下列选项中,( D )的布尔值不是False。 A.None B.0 C.() D.12、假设a=9，b=2，那么下列运算中，错误的是( D )。 A.a+b的值是11 B.a//b的值是4 C.a%b的值是1 D.a**b的值是183、下列符号中，表示Python中单行注释的是( A )。 A.# B.// C.< !-- --> D.“”"4、下列表达式中，返回 True 的是( B )。 A.a=2 b=2 a=b B.3>2>1 C.True and False D.2!=25、下列语句
RabbitMQ与SpringBoot简单结合（二）结合使用简单介绍
博客
02-01 1203
在之前的博客中,我们介绍了如何搭建RabbitMQ环境,在这篇博客中,会介绍SpringBoot和RabbitMQ的简单的综合使用。 目录 RabbitMQ对比ActiveMQ结合SpringBoot的优点 结合使用的简单介绍 POM.xml添加依赖 修改application.properties 创建RabbitMQ相关类 创建消息提供者 创建消息消费者 创建Controll...
RabbitMQ详解以及和SpringBoot整合
m0_37743948的博客
09-27 3380
各消息组件的适用场景 ActiveMQ ActiveMQ 是一款比较早期的消息组件，由Apache开源出来的，它能满足吞吐量一般的业务场景，但是对于高并发场景，性能较差。 Kafka Kafka追求高吞吐量的特性，它一开始使用于日志的收集。缺点是消息可靠性支持较少，适合产生大量数据的互联网服务的数据收集业务。 RocketMQ RocketMQ 早期由阿里团队开发的，现在升级为Apache的顶级...
Spring boot 怎么使用Rabbitmq
04-04
Spring Boot中使用RabbitMQ可以通过以下步骤进行： 1. 添加RabbitMQ依赖 在pom.xml中添加以下依赖： ``` <groupId>org.springframework.boot <artifactId>spring-boot-starter-amqp ``` 2. 配置RabbitMQ连接...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值