RabbitMQ 实战

1：安装 RabbitMQ

这里我会先同时安装三台机器，为以后的高可用集群做准备

注意在进行以下操作之前可以先关闭防火墙或者开放防火墙端口

开放防火墙端口
//永久的添加该端口。去掉--permanent则表示临时。
firewall-cmd --permanent --zone=public --add-port=5672/tcp
firewall-cmd --permanent --zone=public --add-port=15672/tcp
//重新加载配置，使得修改有效。
firewall-cmd --reload
//查看开启的端口，出现5672/15672这开启正确
firewall-cmd --permanent --zone=public --list-ports

（推荐使用）

永久关闭防火墙

首先查看防火墙的状态
systemctl status firewalld.service

然后执行命令进行关闭
systemctl stop firewalld service 临时关闭防火墙

systemctl disable firewalld.service 开机禁止防火墙服务器永久关闭
systemctl enable firewalld.service 开机启动防火墙服务器

（自己学习的时候使用）

1.1：安装RabbitMQ 的依赖环境

安装常用的环境和工具包

yum -y install gcc glibc-devel make ncurses-devel openssl-devel xmlto perl wget gtk2-devel binutils-devel

erlang官网下载你需要的erlang的版本：

https://www.erlang.org/downloads

将下载的tar.gz 上传到 Linux 虚拟机解压安装

tar -xzvf otp_src_23.3.4.9.tar.gz -C /usr/local

cd /usr/local/otp_src_23.3.4.9

mkdir -p /usr/local/erlang

./configure --prefix=/usr/local/erlang 编译配置

直到打印如下日志

使用make install 进行安装

然后检查环境变量是否有erlang

如果没有则需要配置环境变量
echo 'export PATH=$PATH:/usr/local/erlang/bin' >> /etc/profile

刷新环境变量
source /etc/profile

检查是否安装成功

ll /usr/local/erlang/bin

输入 erl 并用 halt() . 函数退出

到这里 erlang 环境安装完成

1.2：安装RabbitMQ

下载 RabbitMQ :

https://github.com/rabbitmq/rabbitmq-server/releases/tag/v3.8.26

注意官网上的这句话

Erlang/OTP Compatibility Notes

This release requires Erlang 23.2 and supports Erlang 24.

Erlang 和 rabbitMQ 是有版本对应关系的，版本不对应安装不成功

上传到 linux

rpm -ivh --nodeps rabbitmq-server-3.8.26-1.el7.noarch.rpm

使用 yum 安装时会报错，因为yum 比较谨慎一般都安装比较旧的版本，

rpm -ivh --nodeps rabbitmq-server-3.9.5-1.el7.noarch.rpm 添加参数 --nodeps 忽略依赖校验

再次执行可以发现安装成功了

#启动rabbitmq，-detached代表后台守护进程方式启动

# 启动服务：rabbitmq-server -detached
# 查看状态：rabbitmqctl status
# 关闭服务：rabbitmqctl stop
# 列出角色：rabbitmqctl list_users

查看状态如下说明安装启动成功

查看用户列表

#启用管理插件
rabbitmq-plugins enable rabbitmq_management

# 端口 15672（网页管理） 5672 （AMQP端口）：
#在浏览器中输入服务器IP:15672 就可以看到RabbitMQ的WEB管理页面了，但是现在并不能登录

我们需要新建一个用户

此时还无法登录，我们需要给管理控制台添加用户并授予权限

rabbitmqctl add_user developer 添加用户

根据提示输入密码： dev123456

给用户添加角色并查看用户信息

rabbitmqctl set_user_tags developer dev123456 administrator

rabbitmqctl list_users 查看用户列表

删除原有的 guest 用户

rabbitmqctl delete_user guest

使用新的用户名 developer 密码 dev123456 登录后台管理界面可以发现三个机器的管理后台都可以正常进入了

1.3：常用的用户管理的命令及界面操作

# 启动服务：rabbitmq-server -detached
# 查看状态：rabbitmqctl status
# 关闭服务：rabbitmqctl stop
# 列出角色：rabbitmqctl list_users

添加用户 rabbitmqctl add_user developer
#根据提示添加密码

删除用户：rabbitmqctl delete_user guest

修改密码： rabbitmqctl change_password developer dev123456

RabbitMQ中主要有administrator，monitoring，policymaker，management，impersonator,none几种角色

修改角色： rabbitmqctl set_user_tags developer administrator

也可以给用户设置多个角色，如给用户developer设置administrator，monitoring

rabbitmqctl set_user_tags developer administrator monitoring

权限包含读写配置

权限赋值 rabbitmqctl set_permissions -p / developer ".*" ".*" ".*"

查看(指定vhostpath)所有用户的权限
rabbitmqctl list_permissions

查看virtual host为/的所有用户权限：
rabbitmqctl list_permissions -p /

查看指定用户的权限
rabbitmqctl list_user_permissions developer

清除用户权限
rabbitmqctl clear_permissions developer

1.4：RabbitMQ用户角色及权限控制

RabbitMQ的用户角色分为5类：
none、management、policymaker、monitoring、administrator

none
不能访问 management plugin

management
拥有这种角色的用户通过AMQP做的任何事外
还可以列出自己可以通过AMQP登入的virtual hosts
查看自己的virtual hosts中的queues, exchanges 和 bindings
查看和关闭自己的channels 和 connections
查看有关自己的virtual hosts的“全局”的统计信息，包含其他用户在这些virtual hosts中的活动

policymaker
该角色可以拥有management可以做的任何事外加权限：
查看、创建和删除自己的virtual hosts所属的policies和parameters

monitoring
management可以做的任何事外加：
列出所有virtual hosts，包括他们不能登录的virtual hosts
查看其他用户的connections和channels
查看节点级别的数据如clustering和memory使用情况
查看真正的关于所有virtual hosts的全局的统计信息

administrator 最高权限
policymaker和monitoring可以做的任何事外加:
创建和删除virtual hosts
查看、创建和删除users
查看创建和删除permissions
关闭其他用户的connections

创建用户并设置角色：
可以创建管理员用户，负责整个MQ的运维，例如：
$sudo rabbitmqctl add_user admin（用户名） admin（密码）
赋予其administrator角色：
$sudo rabbitmqctl set_user_tags admin administrator 添加 administrator 角色

创建和赋角色完成后查看并确认：
$sudo rabbitmqctl list_users

添加权限

对何种资源具有配置、写、读的权限通过正则表达式来匹配，具体命令如下：
set_permissions [-p ]

其中，的位置分别用正则表达式来匹配特定的资源，如'^(amq\.gen.*|amq\.default)$'可以匹配server生成的和默认的exchange，'^$'不匹配任何资源
需要注意的是RabbitMQ会缓存每个connection或channel的权限验证结果、因此权限发生变化后需要重连才能生效。
为用户赋权：
$sudo rabbitmqctl set_permissions -p /TEST admin '.*' '.*' '.*'
该命令使用户admin具有/TEST这个virtual host中所有资源的配置、写、读权限以便管理其中的资源

2: Java 操作RabbitMQ

2.1: 第一个Java RabbitMQ 程序

创建一个 maven 工程，添加如下依赖和配置


  4.0.0
  org.rb
  rb
  1.0-SNAPSHOT

  rb
  
    UTF-8
    1.8
    1.8
  

  
    
      junit
      junit
      4.11
      test
    
    
    
      com.rabbitmq
      amqp-client
      5.10.0
    
    
    
      org.slf4j
      slf4j-log4j12
      1.7.30
      test
    

    
    
      commons-io
      commons-io
      2.4
    

    
    
      org.apache.commons
      commons-lang3
      3.7
    
  

  
    
      
        org.springframework.boot
        spring-boot-maven-plugin

编写一个消息生产者

package org.rb;

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

/**
 * Hello world!
 *
 */

public class MsgProducer
{
    private static final String QUEEN_NAME="hello";
    public static void main( String[] args )throws Exception {
        String msg = "Hello World";
        //创建链接工厂
        ConnectionFactory factory = new ConnectionFactory();
        //设置工厂配置信息
        factory.setHost("192.168.217.128");
        factory.setPassword("dev123456");
        factory.setUsername("developer");
        //创建链接
        Connection connection = factory.newConnection();
        //创建信道
        Channel channel = connection.createChannel();
        //创建队列
        //参数说明
        /***
        1:队列名称
        2:是否持久化持久化会保存到磁盘，默认是保存到内存
        3:是否多个消费者共享消费
        4:是否自动删除
        5:其他参数，延迟或者死信队列等
        ***/

        channel.queueDeclare(QUEEN_NAME,false,false, false,null);
        /**
         * 1: 发送到那个交换机
         * 2：路由的key值
         * 3: 其他参数信息
         * 4：参数内容
         * **/
        channel.basicPublish("",QUEEN_NAME,null,msg.getBytes());
        System.out.println("消息發送完畢");
    }
}

执行生产者代码发送信息，并在 rabbitmq 的管理控制台检查对列中的消息是否发送成功，看到如下结果说明信息发送成功

创建消费者

package org.rb;

import com.rabbitmq.client.*;

public class MsgConsumer {
    private static final String QUEEN_NAME="hello";
    public static void main(String[] args) throws Exception{
        //创建链接工厂
        ConnectionFactory factory = new ConnectionFactory();
        //设置工厂配置信息
        factory.setHost("192.168.217.128");
        factory.setPassword("dev123456");
        factory.setUsername("developer");
        //创建链接
        Connection connection = factory.newConnection();
        //创建信道
        Channel channel = connection.createChannel();
        /**
         * 1:被消费队列名
         * 2:是否自动应答 true 是自动应答 false 手动应答
         * 3:消费者未成功消费的回调函数
         * 4: 消费者去掉消费的回调
         * */
        //正常获取消息
        DeliverCallback deliverCallback = (consumerTag,message)->{
            System.out.println(new String(message.getBody()));
        };
        //消费消息被中断
        CancelCallback cancelCallback=(consumerTag)->{
            System.out.println("消费消息被中断");
        };

        channel.basicConsume(QUEEN_NAME,true,deliverCallback,cancelCallback);
        System.out.println("消息接受完毕");
    }
}

可以看见消息被消费了，消息个数变成0 了

2.2: work queen 模式

一个生产者发送消息

可以有多个消费者，但是只有一个消费者可以获取到消息，使用轮询方式来处理消息，消息不可以重复被消费

编写 work01 工作线程，并在idea 中设置使这个class 可以多个线程执行

通过修改这里来表示多个线程收到信息

DeliverCallback deliverCallback = (consumerTag, message)->{
    System.out.println("C02接受到的消息:"+ new String(message.getBody()));
};

package org.rb.day01;

import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import org.rb.util.RabbitMqUtils;
//消费类
public class Worker01 {
    private static final String QUEEN_NAME="hello";

    public static void main(String[] args) throws Exception{
       Channel channel =  RabbitMqUtils.getChannel();
        /**
         * 1:被消费队列名
         * 2:是否自动应答 true 是自动应答 false 手动应答
         * 3:消费者未成功消费的回调函数
         * 4: 消费者去掉消费的回调
         * */
        DeliverCallback deliverCallback = (consumerTag, message)->{
            System.out.println("接受到的消息:"+ new String(message.getBody()));
        };

        CancelCallback cancelCallback = (consumerTag)->{
            System.out.println(consumerTag+"消息被取消回调");
        };
        channel.basicConsume(QUEEN_NAME,true,deliverCallback,cancelCallback);
    }
}

编写生产者代码

package org.rb.day01;

import com.rabbitmq.client.Channel;
import org.apache.commons.lang3.StringUtils;
import org.rb.util.RabbitMqUtils;

import java.util.Scanner;

public class Producer01 {
    private static final String QUEEN_NAME="hello";
    public static void main(String[] args) throws Exception{
        Channel channel = RabbitMqUtils.getChannel();
        /***
         1:队列名称  queue
         2:是否持久化持久化会保存到磁盘，默认是保存到内存 durable
         3:是否多个消费者共享消费 exclusive
         4:是否自动删除 autoDelete
         5:其他参数，延迟或者死信队列等  arguments
         ***/
        channel.queueDeclare(QUEEN_NAME,false,false,false,null);
        //为了发消息比较明显，使用控制台发送
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()){
            String message = scanner.next();
            channel.basicPublish("",QUEEN_NAME,null,message.getBytes());
            System.out.println("消息"+message+"发送完成");
        }
    }
}

执行producer代码发送多个消息，会发现消费端会轮流的打印发送的消息，并且不会重复消费，是轮询的的消费消息的

2.3：消息应答机制

在消费者消费完之后进行应答，只有在获取到消费端消费完的应到之后才删除队列里的消息

避免消息丢失，自动应答并不靠谱，特别是在接受到大量消息的时候，如果后续处理消息的过程中发生了异常，可能会导致大量消息丢失

消息应答的方式：

Channel.basicAck() 用于肯定确认，消息已经肯定处理成功了

Channel.basicNack() 用于否定确认，不能确定消息已经肯定处理成功了

Channel.basicReject() 用于拒绝确认，不能确定消息已经肯定处理成功了比这个 Channel.basicNack() 对一个是否批量处理的参数mutilple

手动应答的好处可以批量应答，你比那个且可以减少网络阻塞,如下图所示当批量应答时只要channel 中的第一个被应答，信道中的其他消息就会一并被应答

而不批量应答只能一个一个的应答

消息自动重新入队,开启手动应答

当有多个消费端时，如果一个消息已经发送，并且被一个消费端获取了，但是队列并未收到ack ，这时队列并不会删除消息，而是将消息从新入队并将消息发送个另外一个可达的消费端消费

消息手动应答的代码

