RabbitMQ之旅 - 技术栈

遇到的坑：

1.connection error; protocol method: #method(reply-code=530, reply-text=NOT_ALLOWED - access to vhost '/' refused for user 'root', class-id=10, method-id=40)

去页面设置

点击即可

2.在使用队列的时候，其中在使用publish/subscribe和Routing中,俩个消费者使用的队列都是一样的的时候，这样都是同一个队列，无论怎么样都是对这来个对立进行轮询操作没有什么效果！！！！！

RabbitMQ（免费！！！）

它是什么？

是一个第三方的软件，他兼容各种计算机语言（包括java），有各种语言的客户端，他是一个功能非常完整的队列（先进先出），主要有发送者，队列，消费者三种角色

生产者：制造消息的角色（将消息放入队列）

队列：存放信息的的地方（就像一个邮箱）

消费者：去队列中拿消息的角色

它能干什么？

1.最明显的是它能够存储生产者制造出来的消息，可以让消费者到特定的队列去取（这个消息可以存储很久，不那么容易丢失，有各种对策）

2.可以做流量的消峰，一个时间段内，如果用户登录的太多了，可以做一定限制，让这些消息，一个个放入队列，然后一个一个慢慢的处理，（让他们再里面排队，一个一个处理）保证我们服务器的健壮性

3.可以做异步处理，比如俩个操作可以同步进行最常见的就是数据库中生成下单的信息，向用户与服务商发送下单消息，都是可以同时进行的，我们将这个下单的信息存储到rabbitmq中，然后这俩个模块都可以接收到这个消息就可以同时做处理了。

4.有助于系统解耦，我们可以看出上面这些操作，获得数据都是从rabbitmq中获取的，并没有用到其他模块的类就可以执行；可以说俩个模块之间都不需要，对方做了什么，一个只需要知道发送小心进队列，一个是有消息了从队列里面拿出来干活就行

RabbitMQ使用中的一些操作

首先引入包

xml 复制代码

 <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-amqp</artifactId>
             <version>2.7.2</version>
         </dependency>
         <!-- https://mvnrepository.com/artifact/com.rabbitmq/amqp-client -->
         <dependency>
             <groupId>com.rabbitmq</groupId>
             <artifactId>amqp-client</artifactId>
             <version>5.17.0</version>
         </dependency>

第二，创建连接工具类

java 复制代码

 public class RabbitUtils {
 
     public static Channel getRabbitMqChannel(){
         ConnectionFactory factory = new ConnectionFactory();
         factory.setHost("127.0.0.1");
         factory.setUsername("root");
         factory.setPassword("root");
         Channel channel = null;
         try {
             Connection connection = factory.newConnection();
             channel = connection.createChannel();
         } catch (IOException | TimeoutException e) {
             throw new RuntimeException(e);
         }
         return channel;
     }
 }

简单的发送队列hello word

作为生产者我们需要什么？

1.首先肯定是要发出去消息（所以消息放在哪里呢？）

2.其次要有放的队列 channel.queueDeclare（String queue, boolean durable, boolean exclusive, boolean autoDelete, Map arguments）

3.最后是发送消息channel.basicPublish（String exchange, String routingKey, BasicProperties props, byte[] body）

介绍一下发送的参数：

我们先从channel.queueDeclare 开始

queue：队列的名称

durable：是否让这个队列永远存在

exclusive：只允许一个连接（消费者）独占队列

autoDelete：当没有消费者使用这条消息的时候直接自动删除

arguments：构造队列的时候设置的参数（队列属性）

发布消息channel.basicPublish

exchange:指定交换机的名字这个消息发布到哪一个交换机

routingKey：路由key，可以根据key找到对应的路径

props：其他的路由的配置

body：发送的消息

生产者：

java 复制代码

 public class HelloWordProduce {
 
     private final static String QUEUE_NAME = "hello";
 
     public static void main(String[] args) throws IOException {
         Channel channel = RabbitUtils.getRabbitMqChannel();
         channel.queueDeclare(QUEUE_NAME, false, false, false, null);
         String message = "Hello World!";
         channel.basicPublish("", QUEUE_NAME, null, message.getBytes(StandardCharsets.UTF_8));
         System.out.println(" [x] Sent '" + message + "'");
     }
 }

消费者的一些参数设置

1.首先我们消费者肯定是也要声明一个队列的，queueDeclare（）这个一定要和上面的生产者的一致，这样才能是同一条队列里面取东西。

2.我们收到消息是不是要获取，那么我们怎么获取呢？

使用basicConsume(String queue, boolean autoAck, DeliverCallback deliverCallback, CancelCallback cancelCallback)方法

queue：接收消息的队列的名称

autoAck:是否自动接收消息（自动应答，服务器自动应答）

deliverCallback: 接收到消息的方法，里面可以获取得到的数据

cancelCallback: 拒绝接收方法的操作

消费者

java 复制代码

 public class HelloWordConsumer {
 
     private final static String QUEUE_NAME = "hello";
 
     public static void main(String[] argv) throws Exception {
         Channel channel = RabbitUtils.getRabbitMqChannel();
         channel.queueDeclare(QUEUE_NAME, false, false, false, null);
         System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
 
         DeliverCallback deliverCallback = (consumerTag, delivery) -> {
             String message = new String(delivery.getBody(), StandardCharsets.UTF_8);
             System.out.println(" [x] Received '" + message + "'");
         };
         channel.basicConsume(QUEUE_NAME, true, deliverCallback, consumerTag -> { });
     }
 }

工作队列分发任务Work Queue

