RabbitMQ

最新推荐文章于 2023-02-21 19:14:25 发布
最新推荐文章于 2023-02-21 19:14:25 发布
阅读量650 收藏
点赞数
分类专栏： 微服务 文章标签： rabbitmq

RabbitMQ

一、MQ引言

1.1 MQ的概念
  • MQ(Message Quene) : 翻译为消息队列,通过典型的生产者和消费者模型,生产者不断向消息队列中生产消息，消费者不断的从队列中获取消息。
  • 因为消息的生产和消费都是异步的，而且只关心消息的发送和接收，没有业务逻辑的侵入,轻松的实现系统间解耦。
  • 别名为 消息中间件通过利用高效可靠的消息传递机制进行平台无关的数据交流，并基于数据通信来进行分布式系统的集成。
1.2 MQ的分类
  • 当今市面上有很多主流的消息中间件，如老牌的ActiveMQ、RabbitMQ，炙手可热的Kafka，阿里巴巴自主开发RocketMQ等。
1.3 不同MQ之间的对比
  • ActiveMQ:ActiveMQ 是Apache出品，最流行的，能力强劲的开源消息总线。它是一个完全支持JMS规范的的消息中间件。丰富的API,多种集群架构模式让ActiveMQ在业界成为老牌的消息中间件,在中小型企业颇受欢迎!
  • Kafka:Kafka是LinkedIn开源的分布式发布-订阅消息系统，目前归属于Apache顶级项目。Kafka主要特点是基于Pull的模式来处理消息消费，追求高吞吐量，一开始的目的就是用于日志收集和传输。0.8版本开始支持复制，不支持事务，对消息的重复、丢失、错误没有严格要求，适合产生大量数据的互联网服务的数据收集业务。
  • RocketMQ:RocketMQ是阿里开源的消息中间件，它是纯Java开发，具有高吞吐量、高可用性、适合大规模分布式系统应用的特点。RocketMQ思路起源于Kafka，但并不是Kafka的一个Copy，它对消息的可靠传输及事务性做了优化，目前在阿里集团被广泛应用于交易、充值、流计算、消息推送、日志流式处理、binglog分发等场景。
  • RabbitMQ:RabbitMQ是使用Erlang语言开发的开源消息队列系统，基于AMQP协议来实现。AMQP的主要特征是面向消息、队列、路由（包括点对点和发布/订阅）、可靠性、安全。AMQP协议更多用在企业系统内对数据一致性、稳定性和可靠性要求很高的场景，对性能和吞吐量的要求还在其次。
  • RabbitMQ比Kafka可靠，Kafka更适合IO高吞吐的处理，一般应用在大数据日志处理或对实时性（少量延迟），可靠性（少量丢数据）要求稍低的场景使用，比如ELK日志收集。

二、RabbitMQ 的引言

2.1 RabbitMQ
  • 基于AMQP协议，erlang语言开发，是部署最广泛的开源消息中间件,是最受欢迎的开源消息中间件之一。
  • AMQP 协议:AMQP（advanced message queuing protocol）在2003年时被提出，最早用于解决金融领不同平台之间的消息传递交互问题。顾名思义，AMQP是一种协议，更准确的说是一种binary wire-level protocol（链接协议）。这是其和JMS的本质差别，AMQP不从API层进行限定，而是直接定义网络交换的数据格式。这使得实现了AMQP的provider天然性就是跨平台的。以下是AMQP协议模型:
    在这里插入图片描述
2.2 RabbitMQ的安装

  • 下载：

    # 版本选型 https://www.rabbitmq.com/which-erlang.html
# 下载erlang
wget https://github.com/rabbitmq/erlang-rpm/releases/download/v23.3.1/erlang-23.3.1-1.el7.x86_64.rpm

# 下载rabbitmq
wget https://github.com/rabbitmq/rabbitmq-server/releases/download/v3.8.11/rabbitmq-server-3.8.11-1.el7.noarch.rpm

  • 安装Erlang依赖包:

    rpm -ivh erlang-23.3.1-1.el7.x86_64.rpm

  • 安装RabbitMQ安装包(需要联网):

    yum install -y rabbitmq-server-3.8.11-1.el7.noarch.rpm