package org.rb.day01;

import com.rabbitmq.client.Channel;
import org.rb.util.RabbitMqUtils;

import java.util.Scanner;

public class NotAutoAckProducer {
    private static final String NOTAUTOACK_QUEEN_NAME="ack_queen";
    public static void main(String[] args) throws Exception{
        Channel channel = RabbitMqUtils.getChannel();
        channel.queueDeclare(NOTAUTOACK_QUEEN_NAME,false,false,false,null);
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()){
            String message = scanner.next();
            channel.basicPublish("",NOTAUTOACK_QUEEN_NAME,null,message.getBytes("UTF-8"));
            System.out.println("消息"+message+"发送完成");
        }
    }
}

package org.rb.day01;

import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import org.rb.util.RabbitMqUtils;

//手动应答,消息不丢失，返回队列个可达的消费者消费
public class NotAutoAckConsumer {
    private static final String NOTAUTOACK_QUEEN_NAME="ack_queen";
    public static void main(String[] args) throws Exception{
        Channel channel = RabbitMqUtils.getChannel();
        DeliverCallback deliverCallback = (consumerTag, message)->{
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            /**
             * 手动应答 获取消息标签
             * 和不批量应答
             * **/
            channel.basicAck(message.getEnvelope().getDeliveryTag(),false);
            System.out.println("NotAutoAckConsumer1接受到的消息:"+ new String(message.getBody()));
        };

        CancelCallback cancelCallback = (consumerTag)->{
            System.out.println(consumerTag+"消息被取消回调");
        };

        boolean autoAck = false;
        channel.basicConsume(NOTAUTOACK_QUEEN_NAME,autoAck,deliverCallback,cancelCallback);
    }
}

package org.rb.day01;

import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import org.rb.util.RabbitMqUtils;

//手动应答,消息不丢失，返回队列个可达的消费者消费
public class NotAutoAckConsumer2 {
    private static final String NOTAUTOACK_QUEEN_NAME="ack_queen";
    public static void main(String[] args) throws Exception{
        Channel channel = RabbitMqUtils.getChannel();
        DeliverCallback deliverCallback = (consumerTag, message)->{
            try {
                Thread.sleep(1000*20);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            channel.basicAck(message.getEnvelope().getDeliveryTag(),false);
            System.out.println("NotAutoAckConsumer2接受到的消息:"+ new String(message.getBody()));
        };

        CancelCallback cancelCallback = (consumerTag)->{
            System.out.println(consumerTag+"消息被取消回调");
        };

        boolean autoAck = false;
        channel.basicConsume(NOTAUTOACK_QUEEN_NAME,autoAck,deliverCallback,cancelCallback);
    }
}

队列持久化:

在消息发送的时候，将durable 设置为true 表示开启持久化

channel.queueDeclare(NOTAUTOACK_QUEEN_NAME,true,false,false,null);

package org.rb.day01;

import com.rabbitmq.client.Channel;
import org.rb.util.RabbitMqUtils;

import java.util.Scanner;
//持久化队列
public class PersistProducer {
    private static final String NOTAUTOACK_QUEEN_NAME="persist_queen";
    public static void main(String[] args) throws Exception{
        Channel channel = RabbitMqUtils.getChannel();
        // durable true 表示 开启持久化
        channel.queueDeclare(NOTAUTOACK_QUEEN_NAME,true,false,false,null);
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()){
            String message = scanner.next();
            channel.basicPublish("",NOTAUTOACK_QUEEN_NAME,null,message.getBytes("UTF-8"));
            System.out.println("消息"+message+"发送完成");
        }
    }
}

执行代码去控制台可以发现 queen 里面的 features 里面的只有个大写的D ，表示持久化了，此时关闭rabbbitmq 服务再重启，发现队列不会消失了

消息持久化：

只需要修改生产者在发送消息的时候将第三个参数修改为

//开启消息持久化 MessageProperties.PERSISTENT_TEXT_PLAIN
channel.basicPublish("",NOTAUTOACK_QUEEN_NAME, MessageProperties.PERSISTENT_TEXT_PLAIN,message.getBytes("UTF-8"));

这里并不能保证绝对的消息不丢失，可能会在发送的某个时间点还没完全处理完但是对服务挂了，也不能持久化

package org.rb.day01;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.MessageProperties;
import org.rb.util.RabbitMqUtils;

import java.util.Scanner;

//持久化队列
public class PersistProducer2 {
    private static final String NOTAUTOACK_QUEEN_NAME="persist_queen";
    public static void main(String[] args) throws Exception{
        Channel channel = RabbitMqUtils.getChannel();
        // durable true 表示 开启持队列久化
        channel.queueDeclare(NOTAUTOACK_QUEEN_NAME,true,false,false,null);
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()){
            String message = scanner.next();
            //开启消息持久化 MessageProperties.PERSISTENT_TEXT_PLAIN
            channel.basicPublish("",NOTAUTOACK_QUEEN_NAME, MessageProperties.PERSISTENT_TEXT_PLAIN,message.getBytes("UTF-8"));
            System.out.println("消息"+message+"发送完成");
        }
    }
}

此时执行代码，关闭服务再次进入控制台检查发现消息不会丢失了

不公平分发

在多个消费端的情况下，添加如下代码

channel.basicQos(1);
// 设置不公平分发原则，体现一种能者多劳的方式哪个线程处理的快，就会多处理消息而处理的慢的就会少处理

预取值

在上面的不公平分发的时候传递给channel.basicQos(1)这个的参数为1 ，多个客户端里面的都是1 ，当有一种情况我们需要发的数据的消息总数是已知的，这时候我们就可以通过改变这个参数来指定不同的客户端消费的消息数量，比如总共1000条消息，就可以指定某个消费端消费 200 条channel.basicQos(200) ，其他消费端消费 800 条 channel.basicQos(1)，这样就不管客户端消费能力的问题，哪怕消费端1 的消费能力很强但是它也只消费 200条消息，消费端2 消费能力很差但是它也得消费800 条，这就是没有了能者多劳特性了

2.4：发布确认

在之前的讲解中，当生产者发送消息给队列之后

虽然已经通过 durable 将队列持久化和 MessageProperties.PERSISTENT_TEXT_PLAIN 来持久化消息，但是生产者是不知道消息是否真的持久化了的，这就需要 RabbitMQ 的应答机制来处理这个场景

RabbitMQ 的应答机制主要有三种

单个应答： 一个一个应答，准确性最高消息不回丢失但是效率比较低，同步操作

批量应答 ：效率比较高，但是当消费端批量消费的过程中，如果还没处理完就出现异常了，那么被取出的数据中还未处理完的那部分消息就会丢失，同步操作

异步批量应答：采用多线程的方式使用监听器，在发送消息的同时也在监控没有发送成功的数据

package org.rb.day02;

//发布确认
//1: 单个确认
//2:批量确认
//3:异步确认


import com.rabbitmq.client.Channel;
import com.rabbitmq.client.ConfirmCallback;
import org.rb.util.RabbitMqUtils;

import java.util.UUID;

public class ConfirmProducer {
    public static int MESSAGE_COUNT = 800;
    public static void main(String[] args) throws Exception{
        //ConfirmProducer.publishMsgSingle(); //发布800个消息耗时1575ms
        //ConfirmProducer.publishMsgBatch();  //发布800个消息耗时242ms ,当出现消息未确认时无法知道那个消息没有被确认
        ConfirmProducer.publishMsgSynchBatch(); //发布800个消息耗时197ms  异步的时间
    }

    //1: 单个确认
    public static void publishMsgSingle() throws Exception{
        Channel channel = RabbitMqUtils.getChannel();
        String queenName = UUID.randomUUID().toString();
        channel.queueDeclare(queenName,true,false,false,null);
        channel.confirmSelect(); // 开启发布确认
        long start = System.currentTimeMillis();
        for (int i = 0; i < MESSAGE_COUNT; i++) {
            String message = "msg"+i;
            channel.basicPublish("",queenName,null,message.getBytes());
            boolean flag = channel.waitForConfirms();  //等候确认
            if(flag){
              System.out.println("第"+i+"个消息发送成功");
            }
        }
        long end = System.currentTimeMillis();
        System.out.println("发布"+MESSAGE_COUNT+"个消息耗时"+(end-start)+"ms");
    }

    //2:批量确认
    public static void publishMsgBatch() throws Exception{
        Channel channel = RabbitMqUtils.getChannel();
        String queenName = UUID.randomUUID().toString();
        channel.queueDeclare(queenName,true,false,false,null);
        channel.confirmSelect(); // 开启发布确认
        //批量确认的大小 假设 200条
        int batchSize = 200;
        long start = System.currentTimeMillis();
        for (int i = 0; i < MESSAGE_COUNT; i++) {
            String message = "msg"+i;
            channel.basicPublish("",queenName,null,message.getBytes());
            if(i%batchSize == 0 ){
                channel.waitForConfirms();
            }
        }
        long end = System.currentTimeMillis();
        System.out.println("发布"+MESSAGE_COUNT+"个消息耗时"+(end-start)+"ms");
    }

    //3:异步确认
    public static void publishMsgSynchBatch() throws Exception{
        Channel channel = RabbitMqUtils.getChannel();
        String queenName = UUID.randomUUID().toString();
        channel.queueDeclare(queenName,true,false,false,null);
        channel.confirmSelect(); // 开启发布确认

        long start = System.currentTimeMillis();
        //消息成功发送回调函数  deliveryTag  消息标记  multiple 是否批量确认
        ConfirmCallback ackCallback = (deliveryTag, multiple)->{
              System.out.println("正确确认的消息:"+deliveryTag);
        };

        //消息失败回调函数  deliveryTag  消息标记  multiple 是否批量确认
        ConfirmCallback nackCallback = (deliveryTag, multiple)->{
            //这里获取到未处理成功的消息
            System.out.println("未确认的消息:"+deliveryTag);

        };

        //创建监听器在发送消息之前，监听消息的成功和失败
        channel.addConfirmListener(ackCallback,nackCallback);
        for (int i = 0; i < MESSAGE_COUNT; i++) {
            String message = "msg"+i;
            channel.basicPublish("",queenName,null,message.getBytes());
        }
        long end = System.currentTimeMillis();
        System.out.println("发布"+MESSAGE_COUNT+"个消息耗时"+(end-start)+"ms");
    }


}

采用异步方式的时候怎样去处理未被及时确认的信息呢？

最常用的一种方式是将为被确认的消息放到一个基于内存的可以被发布线程访问的队列

比如 ConcurrentLinkedQueen ,这个队列可以在 confirm callbacks 与发布线程之间进行消息的传递

异步确认处理未被确认消息的处理逻辑

public static void publishMsgSynchBatch() throws Exception{
    Channel channel = RabbitMqUtils.getChannel();
    String queenName = UUID.randomUUID().toString();
    channel.queueDeclare(queenName,true,false,false,null);
    channel.confirmSelect(); // 开启发布确认

    //方便批量删除 ，通过序号
    //支持多线程并发
    ConcurrentSkipListMap confirmMap = new ConcurrentSkipListMap<>();

    long start = System.currentTimeMillis();
    //消息成功发送回调函数  deliveryTag  消息标记  multiple 是否批量确认
    ConfirmCallback ackCallback = (deliveryTag, multiple)->{
        //步骤002 删除掉已经被消费的消息
        if(multiple){
            //可能会造成消息丢失 一般不用
            ConcurrentNavigableMap confirmedMap =  confirmMap.headMap(deliveryTag);
            confirmedMap.clear();
        }else{
            //推荐使用这种方式
            confirmMap.remove(deliveryTag);
        }
        System.out.println("正确确认的消息:"+deliveryTag);

    };

    //消息失败回调函数  deliveryTag  消息标记  multiple 是否批量确认
    ConfirmCallback nackCallback = (deliveryTag, multiple)->{
        //这里获取到未处理成功的消息

        //步骤003 处理 步骤002 操作完成之后违未被确认的消息
        String unConfirmMessage = confirmMap.get(deliveryTag);
        System.out.println("未确认的消息:"+deliveryTag+"内容是:"+unConfirmMessage);

    };

    //创建监听器在发送消息之前，监听消息的成功和失败
    channel.addConfirmListener(ackCallback,nackCallback);
    for (int i = 0; i < MESSAGE_COUNT; i++) {
        String message = "msg"+i;
        channel.basicPublish("",queenName,null,message.getBytes());
        //步骤001 记录下所有的记录
        confirmMap.put(channel.getNextPublishSeqNo(),message);
    }
    long end = System.currentTimeMillis();
    System.out.println("发布"+MESSAGE_COUNT+"个消息耗时"+(end-start)+"ms");
}

2.5：交换机

当需要消息被多个消费者消费的时候，就需要交换机，即发布订阅模式

交换机分为：直接类型 direct 主题类型 topic 标题类型 header 广播类型 fanout

队列和交换机之间需要使用绑定来产生联系

以 fanout 模式为例演示交换机和队列之间的绑定关系，以及生产者发送消息，多个消费者获取消息消费

分别编写消息生产者和两个消费者

package org.rb.day02;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.MessageProperties;
import org.rb.util.RabbitMqUtils;

import java.util.Scanner;

public class ExProducer {
    private static final String EXCHANGE_NAME="EX";
    public static void main(String[] args) throws Exception{
        Channel channel = RabbitMqUtils.getChannel();
        channel.exchangeDeclare(EXCHANGE_NAME,"fanout");
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()){
            String message = scanner.next();
            channel.basicPublish(EXCHANGE_NAME,"", null,message.getBytes("UTF-8"));
            System.out.println("消息"+message+"发送完成");
        }
    }
}

package org.rb.day02;