其实就是上面的demo再多添加一个消费者即可

工作队列：rabbitmq默认就是会形象一个轮询的负载均衡操作，每个消费者轮着去队列里面的消息

使用场景（10/2）：就好像你部署了多台的服务器，上面都用了rabbitmq，然后都用者一个队列，他们就可以做到负载均衡，根据情况按顺序的转发每一个队列（如果一个消息还没有处理完，时间太久了，可以给其他的消费者进行取，然后使用方法）

消息丢失？

这个时候我们应该考虑一个问题，有没有可能消息会丢失呢？

其实这就是rabbitmq这种专门做消息的软件，是肯定有这些预防措施的，这种一般都是在消费者端可以设置一个返回值，让队列知道，消息队列一旦收到了确认消息的提示，就会删除这条消息消息，如果很久都没有返回消息，那就会重新将消息入队；如果此时那个消费者宕机了，如果还有其他的对应队列的消费者存在就会发送到那个另外存活的消费者 ，如果只是你忘记在消费者端口标记确认收到消息，那么就会发生，消费者没有收到，然后其他队列也没有收到的情况，并且有一个超时时间30分钟，30分钟后会消息重新入队

那么这个参数又是什么呢？

这个参数就是在消费者这边确认消息时候的autoAck，我们之前都是将他设置成true，我们就会导致消息队列如果还没有处理完消息，就崩溃了，就会导致这条消息直接消失，但是我们设置成false就可以变为手动应答，就可以有效的阻止这个情况发送

如下

java 复制代码

 public static void main(String[] args) throws IOException {
         Connection connection = RabbitUtils.getRabbitMqChannel();
         Channel channel = connection.createChannel();
         channel.queueDeclare(WORK_QUEUE_NAME, false, false, false, null);
         channel.basicQos(1);
         System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
 
         DeliverCallback deliverCallback = (consumerTag, delivery) -> {
             String message = new String(delivery.getBody(), StandardCharsets.UTF_8);
             try {
                 Thread.sleep(1000000);
             } catch (InterruptedException e) {
                 throw new RuntimeException(e);
             }
             System.out.println(" 接收的消息WORK0 '" + message + "'");
             channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
         };
 
         channel.basicConsume(WORK_QUEUE_NAME, false, deliverCallback, consumerTag -> { });
     }

其中我们发现在我们设置成功手动应答之后，在接收消息的方法中多了一个方法

channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false); （如果这个忘记设置，那么会导致rabbitmq内存越吃越多，因为rabbitmq不能释放没有确认的消息）

这个就是设置手动应答，如果消息接收到了我们才进行确认消息，他参数如下

java 复制代码

 void basicAck(long deliveryTag, boolean multiple) throws IOException;

deliveryTag: 一个rabbitmq收到消息的一个标记

multiple:如果是true，那就是发送过来的消息，直接全部都确认（还是可能造成消息丢失，因为可能确认还没有真正确认的消息），false代表消息一条一条慢慢确认

还有一个在消费者端口要设置的每次都只接收一条消息如果不需要限制一条一条收可以设置为0

ini 复制代码

 channel.basicQos(1);

接下来又有一个问题：如果服务器宕机了，那队列是不是就消失了？那我们该如何让这个队列也持久化呢？

我们可以看到我们队列创建的时候有一个参数 durable 他的作用就是让队列永远存在，如果设置为true就可以让他永远存在，就算重启也会存在这个队列，但是如果一个已经存在的队列，已经设置好了不是true，如果你要对这个队列进行修改为true那么这个将会报错（这是一个值得注意的事项）这个时候切记，设置队列的时候俩端（生产者，消费者）都要设置为true不然也会报错（注意事项二）

最后我们的消息会不会丢失呢？其实还是有可以能的

因为我们发送的消息，如果在发送的过程中到队列的时候，突然宕机了，那这个消息就会丢失，虽然队列持久化了，消费者那边有是否确认消息，但是消息他没有持久化啊，还是会丢失消息的，所以我们也需要将发送的消息设置为持久化这个时候我们需要设置发送的消息也为持久化！！！

这个怎么设置呢，肯定是要从发送消息那边设置的就是这个方法中channel.basicPublish（）从上面我们可以看到它还有一个参数就是BasicProperties props这个可以做一些设置，需要写入MessageProperties.PERSISTENT_TEXT_PLAIN,就可以保证消息也持久化了

这里面设置了好了消息持久化如下

java 复制代码

 public static final BasicProperties PERSISTENT_TEXT_PLAIN =
         new BasicProperties("text/plain",
                             null,
                             null,
                             2,
                             0, null, null, null,
                             null, null, null, null,
                             null, null);

其实就算都设置好了，还是有可能会丢失消息，当你设置了消息是持久化后，生产者写入消息会到磁盘中，但是期间还是有一个很短的时间窗口，如果这个时候宕机了也没有办法（当然rabbitmq不会把所有的消息都同步至硬盘，也有可能放入缓存中，虽然这个持久性保证并不是很强，但是一般的队列够用了）

Fair dispatch

其实消息队列本身不设置任何参数的话，会可能导致的结果就是消费者的资源分配的不是很合理（由于各种原因，服务器的处理性能等）最后造成的结果会是，一个服务器很忙，一个服务器会很闲；

例如一个处理很快的机器和一个处理很慢的机器，然后rabbitmq一致轮询发送，不管他与没有处理完，就会导致消息处理慢的那一方积压

因为 rabbitmq只是负责生产者发送消息的时候在消息进入队列的时候做调度，进去了就不管了

所以我们就要在消费者端口做一些配置