RabbitMQ安装、工作模式和SpringBoot整合RabbitMQ

已于 2022-07-14 10:36:21 修改
阅读量1.8k 收藏 2
点赞数
分类专栏： Spring 文章标签： rabbitmq spring boot
于 2021-11-09 09:59:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43492477/article/details/120995839
版权

RabbitMQ

一、RabbitMQ

1.1 RabbitMQ介绍

MQ全称为Message Queue，即消息队列， RabbitMQ是由erlang语言开发，基于AMQP（Advanced Message Queue 高级消息队列协议）协议实现的消息队列，它是一种应用程序之间的通信方法，消息队列在分布式系统开发中应用非常广泛。RabbitMQ官方地址：http://www.rabbitmq.com/

  • 开发中消息队列通常有如下应用场景：

    • 1 、任务异步处理。
      将不需要同步处理的并且耗时长的操作由消息队列通知消息接收方进行异步处理。提高了应用程序的响应时间。
    • 2 、应用程序解耦合
      MQ相当于一个中介，生产方通过MQ与消费方交互，它将应用程序进行解耦合。

  • 市场上还有哪些消息队列？

    ActiveMQ，RabbitMQ，ZeroMQ，Kafka，MetaMQ，RocketMQ、Redis。

  • 为什么使用RabbitMQ呢？

    • 1 、使得简单，功能强大。
    • 2 、基于AMQP协议。
    • 3 、社区活跃，文档完善。
    • 4 、高并发性能好，这主要得益于Erlang语言。
    • 5 、Spring Boot默认已集成RabbitMQ

1.2 AMQP

在这里插入图片描述

总结：AMQP是一套公开的消息队列协议，最早在 2003 年被提出，它旨在从协议层定义消息通信数据的标准格式，为的就是解决MQ市场上协议不统一的问题。RabbitMQ就是遵循AMQP标准协议开发的MQ服务。

1.3 JMS

在这里插入图片描述

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

1.4 RabbitMQ工作原理

RabbitMQ的基本结构：

在这里插入图片描述
组成部分说明如下：

  • Broker：消息队列服务进程，此进程包括两个部分：Exchange和Queue。
  • Exchange：消息队列交换机，按一定的规则将消息路由转发到某个队列，对消息进行过虑。
  • Queue：消息队列，存储消息的队列，消息到达队列并转发给指定的消费方。
  • Producer：消息生产者，即生产方客户端，生产方客户端将消息发送到MQ。
  • Consumer：消息消费者，即消费方客户端，接收MQ转发的消息。

消息发布接收流程：

  • - - - -发送消息 - - - - -

1 、生产者和Broker建立TCP连接。
2 、生产者和Broker建立通道。
3 、生产者通过通道消息发送给Broker，由Exchange将消息进行转发。
4 、Exchange将消息转发到指定的Queue（队列）

  • - - - - 接收消息 - - - -

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

二、RabbitMQ安装使用

2.1 下载安装

RabbitMQ由Erlang语言开发，Erlang语言用于并发及分布式系统的开发，在电信领域应用广泛，OTP（Open Telecom Platform）作为Erlang语言的一部分，包含了很多基于Erlang开发的中间件及工具库，安装RabbitMQ需要安装Erlang/OTP，并保持版本匹配，如下图：
RabbitMQ的下载地址：http://www.rabbitmq.com/download.html