import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import org.rb.util.RabbitMqUtils;

public class ExConsumer {
    private static final String EXCHANGE_NAME="EX";

    public static void main(String[] args) throws Exception{
        Channel channel = RabbitMqUtils.getChannel();
        //声明交换机
        channel.exchangeDeclare(EXCHANGE_NAME,"fanout");
        //声明一个临时队列,队列名称是随机的，当消费者断开连接自动删除
        String queenName = channel.queueDeclare().getQueue();
        //绑定交换机和队列
        channel.queueBind(queenName,EXCHANGE_NAME,"");
        //接受消息
        DeliverCallback deliverCallback = (consumerTag, message)->{
           System.out.println("ExConsumer01接受到消息"+new String(message.getBody()));
        };
        CancelCallback cancelCallback = (consumerTag)->{
            //未处理
        };
        channel.basicConsume(queenName,true,deliverCallback,cancelCallback);
    }
}

package org.rb.day02;


import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import org.rb.util.RabbitMqUtils;

public class ExConsumer02 {
    private static final String EXCHANGE_NAME="EX";

    public static void main(String[] args) throws Exception{
        Channel channel = RabbitMqUtils.getChannel();
        //声明交换机
        channel.exchangeDeclare(EXCHANGE_NAME,"fanout");
        //声明一个临时队列,队列名称是随机的，当消费者断开连接自动删除
        String queenName = channel.queueDeclare().getQueue();
        //绑定交换机和队列
        channel.queueBind(queenName,EXCHANGE_NAME,"");
        //接受消息
        DeliverCallback deliverCallback = (consumerTag, message)->{
           System.out.println("ExConsumer02接受到消息"+new String(message.getBody()));
        };
        CancelCallback cancelCallback = (consumerTag)->{
            //未处理
        };
        channel.basicConsume(queenName,true,deliverCallback,cancelCallback);
    }
}

启动生产者和消费者查看管理控制台中的绑定关系

说明交换机队列声明并绑定成功

在生产端执行发送消息，并在两个消费端的控制台查看打印信息，发现两个消费端都消费了消息

直接交换机：direct

如果RoutingKey 在生产者绑定交换机得时候使用的是一样的，那么其实和上面的 fanout 是一样的，但是要发送的时候 RoutingKey 不一样，那么就会发送消息到不同的队列去

可以看到当我们改变生产者中的 RoutingKey 的时候，不同Routingkey 对应的consumer 会接受到对应的消息

package org.rb.day02;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import org.rb.util.RabbitMqUtils;

import java.util.Scanner;

//演示直接交换机生产者
public class DirectExProducer {
    private static final String DIRECT_EXCHANGE_NAME="DIRECT_EX";
    public static void main(String[] args) throws Exception{
        Channel channel = RabbitMqUtils.getChannel();
        channel.exchangeDeclare(DIRECT_EXCHANGE_NAME, BuiltinExchangeType.DIRECT);
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()){
            String message = scanner.next();
            //根据不同的RoutingKey 将消息发送的不同的队列
            channel.basicPublish(DIRECT_EXCHANGE_NAME,"003", null,message.getBytes("UTF-8"));
            //channel.basicPublish(DIRECT_EXCHANGE_NAME,"002", null,message.getBytes("UTF-8"));
            //channel.basicPublish(DIRECT_EXCHANGE_NAME,"003", null,message.getBytes("UTF-8"));
            System.out.println("消息"+message+"发送完成");
        }
    }
}

package org.rb.day02;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import org.rb.util.RabbitMqUtils;

//演示直接交换机消费者
public class DirectExConsumer {
    private static final String DIRECT_EXCHANGE_NAME="DIRECT_EX";

    public static void main(String[] args) throws Exception{
        Channel channel = RabbitMqUtils.getChannel();
        //声明交换机
        channel.exchangeDeclare(DIRECT_EXCHANGE_NAME, BuiltinExchangeType.DIRECT);
        //声明一个临时队列,队列名称是随机的，当消费者断开连接自动删除
        String queenName = channel.queueDeclare().getQueue();
        //绑定交换机和队列  可以多重绑定
        channel.queueBind(queenName,DIRECT_EXCHANGE_NAME,"001");
        channel.queueBind(queenName,DIRECT_EXCHANGE_NAME,"002");
        //接受消息
        DeliverCallback deliverCallback = (consumerTag, message)->{
            System.out.println("DirectExConsumer01接受到消息"+new String(message.getBody()));
        };
        CancelCallback cancelCallback = (consumerTag)->{
            //未处理
        };
        channel.basicConsume(queenName,true,deliverCallback,cancelCallback);
    }
}

package org.rb.day02;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import org.rb.util.RabbitMqUtils;

//演示直接交换机消费者
public class DirectExConsumer2 {
    private static final String DIRECT_EXCHANGE_NAME="DIRECT_EX";

    public static void main(String[] args) throws Exception{
        Channel channel = RabbitMqUtils.getChannel();
        //声明交换机
        channel.exchangeDeclare(DIRECT_EXCHANGE_NAME, BuiltinExchangeType.DIRECT);
        //声明一个临时队列,队列名称是随机的，当消费者断开连接自动删除
        String queenName = channel.queueDeclare().getQueue();
        //绑定交换机和队列  可以多重绑定
        channel.queueBind(queenName,DIRECT_EXCHANGE_NAME,"003");
        //接受消息
        DeliverCallback deliverCallback = (consumerTag, message)->{
            System.out.println("DirectExConsumer2接受到消息"+new String(message.getBody()));
        };
        CancelCallback cancelCallback = (consumerTag)->{
            //未处理
        };
        channel.basicConsume(queenName,true,deliverCallback,cancelCallback);
    }
}

Topic 主题交换机：

Topic: 所有符合routingKey表达式所绑定的队列可以接收消息

发送到topic类型交换机的消息的routing_key不能随便设置
它必须是多个用点(.)分割的单词组成,单词可以是任意的
但它们通常指定连接到该消息的某些功能
路由关键字可包含任意多的单词但最高限制是255字节。

绑定的关键字必须有相同的格式。topic交换机和direct交换的逻辑是相似的–拥有特定的路由关键字的消息将被发送到所有匹配关键字的队列，还可以有两种特殊的正则

（1）* (星号) 可以代替一个完整的单词.
（2）# (井号) 可以代替零个或多个单词.

如: *.aaa.* 表示要发到有三个单词但中间一个单词必须是 aaa 的

#.aaa.* 表示要发到有多个单词，但倒数第二个单词必须是 aaa 的

#.aaa.# 表示要发到有多个单词，单词包含aaa 的

*.aaa.# 表示要发到有多个单词，第二个单词是aaa 的等

代码演示：

package org.rb.day02;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import org.rb.util.RabbitMqUtils;

import java.util.Scanner;

public class TopicProducer {
    private static final String TOPIC_EXCHANGE_NAME="TOPIC_EX";
    public static void main(String[] args) throws Exception{
        Channel channel = RabbitMqUtils.getChannel();
        channel.exchangeDeclare(TOPIC_EXCHANGE_NAME, BuiltinExchangeType.TOPIC);
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()){
            String message = scanner.next();
            channel.basicPublish(TOPIC_EXCHANGE_NAME,"*.aaa.*", null,message.getBytes("UTF-8"));
//            channel.basicPublish(TOPIC_EXCHANGE_NAME,"#.aaa.*", null,message.getBytes("UTF-8"));
//            channel.basicPublish(TOPIC_EXCHANGE_NAME,"*.aaa.*", null,message.getBytes("UTF-8"));
//            channel.basicPublish(TOPIC_EXCHANGE_NAME,"*.aaa.#", null,message.getBytes("UTF-8"));
 //            channel.basicPublish(TOPIC_EXCHANGE_NAME,"#.aaa.#", null,message.getBytes("UTF-8"));
            System.out.println("消息"+message+"发送完成");
        }
    }
}

package org.rb.day02;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import org.rb.util.RabbitMqUtils;

public class TopicConsumer {
    private static final String TOPIC_EXCHANGE_NAME="TOPIC_EX";
    public static void main(String[] args) throws Exception{
        Channel channel = RabbitMqUtils.getChannel();
        //声明交换机
        channel.exchangeDeclare(TOPIC_EXCHANGE_NAME, BuiltinExchangeType.TOPIC);
        //声明一个临时队列,队列名称是随机的，当消费者断开连接自动删除
        String queenName = channel.queueDeclare().getQueue();
        //绑定交换机和队列  可以多重绑定
        channel.queueBind(queenName,TOPIC_EXCHANGE_NAME,"www.aaa.www");

        //接受消息
        DeliverCallback deliverCallback = (consumerTag, message)->{
            System.out.println("DirectExConsumer01接受到消息"+new String(message.getBody()));
        };
        CancelCallback cancelCallback = (consumerTag)->{
            //未处理
        };
        channel.basicConsume(queenName,true,deliverCallback,cancelCallback);
    }
}

package org.rb.day02;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import org.rb.util.RabbitMqUtils;

public class TopicConsumer2 {
    private static final String TOPIC_EXCHANGE_NAME="TOPIC_EX";
    public static void main(String[] args) throws Exception{
        Channel channel = RabbitMqUtils.getChannel();
        //声明交换机
        channel.exchangeDeclare(TOPIC_EXCHANGE_NAME, BuiltinExchangeType.TOPIC);
        //声明一个临时队列,队列名称是随机的，当消费者断开连接自动删除
        String queenName = channel.queueDeclare().getQueue();
        //绑定交换机和队列  可以多重绑定
        channel.queueBind(queenName,TOPIC_EXCHANGE_NAME,"www.SSS.www");

        //接受消息
        DeliverCallback deliverCallback = (consumerTag, message)->{
            System.out.println("DirectExConsumer02接受到消息"+new String(message.getBody()));
        };
        CancelCallback cancelCallback = (consumerTag)->{
            //未处理
        };
        channel.basicConsume(queenName,true,deliverCallback,cancelCallback);
    }
}

package org.rb.day02;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import org.rb.util.RabbitMqUtils;

public class TopicConsumer3 {
    private static final String TOPIC_EXCHANGE_NAME="TOPIC_EX";
    public static void main(String[] args) throws Exception{
        Channel channel = RabbitMqUtils.getChannel();
        //声明交换机
        channel.exchangeDeclare(TOPIC_EXCHANGE_NAME, BuiltinExchangeType.TOPIC);
        //声明一个临时队列,队列名称是随机的，当消费者断开连接自动删除
        String queenName = channel.queueDeclare().getQueue();
        //绑定交换机和队列  可以多重绑定
        channel.queueBind(queenName,TOPIC_EXCHANGE_NAME,"*.aaa.*");

        //接受消息
        DeliverCallback deliverCallback = (consumerTag, message)->{
            System.out.println("DirectExConsumer03接受到消息"+new String(message.getBody()));
        };
        CancelCallback cancelCallback = (consumerTag)->{
            //未处理
        };
        channel.basicConsume(queenName,true,deliverCallback,cancelCallback);
    }
}

也可以在生产端使用一个map 来将参数包装之后在循环发送消息，并使用不同的消费端规则生产多个消费端来检测这个夏曦会被路由到哪个消费端去消费

2.6：死信队列

死信队列的来源，信息在消费过程中没有正确的被消费

消息被拒绝（Basic.Reject或Basic.Nack）并且设置 requeue 参数的值为 false
消息过期了
队列达到最大的长度

死信队列&死信交换器：DLX 全称（Dead-Letter-Exchange）,称之为死信交换器，
当消息变成一个死信之后，如果这个消息所在的队列存在x-dead-letter-exchange参数，
那么它会被发送到x-dead-letter-exchange对应值的交换器上，这个交换器就称之为死信交换器，
与这个死信交换器绑定的队列就是死信队列。

时间过期进入死信代码演示

先编写一个消费者里面需要定义如下内容

/**
 * 需要定义 正常的交换机            死信交换机
 *         正常队列                死信队列
 *         正常交换机的RoutingKey   死信的 RoutingKey
 *         以及正常的交换即和正常队列的绑定    死信交换机和死信队列的绑定
 *         以及 发生异常时 将信息发送到死信的操作
 *
 * **/

代码如下

package org.rb.day02;

//正常的消费者

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import org.rb.util.RabbitMqUtils;

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

/**
 * 需要定义 正常的交换机            死信交换机
 *         正常队列                死信队列
 *         正常交换机的RoutingKey   死信的 RoutingKey
 *         以及正常的交换即和正常队列的绑定    死信交换机和死信队列的绑定
 *         以及 发生异常时 将信息发送到死信的操作
 *
 * **/
public class DeadMessageConsumer {
    //正常的交换机
    public static final String NORMAL_EXCHANGE = "NORMAL_EXCHANGE";
    //死信交换机
    public static final String DEAD_EXCHANGE = "DEAD_EXCHANGE";

    //正常的交队列
    public static final String NORMAL_QUEUE = "NORMAL_QUEUE";
    //死信交队列
    public static final String DEAD_QUEUE = "DEAD_QUEUE";

    //正常交换机的RoutingKey
    public static final String NORMAL_ROUTING_KEY = "NORMAL_ROUTING_KEY";
    //死信的 RoutingKey
    public static final String DEAD_ROUTING_KEY = "DEAD_ROUTING_KEY";


