RabbitMQ使用

最新推荐文章于 2024-04-25 23:01:38 发布
最新推荐文章于 2024-04-25 23:01:38 发布
阅读量1.1k 收藏
点赞数
分类专栏： java 文章标签： rabbitmq 分布式 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lunge1234/article/details/122071119
版权

一、引言

模块之间的耦合度过高，一旦一个模块宕机后，全部功能都不能用了，并且同步通讯的成本过高，用户体验差。

RabbitMQ引言

二、RabbitMQ介绍

市面上比较火爆的几款MQ：

ActiveMQ，RocketMQ，Kafka，RabbitMQ。

  • 语言的支持：ActiveMQ，RocketMQ只支持Java语言，Kafka可以支持多门语言，RabbitMQ支持多种语言。

  • 效率方面：ActiveMQ，RocketMQ，Kafka效率都是毫秒级别，RabbitMQ是微秒级别的。

  • 消息丢失，消息重复问题： RabbitMQ针对消息的持久化，和重复问题都有比较成熟的解决方案。

  • 学习成本：RabbitMQ非常简单。

RabbitMQ是由Rabbit公司去研发和维护的，最终是在Pivotal，由Erlang语言开发（并发的编程语言）

RabbitMQ严格的遵循AMQP协议，高级消息队列协议，帮助我们在进程之间传递异步消息。

RabbitMQ是用Erlang实现的一个高并发高可靠AMQP消息队列服务器。支持消息的持久化、事务、拥塞控制、负载均衡等特性，使得RabbitMQ拥有更加广泛的应用场景。RabbitMQ跟Erlang和AMQP有关。下面简单介绍一下Erlang和AMQP。

Erlang是一门动态类型的函数式编程语言，它也是一门解释型语言，由Erlang虚拟机解释执行。从语言模型上说，Erlang是基于Actor模型的实现。在Actor模型里面，万物皆Actor，每个Actor都封装着内部状态，Actor相互之间只能通过消息传递这一种方式来进行通信。对应到Erlang里，每个Actor对应着一个Erlang进程，进程之间通过消息传递进行通信。相比共享内存，进程间通过消息传递来通信带来的直接好处就是消除了直接的锁开销(不考虑Erlang虚拟机底层实现中的锁应用)。

AMQP(Advanced Message Queue Protocol)定义了一种消息系统规范。这个规范描述了在一个分布式的系统中各个子系统如何通过消息交互。而RabbitMQ则是AMQP的一种基于erlang的实现。AMQP将分布式系统中各个子系统隔离开来，子系统之间不再有依赖。子系统仅依赖于消息。子系统不关心消息的发送者，也不关心消息的接受者。

优点

1、解耦：降低系统模块的耦合度

2、提高系统响应时间

3、异步消息

4、过载保护，流量削峰

1.应用解耦

场景：双11购物，用户下单后，订单系统需要通知库存系统，传统的做法就是订单系统调用库存系统的接口.

这种做法有一个缺点:

  • 当库存系统出现故障时，订单就会失败.

  • 订单系统和库存系统高耦合.

引入消息队列

  • 订单系统: 用户下单后，订单系统完成持久化处理，将消息写入消息队列,返回用户订单下单成功。

  • 库存系统: 订阅下单的消息,获取下单消息，进行库操作。 就算库存系统出现故障，消息队列也能保证消息的可靠投递，不会导致消息丢失

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

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

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

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

消息队列

引入消息队列后，把发送邮件，短信不是必须的业务逻辑异步处理，引入消息队列后，用户的响应时间就等于写入数据库的时间+写入消息队列的时间(可以忽略不计)，引入消息队列后处理后，响应时间是串行的3倍，是并行的2倍

3.流量削峰

流量削峰一般在秒杀活动中应用广泛

场景:秒杀活动，一般会因为流量过大，导致应用挂掉，为了解决这个问题，一般在应用前端加入消息队列。

作用: 1.可以控制活动人数，超过此一定阀值的订单直接丢弃

2.可以缓解短时间的高流量压垮应用(应用程序按自己的最大处理能力获取订单)

这样我们就可以采用队列的机制来处理，如同我们在超市结算一样，并不会一窝蜂一样涌入收银台，而是排队结算，一个接着一个的处理，不能插队，因为同时结算就只能达到这么多。

三、RabbitMQ安装

version: "3.1"
services:
  rabbitmq:
    image: daocloud.io/library/rabbitmq:management
    restart: always
    container_name: rabbitmq
    ports:
      - 5672:5672
      - 15672:15672
    volumes:
      - ./data:/var/lib/rabbitmq