#注意:默认安装完成后配置文件模板在:/usr/share/doc/rabbitmq-server-3.8.14/rabbitmq.config.example目录中,
#需要	将配置文件复制到/etc/rabbitmq/目录中,并修改名称为rabbitmq.config
#如果安装报错
yum install socat

  • 复制配置文件

    cp /usr/share/doc/rabbitmq-server-3.8.11/rabbitmq.config.example /etc/rabbitmq/rabbitmq.config

#这个版本没有example （目的是使用guest能够登陆）
vim /etc/rabbitmq/rabbitmq.config
[{rabbit, [{loopback_users, []}]}].

  • 启动rabbitmq中的插件管理:

    rabbitmq-plugins enable rabbitmq_management

  • 启动RabbitMQ的服务:

    systemctl start rabbitmq-server
systemctl restart rabbitmq-server
systemctl stop rabbitmq-server

  • 查看服务状态:

    systemctl status rabbitmq-server

  • 关闭防火墙服务:

    systemctl disable firewalld
Removed symlink /etc/systemd/system/multi-user.target.wants/firewalld.service.
Removed symlink /etc/systemd/system/dbus-org.fedoraproject.FirewallD1.service.
systemctl stop firewalld

  • 访问web管理界面:

    http://10.15.0.8:15672/
guest
guest
2.3 web管理界面介绍

  • overview概览:

    • connections：无论生产者还是消费者，都需要与RabbitMQ建立连接后才可以完成消息的生产和消费，在这里可以查看连接情况.
    • channels：通道，建立连接后，会形成通道，消息的投递获取依赖通道.
    • Exchanges：交换机，用来实现消息的路由.
    • Queues：队列，即消息队列，消息存放在队列中，等待消费，消费后被移除队列。

  • Admin用户和虚拟主机管理:

    • 添加用户：
      在这里插入图片描述

      • 超级管理员(administrator)：可登陆管理控制台，可查看所有的信息，并且可以对用户，策略(policy)进行操作.
      • 监控者(monitoring):可登陆管理控制台，同时可以查看rabbitmq节点的相关信息(进程数，内存使用情况，磁盘使用情况等).
      • 策略制定者(policymaker):可登陆管理控制台, 同时可以对policy进行管理。但无法查看节点的相关信息.
      • 普通管理者(management):仅可登陆管理控制台，无法看到节点信息，也无法对策略进行管理.
      • 其他:无法登陆管理控制台，通常就是普通的生产者和消费者。

    • 创建虚拟主机：
      在这里插入图片描述

      • 虚拟主机为了让各个用户可以互不干扰的工作，RabbitMQ添加了虚拟主机（Virtual Hosts）的概念。其实就是一个独立的访问路径，不同用户使用不同路径，各自有自己的队列、交换机，互相不会影响。

    • 绑定虚拟主机和用户:
      在这里插入图片描述

三、RabbitMQ的入门程序

3.1 AMQP协议的回顾

在这里插入图片描述

3.2 RabbitMQ支持的消息模型

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

3.3 引入依赖
<dependency>
    <groupId>com.rabbitmq</groupId>
    <artifactId>amqp-client</artifactId>
    <version>5.7.2</version>
</dependency>
3.4 第一种模型(直连)