    public static void main(String[] args) throws Exception{
        Channel channel = RabbitMqUtils.getChannel();
        //正常的交换机
        channel.exchangeDeclare(NORMAL_EXCHANGE, BuiltinExchangeType.DIRECT);
        //死信交换机
        channel.exchangeDeclare(DEAD_EXCHANGE, BuiltinExchangeType.DIRECT);
        //=======================================
        //接受消息
        DeliverCallback deliverCallback = (consumerTag, message)->{
            System.out.println("DeadMessageConsumer接受到消息"+new String(message.getBody()));
        };
        CancelCallback cancelCallback = (consumerTag)->{
            //未处理
        };
        //正常队列
        //準備給正常隊列的參數
        Map arguments = new HashMap<>();
        //设置不能正常消费时的私信交换机的参数
        arguments.put("x-dead-letter-exchange",DEAD_EXCHANGE);
        //设置死信交换机的RoutingKey
        arguments.put("x-dead-letter-routing-key",DEAD_ROUTING_KEY);
        arguments.put("x-message-ttl",10000); //设置过期时间
        channel.queueDeclare(NORMAL_QUEUE,false,false,false,null);

        //死信队列
        channel.queueDeclare(DEAD_QUEUE,false,false,false,null);

        //正常的交换即和正常队列的绑定
        channel.queueBind(NORMAL_QUEUE,NORMAL_EXCHANGE,NORMAL_ROUTING_KEY);
        //死信交换机和死信队列的绑定
        channel.queueBind(DEAD_QUEUE,DEAD_EXCHANGE,DEAD_ROUTING_KEY);
        //=======================================
        System.out.println("..........等待接受消息..............");
        channel.basicConsume(NORMAL_QUEUE,true, deliverCallback, cancelCallback);

    }

}

编写完成后启动这个消费端，查看控制台，可以看到相应的绑定关系如下

再编写一个生产者

package org.rb.day02;

import com.rabbitmq.client.Channel;
import org.rb.util.RabbitMqUtils;

//测试死信队列
public class DeadMessageProducer {
    //正常的交换机
    public static final String NORMAL_EXCHANGE = "NORMAL_EXCHANGE";
    //正常交换机的RoutingKey
    public static final String NORMAL_ROUTING_KEY = "NORMAL_ROUTING_KEY";


    public static void main(String[] args) throws Exception{
        Channel channel = RabbitMqUtils.getChannel();
        //定义消息被消费的过期时间
        //超过这个时间 还没收到ack 将会把信息 丢入到死信队列
        for (int i = 0; i < 25; i++) {
            String message = "messagewwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww"+i;
           // channel.basicPublish(NORMAL_EXCHANGE,NORMAL_ROUTING_KEY,properties,message.getBytes());
          //测试超过做大长度
           channel.basicPublish(NORMAL_EXCHANGE,NORMAL_ROUTING_KEY,null,message.getBytes());
        }

    }
}

将上一步中的消费者线程关闭，启动生产者并发送信息，查看10 秒后正常队列和死信队列里面的数据变化，会发现正常队列中现有数据，然后逐渐减少，但是重新启动消费者后死信队列里面会逐渐增加，而正常队列逐渐减少

超过10s之后正常队列里的信息进入了死信队列

再编写一个简单的消费者去消费死信队列里面的消息

package org.rb.day02;

//正常的消费者
import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import org.rb.util.RabbitMqUtils;
public class DeadMessageConsumer2 {

    //死信交队列
    public static final String DEAD_QUEUE = "DEAD_QUEUE";
    public static void main(String[] args) throws Exception{
        Channel channel = RabbitMqUtils.getChannel();

        DeliverCallback deliverCallback = (consumerTag, message)->{
            System.out.println("DeadMessageConsumer2接受到消息"+new String(message.getBody()));
        };
        CancelCallback cancelCallback = (consumerTag)->{
            //未处理
        };
        //=======================================
        System.out.println("..........等待接受消息..............");
        channel.basicConsume(DEAD_QUEUE,true, deliverCallback, cancelCallback);

    }

}

启动消费死信的消费者可以看到消息被消费了，再检查管理控制台发现上一步中的死信队列里的数据已经被消费了

队列达到最大长度的演示，

删除之前生成的队列，并重新启动正常消费者

重新生成队列，重新启动生产者发送消息，发现队列里面超过最大长度的部分会进入死信队列

代码：

package org.rb.day02;

import com.rabbitmq.client.Channel;
import org.rb.util.RabbitMqUtils;

//测试死信队列
public class DeadMessageProducer {
    //正常的交换机
    public static final String NORMAL_EXCHANGE = "NORMAL_EXCHANGE";
    //正常交换机的RoutingKey
    public static final String NORMAL_ROUTING_KEY = "NORMAL_ROUTING_KEY";


    public static void main(String[] args) throws Exception{
        Channel channel = RabbitMqUtils.getChannel();
        //定义消息被消费的过期时间
        //超过这个时间 还没收到ack 将会把信息 丢入到死信队列
        for (int i = 0; i < 25; i++) {
            String message = "messagewwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww"+i;
           // channel.basicPublish(NORMAL_EXCHANGE,NORMAL_ROUTING_KEY,properties,message.getBytes());
          //测试超过做大长度
           channel.basicPublish(NORMAL_EXCHANGE,NORMAL_ROUTING_KEY,null,message.getBytes());
        }

    }
}

package org.rb.day02;

//正常的消费者

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import org.rb.util.RabbitMqUtils;

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

/**
 * 需要定义 正常的交换机            死信交换机
 *         正常队列                死信队列
 *         正常交换机的RoutingKey   死信的 RoutingKey
 *         以及正常的交换即和正常队列的绑定    死信交换机和死信队列的绑定
 *         以及 发生异常时 将信息发送到死信的操作
 *
 * **/
public class DeadMessageConsumer {
    //正常的交换机
    public static final String NORMAL_EXCHANGE = "NORMAL_EXCHANGE";
    //死信交换机
    public static final String DEAD_EXCHANGE = "DEAD_EXCHANGE";

    //正常的交队列
    public static final String NORMAL_QUEUE = "NORMAL_QUEUE";
    //死信交队列
    public static final String DEAD_QUEUE = "DEAD_QUEUE";

    //正常交换机的RoutingKey
    public static final String NORMAL_ROUTING_KEY = "NORMAL_ROUTING_KEY";
    //死信的 RoutingKey
    public static final String DEAD_ROUTING_KEY = "DEAD_ROUTING_KEY";


    public static void main(String[] args) throws Exception{
        Channel channel = RabbitMqUtils.getChannel();
        //正常的交换机
        channel.exchangeDeclare(NORMAL_EXCHANGE, BuiltinExchangeType.DIRECT);
        //死信交换机
        channel.exchangeDeclare(DEAD_EXCHANGE, BuiltinExchangeType.DIRECT);
        //=======================================
        //接受消息
        DeliverCallback deliverCallback = (consumerTag, message)->{
            System.out.println("DeadMessageConsumer接受到消息"+new String(message.getBody()));
        };
        CancelCallback cancelCallback = (consumerTag)->{
            //未处理
        };
        //正常队列
        //準備給正常隊列的參數
        Map arguments = new HashMap<>();
        //设置不能正常消费时的私信交换机的参数
        arguments.put("x-dead-letter-exchange",DEAD_EXCHANGE);
        //设置死信交换机的RoutingKey
        arguments.put("x-dead-letter-routing-key",DEAD_ROUTING_KEY);
        //arguments.put("x-message-ttl",10000); //设置过期时间
        //测试超过最大长度
        arguments.put("x-max-length",20);
        channel.queueDeclare(NORMAL_QUEUE,false,false,false,arguments);

        //死信队列
        channel.queueDeclare(DEAD_QUEUE,false,false,false,null);

        //正常的交换即和正常队列的绑定
        channel.queueBind(NORMAL_QUEUE,NORMAL_EXCHANGE,NORMAL_ROUTING_KEY);
        //死信交换机和死信队列的绑定
        channel.queueBind(DEAD_QUEUE,DEAD_EXCHANGE,DEAD_ROUTING_KEY);
        //=======================================
        System.out.println("..........等待接受消息..............");
        channel.basicConsume(NORMAL_QUEUE,true, deliverCallback, cancelCallback);

    }

}

package org.rb.day02;

//正常的消费者
import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import org.rb.util.RabbitMqUtils;
public class DeadMessageConsumer2 {

    //死信交队列
    public static final String DEAD_QUEUE = "DEAD_QUEUE";
    public static void main(String[] args) throws Exception{
        Channel channel = RabbitMqUtils.getChannel();

        DeliverCallback deliverCallback = (consumerTag, message)->{
            System.out.println("DeadMessageConsumer2接受到消息"+new String(message.getBody()));
        };
        CancelCallback cancelCallback = (consumerTag)->{
            //未处理
        };
        //=======================================
        System.out.println("..........等待接受消息..............");
        channel.basicConsume(DEAD_QUEUE,true, deliverCallback, cancelCallback);

    }

}

分别启动正常消费者和消费死信队列的消费者，会发现管理控台中的消息被消费了，并且代码的控制台中两个consumer 分别打印20 条和 5 条，这样超过最大长度的案例演示完成

消息被拒绝进入死信队列

重新编写一个生产者和消费者，消费死信的消费者还用原来的

package org.rb.day02;

import com.rabbitmq.client.Channel;
import org.rb.util.RabbitMqUtils;

//测试死信队列
public class DeadMessageProducer {
    //正常的交换机
    public static final String NORMAL_EXCHANGE = "NORMAL_EXCHANGE";
    //正常交换机的RoutingKey
    public static final String NORMAL_ROUTING_KEY = "NORMAL_ROUTING_KEY";


    public static void main(String[] args) throws Exception{
        Channel channel = RabbitMqUtils.getChannel();
        //定义消息被消费的过期时间
        //超过这个时间 还没收到ack 将会把信息 丢入到死信队列
        for (int i = 0; i < 20; i++) {
            String message = "info"+i;
           // channel.basicPublish(NORMAL_EXCHANGE,NORMAL_ROUTING_KEY,properties,message.getBytes());
          //测试超过做大长度
           channel.basicPublish(NORMAL_EXCHANGE,NORMAL_ROUTING_KEY,null,message.getBytes());
        }

    }
}

package org.rb.day02;

//正常的消费者

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import org.rb.util.RabbitMqUtils;

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

/**
 * 需要定义 正常的交换机            死信交换机
 *         正常队列                死信队列
 *         正常交换机的RoutingKey   死信的 RoutingKey
 *         以及正常的交换即和正常队列的绑定    死信交换机和死信队列的绑定
 *         以及 发生异常时 将信息发送到死信的操作
 *
 * **/
public class DeadMessageConsumer3 {
    //正常的交换机
    public static final String NORMAL_EXCHANGE = "NORMAL_EXCHANGE";
    //死信交换机
    public static final String DEAD_EXCHANGE = "DEAD_EXCHANGE";

    //正常的交队列
    public static final String NORMAL_QUEUE = "NORMAL_QUEUE";
    //死信交队列
    public static final String DEAD_QUEUE = "DEAD_QUEUE";

    //正常交换机的RoutingKey
    public static final String NORMAL_ROUTING_KEY = "NORMAL_ROUTING_KEY";
    //死信的 RoutingKey
    public static final String DEAD_ROUTING_KEY = "DEAD_ROUTING_KEY";


    public static void main(String[] args) throws Exception{
        Channel channel = RabbitMqUtils.getChannel();
        //正常的交换机
        channel.exchangeDeclare(NORMAL_EXCHANGE, BuiltinExchangeType.DIRECT);
        //死信交换机
        channel.exchangeDeclare(DEAD_EXCHANGE, BuiltinExchangeType.DIRECT);
        //=======================================
        //接受消息
        DeliverCallback deliverCallback = (consumerTag, message)->{
            String msg = new String(message.getBody());
            if(msg.equals("info5")){
                System.out.println("DeadMessageConsumer拒绝接受"+msg);
                //requeue 表示是否重新放回队列,拒绝不放回队列 ，使其进入死信队列
                channel.basicReject(message.getEnvelope().getDeliveryTag(),false);
            }else{
                System.out.println("DeadMessageConsumer接受到消息"+new String(message.getBody()));
                //mutiple 设置false 表示不批量应答
                channel.basicAck(message.getEnvelope().getDeliveryTag(),false);
            }
        };
        CancelCallback cancelCallback = (consumerTag)->{
            //未处理
        };
        //正常队列
        //準備給正常隊列的參數
        Map arguments = new HashMap<>();
        //设置不能正常消费时的私信交换机的参数
        arguments.put("x-dead-letter-exchange",DEAD_EXCHANGE);
        //设置死信交换机的RoutingKey
        arguments.put("x-dead-letter-routing-key",DEAD_ROUTING_KEY);
        //arguments.put("x-message-ttl",10000); //设置过期时间
        //测试超过最大长度
        //arguments.put("x-max-length",20);
        channel.queueDeclare(NORMAL_QUEUE,false,false,false,arguments);

        //死信队列
        channel.queueDeclare(DEAD_QUEUE,false,false,false,null);

        //正常的交换即和正常队列的绑定
        channel.queueBind(NORMAL_QUEUE,NORMAL_EXCHANGE,NORMAL_ROUTING_KEY);
        //死信交换机和死信队列的绑定
        channel.queueBind(DEAD_QUEUE,DEAD_EXCHANGE,DEAD_ROUTING_KEY);
        //=======================================
        System.out.println("..........等待接受消息..............");
        //autoAck 为false 不自动应答
        channel.basicConsume(NORMAL_QUEUE,false, deliverCallback, cancelCallback);

    }

}

删除之前的同名队列 ,不让启动成都的时候会报错，然后再次启动消费者

生成交换机和队列等

然后执行生产者的代码，并查看代码日志，发现被拒绝的消息也进入了死信队列

启动消费死信的消费者该条信息被消费

查看管理控制台也发现消息被消费了

3:SpringBoot 和队列 TTL