[root@iz8vbdmrir2n6xqzrbd93hz /]# cd /opt
[root@iz8vbdmrir2n6xqzrbd93hz opt]# ls
containerd  docker_mysql_tomcat  docker_nginx  docker_ssm  yangl
[root@iz8vbdmrir2n6xqzrbd93hz opt]# mkdir docker_rabbitmq
[root@iz8vbdmrir2n6xqzrbd93hz opt]# cd docker_rabbitmq/
[root@iz8vbdmrir2n6xqzrbd93hz docker_rabbitmq]# vim docker-compose.yml
[root@iz8vbdmrir2n6xqzrbd93hz docker_rabbitmq]# docker-compose-Linux-x86_64 up -d
Creating network "docker_rabbitmq_default" with the default driver
Pulling rabbitmq (daocloud.io/library/rabbitmq:management)...
management: Pulling from library/rabbitmq
d7c3167c320d: Pulling fs layer
d7c3167c320d: Pull complete
131f805ec7fd: Pull complete
322ed380e680: Pull complete
6ac240b13098: Pull complete
58ab633708c7: Pull complete
4ef7b4c52e3f: Pull complete
0bcc8241708b: Pull complete
4bbf89f47f34: Pull complete
2dcee968b577: Pull complete
8f702d8e2d02: Pull complete
5159883c6988: Pull complete
ba6d73924acf: Pull complete
Digest: sha256:a9f93f113e1bbcd1de7035bdc433be68fa04086d672464233d339fa0a52b9747
Status: Downloaded newer image for daocloud.io/library/rabbitmq:management
Creating rabbitmq ... done
[root@iz8vbdmrir2n6xqzrbd93hz docker_rabbitmq]# docker ps
CONTAINER ID        IMAGE                                     COMMAND                  CREATED             STATUS              PORTS                                                                                        NAMES
a9ecaea4f19a        daocloud.io/library/rabbitmq:management   "docker-entrypoint.s…"   10 seconds ago      Up 9 seconds        4369/tcp, 5671/tcp, 0.0.0.0:5672->5672/tcp, 15671/tcp, 25672/tcp, 0.0.0.0:15672->15672/tcp   rabbitmq
​

浏览器访问：http://ip:15672 （注：云服务器记得开放 15672 和 5672 端口）

用户名和密码默认都是：guest

四、RabbitMQ架构【重点】

4.1 官方的简单架构图

  • Publisher - 生产者：发布消息到RabbitMQ中的Exchange

  • Consumer - 消费者：监听RabbitMQ中的Queue中的消息

  • Exchange - 交换机：和生产者建立连接并接收生产者的消息

  • Queue - 队列：Exchange会将消息分发到指定的Queue，Queue和消费者进行交互

  • Routes - 路由：交换机以什么样的策略将消息发布到Queue

简单架构图

4.2 RabbitMQ的完整架构图

完整架构图

完整架构图

4.3 RabbitMQ 通讯方式

RabbitMQ Tutorials — RabbitMQ

4.4 Hello-World案例演示

  1. 导入依赖

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

  1. 创建生产者 Publisher

package com.qf.rabbitmq;
​
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
​
//生产者
public class Publisher {
    public static void main(String[] args) throws Exception{
        System.out.println("Publisher...");
        //配置连接参数
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.25.132");
        factory.setPort(5672);
        factory.setUsername("guest");
        factory.setPassword("guest");
        //获取连接
        Connection connection = factory.newConnection();
        //获取Channel
        Channel channel = connection.createChannel();
        //配置队列参数
        //参数1：queue - 指定队列的名称
        //参数2：durable - 当前队列是否需要持久化,值为true时表示持久化，rabbitmq宕机或重启后，队列依然在
        //参数3：exclusive - 当前队列是否为排他队列，值为true时表示与当前连接（connection）绑定，连接关闭，队列消失
        //参数4：autoDelete - 当前队列是否自动删除，值为true时表示队列中的消息一旦被消费，该队列会消失
        //参数5：arguments - 指定当前队列的相关参数
        channel.queueDeclare("helloworldQueue",false,false,false,null);
        //发布消息到exchange，同时指定路由的规则
        // 参数1：指定exchange，使用""
        // 参数2：指定路由的规则，使用具体的队列名称
        // 参数3：指定传递的消息所携带的properties，使用null
        // 参数4：指定发布的具体消息，byte[]类型
        channel.basicPublish("","helloworldQueue",null,"helloworld".getBytes());
        //关闭资源
        //channel.close();
        //connection.close();
    }
}

  1. 创建消费者 Consumer

package com.qf.rabbitmq;
​
import com.rabbitmq.client.*;
import java.io.IOException;
​
//消费者
public class Consumer {
    public static void main(String[] args)throws Exception {
        System.out.println("Consumer...");
        //配置连接参数
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.25.132");
        factory.setPort(5672);
        factory.setUsername("guest");
        factory.setPassword("guest");
        //获取连接
        Connection connection = factory.newConnection();
​
        Channel channel = connection.createChannel();
        //要与生产者中的该方法一致（注：方法中的参数值必须保持一致）
        channel.queueDeclare("helloworldQueue",false,false,false,null);
​
        //监听队列
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel){
​
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("来自生产者的消息："+new String(body));
            }
        };
​
        //消费消息
        //参数1：queue - 指定消费哪个队列
        //参数2：autoAck - 指定是否自动ACK （true表示接收到消息后，会立即告知RabbitMQ，false表示不告知）
        //参数3：consumer - 指定消费回调
        channel.basicConsume("helloworldQueue",true,defaultConsumer);
    }
}

分别启动生产者和消费者进行测试（生产一次才能消费一次）

4.5 基本原理

RabbitMQ是消息队列的一种实现，那么一个消息队列到底需要什么？答案是队列，即Queue，那么接下来所有名词都是围绕这个Queue来拓展的。

就RabbimtMQ而言，Queue是其中的一个逻辑上的实现，我们需要连接到RabbitMQ来操作队列进而实现业务功能，所以就会有Connection，我们发一条消息连接一次，这样很显然是浪费资源的，建立连接的过程也很耗时，所以我们就会做一个东西让他来管理连接，当我用的时候，直接从里边拿出来已经建立好的连接发信息，那么ConnectionFactory应运而生。