在这里插入图片描述

  • P：生产者，也就是要发送消息的程序.

  • C：消费者：消息的接受者，会一直等待消息到来.

  • queue：消息队列，图中红色部分。类似一个邮箱，可以缓存消息；生产者向其中投递消息，消费者从其中取出消息。

  • 生产者:

    public static void main(String[] args) throws IOException, TimeoutException {
        //创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("101.20.142.277");
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("ems");
        connectionFactory.setPassword("123");
        connectionFactory.setVirtualHost("/ems");
        Connection connection = connectionFactory.newConnection();
        //创建通道
        Channel channel = connection.createChannel();
        //通道绑定对应的队列
        //参数1：队列名称 参数2: 是否持久化  参数3:是否独占队列 参数4:是否自动删除  参数5:其他属性
        channel.queueDeclare("hello",true,false,false,null);
        //发布消息
        //参数1：交换机名称 参数2：队列名称 参数3：额外参数设置 参数4：消息内容
        channel.basicPublish("","hello", null,"hello rabbitmq".getBytes());
        channel.close();
        connection.close();
    }

  • 消费者：

    public static void main(String[] args) throws IOException, TimeoutException {
    //创建连接工厂
    ConnectionFactory connectionFactory = new ConnectionFactory();
    connectionFactory.setHost("101.20.142.277");
    connectionFactory.setPort(5672);
    connectionFactory.setUsername("ems");
    connectionFactory.setPassword("123");
    connectionFactory.setVirtualHost("/ems");
    Connection connection = connectionFactory.newConnection();
    Channel channel = connection.createChannel();
    channel.queueDeclare("hello", true, false, false, null);
    //消费消息
    //参数1：队列名称 参数2：开启消息的自动确认 参数3：消费时的回调接口
    channel.basicConsume("hello",true,new DefaultConsumer(channel){
        @Override
        public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body)  {
            System.out.println(new String(body));
        }
    });
}
//结果
hello rabbitmq
hello rabbitmq
hello rabbitmq
hello rabbitmq
3.5 第二种模型(work quene)

  • Work queues，也被称为（Task queues），任务模型。当消息处理比较耗时的时候，可能生产消息的速度会远远大于消息的消费速度。长此以往，消息就会堆积越来越多，无法及时处理。此时就可以使用work 模型：让多个消费者绑定到一个队列，共同消费队列中的消息。队列中的消息一旦消费，就会消失，因此任务是不会被重复执行的。
    在这里插入图片描述

    • P：生产者：任务的发布者.
    • C1：消费者-1，领取任务并且完成任务，假设完成速度较慢.
    • C2：消费者-2：领取任务并完成任务，假设完成速度快。

  • 工具类：

    public class RabbitMQUtils {
    /**
     * 提供创建链接的方法
     * @return
     */
    public static Connection getConnection(){
        try {
            //创建连接工厂
            ConnectionFactory connectionFactory = new ConnectionFactory();
            connectionFactory.setHost("101.20.142.277");
            connectionFactory.setPort(5672);
            connectionFactory.setUsername("ems");
            connectionFactory.setPassword("123");
            connectionFactory.setVirtualHost("/ems");
            return connectionFactory.newConnection();
        }catch (Exception e){
            e.printStackTrace();
        }
        return null;
    }
    /**
     * 关闭连接
     * @param channel
     * @param connection
     */
    public static void close(Channel channel,Connection connection){
        try {
            if (channel != null){channel.close();}
            if (connection != null){connection.close();}
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

  • 生产者:

    public static void main(String[] args) throws IOException{
    Connection connection = RabbitMQUtils.getConnection();
    //创建通道
    Channel channel = connection.createChannel();
    //通道绑定对应的队列
    channel.queueDeclare("work", true, false, false, null);
    for (int i = 0; i < 10; i++) {
        channel.basicPublish("", "work", null, (i+"====>:我是消息").getBytes());
    }
    RabbitMQUtils.close(channel,connection);
}

  • 消费者1：

    public static void main(String[] args) throws IOException, TimeoutException {
    Connection connection = RabbitMQUtils.getConnection();
    Channel channel = connection.createChannel();
    channel.queueDeclare("work",true,false,false,null);
    channel.basicConsume("work",true,new DefaultConsumer(channel){
        @Override
        public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
            System.out.println("消费者1: "+new String(body));
        }
    });
}
//结果
消费者1: 0====>:我是消息
消费者1: 2====>:我是消息
消费者1: 4====>:我是消息
消费者1: 6====>:我是消息
消费者1: 8====>:我是消息

  • 消费者2：

    public static void main(String[] args) throws IOException {
    Connection connection = RabbitMQUtils.getConnection();
    Channel channel = connection.createChannel();
    channel.queueDeclare("work",true,false,false,null);
    channel.basicConsume("work",true,new DefaultConsumer(channel){
        @Override
        public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
        	try {
		      Thread.sleep(1000);   //处理消息比较慢 一秒处理一个消息
		    } catch (InterruptedException e) {
		      e.printStackTrace();
		    }
            System.out.println("消费者2: "+new String(body));
        }
    });
}
//结果
消费者2: 1====>:我是消息
消费者2: 3====>:我是消息
消费者2: 5====>:我是消息
消费者2: 7====>:我是消息
消费者2: 9====>:我是消息

  • 总结:默认情况下，RabbitMQ将按顺序将每个消息发送给下一个使用者。平均而言，每个消费者都会收到相同数量的消息。这种分发消息的方式称为循环。

  • 消息自动确认机制:

    public static void main(String[] args) throws IOException, TimeoutException {
    Connection connection = RabbitMQUtils.getConnection();
    Channel channel = connection.createChannel();
    channel.queueDeclare("work",true,false,false,null);
    channel.basicQos(1);//一次只接受一条未确认的消息
    channel.basicConsume("work",false,new DefaultConsumer(channel){
        @Override
        public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
            System.out.println("消费者1: "+new String(body));
            //参数1：确定队列中那个消息 参数2：是否开启多个消息同时确认
            channel.basicAck(envelope.getDeliveryTag(),false);//手动确认消息
        }
    });
}
    • 设置通道一次只能消费一个消息.
    • 关闭消息的自动确认,开启手动确认消息.