3.1：使用springboot 来演示一个实际环境中的延迟队列

途中的蓝色部分是死信队列死信交换机，黑色部分之前的是普通队列和普通的交换机

需要编写一个配置类来实现除了生产者和消费者的中间部分的代码逻辑

普通交换机和普通队列使用不同的RoutingKey 来表示不同的规则，死信队列和死信交换机使用相同的 RoutingKey

这个架构图中的消息会经过一个生产者产生一条信息分别发送到普通推列之后，分别经过10秒和20 秒言延迟后变成延迟的消息进入死信队列，再由消费端监听到死信队列的消息之后消费

创建springboot 项目

添加依赖



  4.0.0
  
  
    org.springframework.boot
    spring-boot-starter-parent
    2.1.2.RELEASE
    
  
  org.rmq
  sptingboot-rabbitmq
  1.0-SNAPSHOT
  sptingboot-rabbitmq


  
    UTF-8
    1.8
    1.8
  

  
    
      junit
      junit
      4.11
      test
    
    
    
      org.springframework.boot
      spring-boot-starter
    
    
      org.springframework.boot
      spring-boot-starter-test
      test
    

    
    
      commons-io
      commons-io
      2.9.0
    
    
      org.apache.commons
      commons-lang3
    

    
      org.apache.commons
      commons-pool2
    

    
      org.springframework.boot
      spring-boot-starter-web
    

    
      org.springframework.amqp
      spring-amqp
    

    
      org.springframework.amqp
      spring-rabbit
    

    
    
      org.springframework.amqp
      spring-rabbit-test
      2.3.10
      test
    

    
    
      org.projectlombok
      lombok
      1.18.22
      provided
    


    

    
      com.fasterxml.jackson.core
      jackson-databind
      2.9.6
    

    
    
      io.springfox
      springfox-swagger2
      2.9.2
    

    
      io.springfox
      springfox-swagger-ui
      2.9.2
    

    
  

  
    
      
        org.springframework.boot
        spring-boot-maven-plugin

配置文件 application.properties

# 应用名
spring.application.name=springboot-rabbitmq
# rabbitmq配置信息
# ip
spring.rabbitmq.host=192.168.217.128
# 端口
spring.rabbitmq.port=5672
# 用户名
spring.rabbitmq.username=developer
# 密码
spring.rabbitmq.password=dev123456
# 配置虚拟机
spring.rabbitmq.virtual-host=/
# 消息开启手动确认
spring.rabbitmq.listener.direct.acknowledge-mode=manual

编写生产者

package org.rmq.controller;

import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.Date;

@Slf4j
@RestController
@RequestMapping("/ttl")
public class TestController {
    //普通交换机
    private static final String X_EXCHANGE = "X";
    //普通RoutingKey
    private static final String NOMAL_ROUTINGKEY_A = "XA";
    private static final String NOMAL_ROUTINGKEY_B = "XB";

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @ResponseBody
    @GetMapping("/sendmsg/{message}")
    public void sendMsg(@PathVariable("message") String message){
        log.info("当前时间:{},发送消息{}给两个ttl队列",new Date().toString(),message);
        rabbitTemplate.convertAndSend(X_EXCHANGE,NOMAL_ROUTINGKEY_A,"消息来自ttl为10秒的队列:"+message);
        rabbitTemplate.convertAndSend(X_EXCHANGE,NOMAL_ROUTINGKEY_B,"消息来自ttl为20秒的队列:"+message);
    }
}

编写交换机队列 routingKey 的配置以及绑定配置类

package org.rmq.config;


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

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

@Configuration
public class TTLQueueConfig {
    //普通交换机
    private static final String X_EXCHANGE = "X";
    //死信交换机
    private static final String DEAD_LETTER_EXCHANGE = "Y";

    //普通队列
    private static final String QUEUE_A = "QA";
    private static final String QUEUE_B = "QB";
    //死信队列
    private static final String DEAD_LETTER_QUEUE = "QD";

    //普通RoutingKey
    private static final String NOMAL_ROUTINGKEY_A = "XA";
    private static final String NOMAL_ROUTINGKEY_B = "XB";
    //死信RoutingKey
    private static final String DEAD_ROUTINGKEY= "YD";


    //声明普通交换机
    @Bean("xExchange")
    public DirectExchange xExchange(){
       return  new DirectExchange(X_EXCHANGE);
    }

    //声明死信交换机
    @Bean("yExchange")
    public DirectExchange yExchange(){
        return  new DirectExchange(DEAD_LETTER_EXCHANGE);
    }

    //声明两个普通队列
    @Bean("queueA")
    public Queue queueA(){
        //準備給正常隊列的參數
        Map arguments = new HashMap<>(3);
        //设置不能正常消费时的私信交换机的参数
        arguments.put("x-dead-letter-exchange",DEAD_LETTER_EXCHANGE);
        //设置死信交换机的RoutingKey
        arguments.put("x-dead-letter-routing-key",DEAD_ROUTINGKEY);
        arguments.put("x-message-ttl",10000); //设置过期时间 单位为ms (毫秒)
        return QueueBuilder.durable(QUEUE_A).withArguments(arguments).build();
    }

    @Bean("queueB")
    public Queue queueB(){
        //準備給正常隊列的參數
        Map arguments = new HashMap<>(3);
        //设置不能正常消费时的私信交换机的参数
        arguments.put("x-dead-letter-exchange",DEAD_LETTER_EXCHANGE);
        //设置死信交换机的RoutingKey
        arguments.put("x-dead-letter-routing-key",DEAD_ROUTINGKEY);
        arguments.put("x-message-ttl",20000); //设置过期时间 单位为ms (毫秒)
        return QueueBuilder.durable(QUEUE_B).withArguments(arguments).build();
    }

    //声明死新队列
    @Bean("deadQueueD")
    public Queue deadQueueD(){
        return QueueBuilder.durable(DEAD_LETTER_QUEUE).build();
    }


    //绑定普通交换机
    @Bean
    public Binding queueAbindingToxExchange(@Qualifier("queueA") Queue queueA,
                                            @Qualifier("xExchange") DirectExchange xExchange){
      return BindingBuilder.bind(queueA).to(xExchange).with(NOMAL_ROUTINGKEY_A);
    }

    @Bean
    public Binding queueBbindingToxExchange(@Qualifier("queueB") Queue queueB,
                                            @Qualifier("xExchange") DirectExchange xExchange){
        return BindingBuilder.bind(queueB).to(xExchange).with(NOMAL_ROUTINGKEY_B);
    }

    //绑定死信交换机
    @Bean
    public Binding deadQueueDbindingToYExchange(@Qualifier("deadQueueD") Queue deadQueueD,
                                            @Qualifier("yExchange") DirectExchange yExchange){
        return BindingBuilder.bind(deadQueueD).to(yExchange).with(DEAD_ROUTINGKEY);
    }

}

编写消费者

package org.rmq.consumer;

import com.rabbitmq.client.Channel;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import java.util.Date;

@Slf4j
@Component
public class TTLQueueConsumer {
    //死信队列
    private static final String DEAD_LETTER_QUEUE = "QD";
    @RabbitListener(queues = DEAD_LETTER_QUEUE)
    public void recieveTTLInfo(Message message, Channel channel){
      String msg = new String(message.getBody());
      log.info("当前时间{},收到死信队列的消息{}",new Date().toString(),msg);
    }
}

启动项目，

在浏览器访问

至此使用死信队列 + ttl 来处理延迟消息的例子完成，这里实际上就是工作中常用到的延迟队列

3.2: TTL 队列优化

在3.1 里面演示的延迟队列是存在问题的，当我们还需要定义更多的延迟时间的队列的时候，就还需要增加不同的普通队列和 RoutingKey 这样就不得不修改代码，我们希望可以写一个通用的来替代

可以在之前的代码中添加一个新的交换机和队列，不在消费端定义过期时间，而是在生产者端去指指定时间，这样就可以可解决问题

在3.1 的TTLQueueConfig代码中添加变量

private static final String QUEUE_C = "QC";

private static final String NOMAL_ROUTINGKEY_C = "XC";

再新增一个队列的定义，并绑定死信队列，不指定过期时间参数

@Bean("queueC")
public Queue queueC(){
    //準備給正常隊列的參數
    Map arguments = new HashMap<>(3);
    //设置不能正常消费时的私信交换机的参数
    arguments.put("x-dead-letter-exchange",DEAD_LETTER_EXCHANGE);
    //设置死信交换机的RoutingKey
    arguments.put("x-dead-letter-routing-key",DEAD_ROUTINGKEY);
    //arguments.put("x-message-ttl",20000); //设置过期时间 单位为ms (毫秒)
    return QueueBuilder.durable(QUEUE_C).withArguments(arguments).build();
}

@Bean
public Binding queueCBindingToxExchange(@Qualifier("queueC") Queue queueC,
                                        @Qualifier("xExchange") DirectExchange xExchange){
    return BindingBuilder.bind(queueC).to(xExchange).with(NOMAL_ROUTINGKEY_C);
}

这样就加好了配置类中的内容

在生产端添加一个新的测试代码

@ResponseBody
@GetMapping("/sendmsgttl/{message}/{ttltime}")
public void sendMsg(@PathVariable("message") String message,@PathVariable("ttltime") String ttltime){
    log.info("当前时间:{},发送消息{}给一个ttl队列,过期时间是{}ms",new Date().toString(),message,ttltime);
    rabbitTemplate.convertAndSend(X_EXCHANGE,NOMAL_ROUTINGKEY_C,message,msg->{
        msg.getMessageProperties().setExpiration(ttltime);
        return msg;
    });
}

执行结果

发现当有多条消极被发送时，发送时间基于了第一条的时间来执行了，哪怕第二条消息时间比第一条端，还是按第一条的时间来处理了，所以这里还是有问题的，我们还需要更多的优化

3.3 TTL + 死信队列优化2

解决上面的问题我们需要安装一个插件

官网地址：Community Plugins — RabbitMQ 点击进去之后会发现，已经被托管到git 上了

进入 git https://github.com/rabbitmq/rabbitmq-delayed-message-exchange/releases

下载对应的版本注意 Erlang 支持的版本，由于我的符合这个版本要求，就直接下载啦

下载之后将该文件放到 rabbitmq 的 plugins 目录下

我的机器目录 /usr/lib/rabbitmq/lib/rabbitmq_server-3.8.26

执行 rabbitmq-plugins enable rabbitmq_delayed_message_exchange 安装插件

安装玩插件后需要重启服务

rabbitmqctl rabbitmq-server stop 关闭服务
rabbitmq-server -detached 启动服务
rabbitmqctl status 查看服务状态

此时我我们延迟交换机的延迟队列就变更到交换机了

编写一个新的延迟对类的配置类

package org.rmq.config;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.CustomExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

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

@Configuration
public class DelayedQueueConfig {
    private static final String DELAYED_EXCHANGE = "DELAYED.EXCHANGE";
    private static final String DELAYED_QUEUE = "DELAYED.QUEUE";
    private static final String DELAYED_ROUTING_KEY = "DELAYED.ROUTINGKEY";
    private static final String DELAYED_EXCHANGE_TYPE = "x-delayed-message";

    @Bean("delayedExchange")
    public CustomExchange delayedExchange(){
        /**
         * name  交换机名称
         * type  交换机类型
         * durable  是否持久化交换机
         * autoDelete 是否自动删除交换机
         * arguments  其他参数
         */
        Map arguments = new HashMap<>();
        arguments.put("x-delayed-type","direct"); //延迟类型
        //x-delayed-message  延迟消息
        return new CustomExchange(DELAYED_EXCHANGE,DELAYED_EXCHANGE_TYPE,true,false,arguments);
    }

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

    @Bean
    public Binding delayedQueueBindingTodelayedExchange(
            @Qualifier("delayedQueue") Queue delayedQueue,
            @Qualifier("delayedExchange") CustomExchange delayedExchange){
            return BindingBuilder.bind(delayedQueue).to(delayedExchange).with(DELAYED_ROUTING_KEY).noargs();
    }

}

编写生产者延时时间多少由生产多发消息的时候指定

//############################################
private static final String DELAYED_EXCHANGE = "DELAYED.EXCHANGE";
private static final String DELAYED_ROUTING_KEY = "DELAYED.ROUTINGKEY";
//############################################

@ResponseBody
@GetMapping("/sendDelayedmsg/{message}/{delaredTime}")
public void sendMsg(@PathVariable("message") String message,@PathVariable("delaredTime") Integer delaredTime){
    log.info("当前时间:{},发送消息{}给一个延迟队列,时间是{}ms",new Date().toString(),message,delaredTime);
    rabbitTemplate.convertAndSend(DELAYED_EXCHANGE,DELAYED_ROUTING_KEY,message,msg->{
        msg.getMessageProperties().setDelay(delaredTime);
        return msg;
    });
}

编写消费者：

package org.rmq.consumer;

import com.rabbitmq.client.Channel;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import java.util.Date;

@Component
@Slf4j
public class DelayedQueueConsumer {
    private static final String DELAYED_QUEUE = "DELAYED.QUEUE";
    @RabbitListener(queues = DELAYED_QUEUE)
    public void recieveDelayedInfo(Message message){
        String msg = new String(message.getBody());
        log.info("当前时间{},收到延迟队列的消息{}",new Date().toString(),msg);
    }
}
执行结果发现延迟的消息按照我们预想打印消费了，延迟时间长的后打印，延迟时间短的后打印，说明插件可用

4:发布确认的高级内容

在之前的内容里，都没有讨论交换机,队列由于某些原因收不到消息的情况，怎么在交换机和队列粗问题的时候，生产者能够知道消息发送失败了，这样就可以记录或者重发那些消息