接下来，当程序开发时，可能不止用到一个队列，可能有订单的队列、消息的队列、任务的队列等等，那么就需要给不同的queue发信息，那么和每一个队列连接的这个概念，就叫Channel。

再往下来，当我们开发的时候还有时候会用到这样一种功能，就是当我发送一条消息，需要让几个queue都收到，那么怎么解决这个问题呢，难道我要给每一个queue发送一次消息？那岂不是浪费带宽又浪费资源，我们能想到什么办法呢，当然是我们发送给RabbitMQ服务器一次，然后让RabbitMQ服务器自己解析需要给哪个Queue发，那么Exchange就是干这件事的 但是我们给Exchange发消息，他怎么知道给哪个Queue发呢？这里就用到了RoutingKey和BindingKey BindingKey是Exchange和Queue绑定的规则描述，这个描述用来解析当Exchange接收到消息时，Exchange接收到的消息会带有RoutingKey这个字段，Exchange就是根据这个RoutingKey和当前Exchange所有绑定的BindingKey做匹配，如果满足要求，就往BindingKey所绑定的Queue发送消息，这样我们就解决了我们向RabbitMQ发送一次消息，可以分发到不同的Queue的过程

至此，我们就把所有的名词贯通咯，接下来做个概要描述：

  • Broker:提供一种传输服务,它的角色就是维护一条从生产者到消费者的路线，保证数据能按照指定的方式进行传输

  • ConnectionFactory：与RabbitMQ服务器连接的管理器

  • Connection：与RabbitMQ服务器的TCP连接

  • Channel：与Exchange的连接，一个Connection可以包含多个Channel。之所以需要Channel，是因为TCP连接的建立和释放都是十分昂贵的，为了多路复用。RabbitMQ建议客户端线程之间不要共用Channel，但是建议尽量共用Connection。

  • Queue:消息的载体,每个消息都会被投到一个或多个队列。

  • Exchange：接受消息生产者的消息，并根据消息的RoutingKey和 Exchange绑定的BindingKey，以及Binding规则将消息路由给服务器中的队列。ExchangeType决定了Exchange路由消息的行为，例如，在RabbitMQ中，ExchangeType有direct、Fanout和Topic三种，不同类型的Exchange路由的行为是不一样的。

  • Message Queue：消息队列，用于存储还未被消费者消费的消息。

  • Message: 由Header和Body组成，Header是由生产者添加的各种属性的集合，包括Message是否被持久化、由哪个Message Queue接受、优先级是多少等。而Body是真正需要传输的APP数据。

  • RoutingKey：由Producer发送Message时指定，指定当前消息被谁接受

  • BindingKey：由Consumer在Binding Exchange与Message Queue时指定，指定当前Exchange下，什么样的RoutingKey会被下派到当前绑定的Queue中

  • Binding:联系了Exchange与Message Queue。Exchange在与多个Message Queue发生Binding后会生成一张路由表，路由表中存储着Message Queue所需消息的限制条件即Binding Key。当Exchange收到Message时会解析其Header得到Routing Key，Exchange根据Routing Key与Exchange Type将Message路由到Message Queue。Binding Key由Consumer在Binding Exchange与Message Queue时指定，而Routing Key由Producer发送Message时指定，两者的匹配方式由Exchange Type决定。

  • Server: 接受客户端连接，实现AMQP消息队列和路由功能的进程。

  • Virtual Host:其实是一个虚拟概念，类似于权限控制组，可以通过命令分配给用户Virtual Host的权限，默认的guest用户是管理员权限，初始空间有/，一个Virtual Host里面可以有若干个Exchange和Queue，但是权限控制的最小粒度是Virtual Host

五、SpringBoot整合RabbitMQ的使用【重点】

5.1 导入依赖

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

5.2 在application.properties中增加配置

#对于rabbitMQ的支持
spring.rabbitmq.host=192.168.153.136
spring.rabbitmq.port=5672
spring.rabbitmq.username=guest
spring.rabbitmq.password=guest

5.3 Hello-World 简单队列

一个生产者，一个默认的交换机，一个队列，一个消费者

结构图

1）创建配置类，用于创建队列对象

package com.qf.simple;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
​
@Configuration
public class SimpleQueueConfig {
​
    @Bean
    public Queue simple(){
        return new Queue("simpleQueue");
    }
}

2）创建生产者

package com.qf.simple;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
​
@Component
public class SimpleQueueProducer {
​
    @Autowired
    private RabbitTemplate rabbitTemplate;
​
    public void send(){
        System.out.println("SimpleQueueProducer");
        //发送消息，第一个参数为队列名称，第二参数为消息内容
        rabbitTemplate.convertAndSend("simpleQueue","简单模式");
    }
}

3）创建消费者

package com.qf.simple;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
​
@Component
@RabbitListener(queues="simpleQueue")//监听指定的消息队列
public class SimpleQueueCustomer {
    
    //@RabbitHandler修饰的方法中实现接受到消息后的处理逻辑
    @RabbitHandler
    public void receive(String content){
        System.out.println("SimpleQueueCustomer");
        System.out.println("来SimpleQueueProducer的信息："+content);
    }
}

4）在src\test\java\com\qf\Rabbitmq01ApplicationTests.java进行测试

package com.qf;
import com.qf.simple.SimpleQueueProducer;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
​
@SpringBootTest
class Rabbitmq01ApplicationTests {
    