3.6 第三种模型(fanout)

  • fanout扇出:也称为广播.
    在这里插入图片描述

  • 在广播模式下，消息发送流程:

    • 可以有多个消费者.
    • 每个消费者有自己的queue（队列）.
    • 每个队列都要绑定到Exchange（交换机）.
    • 生产者发送的消息，只能发送到交换机，交换机来决定要发给哪个队列，生产者无法决定.
    • 交换机把消息发送给绑定过的所有队列.
    • 队列的消费者都能拿到消息。实现一条消息被多个消费者消费。

  • 生产者：

    public static void main(String[] args) throws IOException{
    //获取连接
    Connection connection = RabbitMQUtils.getConnection();
    //创建通道
    Channel channel = connection.createChannel();
    //声明交换机，参数1：交换机名称 参数2：交换机的类型 fanout 广播类型
    channel.exchangeDeclare("logs","fanout");//广播 一条消息多个消费者同时消费
    //发布消息
    channel.basicPublish("logs","",null,"hello".getBytes());
    //释放资源
    RabbitMQUtils.close(channel,connection);
}

  • 消费者1：

    public static void main(String[] args) throws IOException, TimeoutException {
    Connection connection = RabbitMQUtils.getConnection();
    Channel channel = connection.createChannel();
    //绑定交换机
    channel.exchangeDeclare("logs","fanout");
    //创建临时队列
    String queue = channel.queueDeclare().getQueue();
    //将临时队列绑定exchange
    channel.queueBind(queue,"logs","");
    //处理消息
    channel.basicConsume(queue,true,new DefaultConsumer(channel){
        @Override
        public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
            System.out.println("消费者1: "+new String(body));
        }
    });
}
//结果
消费者1: hello

  • 消费者2：

    public static void main(String[] args) throws IOException, TimeoutException {
    Connection connection = RabbitMQUtils.getConnection();
    Channel channel = connection.createChannel();
    //绑定交换机
    channel.exchangeDeclare("logs","fanout");
    //创建临时队列
    String queue = channel.queueDeclare().getQueue();
    //将临时队列绑定exchange
    channel.queueBind(queue,"logs","");
    //处理消息
    channel.basicConsume(queue,true,new DefaultConsumer(channel){
        @Override
        public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
            System.out.println("消费者2: "+new String(body));
        }
    });
}
//结果
消费者2: hello
3.7 第四种模型(Routing)-Direct(直连)

  • 在Fanout模式中，一条消息，会被所有订阅的队列都消费。但是，在某些场景下，我们希望不同的消息被不同的队列消费。这时就要用到Direct类型的Exchange。

  • Direct模型:

    • 队列与交换机的绑定，不能是任意绑定了，而是要指定一个RoutingKey（路由key）消息的发送方在向Exchange发送消息时，也必须指定消息的RoutingKey.
    • Exchange不再把消息交给每一个绑定的队列，而是根据消息的Routing Key进行判断，只有队列的Routingkey与消息的Routing key完全一致，才会接收到消息。
      在这里插入图片描述
    • P：生产者，向Exchange发送消息，发送消息时，会指定一个routing key.
    • X：Exchange（交换机），接收生产者的消息，然后把消息递交给 与routing key完全匹配的队列.
    • C1：消费者，其所在队列指定了需要routing key为 error 的消息.
    • C2：消费者，其所在队列指定了需要routing key 为 info、error、warning的消息。

  • 生产者

    public static void main(String[] args) throws IOException{
    //获取连接
    Connection connection = RabbitMQUtils.getConnection();
    //创建通道
    Channel channel = connection.createChannel();
    //声明交换机  参数1:交换机名称 参数2:交换机类型 基于指令的Routing key转发
    channel.exchangeDeclare("logs_direct","direct");
    String key = "error";
    //发布消息
    channel.basicPublish("logs_direct",key,null,("指定的route key"+key+"的消息").getBytes());
    //释放资源
    RabbitMQUtils.close(channel,connection);
}

  • 生产者1：

    public static void main(String[] args) throws IOException, TimeoutException {
    Connection connection = RabbitMQUtils.getConnection();
    Channel channel = connection.createChannel();
    //声明交换机
    channel.exchangeDeclare("logs_direct","direct");
    //创建临时队列
    String queue = channel.queueDeclare().getQueue();
    //绑定队列和交换机
    channel.queueBind(queue,"logs_direct","error");
    channel.queueBind(queue,"logs_direct","info");
    channel.queueBind(queue,"logs_direct","warn");
    //消费消息
    channel.basicConsume(queue,true,new DefaultConsumer(channel){
        @Override
        public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
            System.out.println("消费者1: "+new String(body));
        }
    });
}
//结果
消费者1: 指定的route keyinfo的消息
消费者1: 指定的route keyerror的消息

  • 消费者2：

    public static void main(String[] args) throws IOException, TimeoutException {
    Connection connection = RabbitMQUtils.getConnection();
    Channel channel = connection.createChannel();
    //声明交换机
    channel.exchangeDeclare("logs_direct","direct");
    //创建临时队列
    String queue = channel.queueDeclare().getQueue();
    //绑定队列和交换机
    channel.queueBind(queue,"logs_direct","error");
    //消费消息
    channel.basicConsume(queue,true,new DefaultConsumer(channel){
        @Override
        public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
            System.out.println("消费者2: "+new String(body));
        }
    });
}
3.8 第五种模型(Routing)-Topic