4.1：交换机确认回调

编写配置文件

package org.rmq.config;

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 ConfirmConfig {

    private static final String CONFIRM_EXCHANGE = "CONFIRM.EXCHANGE";
    private static final String CONFIRM_QUEUE = "CONFIRM.QUEUE";
    private static final String CONFIRM_ROUTING_KEY = "CONFIRM.ROUTINGKEY";

    @Bean("confirmExchange")
    public DirectExchange confirmExchange(){
        return  new DirectExchange(CONFIRM_EXCHANGE);
    }

    @Bean("confirmQueue")
    public Queue confirmQueue(){
        return QueueBuilder.durable(CONFIRM_QUEUE).build();
    }

    @Bean
    public Binding confirmBind(@Qualifier("confirmQueue") Queue confirmQueue,
                               @Qualifier("confirmExchange") DirectExchange confirmExchange){
        return BindingBuilder.bind(confirmQueue).to(confirmExchange).with(CONFIRM_ROUTING_KEY);
    }

}

编写生产者

//############################################
private static final String CONFIRM_EXCHANGE = "CONFIRM.EXCHANGE";
private static final String CONFIRM_ROUTING_KEY = "CONFIRM.ROUTINGKEY";
//############################################

@ResponseBody
@GetMapping("/sendConfirmmsg/{message}")
public void sendConfirmMsg(@PathVariable("message") String message){
    /**
    exchange
    routingKey
    message
    CorrelationData correlationData  放入确认回调的信息
   **/
    String id = UUID.randomUUID().toString();
    CorrelationData correlationData = new CorrelationData(id);
    rabbitTemplate.convertAndSend(CONFIRM_EXCHANGE+"1234",CONFIRM_ROUTING_KEY,message,correlationData);
    System.out.println("发送了编号为:"+id+"消息"+"内容是:"+message);
}

这个 CONFIRM_EXCHANGE+"1234" 是故意制造错误用来验证数据发送不到交换机

编写消费者

package org.rmq.consumer;

import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Slf4j
@Component
public class ConfirmConsumer {
    private static final String CONFIRM_QUEUE = "CONFIRM.QUEUE";

    @RabbitListener(queues = CONFIRM_QUEUE)
    public void recieveConfirmMsg(Message message){
        System.out.println("ConfirmConsumer 接受到消息:"+new String(message.getBody()));
    }

}

测试：故意修改交换机的RoutingKey , 让生产端的消息不能发送到交换机，检查控制台信息，报错

如果没有这个 spring.rabbitmq.publisher-confirms=true 配置会发现我们得 fallbak 函数不会被调用，发送了编号为:3fec94f3-c023-4653-badd-fbf9505be401消息内容是:www012
2021-11-26 20:00:12.881 ERROR 31628 --- [68.217.128:5672] o.s.a.r.c.CachingConnectionFactory : Channel shutdown: channel error; protocol method: #method(reply-code=404, reply-text=NOT_FOUND - no exchange 'CONFIRM.EXCHANGE1234' in vhost '/', class-id=60, method-id=40)

这个错误是因为我们还少了个配置需要配置到 properties 文件

# 应用名
spring.application.name=springboot-rabbitmq
# rabbitmq配置信息
# ip
spring.rabbitmq.host=192.168.217.128
# 端口
spring.rabbitmq.port=5672
# 用户名
spring.rabbitmq.username=developer
# 密码
spring.rabbitmq.password=dev123456
# 配置虚拟机
spring.rabbitmq.virtual-host=/
# 消息开启手动确认
spring.rabbitmq.listener.direct.acknowledge-mode=manual
# 开启发布确认回调
spring.rabbitmq.publisher-confirms=true

spring.rabbitmq.publisher-confirms=true 需要将这个配置写入配置文件有的版本是

spring.rabbitmq.publisher-confirm-type= simple 或者 none 或者 corrected 请根据自己的版本来选用

none ：禁用发布确认模式

corrected ：会触发消息发布确认，并且不会关闭信道 channel

simple : 会调用 waitConfirms() 或 waitConfirmsOrDie() 等待broker 返回结果，根据返回结果判断调用下一步逻辑，需要注意的是调用 waitConfirmsOrDie() 返回false 的时候，会关闭channel ，导致、无法继续发消息到broker

4.2：消息回退

当交换机可达但是交换机需要路由到对应的队列的时候无法进行路由，就可以通消息回退的方式来获取到那个消息不能发送成功，获取到这些消息之后，就可以进行重新发送

在配置文件中添加

# 开启消息回退
spring.rabbitmq.publisher-returns=true

修改4.1 中的callback文件

package org.rmq.config;

import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
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 javax.annotation.PostConstruct;

@Slf4j
@Component
public class MyCallback implements RabbitTemplate.ConfirmCallback, RabbitTemplate.ReturnCallback{

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @PostConstruct
    public void init(){
        rabbitTemplate.setConfirmCallback(this);
        rabbitTemplate.setReturnCallback(this);
    }

   /**
    * correlationData  消息确认内容
    * ack 是否收到确认
    * cause 收到或未收到确认的原因
    * **/
    @Override
    public void confirm(CorrelationData correlationData, boolean ack, String cause) {
        if(ack){
            String id = correlationData.getId();
            log.info("确认收到消息,"+"编号:"+id);
        }else{
            String id = correlationData.getId();
            log.info("未能确认收到编号为:"+id+"的消息,失败原因是:"+cause);
        }
    }

    @Override
    public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
        log.info("消息{}无法路由被交换机{}回退,原因是{},路由key:{}",
                message.getBody(),exchange,replyText,routingKey);
    }
}

修改生产者

@ResponseBody
@GetMapping("/sendConfirmmsg/{message}")
public void sendConfirmMsg(@PathVariable("message") String message){
    /**
    exchange
    routingKey
    message
    CorrelationData correlationData  放入确认回调的信息
   **/
    String id = UUID.randomUUID().toString();
    CorrelationData correlationData = new CorrelationData(id);
    rabbitTemplate.convertAndSend(CONFIRM_EXCHANGE,CONFIRM_ROUTING_KEY,message,correlationData);
    System.out.println("发送了编号为:"+id+"消息"+"内容是:"+message);

    String id2 = UUID.randomUUID().toString();
    CorrelationData correlationData2 = new CorrelationData(id2);
    rabbitTemplate.convertAndSend(CONFIRM_EXCHANGE,CONFIRM_ROUTING_KEY+"1234",message,correlationData2);
    System.out.println("发送了编号为:"+id2+"消息"+"内容是:"+message+"key是:"+CONFIRM_ROUTING_KEY+"1234");
}

执行结果：

4.3：备份交换机

我们还可以对4.2中的架构进行优化，但发送不到 queue 的时候可以对交换机做备份，当无法路由时不直接消息回退，而是通过交换机将消息发送给备份交换机

修改配置类

package org.rmq.config;

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 ConfirmConfig {

    private static final String CONFIRM_EXCHANGE = "CONFIRM.EXCHANGE";
    private static final String CONFIRM_QUEUE = "CONFIRM.QUEUE";
    private static final String CONFIRM_ROUTING_KEY = "CONFIRM.ROUTINGKEY";


    // 备份交换机 备份被队列
    private static final String BACKUP_EXCHANGE = "BACKUP.EXCHANGE";
    private static final String BACKUP_QUEUE = "BACKUP.QUEUE";
    private static final String WARNING_QUEUE = "WARNING.QUEUE";

//    @Bean("confirmExchange")
//    public DirectExchange confirmExchange(){
//        return  new DirectExchange(CONFIRM_EXCHANGE);
//    }

    //建立普通交换机在无法消费数据是将消息转发给备份交换机
    @Bean("confirmExchange")
    public DirectExchange confirmExchange(){
        return (DirectExchange) ExchangeBuilder.directExchange(CONFIRM_EXCHANGE).durable(true)
                .withArgument("alternate-exchange",BACKUP_EXCHANGE).build();
    }


    @Bean("confirmQueue")
    public Queue confirmQueue(){
        return QueueBuilder.durable(CONFIRM_QUEUE).build();
    }

    @Bean
    public Binding confirmBind(@Qualifier("confirmQueue") Queue confirmQueue,
                               @Qualifier("confirmExchange") DirectExchange confirmExchange){
        return BindingBuilder.bind(confirmQueue).to(confirmExchange).with(CONFIRM_ROUTING_KEY);
    }

    //声明备份交换机 备份被队列
    @Bean("backupExchange")
    public FanoutExchange backupExchange(){
        return new FanoutExchange(BACKUP_EXCHANGE);
    }

    @Bean("backupQueue")
    public Queue backupQueue(){
        return QueueBuilder.durable(BACKUP_QUEUE).build();
    }

    @Bean("warningQueue")
    public Queue warningQueue(){
        return QueueBuilder.durable(WARNING_QUEUE).build();
    }

    //绑定 备份交换机和备份队列
    @Bean
    public Binding bcackupQueueBindToBackupExchange(@Qualifier("backupQueue") Queue backupQueue,
                                                   @Qualifier("backupExchange") FanoutExchange backupExchange){
        return BindingBuilder.bind(backupQueue).to(backupExchange);
    }
    @Bean
    public Binding warningQueueBindToBackupExchange(@Qualifier("warningQueue") Queue warningQueue,
                                                   @Qualifier("backupExchange") FanoutExchange backupExchange){
        return BindingBuilder.bind(warningQueue).to(backupExchange);
    }

}

添加一个备份的消费者

package org.rmq.consumer;

import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Slf4j
@Component
public class WarningConsumer {
    private static final String WARNING_QUEUE = "WARNING.QUEUE";
    @RabbitListener (queues = WARNING_QUEUE)
    public void recieveWarningMsg(Message message){
        log.info("warning get message"+new String(message.getBody()));
    }
}

生产者还是用 4.2中的代码逻辑

@ResponseBody
@GetMapping("/sendConfirmmsg/{message}")
public void sendConfirmMsg(@PathVariable("message") String message){
    /**
    exchange
    routingKey
    message
    CorrelationData correlationData  放入确认回调的信息
   **/
    String id = UUID.randomUUID().toString();
    CorrelationData correlationData = new CorrelationData(id);
    rabbitTemplate.convertAndSend(CONFIRM_EXCHANGE,CONFIRM_ROUTING_KEY,message,correlationData);
    System.out.println("发送了编号为:"+id+"消息"+"内容是:"+message);

    String id2 = UUID.randomUUID().toString();
    CorrelationData correlationData2 = new CorrelationData(id2);
    rabbitTemplate.convertAndSend(CONFIRM_EXCHANGE,CONFIRM_ROUTING_KEY+"1234",message,correlationData2);
    System.out.println("发送了编号为:"+id2+"消息"+"内容是:"+message+"key是:"+CONFIRM_ROUTING_KEY+"1234");
}

执行代码，报错，需要在管理控制台删除之前在4.2 中创建的队列和交换机，并重新启动程序，因为之前在普通交换机上并没有设置出现不能转发时的备份交换机

2021-11-27 10:14:48.997 ERROR 17092 --- [68.217.128:5672] o.s.a.r.c.CachingConnectionFactory : Channel shutdown: channel error; protocol method: #method(reply-code=406, reply-text=PRECONDITION_FAILED - inequivalent arg 'alternate-exchange' for exchange 'CONFIRM.EXCHANGE' in vhost '/': received the value 'BACKUP.EXCHANGE' of type 'longstr' but current is none, class-id=40, method-id=10)
2021-11-27 10:14:50.009 ERROR 17092 --- [68.217.128:5672] o.s.a.r.c.CachingConnectionFactory : Channel shutdown: channel error; protocol method: #method(reply-code=406, reply-text=PRECONDITION_FAILED - inequivalent arg 'alternate-exchange' for exchange 'CONFIRM.EXCHANGE' in vhost '/': received the value 'BACKUP.EXCHANGE' of type 'longstr' but current is none, class-id=40, method-id=10)
2021-11-27 10:14:52.016 ERROR 17092 --- [68.217.128:5672] o.s.a.r.c.CachingConnectionFactory : Channel shutdown: channel error; protocol method: #method(reply-code=406, reply-text=PRECONDITION_FAILED - inequivalent arg 'alternate-exchange' for exchange 'CONFIRM.EXCHANGE' in vhost '/': received the value 'BACKUP.EXCHANGE' of type 'longstr' but current is none, class-id=40, method-id=10)

重新执行发送信息可以看到不能发送到普通交换机的消息已经被备份交换机获取到了

4.4：优先级队列

创建优先级消息的生产者

@ResponseBody
@GetMapping("/sendprimsg/{message}")
public void sendPriMsg(@PathVariable("message") String message){
    for(int i=10;i>1;i--){
        int finalI = i;
        rabbitTemplate.convertAndSend(EXCHANGE,ROUTING_KEY,"queue:"+i, msg -> {
            msg.getMessageProperties().setPriority(finalI);  //设置优先级
            return msg;
        });
    }
}

设置配置类

package org.rmq.config;

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.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;

import java.util.HashMap;
import java.util.Map;
//优先级队列配置类
@Configuration
public class priQueueConfig {
    private static final String EXCHANGE = "priority-exchange";

    public static final String QUEUE = "priority-queue";

    private static final String ROUTING_KEY = "priority.queue";
    @Bean
    DirectExchange priExchange(){
        return new DirectExchange(EXCHANGE);
    }
    @Bean
    Queue priQueue(){
        Map map = new HashMap<>();
        map.put("x-max-priority",10);//设置最大的优先级数量
        return new Queue(QUEUE,true,false,false,map);
    }
    @Bean
    public Binding priQueueBindpriExchange(
            @Qualifier("priQueue") Queue priQueue,
            @Qualifier("priExchange") DirectExchange priExchange
    ){
        return BindingBuilder.bind(priQueue).to(priExchange).with(ROUTING_KEY);
    }

}