    @Test
    void contextLoads() {
    }
    
    @Autowired
    private SimpleQueueProducer simpleQueueProducer;
​
    @Test
    public void testSimpleQueueProducer(){
        simpleQueueProducer.send();
    }
}

如果传递的是 JavaBean 对象，该实体类需要实现序列化接口，具体流程如下：

  1. 导入lombok依赖，创建User类

package com.qf.pojo;
​
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
​
import java.io.Serializable;
​
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User implements Serializable {
    private String username;
    private String password;
}

  1. 修改生产者中的代码

package com.qf.simple;
​
import com.qf.pojo.User;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
​
//生产者
@Component
public class SimplePublisher {
​
    @Autowired
    private RabbitTemplate rabbitTemplate;
​
    public void send(){
        System.out.println("SimplePublisher...");
        //rabbitTemplate.convertAndSend("","simpleQueue","简单模式");
        rabbitTemplate.convertAndSend("","simpleQueue",new User("张三","123"));
    }
}
​

  1. 修改消费者中的代码

package com.qf.simple;
​
import com.qf.pojo.User;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
​
//消费者
@Component
@RabbitListener(queues = "simpleQueue")
public class SimpleConsumer {
​
//    @RabbitHandler
//    public void receive(String content){
//        System.out.println("SimpleConsumer...");
//        System.out.println("来自SimplePublisher的消息："+content);
//    }
​
    @RabbitHandler
    public void receive(User user){
        System.out.println("SimpleConsumer...");
        System.out.println("来自SimplePublisher的消息："+user);
    }
}

  1. 运行测试类即可！

5.4 Work 工作队列

一个生产者，一个默认的交换机，一个队列，两个消费者，默认采用公平分发

结构图

1）创建配置类，用于创建队列对象

package com.qf.work;
​
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
​
@Configuration
public class WorkQueueConfig {
    
    @Bean
    public Queue work(){
        return new Queue("workQueue");
    }
}

2）创建生产者

package com.qf.work;
​
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
​
@Component
public class WorkQueueProducer {
    
    @Autowired
    private RabbitTemplate rabbitTemplate;
    
    public void send(){
        System.out.println("WorkQueueProducer");
        rabbitTemplate.convertAndSend("workQueue","工作队列模式");
    }
}

3）创建消费者，本案例创建两个消费者

package com.qf.work;
​
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
​
@Component
@RabbitListener(queues="workQueue")
public class WorkQueueCustomer_01 {
    
    @RabbitHandler
    public void receive(String content){
        System.out.println("WorkQueueCustomer_01："+content);
    }
}
package com.qf.work;
​
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
​
@Component
@RabbitListener(queues="workQueue")
public class WorkQueueCustomer_02 {
​
    @RabbitHandler
    public void receive(String content){
        System.out.println("WorkQueueCustomer_02："+content);
    }
}

4）在测试类中添加对象和方法进行测试

@Autowired
private WorkQueueProducer workQueueProducer;
​
@Test
public void testWorkQueueProducer(){
​
    for (int i = 0; i<4; i++){
        workQueueProducer.send();
    }
}

5.5 Publish/Subscribe 发布订阅模式

一个生产者，一个交换机，两个队列，两个消费者

结构图

使用该模式需要借助交换机，生产者将消息发送到交换机，再通过交换机到达队列.

有四种交换机：direct/topic/headers/fanout，默认交换机是direct，发布与订阅的实现使用第四个交换器类型fanout

使用交换机时，每个消费者有自己的队列，生产者将消息发送到交换机(X)，每个队列都要绑定到交换机

本例中：

创建2个消息队列

创建一个fanout交换机对象

Bind交换机和队列

5.6routing路由模式

一个生产者，一个交换机，两个队列，两个消费者

 生产者将消息发送到direct交换机（路由模式需要借助直连交换机实现），在绑定队列和交换机的时候有一个路由key，生产者发送的消息会指定一个路由key，那么消息只会发送到相应key相同的队列，接着监听该队列的消费者消费消息。也就是让消费者有选择性的接收消息。

本例中：

创建2个消息队列

创建一个direct交换机对象

Bind交换机和队列

//配置类
package com.qf.direct;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.DirectExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class DirectConfig {

    @Bean
    public Queue directQueue1(){
        return new Queue("directQueue1");
    }

    @Bean
    public Queue directQueue2(){
        return new Queue("directQueue2");
    }

    @Bean
    public DirectExchange directExchange(){
        return new DirectExchange("directExchange");
    }
              //张三为路由
    @Bean
    public Binding bingDirectQueue1(){
        return BindingBuilder.bind(directQueue1()).to(directExchange()).with("zhangsan");
    }

    @Bean
    public Binding bingDirectQueue2(){
        return BindingBuilder.bind(directQueue2()).to(directExchange()).with("lisi");
    }

}


//创建生产者
package com.qf.direct;

import org.springframework.amqp.core.DirectExchange;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class DirectProducer {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Autowired
    private DirectExchange directExchange;

    public void send(){
        System.out.println("DirectProducer");
        rabbitTemplate.convertAndSend(directExchange.getName(),"zhangsan","zhangsanContent");
        rabbitTemplate.convertAndSend(directExchange.getName(),"lisi","lisiContent");
//参数 交换机 路由 消息内容
    }
}
//2个消费者

package com.qf.direct;

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
@RabbitListener(queues = "directQueue1")
public class DirectCustomer_01 {