在这里插入图片描述

  • 统配符：

    • * (star) can substitute for exactly one word. : 匹配不多不少恰好1个词.
    • # (hash) can substitute for zero or more words. :匹配一个或多个词。

  • 生产者：

    public static void main(String[] args) throws IOException{
    //获取连接
    Connection connection = RabbitMQUtils.getConnection();
    //创建通道
    Channel channel = connection.createChannel();
    //生命交换机和交换机类型 topic 使用动态路由(通配符方式)
    channel.exchangeDeclare("topics","topic");
    String routekey = "user.save.insert";//动态路由key
    //发布消息
    channel.basicPublish("topics",routekey,null,("这是路由中的动态订阅模型,route key: ["+routekey+"]").getBytes());
    //释放资源
    RabbitMQUtils.close(channel,connection);
}

  • 消费者1：

    public static void main(String[] args) throws IOException, TimeoutException {
    Connection connection = RabbitMQUtils.getConnection();
    Channel channel = connection.createChannel();
    //声明交换机
    channel.exchangeDeclare("topics","topic");
    //创建临时队列
    String queue = channel.queueDeclare().getQueue();
    //绑定队列与交换机并设置获取交换机中动态路由
    channel.queueBind(queue,"topics","user.*");
    //消费消息
    channel.basicConsume(queue,true,new DefaultConsumer(channel){
        @Override
        public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
            System.out.println("消费者1: "+new String(body));
        }
    });
}
//结果
消费者1: 这是路由中的动态订阅模型,route key: [user.save]

  • 消费者2：

    public static void main(String[] args) throws IOException, TimeoutException {
    Connection connection = RabbitMQUtils.getConnection();
    Channel channel = connection.createChannel();
    //声明交换机
    channel.exchangeDeclare("topics","topic");
    //创建临时队列
    String queue = channel.queueDeclare().getQueue();
    //绑定队列与交换机并设置获取交换机中动态路由
    channel.queueBind(queue,"topics","user.#");
    //消费消息
    channel.basicConsume(queue,true,new DefaultConsumer(channel){
        @Override
        public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
            System.out.println("消费者2: "+new String(body));
        }
    });
}
//结果
消费者2: 这是路由中的动态订阅模型,route key: [user.save]
消费者2: 这是路由中的动态订阅模型,route key: [user.save.insert]