设置消费者

package org.rmq.consumer;

import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Slf4j
@Component
public class PriConsumer {
    @RabbitListener(queues ="priority-queue")
    public void hand(String msg){
       log.info("接受到了一个消息:"+msg);
    }

}

以上几个章节代码完整路径

GitHub - wanglei111000/RabbitMqDemo

GitHub - wanglei111000/Springboot-rabbitmq

5：RabbitMQ 集群

请参考我的另一个博客： RabbitMQ HAProxy +Keepalived 高可用集群_Java 码农的博客-CSDN博客

你可能感兴趣的:(rabbitmq,分布式,database)

消息中间件有哪些常见类型 xmh-sxh-1314 java
消息中间件根据其设计理念和用途，可以大致分为以下几种常见类型：点对点消息队列（Point-to-PointMessagingQueues）：在这种模型中，消息被发送到特定的队列中，消费者从队列中取出并处理消息。队列中的消息只能被一个消费者消费，消费后即被删除。常见的实现包括IBM的MQSeries、RabbitMQ的部分使用场景等。适用于任务分发、负载均衡等场景。发布/订阅消息模型（Pub/Sub
GitHub上克隆项目 bigbig猩猩 github
从GitHub上克隆项目是一个简单且直接的过程，它允许你将远程仓库中的项目复制到你的本地计算机上，以便进行进一步的开发、测试或学习。以下是一个详细的步骤指南，帮助你从GitHub上克隆项目。一、准备工作1.安装Git在克隆GitHub项目之前，你需要在你的计算机上安装Git工具。Git是一个开源的分布式版本控制系统，用于跟踪和管理代码变更。你可以从Git的官方网站（https://git-scm.
01-Git初识 Meereen Git git
01-Git初识概念：一个免费开源，分布式的代码版本控制系统，帮助开发团队维护代码作用：记录代码内容。切换代码版本，多人开发时高效合并代码内容如何学：个人本机使用：Git基础命令和概念多人共享使用：团队开发同一个项目的代码版本管理Git配置用户信息配置：用户名和邮箱，应用在每次提交代码版本时表明自己的身份命令：查看git版本号git-v配置用户名gitconfig--globaluser.name
Kafka是如何保证数据的安全性、可靠性和分区的喜欢猪猪 kafka 分布式
Kafka作为一个高性能、可扩展的分布式流处理平台，通过多种机制来确保数据的安全性、可靠性和分区的有效管理。以下是关于Kafka如何保证数据安全性、可靠性和分区的详细解析：一、数据安全性SSL/TLS加密：Kafka支持SSL/TLS协议，通过配置SSL证书和密钥来加密数据传输，确保数据在传输过程中不会被窃取或篡改。这一机制有效防止了中间人攻击，保护了数据的安全性。SASL认证：Kafka支持多种
06选课支付模块之基于消息队列发送支付通知消息 echo 云清学成在线 java rabbitmq 消息队列支付通知学成在线
消息队列发送支付通知消息需求分析订单服务作为通用服务，在订单支付成功后需要将支付结果异步通知给其他对接的微服务，微服务收到支付结果根据订单的类型去更新自己的业务数据技术方案使用消息队列进行异步通知需要保证消息的可靠性即生产端将消息成功通知到服务端：消息发送到交换机-->由交换机发送到队列-->消费者监听队列，收到消息进行处理，参考文章02-使用Docker安装RabbitMQ-CSDN博客生产者确
在RabbitMQ中四种常见的消息路由模式 Xwzzz_ rabbitmq 分布式
1.Fanout模式Fanout模式的交换机是扇出交换机（FanoutExchange），它会将消息广播给所有绑定到它的队列，而不考虑消息的内容或路由键。工作原理：生产者发送消息到FanoutExchange。FanoutExchange会将消息广播给所有绑定到它的队列，所有绑定的队列都会收到这条消息。消费者监听绑定的队列，处理收到的消息。特点：没有路由键：消息不需要路由键，所有绑定的队列都会接收
WebMagic：强大的Java爬虫框架解析与实战 Aaron_945 Java java 爬虫开发语言
文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
博客网站制作教程 2401_85194651 java maven
首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
【RabbitMQ 项目】服务端：数据管理模块之绑定管理月夜星辉雪 rabbitmq 分布式
文章目录一.编写思路二.代码实践一.编写思路定义绑定信息类交换机名称队列名称绑定关键字：交换机的路由交换算法中会用到没有是否持久化的标志，因为绑定是否持久化取决于交换机和队列是否持久化，只有它们都持久化时绑定才需要持久化。绑定就好像一根绳子，两端连接着交换机和队列，当一方不存在，它就没有存在的必要了定义绑定持久化类构造函数：如果数据库文件不存在则创建，打开数据库，创建binding_table插入
RabbitMQ生产者重复机制与确认机制 java炒饭小能手 java-rabbitmq rabbitmq java
重复机制生产者发送消息时，出现了网络故障，导致与MQ的连接中断。为了解决这个问题，SpringAMQP提供的消息发送时的重试机制。即：当RabbitTemplate与MQ连接超时后，多次重试。需要修该发送端模块的application.yaml文件，添加下面的内容：spring:rabbitmq:connection-timeout:1s#设置MQ的连接超时时间template:retry:ena
华为云分布式缓存服务DCS 8月新特性发布华为云PaaS服务小智华为云分布式缓存
分布式缓存服务（DistributedCacheService，简称DCS）是华为云提供的一款兼容Redis的高速内存数据处理引擎，为您提供即开即用、安全可靠、弹性扩容、便捷管理的在线分布式缓存能力，满足用户高并发及数据快速访问的业务诉求。此次为大家带来DCS8月的特性更新内容，一起来看看吧！
浅谈MapReduce Android路上的人 Hadoop 分布式计算 mapreduce 分布式框架 hadoop
从今天开始，本人将会开始对另一项技术的学习，就是当下炙手可热的Hadoop分布式就算技术。目前国内外的诸多公司因为业务发展的需要，都纷纷用了此平台。国内的比如BAT啦，国外的在这方面走的更加的前面，就不一一列举了。但是Hadoop作为Apache的一个开源项目，在下面有非常多的子项目，比如HDFS，HBase,Hive，Pig,等等，要先彻底学习整个Hadoop，仅仅凭借一个的力量，是远远不够的。
KVM+GFS分布式存储系统构建KVM高可用 henan程序媛分布式 GFS 高可用 KVM
一、案列分析1.1案列概述本章案例主要使用之前章节所学的KVM及GlusterFs技术,结合起来从而实现KVM高可用。利用GlusterFs分布式复制卷，对KVM虚拟机文件进行分布存储和冗余。分布式复制卷主要用于需要冗余的情况下把一个文件存放在两个或两个以上的节点,当其中一个节点数据丢失或者损坏之后，KVM仍然能够通过卷组找到另一节点上存储的虚拟机文件，以保证虚拟机正常运行。当节点修复之后，Glu
Hadoop 傲雪凌霜，松柏长青后端大数据 hadoop 大数据分布式
ApacheHadoop是一个开源的分布式计算框架，主要用于处理海量数据集。它具有高度的可扩展性、容错性和高效的分布式存储与计算能力。Hadoop核心由四个主要模块组成，分别是HDFS（分布式文件系统）、MapReduce（分布式计算框架）、YARN（资源管理）和HadoopCommon（公共工具和库）。1.HDFS（HadoopDistributedFileSystem）HDFS是Hadoop生
大模型训练数据库Common Crawl WindyChanChan 数据集语言模型数据库
CommonCrawl介绍‌‌CommonCrawl是一个非营利组织，致力于通过大规模分布式爬虫系统定期抓取整个Web并将其存储在一个可公开访问的数据库中。CommonCrawl的数据收集和处理过程包括使用Python开源爬虫工具收集全球范围内的网站数据，并将其上传到‌CommonCrawl基金会的数据仓库中。该项目从2008年开始，至今已经积累了大量的原始网页数据、元数据和文本提取数据。这些数据
慢速连接攻击是什么？慢速连接攻击怎么防护？快快小毛毛网络 ddos 服务器
慢速连接攻击（SlowConnectionAttack），又称慢速攻击（SlowlorisAttack），是一种网络攻击技术，旨在通过占用服务器上的所有可用连接资源来使其无法响应正常请求。与传统的拒绝服务（DoS）和分布式拒绝服务（DDoS）攻击不同，慢速攻击并不依赖于发送大量数据包来消耗带宽，而是利用HTTP、TCP或SSL等协议的特性，通过发送大量不完整的请求或缓慢发送数据来占用服务器资源，使
分布式锁和spring事务管理暴躁的鱼锁及事务分布式 spring java
最近开发一个小程序遇到一个需求需要实现分布式事务管理业务需求用户在使用小程序的过程中可以查看景点，对景点地区或者城市标记是否想去，那么需要统计一个地点被标记的人数，以及记录某个用户对某个地点是否标记为想去，用两个表存储数据，一个地点表记录改地点被标记的次数，一个用户意向表记录某个用户对某个地点是否标记为想去。由于可能有多个用户同时标记一个地点，每个用户在前端点击想去按钮之后，后台接收到请求，从数据
Gobelieve 架构 weixin_34099526 数据库 golang json
Gobelievegithub地址声明:转简书JackieF的文章,为了自己方便copy了一份,加一些自己的东西.链接：https://www.jianshu.com/p/8121d6e85282IMCore主要分三大块:im客户连接服务器（可分布式部署，暂无负载均衡模块)imr路由查询服务器（主要解决im分布式部署的问题）ims存储服务器(主从部署)基础模块1.数据包协议包：header(12)
Kafka详细解析与应用分析芊言芊语 kafka 分布式
Kafka是一个开源的分布式事件流平台（EventStreamingPlatform），由LinkedIn公司最初采用Scala语言开发，并基于ZooKeeper协调管理。如今，Kafka已经被Apache基金会纳入其项目体系，广泛应用于大数据实时处理领域。Kafka凭借其高吞吐量、持久化、分布式和可靠性的特点，成为构建实时流数据管道和流处理应用程序的重要工具。Kafka架构Kafka的架构主要由
linux挂载文件夹小码快撩 linux
1.使用NFS（NetworkFileSystem）NFS是一种分布式文件系统协议，允许一个系统将其文件系统的一部分共享给其他系统。检查是否安装NFSrpm-qa|grepnfs2.启动和启用NFS服务假设服务名称为nfs-server.service，你可以使用以下命令启动和启用它：sudosystemctlstartnfs-server.servicesudosystemctlenablenf
Kafka 基础与架构理解 StaticKing KAFKA kafka
目录前言Kafka基础概念消息队列简介：Kafka与传统消息队列（如RabbitMQ、ActiveMQ）的对比Kafka的组件Kafka的工作原理：消息的生产、分发、消费流程Kafka系统架构Kafka的分布式架构设计Leader-Follower机制与数据复制Log-basedStorage和持久化Broker间通信协议Zookeeper在Kafka中的角色总结前言Kafka是一个分布式的消息系
Rides实现分布式锁，保障数据一致性,Redisson分布式事务处理朱杰jjj 缓存分布式
分布式环境下分布式锁有三种方式：基于数据库分布式锁基于Redis分布式锁基于zk分布式锁本帖只介绍Redis分布式锁为什么需要用到分布式锁？在单机环境下一个服务中多个线程对同一个事物或数据资源进行操作时，可以通过添加加锁方式（synchronized和lock）来解决数据一致性的问题。但是如果出现多个服务的情况下，这时候我们在通过synchronized和lock的方式来加锁会出现问题，因为多个服
机电综合管理系统架构小熊coder 机载系统系统架构
文章目录一、机电综合管理系统架构1.系统概述2.架构层次3.核心组件二、余度管理1.余度概述2.硬件冗余3.软件冗余4.通信冗余三、总线架构1.MIL-STD-1553B总线2.ARINC429总线3.ARINC629总线4.AFDX/ARINC664总线四、未来发展趋势1.分布式架构2.高速网络3.智能化与自动化结语机电综合管理系统（ElectromechanicalManagementSyst
华为云分布式缓存服务DCS与开源服务差异对比 hcinfo_18 redis使用华为云 Redis5.0 分布式缓存服务 Redis客户端
分布式缓存服务DCS提供单机、主备、集群等丰富的实例类型，满足用户高读写性能及快速数据访问的业务诉求。支持丰富的实例管理操作，帮助用户省去运维烦恼。用户可以聚焦于业务逻辑本身，而无需过多考虑部署、监控、扩容、安全、故障恢复等方面的问题。DCS基于开源Redis、Memcached向用户提供一定程度定制化的缓存服务，因此，除了拥有开源服务缓存数据库的优秀特性，DCS提供更多实用功能。一、与开源Red
Jooq 框架介绍及其核心要点木南曌 Java java
一、引言Jooq（JavaPersistenceforRelationalDatabases）是一个强大的类型安全的SQL查询构建器和ORM（Object-RelationalMapping）框架，专为Java和Kotlin设计。它为开发者提供了一种优雅的方式来编写SQL代码，同时还能享受到静态类型检查带来的好处。本文将详细介绍Jooq的核心功能，并通过一系列的代码示例来展示如何使用Jooq。二、
Dubbo架构概览：服务注册与发现、远程调用、监控与管理木南曌 dubbo 架构
Dubbo是一个成熟的、高性能的、基于Java的微服务开发框架，它主要用于解决分布式系统中的服务治理问题，包括服务的注册与发现、远程过程调用（RPC）、服务监控与管理等多个关键环节。以下是Dubbo架构概览的详细介绍：服务注册与发现Dubbo的服务注册与发现机制是其核心功能之一，它依赖于注册中心来管理服务的生命周期和定位服务提供者。1.服务提供者（Provider）服务提供者是实际提供服务的节点，
【RabbitMQ 项目】服务端数据管理模块之交换机管理月夜星辉雪 rabbitmq oracle 数据库
文章目录一.编写思路二.代码实践一.编写思路定义交换机类型直接交换广播交换主题交换定义交换机名字类型是否持久化定义交换机持久化类(持久化到sqlite3)构造函数(只能成功，不能失败)如果数据库(文件)不存在则创建打开数据库打开exchange_table数据库表插入交换机移除交换机将数据库中的交换机恢复到内存中传入一个哈希表，key为名字，value为交换机的智能指针，填充该哈希表定义交换机管理
【仿RabbitMQ消息队列项目day2】使用muduo库中基于protobuf的应用层协议进行通信月夜星辉雪 rabbitmq 网络分布式 c++后端服务器 linux
一.什么是muduo?muduo库是⼀个基于非阻塞IO和事件驱动的C++高并发TCP网络编程库。简单来理解，它就是对原生的TCP套接字的封装，是一个比socket编程接口更好用的编程库。二.使用muduo库完成一个英译汉翻译服务TranslateServer.hpp:#pragmaonce#include#include#include#include#include"muduo/net/TcpC
rabbitmq 楚楚ccc Java系列 rabbitmq 分布式
1.消息服务概述、rabbitmq核心概念消息服务概述：大多数应用中，可通过消息服务中间件来提升系统异步通信，扩展解耦能力两个重要概念：消息代理(messagebroker)和目的地(destination)。当消息发送者者发出消息后，将由消息代理接管，消息代理保证将消息传递至目的地两种形式的目的地：队列(queue):点对点的消息通信(point-to-point)主题(topic):发布(pu
使用 RabbitMQ 实现秒杀订单系统的异步消息处理 c137范特西 rabbitmq 分布式
使用RabbitMQ实现秒杀订单系统的异步消息处理在秒杀系统中，如何确保高并发环境下的订单处理稳定高效是个很大的挑战。为了解决这个问题，我们通常会引入消息队列，通过异步处理来削峰填谷。这篇文章将详细讲解如何使用RabbitMQ来设计一个秒杀订单系统的异步消息处理流程，重点是如何使用交换机（Exchange）、队列（Queue）、路由键（RoutingKey）以及死信队列（DeadLetterQue
戴尔笔记本win8系统改装win7系统 sophia天雪 win7 戴尔改装系统 win8
戴尔win8 系统改装win7 系统详述第一步：使用U盘制作虚拟光驱： 1）下载安装UltraISO：注册码可以在网上搜索。 2）启动UltraISO，点击“文件”—》“打开”按钮，打开已经准备好的ISO镜像文
BeanUtils.copyProperties使用笔记 bylijinnan java
BeanUtils.copyProperties VS PropertyUtils.copyProperties 两者最大的区别是： BeanUtils.copyProperties会进行类型转换，而PropertyUtils.copyProperties不会。既然进行了类型转换，那BeanUtils.copyProperties的速度比不上PropertyUtils.copyProp
MyEclipse中文乱码问题 0624chenhong MyEclipse
一、设置新建常见文件的默认编码格式，也就是文件保存的格式。在不对MyEclipse进行设置的时候，默认保存文件的编码，一般跟简体中文操作系统（如windows2000，windowsXP）的编码一致，即GBK。在简体中文系统下，ANSI 编码代表 GBK编码;在日文操作系统下，ANSI 编码代表 JIS 编码。 Window-->Preferences-->General -
发送邮件不懂事的小屁孩 send email
import org.apache.commons.mail.EmailAttachment; import org.apache.commons.mail.EmailException; import org.apache.commons.mail.HtmlEmail; import org.apache.commons.mail.MultiPartEmail;
动画合集换个号韩国红果果 html css
动画指一种样式变为另一种样式 keyframes应当始终定义0 100 过程 1 transition 制作鼠标滑过图片时的放大效果 css .wrap{ width: 340px;height: 340px; position: absolute; top: 30%; left: 20%; overflow: hidden; bor
网络最常见的攻击方式竟然是SQL注入蓝儿唯美 sql注入
NTT研究表明，尽管SQL注入（SQLi）型攻击记录详尽且为人熟知，但目前网络应用程序仍然是SQLi攻击的重灾区。信息安全和风险管理公司NTTCom Security发布的《2015全球智能威胁风险报告》表明，目前黑客攻击网络应用程序方式中最流行的，要数SQLi攻击。报告对去年发生的60亿攻击行为进行分析，指出SQLi攻击是最常见的网络应用程序攻击方式。全球网络应用程序攻击中，SQLi攻击占
java笔记2 a-john java
类的封装： 1，java中，对象就是一个封装体。封装是把对象的属性和服务结合成一个独立的的单位。并尽可能隐藏对象的内部细节（尤其是私有数据） 2，目的：使对象以外的部分不能随意存取对象的内部数据（如属性），从而使软件错误能够局部化，减少差错和排错的难度。 3，简单来说，“隐藏属性、方法或实现细节的过程”称为——封装。 4，封装的特性： 4.1设置
[Andengine]Error：can't creat bitmap form path “gfx/xxx.xxx” aijuans 学习Android遇到的错误
最开始遇到这个错误是很早以前了，以前也没注意，只当是一个不理解的bug，因为所有的texture，textureregion都没有问题，但是就是提示错误。昨天和美工要图片，本来是要背景透明的png格式，可是她却给了我一个jpg的。说明了之后她说没法改，因为没有png这个保存选项。我就看了一下，和她要了psd的文件，还好我有一点
自己写的一个繁体到简体的转换程序 asialee java 转换繁体 filter 简体
今天调研一个任务，基于java的filter实现繁体到简体的转换，于是写了一个demo，给各位博友奉上，欢迎批评指正。实现的思路是重载request的调取参数的几个方法，然后做下转换。
android意图和意图监听器技术百合不是茶 android 显示意图隐式意图意图监听器
Intent是在activity之间传递数据;Intent的传递分为显示传递和隐式传递显式意图：调用Intent.setComponent() 或 Intent.setClassName() 或 Intent.setClass()方法明确指定了组件名的Intent为显式意图，显式意图明确指定了Intent应该传递给哪个组件。隐式意图;不指明调用的名称,根据设
spring3中新增的@value注解 bijian1013 java spring @Value
在spring 3.0中，可以通过使用@value，对一些如xxx.properties文件中的文件，进行键值对的注入，例子如下： 1.首先在applicationContext.xml中加入： <beans xmlns="http://www.springframework.
Jboss启用CXF日志 sunjing log jboss CXF
1. 在standalone.xml配置文件中添加system-properties： <system-properties> <property name="org.apache.cxf.logging.enabled" value=&
【Hadoop三】Centos7_x86_64部署Hadoop集群之编译Hadoop源代码 bit1129 centos
编译必需的软件 Firebugs3.0.0 Maven3.2.3 Ant JDK1.7.0_67 protobuf-2.5.0 Hadoop 2.5.2源码包 Firebugs3.0.0 http://sourceforge.jp/projects/sfnet_findbug
struts2验证框架的使用和扩展白糖_ 框架 xml bean struts 正则表达式
struts2能够对前台提交的表单数据进行输入有效性校验，通常有两种方式： 1、在Action类中通过validatexx方法验证，这种方式很简单，在此不再赘述； 2、通过编写xx-validation.xml文件执行表单验证，当用户提交表单请求后，struts会优先执行xml文件，如果校验不通过是不会让请求访问指定action的。本文介绍一下struts2通过xml文件进行校验的方法并说
记录-感悟 braveCS 感悟
再翻翻以前写的感悟，有时会发现自己很幼稚，也会让自己找回初心。 2015-1-11 1. 能在工作之余学习感兴趣的东西已经很幸福了； 2. 要改变自己，不能这样一直在原来区域，要突破安全区舒适区，才能提高自己，往好的方面发展； 3. 多反省多思考；要会用工具，而不是变成工具的奴隶； 4. 一天内集中一个定长时间段看最新资讯和偏流式博
编程之美-数组中最长递增子序列 bylijinnan 编程之美
import java.util.Arrays; import java.util.Random; public class LongestAccendingSubSequence { /** * 编程之美数组中最长递增子序列 * 书上的解法容易理解 * 另一方法书上没有提到的是，可以将数组排序（由小到大）得到新的数组， * 然后求排序后的数组与原数
读书笔记5 chengxuyuancsdn 重复提交 struts2的token验证
1、重复提交 2、struts2的token验证 3、用response返回xml时的注意 1、重复提交 (1)应用场景 (1-1)点击提交按钮两次。 (1-2)使用浏览器后退按钮重复之前的操作，导致重复提交表单。 (1-3)刷新页面 (1-4)使用浏览器历史记录重复提交表单。 (1-5)浏览器重复的 HTTP 请求。 (2)解决方法 (2-1)禁掉提交按钮 (2-2)
[时空与探索]全球联合进行第二次费城实验的可能性 comsci
二次世界大战前后,由爱因斯坦参加的一次在海军舰艇上进行的物理学实验 -费城实验至今给我们大家留下很多迷团..... 关于费城实验的详细过程,大家可以在网络上搜索一下,我这里就不详细描述了在这里,我的意思是,现在
easy connect 之 ORA-12154: TNS: 无法解析指定的连接标识符 daizj oracle ORA-12154
用easy connect连接出现“tns无法解析指定的连接标示符”的错误，如下： C:\Users\Administrator>sqlplus username/[email protected]:1521/orcl SQL*Plus: Release 10.2.0.1.0 – Production on 星期一 5月 21 18:16:20 2012 Copyright (c) 198
简单排序:归并排序 dieslrae 归并排序
public void mergeSort(int[] array){ int temp = array.length/2; if(temp == 0){ return; } int[] a = new int[temp]; int
C语言中字符串的\0和空格 dcj3sjt126com c
\0 为字符串结束符，比如说： abcd (空格)cdefg；存入数组时，空格作为一个字符占有一个字节的空间，我们
解决Composer国内速度慢的办法 dcj3sjt126com Composer
用法：有两种方式启用本镜像服务： 1 将以下配置信息添加到 Composer 的配置文件 config.json 中（系统全局配置）。见“例1” 2 将以下配置信息添加到你的项目的 composer.json 文件中（针对单个项目配置）。见“例2” 为了避免安装包的时候都要执行两次查询，切记要添加禁用 packagist 的设置，如下 1 2 3 4 5
高效可伸缩的结果缓存 shuizhaosi888 高效可伸缩的结果缓存
/** * 要执行的算法，返回结果v */ public interface Computable<A, V> { public V comput(final A arg); } /** * 用于缓存数据 */ public class Memoizer<A, V> implements Computable<A,
三点定位的算法 haoningabc c 算法
三点定位，已知a,b,c三个顶点的x,y坐标和三个点都z坐标的距离，la，lb,lc 求z点的坐标原理就是围绕a,b,c 三个点画圆，三个圆焦点的部分就是所求但是，由于三个点的距离可能不准，不一定会有结果，所以是三个圆环的焦点，环的宽度开始为0，没有取到则加1 运行 gcc -lm test.c test.c代码如下 #include "stdi
epoll使用详解 jimmee c linux 服务端编程 epoll
epoll - I/O event notification facility在linux的网络编程中，很长的时间都在使用select来做事件触发。在linux新的内核中，有了一种替换它的机制，就是epoll。相比于select，epoll最大的好处在于它不会随着监听fd数目的增长而降低效率。因为在内核中的select实现中，它是采用轮询来处理的，轮询的fd数目越多，自然耗时越多。并且，在linu
Hibernate对Enum的映射的基本使用方法 linzx0212 enum Hibernate
枚举 /** * 性别枚举 */ public enum Gender { MALE(0), FEMALE(1), OTHER(2); private Gender(int i) { this.i = i; } private int i; public int getI
第10章高级事件（下） onestopweb 事件
index.html <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/
孙子兵法 roadrunners 孙子兵法
始计第一孙子曰：兵者，国之大事，死生之地，存亡之道，不可不察也。故经之以五事，校之以计，而索其情：一曰道，二曰天，三曰地，四曰将，五曰法。道者，令民于上同意，可与之死，可与之生，而不危也；天者，阴阳、寒暑、时制也；地者，远近、险易、广狭、死生也；将者，智、信、仁、勇、严也；法者，曲制、官道、主用也。凡此五者，将莫不闻，知之者胜，不知之者不胜。故校之以计，而索其情，曰
MySQL双向复制 tomcat_oracle mysql
本文包括: 主机配置从机配置建立主-从复制建立双向复制背景按照以下简单的步骤: 参考一下：在机器A配置主机(192.168.1.30) 在机器B配置从机(192.168.1.29) 我们可以使用下面的步骤来实现这一点步骤1：机器A设置主机在主机中打开配置文件 ,
zoj 3822 Domination(dp) 阿尔萨斯 Mina
题目链接：zoj 3822 Domination 题目大意：给定一个N∗M的棋盘，每次任选一个位置放置一枚棋子，直到每行每列上都至少有一枚棋子，问放置棋子个数的期望。解题思路：大白书上概率那一张有一道类似的题目，但是因为时间比较久了，还是稍微想了一下。dp[i][j][k]表示i行j列上均有至少一枚棋子，并且消耗k步的概率（k≤i∗j）,因为放置在i+1~n上等价与放在i+1行上，同理