    @RabbitHandler
    public void receive(String content){
        System.out.println("DirectCustomer_01："+content);
    }
}

5.7主题模式

一个生产者，一个交换机，两个队列，两个消费者

 

又称通配符模式（可以理解为模糊匹配，路由模式相当于精确匹配）

使用直连交换机可以改善我们的系统，但是它仍有局限性，它不能实现多重条件的路由。

在消息系统中，我们不仅想要订阅基于路由键的队列，还想订阅基于生产消息的源。这时候可以使用topic交换机。

使用主题交换机时不能采用任意写法的路由键，路由键的形式应该是由点分割的有意义的单词。例如"goods.stock.info"等。路由key最多255字节。

*号代表一个单词

#号代表0个或多个单词

和路由模式差不多配置类不一样

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.TopicExchange;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class TopicConfig {

    @Bean
    public Queue topicQueue1(){
        return new Queue("topicQueue1");
    }

    @Bean
    public Queue topicQueue2(){
        return new Queue("topicQueue2");
    }

    @Bean
    public TopicExchange topicExchange(){
        return new TopicExchange("topicExchange");
    }

    @Bean
    public Binding bingTopicQueue1(){
        return BindingBuilder.bind(topicQueue1()).to(topicExchange()).with("wangwu.*");
    }

    @Bean
    public Binding bingTopicQueue2(){
        return BindingBuilder.bind(topicQueue2()).to(topicExchange()).with("zhaoliu.#");
    }

}

//生产者
import org.springframework.amqp.core.DirectExchange;
import org.springframework.amqp.core.TopicExchange;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class TopicProducer {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Autowired
    private TopicExchange topicExchange;

    public void send(){
        System.out.println("TopicProducer");
 rabbitTemplate.convertAndSend(topicExchange.getName(),"wangwu.abc","wangwuContent");    rabbitTemplate.convertAndSend(topicExchange.getName(),"zhaoliu.xyz.qwer","zhaoliuContent");
    }
}

5.8手动ack

RabbitMQ中的Ack： 主要是确认消息被消费者消费完成后通知服务器将队列里面的消息清除，spring-boot-data-amqp 是自动ACK机制，就意味着 MQ 会在消息发送完毕后，自动帮我们去ACK，然后删除队列中的消息，这样会存在一些问题：如果消费者处理消息需要较长时间，或者在消费消息的时候出现异常，都会出现问题，手动Ack可以避免消息重复消费。

1.在application 中 

#配置手动Ack
spring.rabbitmq.listener.simple.acknowledge-mode=manual

2.topic主题演示

import com.rabbitmq.client.Channel;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;


@Component
@RabbitListener(queues = "topicQueue1")
public class AckConsumer {

    @RabbitHandler
    public void receive(String content,Channel channel, Message message)throws Exception{

           byte[] messageBody = message.getBody();
            if (messageBody.length>0){
                System.out.println(new String(messageBody));
                //手动Ack，确定消费消息
                // deliveryTag:该消息的index
                // multiple：是否批量.true:将一次性ack所有小于deliveryTag的消息。
                try {
                    channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
                } catch (IOException e) {
                    e.printStackTrace();
                }

            }else {
                //1.放回队列  2.放弃这个消息
                //第三个参数是否放回队列
                try {
                    channel.basicNack(message.getMessageProperties().getDeliveryTag(),false,false);
                } catch (IOException e) {
                    e.printStackTrace();
                }

            }
}

六 事务与confirm机制

1.消息可靠性

思考？

1.如果消息已经到达RabbitMQ，RabbitMQ宕机了，消息是不是就丢失了？

可以使用Queue的持久化机制

2.消费者在消费消息的时候，程序执行到一半，消费者宕机了怎么办？

可以手动Ack

3.生产者发送消息时，由于网络问题，导致消息没有发送到RabbitMQ怎么办？

RabbitMQ提供了事务操作和Confirm以及Return机制

保证消息的传递可以使用RabbitMQ中的事务，事务可以保证消息100%传递，可以通过事务的回滚去记录日志，后面定时再次发送当前消息，但是事务操作效率太低。

RabbitMQ中除了事务，还提供了Confirm的确认机制，这个效率比事务高很多。

RabbitMQ的事务机制是同步操作，会极大的降低RabbitMQ的性能  不建议使用

comfirm 和renturn

   ConnectionFactory connectionFactory = new ConnectionFactory();
        //配置连接参数
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");
        connectionFactory.setHost("192.168.183.129");
        connectionFactory.setPort(5672);
        Connection connection = connectionFactory.newConnection();
        Channel channel = connection.createChannel();
        //配置队列参数
        //参数1：queue - 指定队列的名称
        //参数2：durable - 当前队列是否需要持久化,值为true时表示持久化，rabbitmq宕机或重启后，队列依然在
        //参数3：exclusive - 当前队列是否为排他队列，值为true时表示与当前连接（connection）绑定，连接关闭，队列消失
        //参数4：autoDelete - 当前队列是否自动删除，值为true时表示队列中的消息一旦被消费，该队列会消失
        //参数5：arguments - 指定当前队列的相关参数
        channel.queueDeclare("hello1", true, false, true, null);
        //发布消息到exchange，同时指定路由的规则
        // 参数1：指定exchange，使用"" 默认交换器
        // 参数2：指定路由的规则，使用具体的队列名称
        // 参数3：指定传递的消息所携带的properties，使用null
        // 参数4：指定发布的具体消息，byte[]类型