在这里插入图片描述
本项目使用Erlang/OTP 20.3版本和RabbitMQ3.7.3版本。

  • 1 ） 下载erlang

    地址如下：http://erlang.org/download/otp_win64_20.3.exe
    erlang安装完成需要配置erlang环境变量： ERLANG_HOME=D:\Program Files\erl9.3
    在path中添加：PATH=%ERLANG_HOME%\bin;

  • 2 ）安装RabbitMQ
    https://github.com/rabbitmq/rabbitmq-server/releases/tag/v3.7.3
    `

2.2 启动

安装成功后会自动创建RabbitMQ服务并且启动。

在这里插入图片描述

  • 安装管理插件
    管理员身份运行 rabbitmq-plugins.bat enable rabbitmq_management

  • 启动服务
    rabbitmq-service.bat install 安装服务
    rabbitmq-service.bat stop 停止服务
    rabbitmq-service.bat start 启动服务
    rabbitmq-service.bat restart 重启服务

  • 启动成功 登录RabbitMQ

    进入浏览器，输入：http://localhost:15672(初始账号和密码：guest/guest)

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

2.3 注意事项

1 、 安装erlang和r abbitMQ以管理员身份运行。
2 、 当卸载重新安装时会出现RabbitMQ服务注册失败，此时需要进入注册表清理erlang，搜索RabbitMQ、E rlSrv，将对应的项全部删除。

2.4 RabbitMQ的使用

在这里插入图片描述

2.4.1搭建环境

创建maven工程、创建生产者工程和消费者工程，分别加入RabbitMQ java client的依赖。

  • rabbitmq-producer：生产者工程
  • rabbitmq-consumer：消费者工程
<dependency>
    <groupId>com.rabbitmq</groupId>
    <artifactId>amqp-client</artifactId>
    <version>4.0.3</version>
</dependency>
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring‐boot‐starter‐logging</artifactId>
</dependency>

2.4.2 生产者

import com.rabbitmq.client.*;

import java.io.IOException;

public class HelloConsumer {

    private static final String HELLO_QUEUE = "hello_queue";

    public static void main(String[] args) {
        Connection connection = null;
        Channel channel = null;
        try {
            // 1.创建Connectionfactory对象，用于生产Connection对象
            ConnectionFactory connectionFactory = new ConnectionFactory();
            connectionFactory.setHost("localhost");
            connectionFactory.setPort(5672);
            connectionFactory.setUsername("guest");
            connectionFactory.setPassword("guest");
            connectionFactory.setVirtualHost("/");
            // 2.生产Connection对象
            connection = connectionFactory.newConnection();
            // 3.通过连接对象创建通道
            channel = connection.createChannel();
            // 4.声明一个队列
            /**
             * queue – 队列名称
             * durable – true代表mq服务重启后，队列依然存在
             * exclusive - true代表当前连接独占该队列,连接关闭，队列就消失了
             * autoDelete - true队列不再使用时，直接删除此队列
             * argments - 扩展参数
             */
            channel.queueDeclare(HELLO_QUEUE, true, false, false, null);
            // 5.读取消息
            channel.basicConsume(HELLO_QUEUE, true, new DefaultConsumer(channel) {
                @Override
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                    System.out.println("入门案例：消费端接收到消息：" + new String(body));
                }
            });
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

2.4.3 消费者

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

/**
 * 轮询
 */
public class HelloProducer {

    private static final String HELLO_QUEUE = "hello_queue";

    public static void main(String[] args) {
        Connection connection = null;
        Channel channel = null;
        try {
            //1.创建ConnectionFactory对象，用于生产Connection对象
            ConnectionFactory connectionFactory = new ConnectionFactory();
            connectionFactory.setHost("localhost");
            connectionFactory.setPort(5672);
            connectionFactory.setUsername("guest");
            connectionFactory.setPassword("guest");
            connectionFactory.setVirtualHost("/");
            //2.生产Connection对象
            connection = connectionFactory.newConnection();
            //3.通过连接对象创建通道
            channel = connection.createChannel();
            //4.声明一个队列
            /**
             * queue – 队列名称
             * durable – true代表mq服务重启后，队列依然存在
             * exclusive - true代表当前连接独占该队列,连接关闭，队列就消失了
             * autoDelete - true队列不再使用时，直接删除此队列
             * argments - 扩展参数
             */
            channel.queueDeclare(HELLO_QUEUE,true,false,false,null);
            //5.定义信息，发送到mq消息队列中
            String msg = "hello RabbitMQ Producer";
            //6.发送信息
            /**
             * exchange – 交换机
             * routingKey – 路由Key
             * props – 消息属性
             * body –  消息内容
             */
            channel.basicPublish("",HELLO_QUEUE,null,msg.getBytes());
            System.out.println("入门案例：上传者发送信息队列 ===> " + msg);
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                if(channel != null){
                    channel.close();
                }
                if(connection != null){
                    connection.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

2.4.4 总结

  • 1 、发送端操作流程

    1 ）创建连接
    2 ）创建通道
    3 ）声明队列
    4 ）发送消息

  • 2 、接收端

    1 ）创建连接
    2 ）创建通道
    3 ）声明队列
    4 ）监听队列
    5 ）接收消息
    6 ）ack回复

三、工作模式

3.1 Work queues

在这里插入图片描述

work queues与入门程序相比，多了一个消费端，两个消费端共同消费同一个队列中的消息。

  • 应用场景：

    对于任务过重或任务较多情况使用工作队列可以提高任务处理的速度。

  • 测试：

    1 、使用入门程序，启动多个消费者。
    2 、生产者发送多个消息。

  • 结果：

    1 、一条消息只会被一个消费者接收；
    2 、rabbit采用轮询的方式将消息是平均发送给消费者的；
    3 、消费者在处理完某条消息后，才会收到下一条消息。

3.2 Publish/subscribe

3.2.1 工作模式

在这里插入图片描述
发布订阅模式：

1 、每个消费者监听自己的队列。
2 、生产者将消息发给broker，由交换机将消息转发到绑定此交换机的每个队列，每个绑定交换机的队列都将接收到消息

3.2.2 代码实现

  • 1 、生产者

    声明Exchange_fanout_inform交换机。
    声明两个队列并且绑定到此交换机，绑定时不需要指定routingkey
    发送消息时不需要指定routingkey

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

import java.io.IOException;

/**
 * publish工作模式 ===> 生产者
 * 发布订阅
 */
public class PublishProducer {

    private static final String PUBLISH_EXCHANGE = "publish_exchange";
    private static final String PUBLISH_QUEUE_EMAIL = "publish_queue_email";
    private static final String PUBLISH_QUEUE_SMS = "publish_queue_sms";


    public static void main(String[] args) {
        Connection connection = null;
        Channel channel = null;
        try {
            // 1.创建Connectionfactory对象，用于生产Connection对象
            ConnectionFactory connectionFactory = new ConnectionFactory();
            connectionFactory.setHost("localhost");
            connectionFactory.setPort(5672);
            connectionFactory.setUsername("guest");
            connectionFactory.setPassword("guest");
            connectionFactory.setVirtualHost("/");
            // 2.生产Connection对象
            connection = connectionFactory.newConnection();

            // 3.通过连接对象创建通道
            channel = connection.createChannel();
            // 4.声明交换机
            channel.exchangeDeclare(PUBLISH_EXCHANGE, BuiltinExchangeType.FANOUT);
            // 5.声明队列
            /**
             * queue – 队列名称
             * durable – true代表mq服务重启后，队列依然存在
             * exclusive - true代表当前连接独占该队列,连接关闭，队列就消失了
             * autoDelete - true队列不再使用时，直接删除此队列
             * argments - 扩展参数
             */
            channel.queueDeclare(PUBLISH_QUEUE_EMAIL, true, false, false, null);
            channel.queueDeclare(PUBLISH_QUEUE_SMS, true, false, false, null);
            // 6.交换机绑定队列
            /**
             * queue – 队列名称
             * exchange – 交换机名称
             * routingKey – 路由Key
             */
            channel.queueBind(PUBLISH_QUEUE_EMAIL, PUBLISH_EXCHANGE, "");
            channel.queueBind(PUBLISH_QUEUE_SMS, PUBLISH_EXCHANGE, "");
            // 7.发送消息
            String msg = "publish msg producer";
            channel.basicPublish(PUBLISH_EXCHANGE, "", null, msg.getBytes());
            System.out.println("publish案例：生产者发送消息：" + msg);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (channel != null) {
                    channel.close();
                }
                if (connection != null) {
                    connection.close();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}
  • 2、消费者
import com.rabbitmq.client.*;

import java.io.IOException;

/**
 * publish-email工作模式 ===> 消费者
 */
public class PublishConsumerEmail {

    private static final String PUBLISH_QUEUE_EMAIL = "publish_queue_email";

    public static void main(String[] args) {
        Connection connection = null;
        Channel channel = null;
        try {
            // 1.创建Connectionfactory对象，用于生产Connection对象
            ConnectionFactory connectionFactory = new ConnectionFactory();
            connectionFactory.setHost("localhost");
            connectionFactory.setPort(5672);
            connectionFactory.setUsername("guest");
            connectionFactory.setPassword("guest");
            connectionFactory.setVirtualHost("/");
            // 2.生产Connection对象
            connection = connectionFactory.newConnection();

            // 3.通过连接对象创建通道
            channel = connection.createChannel();
            // 5.声明队列
            channel.queueDeclare(PUBLISH_QUEUE_EMAIL, true, false, false, null);

            channel.basicConsume(PUBLISH_QUEUE_EMAIL, true, new DefaultConsumer(channel) {
                @Override
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                    System.out.println("publish案例：消费端email接收到消息：" + new String(body));
                }
            });
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}


import com.rabbitmq.client.*;

import java.io.IOException;

/**
 * publish-SMS工作模式 ===> 消费者
 */
public class PublishConsumerSMS {

    private static final String PUBLISH_QUEUE_SMS = "publish_queue_sms";

    public static void main(String[] args) {
        Connection connection = null;
        Channel channel = null;
        try {
            // 1.创建Connectionfactory对象，用于生产Connection对象
            ConnectionFactory connectionFactory = new ConnectionFactory();
            connectionFactory.setHost("localhost");
            connectionFactory.setPort(5672);
            connectionFactory.setUsername("guest");
            connectionFactory.setPassword("guest");
            connectionFactory.setVirtualHost("/");
            // 2.生产Connection对象
            connection = connectionFactory.newConnection();

            // 3.通过连接对象创建通道
            channel = connection.createChannel();
            // 5.声明队列
            channel.queueDeclare(PUBLISH_QUEUE_SMS,true,false,false,null);

            channel.basicConsume(PUBLISH_QUEUE_SMS,true,new DefaultConsumer(channel){
                @Override
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                    System.out.println("publish案例：消费端sms接收到消息："+new String(body));
                }
            });
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

3.2.3 思考

publish/subscribe与work queues有什么区别：

区别：
1 ）work queues不用定义交换机，而publish/subscribe需要定义交换机。
2 ）publish/subscribe的生产方是面向交换机发送消息，work queues的生产方是面向队列发送消息(底层使用默认交换机)。
3 ）publish/subscribe需要设置队列和交换机的绑定，work queues不需要设置，实质上work queues会将队列绑定到默认的交换机 。

相同点：
1、两者实现的发布/订阅的效果是一样的，多个消费端监听同一个队列不会重复消费消息。
2 、实质工作用什么 publish/subscribe还是work queues。

建议使用 publish/subscribe，发布订阅模式比工作队列模式更强大，并且发布订阅模式可以指定自己专用的交换机。

3.3 Routing

3.3.1 工作模式

在这里插入图片描述
路由模式：

1 、每个消费者监听自己的队列，并且设置routingkey。
2 、生产者将消息发给交换机，由交换机根据routingkey来转发消息到指定的队列。

3.3.2 代码实现

  • 1 、生产者

    声明exchange_routing_inform交换机。
    声明两个队列并且绑定到此交换机，绑定时需要指定routingkey
    发送消息时需要指定routingkey

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

import java.io.IOException;

/**
 * routing 路由模式 ===> 生产者
 */
public class RoutingProducer {

    private static final String ROUTING_EXCHANGE = "routing_exchange";
    private static final String ROUTING_QUEUE_EMAIL = "routing_queue_email";
    private static final String ROUTING_QUEUE_SMS = "routing_queue_sms";

    public static void main(String[] args) {
        Connection connection = null;
        Channel channel = null;
        try {
            // 1.创建Connectionfactory对象，用于生产Connection对象
            ConnectionFactory connectionFactory = new ConnectionFactory();
            connectionFactory.setHost("localhost");
            connectionFactory.setPort(5672);
            connectionFactory.setUsername("guest");
            connectionFactory.setPassword("guest");
            connectionFactory.setVirtualHost("/");
            // 2.生产Connection对象
            connection = connectionFactory.newConnection();

            // 3.通过连接对象创建通道
            channel = connection.createChannel();
            // 4.声明交换机
            channel.exchangeDeclare(ROUTING_EXCHANGE, BuiltinExchangeType.DIRECT);
            // 5.声明队列
            channel.queueDeclare(ROUTING_QUEUE_EMAIL,true,false,false,null);
            channel.queueDeclare(ROUTING_QUEUE_SMS,true,false,false,null);
            // 6.交换机绑定队列
            channel.queueBind(ROUTING_QUEUE_EMAIL,ROUTING_EXCHANGE,ROUTING_QUEUE_EMAIL);
            channel.queueBind(ROUTING_QUEUE_SMS,ROUTING_EXCHANGE,ROUTING_QUEUE_SMS);
            // 7.发送消息
            String emailMsg = "routing email msg producer";
            channel.basicPublish(ROUTING_EXCHANGE,ROUTING_QUEUE_EMAIL,null,emailMsg.getBytes());

            String smsMsg = "routing sms msg producer";
            channel.basicPublish(ROUTING_EXCHANGE,ROUTING_QUEUE_SMS,null,smsMsg.getBytes());
            System.out.println("routing案例：生产者发送消息："+emailMsg+"  "+smsMsg);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try{
                if(channel != null){
                    channel.close();
                }
                if(connection != null){
                    connection.close();
                }
            } catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}
  • 消费者
import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * routing-email工作模式 ===> 消费者
 */
public class RoutingConsumerEmail {

    private static final String ROUTING_QUEUE_EMAIL = "routing_queue_email";

    public static void main(String[] args) {
        Connection connection = null;
        Channel channel = null;
        try {
            // 1.创建Connectionfactory对象，用于生产Connection对象
            ConnectionFactory connectionFactory = new ConnectionFactory();
            connectionFactory.setHost("localhost");
            connectionFactory.setPort(5672);
            connectionFactory.setUsername("guest");
            connectionFactory.setPassword("guest");
            connectionFactory.setVirtualHost("/");
            // 2.生产Connection对象
            connection = connectionFactory.newConnection();

            // 3.通过连接对象创建通道
            channel = connection.createChannel();
            // 5.声明队列
            channel.queueDeclare(ROUTING_QUEUE_EMAIL,true,false,false,null);

            channel.basicConsume(ROUTING_QUEUE_EMAIL,true,new DefaultConsumer(channel){
                @Override
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                    System.out.println("routing案例：消费端email接收到消息："+new String(body));
                }
            });
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * routing-sms工作模式 ===> 消费者
 */
public class RoutingConsumerSMS {

    private static final String ROUTING_QUEUE_SMS = "routing_queue_sms";

    public static void main(String[] args) {
        Connection connection = null;
        Channel channel = null;
        try {
            // 1.创建Connectionfactory对象，用于生产Connection对象
            ConnectionFactory connectionFactory = new ConnectionFactory();
            connectionFactory.setHost("localhost");
            connectionFactory.setPort(5672);
            connectionFactory.setUsername("guest");
            connectionFactory.setPassword("guest");
            connectionFactory.setVirtualHost("/");
            // 2.生产Connection对象
            connection = connectionFactory.newConnection();

            // 3.通过连接对象创建通道
            channel = connection.createChannel();
            // 5.声明队列
            channel.queueDeclare(ROUTING_QUEUE_SMS,true,false,false,null);

            channel.basicConsume(ROUTING_QUEUE_SMS,true,new DefaultConsumer(channel){
                @Override
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                    System.out.println("routing案例：消费端sms接收到消息："+new String(body));
                }
            });
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

3.3.3 思考

Routing模式和Publish/subscibe有啥区别？

Routing模式要求队列在绑定交换机时要指定routingkey，消息会转发到符合routingkey的队列。

3.4 Topic

3.4.1 工作模式

在这里插入图片描述

路由模式：

1 、每个消费者监听自己的队列，并且设置带统配符的routingkey。
2 、生产者将消息发给broker，由交换机根据routingkey来转发消息到指定的队列。

3.4.2 代码实现

  • 1 、生产者

    声明交换机，指定topic类型：

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * topics路由模式 ===> 生产者
 */
public class TopicsProducer {

    private static final String TOPICS_EXCHANGE = "topics_exchange";
    private static final String TOPICS_QUEUE_EMAIL = "topics_queue_email";
    private static final String TOPICS_QUEUE_SMS = "topics_queue_sms";

    public static void main(String[] args) {
        Connection connection = null;
        Channel channel = null;
        try {
            // 1.创建Connectionfactory对象，用于生产Connection对象
            ConnectionFactory connectionFactory = new ConnectionFactory();
            connectionFactory.setHost("localhost");
            connectionFactory.setPort(5672);
            connectionFactory.setUsername("guest");
            connectionFactory.setPassword("guest");
            connectionFactory.setVirtualHost("/");
            // 2.生产Connection对象
            connection = connectionFactory.newConnection();

            // 3.通过连接对象创建通道
            channel = connection.createChannel();
            // 4.声明交换机
            channel.exchangeDeclare(TOPICS_EXCHANGE, BuiltinExchangeType.TOPIC);
            // 5.声明队列
            channel.queueDeclare(TOPICS_QUEUE_EMAIL, true, false, false, null);
            channel.queueDeclare(TOPICS_QUEUE_SMS, true, false, false, null);
            // 6.交换机绑定队列
            channel.queueBind(TOPICS_QUEUE_EMAIL, TOPICS_EXCHANGE, "inform.#.email.#");//可以接收inform.xxx.email.xxx的信息
            channel.queueBind(TOPICS_QUEUE_SMS, TOPICS_EXCHANGE, "inform.#.sms.#");
            // 7.发送消息
            String emailMsg = "routing email msg producer";
            channel.basicPublish(TOPICS_EXCHANGE, "inform.email", null, emailMsg.getBytes());

            String smsMsg = "routing sms msg producer";
            channel.basicPublish(TOPICS_EXCHANGE, "inform.sms", null, smsMsg.getBytes());

            String msg = "都得有的消息 all";
            channel.basicPublish(TOPICS_EXCHANGE, "inform.sms.email", null, msg.getBytes());
            System.out.println("routing案例：生产者发送消息：" + emailMsg + "  " + smsMsg + "  " + msg);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (channel != null) {
                    channel.close();
                }
                if (connection != null) {
                    connection.close();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}
  • 2、消费端

    队列绑定交换机指定通配符：
    统配符规则：

    • 中间以“.”分隔。
    • 符号#可以匹配多个词，符号*可以匹配一个词语。
import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * topics-email工作模式 ===> 消费者
 */
public class TopicConsumerEmail {

    private static final String TOPICS_QUEUE_EMAIL = "topics_queue_email";

    public static void main(String[] args) {
        Connection connection = null;
        Channel channel = null;
        try {
            // 1.创建Connectionfactory对象，用于生产Connection对象
            ConnectionFactory connectionFactory = new ConnectionFactory();
            connectionFactory.setHost("localhost");
            connectionFactory.setPort(5672);
            connectionFactory.setUsername("guest");
            connectionFactory.setPassword("guest");
            connectionFactory.setVirtualHost("/");
            // 2.生产Connection对象
            connection = connectionFactory.newConnection();

            // 3.通过连接对象创建通道
            channel = connection.createChannel();
            // 5.声明队列
            channel.queueDeclare(TOPICS_QUEUE_EMAIL, true, false, false, null);

            channel.basicConsume(TOPICS_QUEUE_EMAIL, true, new DefaultConsumer(channel) {
                @Override
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                    System.out.println("topic案例：消费端email接收到消息：" + new String(body));
                }
            });
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * topics-sms工作模式 ===> 消费者
 */
public class TopicConsumerSMS {

    private static final String TOPICS_QUEUE_SMS = "topics_queue_sms";

    public static void main(String[] args) {
        Connection connection = null;
        Channel channel = null;
        try {
            // 1.创建Connectionfactory对象，用于生产Connection对象
            ConnectionFactory connectionFactory = new ConnectionFactory();
            connectionFactory.setHost("localhost");
            connectionFactory.setPort(5672);
            connectionFactory.setUsername("guest");
            connectionFactory.setPassword("guest");
            connectionFactory.setVirtualHost("/");
            // 2.生产Connection对象
            connection = connectionFactory.newConnection();

            // 3.通过连接对象创建通道
            channel = connection.createChannel();
            // 5.声明队列
            channel.queueDeclare(TOPICS_QUEUE_SMS, true, false, false, null);

            channel.basicConsume(TOPICS_QUEUE_SMS, true, new DefaultConsumer(channel) {
                @Override
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                    System.out.println("topic案例：消费端sms接收到消息：" + new String(body));
                }
            });
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

3.4.3 思考

本案例的需求使用Routing工作模式能否实现？

使用Routing模式也可以实现本案例，共设置三个 routingkey，分别是email、sms、all，email队列绑定email和all，sms队列绑定sms和all，这样就可以实现上边案例的功能，实现过程比topics复杂。
Topic模式更多加强大，它可以实现Routing、publish/subscirbe模式的功能。

3.5 Header

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

  • 案例：

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

  • 1 ）生产者

    队列与交换机绑定的代码与之前不同，如下：

import com.rabbitmq.client.*;

import java.util.HashMap;

/**
 * header工作描述 ===> 生产者
 */
public class HeaderProducer {

    private static final String HEADER_EXCHANGE = "header_exchange";
    private static final String HEADER_QUEUE_EMAIL = "header_queue_email";
    private static final String HEADER_QUEUE_SMS = "header_queue_sms";

    public static void main(String[] args) {
        Connection connection = null;
        Channel channel = null;
        try {
            // 1.创建Connectionfactory对象，用于生产Connection对象
            ConnectionFactory connectionFactory = new ConnectionFactory();
            connectionFactory.setHost("localhost");
            connectionFactory.setPort(5672);
            connectionFactory.setUsername("guest");
            connectionFactory.setPassword("guest");
            connectionFactory.setVirtualHost("/");
            // 2.生产Connection对象
            connection = connectionFactory.newConnection();

            // 3.通过连接对象创建通道
            channel = connection.createChannel();
            // 4.声明交换机
            channel.exchangeDeclare(HEADER_EXCHANGE, BuiltinExchangeType.HEADERS);
            // 5.声明队列
            channel.queueDeclare(HEADER_QUEUE_EMAIL,true,false,false,null);
            channel.queueDeclare(HEADER_QUEUE_SMS,true,false,false,null);
            // 6.交换机绑定队列
            HashMap<String, Object> emailMap = new HashMap<>();
            emailMap.put("inform_type","email");
            channel.queueBind(HEADER_QUEUE_EMAIL,HEADER_EXCHANGE,"",emailMap);

            HashMap<String, Object> smsMap = new HashMap<>();
            smsMap.put("inform_type","sms");
            channel.queueBind(HEADER_QUEUE_SMS,HEADER_EXCHANGE,"",smsMap);
            // 7.发送消息
            String emailMsg = "Header模式 email msg 你真棒";
            AMQP.BasicProperties.Builder emailBuilder = new AMQP.BasicProperties.Builder();
            emailBuilder.headers(emailMap);
            channel.basicPublish(HEADER_EXCHANGE,"",emailBuilder.build(),emailMsg.getBytes());

            String smsMsg = "Header模式 sms msg 你真棒";
            AMQP.BasicProperties.Builder smsBuilder = new AMQP.BasicProperties.Builder();
            smsBuilder.headers(smsMap);
            channel.basicPublish(HEADER_EXCHANGE,"",smsBuilder.build(),smsMsg.getBytes());

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try{
                if(channel != null){
                    channel.close();
                }
                if(connection != null){
                    connection.close();
                }
            } catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}
  • 2 ）消费者
import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.Hashtable;
import java.util.Map;

//Header-email工作模式 ===> 消费者
public class HeaderConsumerEmail {

    private static final String HEADER_QUEUE_EMAIL = "header_queue_email";

    public static void main(String[] args) {
        Connection connection = null;
        Channel channel = null;
        try {
            // 1.创建Connectionfactory对象，用于生产Connection对象
            ConnectionFactory connectionFactory = new ConnectionFactory();
            connectionFactory.setHost("localhost");
            connectionFactory.setPort(5672);
            connectionFactory.setUsername("guest");
            connectionFactory.setPassword("guest");
            connectionFactory.setVirtualHost("/");
            // 2.生产Connection对象
            connection = connectionFactory.newConnection();

            // 3.通过连接对象创建通道
            channel = connection.createChannel();
            // 5.声明队列
            Map<String, Object> emailMap = new Hashtable<>();
            emailMap.put("inform_type", "email");
            channel.queueDeclare(HEADER_QUEUE_EMAIL, true, false, false, emailMap);

            channel.basicConsume(HEADER_QUEUE_EMAIL, true, new DefaultConsumer(channel) {
                @Override
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                    System.out.println("headers案例：消费端email接收到消息：" + new String(body));
                }
            });
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.Hashtable;
import java.util.Map;

//Header-SMS工作模式 ===> 消费者
public class HeaderConsumerSMS {

    private static final String HEADER_QUEUE_SMS = "header_queue_sms";

    public static void main(String[] args) {
        Connection connection = null;
        Channel channel = null;
        try {
            // 1.创建Connectionfactory对象，用于生产Connection对象
            ConnectionFactory connectionFactory = new ConnectionFactory();
            connectionFactory.setHost("localhost");
            connectionFactory.setPort(5672);
            connectionFactory.setUsername("guest");
            connectionFactory.setPassword("guest");
            connectionFactory.setVirtualHost("/");
            // 2.生产Connection对象
            connection = connectionFactory.newConnection();

            // 3.通过连接对象创建通道
            channel = connection.createChannel();
            // 5.声明队列
            Map<String, Object> emailMap = new Hashtable<>();
            emailMap.put("inform_type", "email");
            channel.queueDeclare(HEADER_QUEUE_SMS, true, false, false, emailMap);

            channel.basicConsume(HEADER_QUEUE_SMS, true, new DefaultConsumer(channel) {
                @Override
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                    System.out.println("headers案例：消费端sms接收到消息：" + new String(body));
                }
            });
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

3.6 RPC

在这里插入图片描述

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

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

四、SpringBoot整合RabbitMQ

4.1 搭建SpringBoot环境

选择基于Spring-Rabbit去操作RabbitMQ
使用spring-boot-starter-amqp会自动添加spring-rabbit依赖，如下：

<dependency>
	<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>org.springframework.boot</groupId>
    <artifactId>spring‐boot‐starter‐logging</artifactId>
</dependency>

4.2 配置

  • 第一步、配置application.yml

    配置连接rabbitmq的参数

server:
  port: 8080
spring:
  application:
    name: test-springboot-mq
  rabbitmq:
    host: 127.0.0.1
    port: 5672
    username: guest
    password: guest
    virtual-host: /
  • 第二步、定义RabbitConfig类，配置Exchange、Queue、及绑定交换机。

    本例配置Topic交换机。

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

@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";

    /**
    *交换机配置
    *ExchangeBuilder提供了fanout、direct、topic、header交换机类型的配置
    *@return the exchange
    */
    @Bean(EXCHANGE_TOPICS_INFORM)
    public Exchange EXCHANGE_TOPICS_INFORM() {
        //durable(true)持久化，消息队列重启后交换机仍然存在
        return ExchangeBuilder.topicExchange(EXCHANGE_TOPICS_INFORM).durable(true).build();
    }
    //声明队列
    @Bean(QUEUE_INFORM_SMS)
    public Queue QUEUE_INFORM_SMS() {
        Queue queue = new Queue(QUEUE_INFORM_SMS); 
        return queue;
    }
    //声明队列
    @Bean(QUEUE_INFORM_EMAIL)
        public Queue QUEUE_INFORM_EMAIL() {
        Queue queue = new Queue(QUEUE_INFORM_EMAIL); return queue;
    }
    /** channel.queueBind(INFORM_QUEUE_SMS,"inform_exchange_topic","inform.#.sms.#");
    *绑定队列到交换机 .
    *
    *@param queue	the queue
    *@param exchange the exchange
    *@return the binding
    */
    @Bean
    public Binding BINDING_QUEUE_INFORM_SMS(@Qualifier(QUEUE_INFORM_SMS) Queue queue,
    @Qualifier(EXCHANGE_TOPICS_INFORM) Exchange exchange) {
        return BindingBuilder.bind(queue).to(exchange).with("inform.#.sms.#").noargs();
    }
    @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("inform.#.email.#").noargs();
    }
}

4.3 生产端

import com.lxw.test.rabbitmq.config.RabbitmqConfig; 
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.amqp.rabbit.core.RabbitTemplate; 
import org.springframework.beans.factory.annotation.Autowired; 
import org.springframework.boot.test.context.SpringBootTest; 
import org.springframework.test.context.junit4.SpringRunner;
@SpringBootTest
@RunWith(SpringRunner.class)
public class Producer05_topics_springboot {
    @Autowired
    RabbitTemplate rabbitTemplate;
    @Test
    public void testSendByTopics(){ for (int i=0;i<5;i++){
        String message = "sms email inform to user"+i; 			rabbitTemplate.convertAndSend(RabbitmqConfig.EXCHANGE_TOPICS_INFORM,"inform.sms.email",message); System.out.println("Send Message is:'" + message + "'");
        }
    }
}

4.4 消费端

4.5 测试

启动springboot后可直接在控制台看到队列中的消息，也可通过控制面板进行观察

在这里插入图片描述

每日一点点进步
不进则退

【SpringBoot】43、SpringBoot中整合RabbitMQ实现延时队列（延时插件篇）
Asurplus
02-21 21万+
一、介绍 1、什么是延时队列？ 延时队列即就是放置在该队列里面的消息是不需要立即消费的，而是等待一段时间之后取出消费 2、适用场景 （1）商城订单超时未支付，取消订单 （2）使用权限到期前十分钟提醒用户 （3）收益项目，投入后一段时间后产生收益 二、实现方式 从以上场景中，我们可以看出，延时队列的主要功能就是在指定的时间之后做指定的事情，那么，我们思考有哪些工具我们可以使用？ 1、Redis 监听过期 Key 可以参考我的博客【SpringBoot】三十五、SpringBoot整合Redis监听Ke
RabbitMQ镜像集群搭建及Springboot整合使用
m0_46189412的博客
11-04 1580
在任意一台rabbitmq上面增加交换机和队列，另一台会自动同步。主机1：192.168.111.100。主机2：192.168.111.101。两台主机提前安装好docker备用。springboot项目。第一台服务器重启为主节点。第二台服务器加入到主节点。docker相关知识。
SpringBoot整合RabbitMq之简单演示（Direct模式）
我的博客
04-09 1164
一。 下载Erlang，RabbitMq并安装；见 https://blog.csdn.net/zhaodj5660/article/details/79813749二。 安装RabbitMQ-Plugins，这个相当于是一个管理界面，方便我们在浏览器界面查看RabbitMQ各个消息队列以及exchange的工作情况，安装方法是：打开命令行cd进入rabbitmq的sbin目录(我的目录是：D:\...
3 RabbitMQ3.10.7与SpringBoot整合
Xx13624558575的博客
09-06 649
RabbitMQ3.10.7与SpringBoot整合
springboot集成RabbitMQ
最新发布
Flying_Fish_roe的博客
09-26 1637
可以通过@Bean@Bean@Bean@Bean：定义了一个Direct类型的交换器。Queue：定义了一个队列testQueue。Binding：将队列与交换器通过routingKey绑定。
RocketMQ讲解、安装、配置和集成
qq_39234840的博客
08-06 836
官网下载地址：http://rocketmq.apache.org/dowloading/releases/ windows环境安装 1.环境变量配置 2.启动NAMESERVER（弹窗请勿关闭） 3.启动BROKER（弹窗请勿关闭） Cmd命令框执行进入至‘MQ文件夹\bin’下，然后执行‘start mqbroker.cmd -n 127.0.0.1:9987autoCreateTopicEnable=true’，启动BROKER。 ...
rabbitMq工作模式特性及整合springboot
技术萌新缓缓升级ing
03-26 7187
因为公司项目后面需要用到mq做数据的同步，所以学习mq并在此记录，这里的是rabbitMq mq（message queue）消息队列 官网：www.rabbitmq.com 使用消息队列的优点： 1、异步可加快访问速度 （以前一个订单接口需要做下单、库存、付款、快递等相关操作，有了mq只需要给相关信息传入队列，下单、库存、付款、快递等相关操作会自动从队列中收到信息进行异步操作） 2、解耦下游服务或其他服务或语言可接入 3、削峰高并发访问量可分摊多个队列分摊 缺点： 1、系统
Springboot整合rabbitmq,包含 rabbitmq安装
孟美岐的博客
03-01 1415
1、安装rabbitmq 参考：https://www.cnblogs.com/saryli/p/9729591.html 其中我遇到了rabbitmqctl命令出错的问题 参考：https://blog.csdn.net/guo222guo/article/details/79109459 1、Sprinbootg整合rabbitmq 参考1：https://blog.csdn.net/fan521dan/article/details/104912794 参考2：https://www.cnblogs.
SpringBoot基于RabbitMQ实现死信队列 (SpringBoot整合RabbitMQ实战篇)
莫等闲 白了少年头 空悲切
04-24 2018
消息超时的两种方式是？给队列设置ttl属性，进入队列后超过ttl时间的消息变为死信给消息设置ttl属性，队列接收到消息超过ttl时间后变为死信如何实现发送一个消息20秒后消费者才收到消息？给消息的目标队列指定死信交换机将消费者监听的队列绑定到死信交换机发送消息时给消息设置超时时间为20秒每一项技术深挖都是一个庞大的体系，学海无涯，共勉。
spring boot整合RabbitMQ（Direct模式）
08-30
springboot集成RabbitMQ非常简单，如果只是简单的使用配置非常少，springboot提供了spring-boot-starter-amqp项目对消息各种...下面通过本文给大家介绍下spring boot整合RabbitMQ（Direct模式）,需要的朋友可以参考下
RabbitMQ：第三章：Springboot集成RabbitMQ（直连模式，工作队列模式，发布订阅模式，路由模式，通配符模式）
2301_76238237的博客
05-06 763
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
springboot rabbitmq
05-12
在springboot的基础上使用Rabbitmq
springboot+rabbitmq项目demo(亲测,可正常运行)
02-21
使用springboot+rabbitmq搭建一个简单的消息队列项目。
RabbitMq springboot版本与原生引用
SevenLitile的博客
02-19 1302
springboot版本 一般使用MQ分成两种模式 workqueues 模式，Q消息只会发送到一个队列，该队列连接着多个消费者，单同一个Q消息只能被消费一次 exchange 模式，Q消息可以按照一定规则分发到多个队列，每个监听改队列的消费者都可以收到Q消息，类似与广播 --springboot 首先，启动MQ服务，默认的账号和密码是 guest guest 在你的项目中引入依赖 <dependency> <groupId>org.springfram
RabbitMQ--集成Springboot--01--工作模式
zhou920786312的博客
10-24 258
因为我需要MQ单独拿来测试使用，所以我新建一个分区。
SpringBoot整合RabbitMQ(最新笔记)
钟健的博客
05-18 7023
我们使用的springboot版本为2.5.6，其他都是根据自动选择版本引入以下工程即可junit
分布式专题｜进入BAT必备之Springboot 集成 RabbitMQ的五种工作模式
热门推荐
11-14 2万+
分布式专题｜进入BAT必备之Springboot 集成 RabbitMQ的五种工作模式
一步到位！RabbitMQ从安装到SpringBoot整合
m0_55627541的博客
07-28 256
需要安装两个东西1.Erlang(可以理解为基础支持)1.跟我来，进去之后往下拉，点击下面这个2.进去右上角，点击install:windows3.点击之后往下拉。
spring boot 2.6.3快速集成RabbitMq 踩坑点（Win10）
ljp7272的博客
02-23 1591
Rabbit下载和安装 在win10系统安装RabbitMq是需要erlang环境的，选择安装目录一直下一步就行了 链接: https://pan.baidu.com/s/1qM5N7bqOwoIg0ckw4vtzuA 提取码: fc8h 安装完成之后可以看到如下信息，然后启动服务访问 http://localhost:15672 便可看到可视化控制台，默认账号密码都是 guest spring boot快速集成RabbitMq 依赖 <dependency> <gro
CentOS7环境下RabbitMQ服务器搭建与SpringBoot整合教程
"本文档详细介绍了如何在CentOS7环境下搭建RabbitMQ服务器，并整合Java客户端与SpringBoot应用，提供了一个生产者-消费者代码...对于想要学习或者已经在使用RabbitMQ和SpringBoot的开发人员，这是一个非常实用的指南。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

璃尔 °

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值