四、SpringBoot整合RabbitMQ

4.1 搭建初始环境

  • 引入依赖：

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

  • 配置文件:

    spring:
  application:
    name: springboot_rabbitmq
  rabbitmq:
    host: 101.20.142.277
    port: 5672
    username: ems
    password: 123
    virtual-host: /ems

  • 测试：

    @SpringBootTest(classes = Application.class)
@RunWith(SpringRunner.class)
public class RabbitMQTest {
    @Autowired
    private RabbitTemplate rabbitTemplate;

}
4.2 第一种hello world模型

  • 生产者：

    @Test
public void testHello(){
    rabbitTemplate.convertAndSend("hello","hello world");
}

  • 消费者：

    @Component
@RabbitListener(queuesToDeclare = @Queue("hello"))
public class HelloCustomer {
    @RabbitHandler
    public void receive1(String message){
        System.out.println("message = " + message);
    }
}
4.3 第二种work模型

  • 生产者：

    @Test
public void testFanout() throws InterruptedException {
    rabbitTemplate.convertAndSend("logs","","这是日志广播");
}

  • 消费者：

    @Component
public class FanoutCustomer {
    @RabbitListener(bindings = @QueueBinding(
            value = @Queue, //创建临时队列
            exchange = @Exchange(name="logs",type = "fanout") //绑定交换机
    ))
    public void receive1(String message){
        System.out.println("message1 = " + message);
    }

    @RabbitListener(bindings = @QueueBinding(
            value = @Queue, //创建临时队列
            exchange = @Exchange(name="logs",type = "fanout")  //绑定交换机类型
    ))
    public void receive2(String message){
        System.out.println("message2 = " + message);
    }
}
4.4 第三种Fanout广播模型

  • 生产者：

    @Test
public void testFanout() throws InterruptedException {
    rabbitTemplate.convertAndSend("logs","","这是日志广播");
}

  • 消费者：

    @Component
public class FanoutCustomer {
    @RabbitListener(bindings = @QueueBinding(
            value = @Queue, //创建临时队列
            exchange = @Exchange(name="logs",type = "fanout") //绑定交换机
    ))
    public void receive1(String message){
        System.out.println("message1 = " + message);
    }

    @RabbitListener(bindings = @QueueBinding(
            value = @Queue, //创建临时队列
            exchange = @Exchange(name="logs",type = "fanout")  //绑定交换机类型
    ))
    public void receive2(String message){
        System.out.println("message2 = " + message);
    }
}
4.5 第四种Route路由模型

  • 生产者：

    @Test
public void testDirect(){
    rabbitTemplate.convertAndSend("directs","error","error 的日志信息");
}

  • 消费者：

    @Component
public class DirectCustomer {
    @RabbitListener(bindings ={
            @QueueBinding(
                    value = @Queue(),
                    key={"info","error"},
                    exchange = @Exchange(type = "direct",name="directs")
            )})
    public void receive1(String message){
        System.out.println("message1 = " + message);
    }
    @RabbitListener(bindings ={
            @QueueBinding(
                    value = @Queue(),
                    key={"error"},
                    exchange = @Exchange(type = "direct",name="directs")
            )})
    public void receive2(String message){
        System.out.println("message2 = " + message);
    }
}
4.6 第五种Topic订阅模型(动态路由模型)

  • 生产者：

    @Test
public void testTopic(){
    rabbitTemplate.convertAndSend("topics","user.save.findAll","user.save.findAll 的消息");
}

  • 消费者：

    @Component