        channel.basicPublish("", "hello1", null, "hi".getBytes());

        channel.confirmSelect();
        //单条    多条channel.waitForConfirmsOrDie();  //批量消息确认，如果有一条消息没有发送成功，会抛出异常
        //if (channel.waitForConfirms()){
        //    System.out.println("发到交换机成功");
        //}else {
        //    System.out.println("发到交换机没成功");
        //}

        //异步调用
        channel.addConfirmListener(new ConfirmListener() {
            @Override
            public void handleAck(long deliveryTag, boolean multiple) throws IOException {
                System.out.println("到交换机"+deliveryTag +"multiple"+multiple);
            }

            @Override
            public void handleNack(long deliveryTag, boolean multiple) throws IOException {
                System.out.println("没到交换机");

            }
        });
        channel.addReturnListener(new ReturnListener() {
            @Override
            public void handleReturn(int replyCode, String replyText, String exchange, String routingKey, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("发送到队列失败");
            }
        });

        channel.close();
        connection.close();

    }

2.在spring-boot整合

//在application在配置
#comfirm
#spring.rabbitmq.publisher-confirm-type=simple
#spring.rabbitmq.publisher-returns=true

//写个配置类来配置就可以

import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.ReturnedMessage;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;

import javax.annotation.PostConstruct;

@Configuration
public class PublisherConfirmAndReturnConfig implements RabbitTemplate.ConfirmCallback,RabbitTemplate.ReturnsCallback {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @PostConstruct
    public void initMethod(){
        rabbitTemplate.setConfirmCallback(this);
        rabbitTemplate.setReturnsCallback(this);
    }

    @Override
    public void confirm(CorrelationData correlationData, boolean ack, String s) {
        if(ack){
            System.out.println("到达交换机");
        }else{
            System.out.println("没有到达交换机");
        }
    }

    @Override
    public void returnedMessage(ReturnedMessage returnedMessage) {

        System.out.println("没有到达队列");
    }
}

七死信队列

死信队列并不是一个特殊的队列，只是一个普通的队列，只是我们把他们取名叫做死信队列。

死信队列的设计是在某个队列的头信息中设定x-dead-letter-exchange (死信交换机)和x-dead-letter-routing-key(死信路由键)即可。关联到一个绑定到某个死信交换机的队列上。然后给该队列指定过期时间或者指定的消息的过期时间，那么该消息到期后会自动到达死信队列中。