public class TopCustomer {
    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue,
                    key = {"user.*"},
                    exchange = @Exchange(type = "topic",name = "topics")
            )
    })
    public void receive1(String message){
        System.out.println("message1 = " + message);
    }
    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue,
                    key = {"user.#"},
                    exchange = @Exchange(type = "topic",name = "topics")
            )
    })
    public void receive2(String message){
        System.out.println("message2 = " + message);
    }
}

五、MQ的应用场景

5.1 异步处理

  • 场景说明：用户注册后，需要发注册邮件和注册短信,传统的做法有两种 1.串行的方式 2.并行的方式.

  • 串行方式: 将注册信息写入数据库后,发送注册邮件,再发送注册短信,以上三个任务全部完成后才返回给客户端。 这有一个问题是,邮件,短信并不是必须的,它只是一个通知,而这种做法让客户端等待没有必要等待的东西.
    在这里插入图片描述

  • 并行方式: 将注册信息写入数据库后,发送邮件的同时,发送短信,以上三个任务完成后,返回给客户端,并行的方式能提高处理的时间.
    在这里插入图片描述

  • 消息队列:假设三个业务节点分别使用50ms,串行方式使用时间150ms,并行使用时间100ms。虽然并行已经提高的处理时间,但是,前面说过,邮件和短信对我正常的使用网站没有任何影响，客户端没有必要等着其发送完成才显示注册成功,应该是写入数据库后就返回. 消息队列: 引入消息队列后，把发送邮件,短信不是必须的业务逻辑异步处理 .

  • 由此可以看出,引入消息队列后，用户的响应时间就等于写入数据库的时间+写入消息队列的时间(可以忽略不计),引入消息队列后处理后,响应时间是串行的3倍,是并行的2倍。

5.2 应用解耦
  • 场景：双11是购物狂节,用户下单后,订单系统需要通知库存系统,传统的做法就是订单系统调用库存系统的接口.
    在这里插入图片描述
    • 这种做法有一个缺点:当库存系统出现故障时,订单就会失败。 订单系统和库存系统高耦合. 引入消息队列 .
      在这里插入图片描述
    • 订单系统:用户下单后,订单系统完成持久化处理,将消息写入消息队列,返回用户订单下单成功.
    • 库存系统:订阅下单的消息,获取下单消息,进行库操作。 就算库存系统出现故障,消息队列也能保证消息的可靠投递,不会导致消息丢失.
5.4 流量削峰
  • 场景: 秒杀活动，一般会因为流量过大，导致应用挂掉,为了解决这个问题，一般在应用前端加入消息队列。
  • 作用:
    • 可以控制活动人数，超过此一定阀值的订单直接丢弃.
    • 可以缓解短时间的高流量压垮应用(应用程序按自己的最大处理能力获取订单) .
      在这里插入图片描述
    • 用户的请求,服务器收到之后,首先写入消息队列,加入消息队列长度超过最大值,则直接抛弃用户请求或跳转到错误页面.
    • 秒杀业务根据消息队列中的请求信息，再做后续处理.

六、RabbitMQ的集群