场景一：未支付订单在规定的时间取消。实现的方式为，将订单消息放入到一个队列中，并指定其过期时间。当过期时间到了之后，就进入到了死信队列，那么可以直接在死信队列的消费端取出对应的消息即可。
场景二：某条消息在消费端曾多次尝试消费，但是均未消费成功，那么就进入死信队列，让人工干预。 
//工具包
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class RabbitMQUtils {
    /**
     * 1. 创建连接工厂（ConnectionFactory）
     * 2. 创建连接 (Connection)
     * 3. 创建通道  (Channel)
     * Connection conn = connectionFactory.newConnection();
     * <p>
     * Channel channel = conn.createChannel();
     */
    private static ConnectionFactory connectionFactory;

    static {
        connectionFactory = new ConnectionFactory();
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");
        connectionFactory.setHost("39.103.159.36");
    }


    public static Connection getConnection() {
        Connection connection = null;
        try {
            connection = connectionFactory.newConnection();
        } catch (IOException ioException) {
            ioException.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }
        return connection;
    }

    public static void close(Channel channel, Connection connection) {
        try {
            if (null != channel) {
                channel.close();
            }
            if (null != connection) {
                connection.close();
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
}

//配值死信和生产者
import com.rabbitmq.client.AMQP;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;

import java.util.HashMap;
import java.util.Map;

public class DeadQueueTest {

    // 死信交换机
    private static final String dead_letter_exchange = "dead_letter_exchange";
    // 死信路由键
    private static final String dead_letter_routing_key = "dead_letter_routing_key";
    //死信队列
    private static final String dead_letter_queue = "dead_letter_queue";

    private static final String people_exchange = "people_exchange";
    private static final String people_routing_key = "people_routing_key";
    private static final String people_queue = "people_queue";

    public static void main(String[] args) throws Exception{
        Connection connection = RabbitMQUtils.getConnection();
        Channel channel = connection.createChannel();

        // 创建一个死信的交换机
        channel.exchangeDeclare(dead_letter_exchange, "direct");
        // 创建死信队列
        channel.queueDeclare(dead_letter_queue, true, false, false, null);
        // 将死信队列绑定到死信交换机，路由键为 "dead_letter_routing_key"
        channel.queueBind(dead_letter_queue, dead_letter_exchange, dead_letter_routing_key);

        Map<String, Object> arguments = new HashMap<>();
        arguments.put("x-dead-letter-exchange", dead_letter_exchange);
        arguments.put("x-dead-letter-routing-key", dead_letter_routing_key);

        /**
         * 最后一个参数是队列的属性
         */
        channel.exchangeDeclare(people_exchange, "direct");
        
        channel.queueDeclare(people_queue, true, false, false, arguments);

        channel.queueBind(people_queue, people_exchange, people_routing_key);

        AMQP.BasicProperties properties = new AMQP.BasicProperties.Builder()
                .expiration("40000").build();

        channel.basicPublish(people_exchange, people_routing_key, properties, "dead_message".getBytes());

        RabbitMQUtils.close(channel, connection);
    }
}

//配置消费者   测试类中队列参数要一样 才可以

import com.entity.User;
import com.rabbitmq.client.*;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

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


public class AckConsumer {

    public static void main(String args[]) throws IOException {
        Connection connection = RabbitMQUtils.getConnection();
        Channel channel = connection.createChannel();
        Map<String, Object> arguments = new HashMap<>();
        arguments.put("x-dead-letter-exchange","dead_letter_exchange");
        arguments.put("x-dead-letter-routing-key", "dead_letter_routing_key");

        channel.queueDeclare("people_queue", true, false, false, arguments);
        //监听队列 重写监听对象的方法
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {

            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("来自生产者的消息：" + new String(body));
            }
        };


        //消费消息
        //参数1：queue - 指定消费哪个队列
        //参数2：autoAck - 指定是否自动ACK （true表示接收到消息后，会立即告知RabbitMQ，false表示不告知）
        //参数3：consumer - 指定消费回调
        channel.basicConsume("people_queue", true, defaultConsumer);

    }

    }

八 如何避免消息重复消费

1.幂等性

所有的消息中间件都会存在这样一个问题，那就是消息的重复消费问题，所以我们必须做幂等性设计，所谓幂等性设计就是，一条消息无论消费多少次所产生的结果都是相同的。

重复消费消息，是对非幂等性操作造成问题，重复消费消息的原因是因为消费者没有给RabbitMQ一个Ack

 

为了解决消息重复消费的问题，可以采用Redis，在消费者消费消息之前，现将消息的id放到Redis中，

id-0（正在执行业务）

id-1（执行业务成功）

如果ack失败，在RabbitMQ将消息交给其他的消费者时，先执行setnx，如果key已经存在，获取他的值，如果是0，当前消费者就什么都不做，如果是1，直接ack。

极端情况：第一个消费者在执行业务时，出现了死锁，在setnx的基础上，再给key设置一个生存时间。

主要是一个标识 怎么传过去  在simplequeue中改 
  @Bean
    public MessagePostProcessor correlationIdProcessor() {
        MessagePostProcessor messagePostProcessor = new MessagePostProcessor() {
            @Override
            public Message postProcessMessage(Message message, Correlation correlation) {
                MessageProperties messageProperties = message.getMessageProperties();
                //通过Correlation对象存储id参数，Message获取id参数
                if (correlation instanceof CorrelationData) {
                    String correlationId = ((CorrelationData) correlation).getId();
                    messageProperties.setCorrelationId(correlationId);
                }
                //返回
                return message;
            }

            @Override
            public Message postProcessMessage(Message message) throws AmqpException {
                return message;
            }
        };
        return messagePostProcessor;
    }


import org.springframework.amqp.core.MessagePostProcessor;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.UUID;
//
@Component
public class SimpleQueueProduct {
    @Autowired
    MessagePostProcessor messagePostProcessor;
    @Autowired
    private RabbitTemplate rabbitTemplate;
    public void send(){
        System.out.println("SimpleQueueProducer");
        CorrelationData correlationData = new CorrelationData(UUID.randomUUID().toString().replace("-",""));
        System.out.println(correlationData);
//参数
        rabbitTemplate.convertAndSend("","simpleQueue","ssss",messagePostProcessor,correlationData);


    }

}

 

lunge1234
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java连接rabbitmq_RabbitMQ基础
weixin_39822629的博客
11-27 631
1. 消息中间件概述1.1. 什么是消息中间件MQ全称为Message Queue，消息队列是应用程序和应用程序之间的通信方法。为什么使用MQ在项目中，可将一些无需即时返回且耗时的操作提取出来，进行异步处理，而这种异步处理的方式大大的节省了服务器的请求响应时间，从而提高了系统的吞吐量。开发中消息队列通常有如下应用场景：1、任务异步处理将不需要同步处理的并且耗时长的操作由消息队列通知消息接收方进行异...
RabbitMQ教程大全看这一篇就够了-java版本
又逢乱世
11-06 2928
rabbitmq
java操作rabbitmq消费者示例
feinifi的博客
10-12 5985
rabbitmq是作为消息队列，在实际应用中很常见，生产者将消息发送到某个队列，消费者消费这个队列。 消息在队列中，消费者要消费，需要监听队列，简单的来说，就是注册一个方法到消费者通道，这个方法就会在有消息的时候执行。 下面通过java来操作rabbitmq，给出代码示例。 这里介绍三种消费者示例方法 1、最简单的注册。 直接通过channel.basicConsume()设置callback。 2、模拟一个...
RabbitMQ最全使用教程-小白也能看懂
最新发布
2401_84557521的博客
04-25 3259
我还通过一些渠道整理了一些大厂真实面试主要有：蚂蚁金服、拼多多、阿里云、百度、唯品会、携程、丰巢科技、乐信、软通动力、OPPO、银盛支付、中国平安等初，中级，高级Java面试题集合，附带超详细答案，希望能帮助到大家。还有专门针对JVM、SPringBoot、SpringCloud、数据库、Linux、缓存、消息中间件、源码等相关面试题。
三十一、RabbitMQ一（1）
u_hcy2000的博客
02-04 546
文章目录学习目标一、消息队列MQ概述1.1 为什么使用MQ1.2. 消息队列产品1.3. AMQP 和 JMS1.3.1. AMQP1.3.2. JMS1.3.3. AMQP 与 JMS 区别1.4. RabbitMQ**应用场景：****1、双十一商品秒杀/抢票功能实现****2、积分兑换(积分可用于多平台)****3、大平台用户注册**1.5 相关定义：二、安装及配置RabbitMQ2.1. docker中安装RabbitMq2.2. 用户以及Virtual Hosts配置2.2.1. 用户角色2.2.
RabbitMQ使用规范
08-04
RabbitMQ使用规范 概述 RabbitMQ是基于AMQP高性能的开源消息队列服务器，可以用来实现消息的发布、订阅和routing。该规范旨在为RabbitMQ的使用提供一个统一的标准，确保RabbitMQ的使用符合公司的技术架构和安全要求...
RabbitMq使用手册
12-07
RabbitMq 使用手册 本文档为 RabbitMq 使用手册，介绍了 RabbitMq 的应用场景和开发指导。RabbitMq 是一个由 Erlang 开发的 AMQP（Advanced Message Queue）流行的开源消息队列系统。RabbitMq 的结构图如下： ...
RabbitMQ使用总结
03-13
内容为自己总结的RabbitMQ的经验，内容大致有：安装顺序、关键文件路径、常用命令、集群注意事项等，有用的请收入
rabbitMQ使用手册
06-03
RabbitMQ 使用手册 RabbitMQ 是一个流行的消息队列系统，它提供了多种交换机类型，每种交换机类型都有其特点和用途。下面我们将详细介绍 RabbitMQ 中的 Fanout Exchange、Direct Exchange 和 Topic Exchange。 ...
RabbitMQ的使用
qq_47387991的博客
03-03 1272
1.初识MQ 1.1.同步和异步通讯 微服务间通讯有同步和异步两种方式： 同步通讯：就像打电话，需要实时响应。 异步通讯：就像发邮件，不需要马上回复。
RabbitMq应用
weixin_59868842的博客
12-13 461
rabbit 的模式与高可用
一：RabbitMQ概述与工作模式
Xx__WangQi的博客
04-14 311
目录 1、MQ 的基本概念 1.1 MQ概述 1.3 MQ 的优势 1.3.1应用解耦 1.3.2异步提速 1.3.3削峰填谷 1.4 MQ 的劣势 1.5 常见的 MQ 产品 1.6 RabbitMQ 简介 2、RabbitMQ 的工作模式 2.1 简单模式： 2.2Work queues 工作队列模式 2.3 Pub/Sub 订阅模式 2.4Routing 路由模式 2.5Topics 通配符模式 2.6工作模式总结 1、MQ 的基本概念 1.1 ...
RabbitMQ的7种典型使用场景
hudeyong926的专栏
09-10 1万+
场景1：单发送单接收 使用场景：简单的发送与接收，没有特别的处理。 一个P向queue发送一个message，一个C从该queue接收message并打印。producer，连接至RabbitMQ Server，声明队列，发送message，关闭连接，退出。 场景2：单发送多接收 使用场景：一个发送端，多个接收端，如分布式的任务派发。为了保证消息发送的可靠性，不丢失消息，使消息持久化了。同时为了防止接收端在处理消息时down掉，只有在消息处理完成后才发送ack消息。 场景3：Publis.
【RabbitMQ】什么是RabbitMQ？RabbitMQ有什么用？应用场景有那些？
热门推荐
四季轮换叶，一路招摇胜
09-27 3万+
RabbitMQ简称MQ是一套实现了高级消息队列协议的开源消息代理软件，简单来说就是一个消息中间件。是一种程序对程序的通信方法。
RabbitMQ 使用教程（看完就会用了）
Sunshineづ
03-19 2555
本文介绍了 RabbitMQ 的基本概念、安装和配置、使用方法以及应用场景。RabbitMQ 是一个功能强大的消息队列中间件，具有高并发、高可靠、高可扩展等优点，可以应用于多种场景。如果你正在开发一个高并发、分布式的系统，RabbitMQ 绝对是一个值得考虑的选择。
硬核，RabbitMQ入门使用教程，详细到哭
Javanewspaper的博客
12-31 9631
RabbitMQ 简介 RabbitMQ是使用Erlang语言开发的开源消息队列系统，基于AMQP协议来实现。AMQP的主要特征是面向消息、队列、路由(包括点对点和发布/订阅)、可靠性、 安全。AMQP协议更多用在企业系统内，对数据一致性、稳定性和可靠性要求很高的场景，对性能和吞吐量的要求还在其次。 MQ全称为Message Queue, 消息队列(MQ)是一种应用程序对应用程序的通信方法。应用程序通过读写出入队列的消息(针对应用程序的数据)来通信，而无需专用连接来链接它们。消息传递指的是程序之间通过在
RabbitMQ在实际项目中的应用
weixin_67601403的博客
05-29 5404
RabbitMQ简介 以商品订单场景为例， 如果商品服务和订单服务是两个不同的微服务，在下单的过程中订单服务需要调用商品服务进行扣库存操作。按照传统的方式，下单过程要等到调用完毕之后才能返回下单成功，如果网络产生波动等原因使得商品服务扣库存延迟或者失败，会带来较差的用户体验，如果在高并发的场景下，这样的处理显然是不合适的，那怎么进行优化呢？这就需要消息队列登场了。 消息队列提供一个异步通信机制，消息的发送者不必一直等待到消息被成功处理才返回，而是立即返回。消息中间件负责处理网络通信，如果网络连接不可用

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值