残*影
关注
专栏目录
SpringBoot整合RabbitMQ之 典型应用场景实战一
青松之竹_Java博客
10-09 9万+
实战前言 RabbitMQ 作为目前应用相当广泛的消息中间件，在企业级应用、微服务应用中充当着重要的角色。特别是在一些典型的应用场景以及业务模块中具有重要的作用，比如业务服务模块解耦、异步通信、高并发限流、超时业务、数据延迟处理等。 其中课程的学习链接地址：https://edu.csdn.net/course/detail/9314 RabbitMQ 官网拜读 首先，让我们先拜读 Ra...
rabbitMq实战
02-27
RabbiMQ消息队列的介绍和在各个场景下的使用
RabbitMQ实战
InterceptWall的博客
08-28 2177
解耦：在项目启动之初来预测将来会碰到什么需求是极其困难的。消息中间件在处理过程中间插入了一个隐含的、基于数据的接口层，两边的处理过程都要实现这一接口，这允许你独立地扩展或修改两边的处理过程，只要确保它们遵守同样的接口约束即可冗余〈存储) 有些情况下，处理数据的过程会失败。消息中间件可以把数据进行持久化直到它们已经被完全处理，通过这一方式规避了数据丢失风险。在把 个消息从消息中间件中删除之前，需要你的处理系统明确地指出该消息己经被处理完成，从而确保你的数据被安全地保存直到你使用完毕。...
Rabbit MQ实战
zhj52666的博客
05-13 526
消息队列是一种应用之间的通信方式，消息发送后可以立即返回，由消息系统保证消息的可靠传递。可以用于分布式的削峰限流，通过异步解耦，可以实现分布式事务
RabbitMQ Server3.13.0
最新发布
04-02
**RabbitMQ Server 3.13.0** RabbitMQ 是一个开源的消息代理和队列服务器，它基于AMQP（Advanced Message Queuing Protocol）协议，用于在分布式系统中高效地路由和传递消息。RabbitMQ 3.13.0 版本是其稳定版本之一...
kettle rabbitmq 插件开发
10-26
标题 "kettle rabbitmq 插件开发" 涉及的是如何在 Pentaho Kettle（也称为 Spoon）中创建和使用 RabbitMQ 插件。Kettle 是一个开源的数据集成工具，它允许用户进行数据抽取、转换和加载（ETL）操作。RabbitMQ 是一个...
RabbitMQ实战指南-rabbitmq-action.zip
11-07
**RabbitMQ实战指南** RabbitMQ是一款广泛应用的开源消息队列系统，它基于Advanced Message Queuing Protocol（AMQP）标准，提供高可用性、可靠性和可扩展性。本实战指南将带你深入理解RabbitMQ的核心概念、安装与...
rabbitMQ实战java版-rabbitMQ-demo.zip
11-07
《RabbitMQ实战Java版——基于rabbitMQ-demo.zip的详解》 在当今的分布式系统中，消息队列作为异步处理、解耦组件的关键技术，得到了广泛应用。RabbitMQ作为一款开源的消息代理和队列服务器，以其稳定性和易用性...
rabbitMQ实战
10-10
这是牧码人王老师讲的，里面的rabbitMQ下载、安装、六种消息类型都很全，代码我也都试过了，直接复制粘贴就可以使用，希望可以帮助到大家
RabbitMQ 实战教程
weixin_68306883的博客
02-21 1290
了解RabbitMQ的使用和springboot集成的使用方法
rabbitmq实战
农码一生
01-21 192
原理： 消息生产者 -> 交换机 ->消息队列 -> 消息消费者 交换机(Exchanges) 消息队列(Quences) 交换机和消息队列 之间需要绑定 Bind 消息队列发消息给消息消费者，是通过TCP/IP 管道模式发送 创建交换机(Add exchange) name:起一个名字 Type: direct单点模式、 fanout全部发送、 topi...
RabbitMQ实战（一）
qq_34800986的博客
04-07 208
RabbitMQ 是一个消息代理：它接受并转发消息。你可以将其视为邮局：当你将要发布的邮件放在邮箱中时，您可以确信 Postman 先生最终会将邮件发送给收件人。在这个比喻中，RabbitMQ 是一个邮箱，邮局和邮递员。 RabbitMQ 和邮局之间的主要区别在于它不处理纸张，而是接受，存储和转发二进制数据块的消息。
RabbitMQ 实战
GitChat
04-12 1516
作为主流的消息中间件之一，RabbitMQ 广泛应用于互联网行业。本场 Chat，通过深入浅出的分析阐述，期望能够帮助读者获取 RabbitMQ 相关的基础知识，主要包括以下内容： RabbitMQ 基础概念 RabbitMQ 安装 & 管理 实战：RabbitMQ 生产者、消费者、编程模型 确保 RabbitMQ 高可用的基本方法 RabbitMQ 内部原理概述 本场 Chat 适用...
RabbitMQ实战指南
"RabbitMQ Cookbook：由Sigismondo Boschi和Gabriele Santomaggio合著，该书提供了超过70个实用的食谱，旨在帮助读者利用RabbitMQ开发消息传递应用程序，通过大量现实生活中的例子进行教学。" 《RabbitMQ Cookbook...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值