rabbitmq笔记（看完即入门）

阳光穿透心脏的1/2处 2023-10-02 16:09 18阅读 0赞

该笔记是在逼站学习 编程不良人 老师rabbitmq自己记录的笔记，请大家去支持他的课程、买他的笔记（更全更清晰）  
链接

#### 目录 ####

*   *  一、基础
     *   *  1、docker安装rabbitmq,下载管理界面
         *  2、添加用户、虚拟主机
         *  3、各个模型简介、简单尝试
         *  1、helloWord模型（直连）
         *  2、能者多劳模型（work queues）
         *  3、fanout（扇出、广播）模型(publish/Subscribe)
         *  4、路由模型（Routing）订阅模型-Direct(直连)
         *  5、Topic模型
     *  二、整合springboot
     *   *  1、hello word
         *  2、work模型
         *  3、publish/Subscribe(广播)
         *  4、Routing模型
         *  5、Topic模型
         *  6、发送对象
     *  三、业务场景
     *   *  1、异步
         *  2、应用解耦
         *  3、流量削峰
     *  四、集群
     *   *  1、普通集群
         *  2、镜像集群（高可用）（推荐）
     *  五、与其他mq的区别

### 一、基础 ###

#### 1、docker安装rabbitmq,下载管理界面 ####

docker pull rabbitmq

docker run -d --hostname my-rabbit --name rabbit  -v /home/rabbitmq/data:/var/lib/rabbitmq -p 15672:15672 -p 5672:5672 rabbitmq

docker ps   // 查看启动容器信息
    docker exec -it 镜像ID /bin/bash    //开启进入终端
    rabbitmq-plugins enable rabbitmq_management    // 安装管理界面

http://linuxip地址:15672，这里的用户名和密码默认都是guest  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6LS154y_5qKm_size_20_color_FFFFFF_t_70_g_se_x_16]

#### 2、添加用户、虚拟主机 ####

1、添加虚拟主机  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6LS154y_5qKm_size_20_color_FFFFFF_t_70_g_se_x_16 1]2、添加用户  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6LS154y_5qKm_size_20_color_FFFFFF_t_70_g_se_x_16 2]3、点击用户名给用户配置可用虚拟主机  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6LS154y_5qKm_size_20_color_FFFFFF_t_70_g_se_x_16 3]

#### 3、各个模型简介、简单尝试 ####

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

#### 1、helloWord模型（直连） ####

![在这里插入图片描述][963af96ed5a84e08b6bdcf783db2b70f.png]

生产者

public static void main(String[] args) throws IOException, TimeoutException {
    		// 创建连接mq的连接工厂
    		ConnectionFactory connectionFactory = new ConnectionFactory();
    		// 设置连接rabbitmq主机
    		connectionFactory.setHost("服务器ip");
    		// 设置端口号
    		connectionFactory.setPort(5672);
    		// 连接连接哪个虚拟主机
    		connectionFactory.setVirtualHost("/ems");
    		// 设置访问虚拟主机的用户名和密码
    		connectionFactory.setUsername("emstest");
    		connectionFactory.setPassword("guest");
    
    		// 获取连接对象
    		Connection connection = connectionFactory.newConnection();
    		// 获取连接通道
    		Channel channel = connection.createChannel();
    		// 通道绑定对应详细队列
    		// 1、对列名称
    		// 2、队列是否持久化   (注意点)
    		// 3、是否独占队列
    		// 4、是否消费完成后自动删除队列    (注意点)
    		// 5、额外参数
    		channel.queueDeclare("aa",true,false,true,null);
    		// 发布消息
    		/**
    		 * 1、交换机名称  2、对列名称 3、传递参数额外设置(如下面这个  消息持久化 注意：上面是队列持久化、下面是消息持久化) 4、消息的具体内容    (注意点)
    		 */
    		channel.basicPublish("","aa", MessageProperties.PERSISTENT_TEXT_PLAIN,"hello rabbitmq".getBytes());
    		// 关闭消息
    		channel.close();
    		// 关闭连接
    		connection.close();
    	}

消费者

// 消费者
    	// 消费者
    	public static void main(String[] args) throws IOException, TimeoutException {
    		// 创建连接工厂
    		ConnectionFactory connectionFactory = new ConnectionFactory();
    		connectionFactory.setHost("服务器ip");
    		connectionFactory.setPort(5672);
    		connectionFactory.setVirtualHost("/ems");
    		connectionFactory.setUsername("emstest");
    		connectionFactory.setPassword("guest");
    
    		// 创建连接对象
    		Connection connection = connectionFactory.newConnection();
    		// 创建通道
    		Channel channel = connection.createChannel();
    		// 绑定对象
    		channel.queueDeclare("aa",true,false,true,null);
    		// 消费消息
    		// 参数1：消费哪个队列消息   队列名称
    		// 参数2：开启消息的自动确认队列
    		// 参数3：消费时的回调接口
    		channel.basicConsume("aa",true,new DefaultConsumer(channel){
    			@Override  // body:消息队列中取出的消息
    			public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
    				System.out.println("body = " + new String(body));
    			}
    		});
    		
    	}

运行生产者 （消费者收到生产者消息）  
![在这里插入图片描述][613818ec4f724b3d89742bc3631904ab.png]

#### 2、能者多劳模型（work queues） ####

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAZm9yX2FfYmV0dGVyX2xpZmUg4oaR_size_6_color_FFFFFF_t_70_g_se_x_16]

1、生产者

channel.queueDeclare("aa",true,false,false,null);
    		// 发布消息
    		/**
    		 * 1、交换机名称  2、对列名称 3、传递参数额外设置(如下面这个  消息持久化 注意：上面是队列持久化、下面是消息持久化) 4、消息的具体内容
    		 */
    		for (int i = 0; i <20 ; i++) {
    			channel.basicPublish("","aa", MessageProperties.PERSISTENT_TEXT_PLAIN,"hello rabbitmq".getBytes());
    		}

2、消费者1

channel.basicQos(1); //每一次只能消费一个消息
    		// 绑定对象
    		channel.queueDeclare("aa",true,false,false,null);
    		// 消费消息
    		// 参数1：消费哪个队列消息   队列名称
    		// 参数2：开启消息的自动确认队列
    		// 参数3：消费时的回调接口
    		channel.basicConsume("aa",true,new DefaultConsumer(channel){
    			@Override  // body:消息队列中取出的消息
    			public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
    				try {
    					Thread.sleep(2000);
    				} catch (InterruptedException e) {
    					e.printStackTrace();
    				}
    				System.out.println("body = " + new String(body));
    				// 手动确认  参数1：手动确认消息标识，   参数2：false 每次确认一次
    				channel.basicAck(envelope.getDeliveryTag(),false);
    			}
    		});

3、消费者2 （消费多一点）

channel.basicQos(1); //每一次只能消费一个消息
    		// 绑定对象
    		channel.queueDeclare("aa",true,false,false,null);
    		// 消费消息
    		// 参数1：消费哪个队列消息   队列名称
    		// 参数2：开启消息的自动确认队列
    		// 参数3：消费时的回调接口
    		channel.basicConsume("aa",true,new DefaultConsumer(channel){
    			@Override  // body:消息队列中取出的消息
    			public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
    
    				System.out.println("body1 = " + new String(body));
    				// 手动确认  参数1：手动确认消息标识，   参数2：false 每次确认一次
    				channel.basicAck(envelope.getDeliveryTag(),false);
    			}
    		});

连接工具类

package com.example.rabbitmq.util;
    
    import com.rabbitmq.client.Channel;
    import com.rabbitmq.client.Connection;
    import com.rabbitmq.client.ConnectionFactory;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.context.properties.ConfigurationProperties;
    
    import java.io.IOException;
    import java.util.concurrent.TimeoutException;
    
    
    public class RabbitmqUtils {
    
    	private static ConnectionFactory connectionFactory;
    	static {
    		// 设置连接rabbitmq主机
    		connectionFactory.setHost("服务器ip");
    		// 设置端口号
    		connectionFactory.setPort(5672);
    		// 连接连接哪个虚拟主机
    		connectionFactory.setVirtualHost("/ems");
    		// 设置访问虚拟主机的用户名和密码
    		connectionFactory.setUsername("emstest");
    		connectionFactory.setPassword("guest");
    	}
    
    	// 定义提供连接对象的方法
    	public static Connection getConnection(){
    		try {
    			// 创建连接mq的连接工厂
    			return connectionFactory.newConnection();
    
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    		return null;
    	}
    
    	public static void closeConnectionAndChanel(Channel channel,Connection connection){
    		try {
    			if (channel!=null) channel.close();
    			if (connection!=null) connection.close();
    		} catch (IOException e) {
    			e.printStackTrace();
    		} catch (TimeoutException e) {
    			e.printStackTrace();
    		}
    	}
    
    }

#### 3、fanout（扇出、广播）模型(publish/Subscribe) ####

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAZm9yX2FfYmV0dGVyX2xpZmUg4oaR_size_6_color_FFFFFF_t_70_g_se_x_16 1]

广播模型，消息发送流程：

> 1、可以有多个消费者  
> 2、 每个消费者有自己的queue(队列)  
> 3、生产者发送消息，只能发送到交换机，交换机来决定发给哪个队列，生产者无法决定。  
> 4、交换机把消息发送给绑定过的所有队列  
> 5、队列的消费者都能拿到消息，实现一条消息被多个消费者消费

1、生产者

public static void main(String[] args) throws IOException {
    		// 连接对象
    		Connection connection = RabbitmqUtils.getConnection();
    		//创建通道
    		Channel channel = connection.createChannel();
    
    		// 将通道声名指定的交换机
    		// 参数1：交换机名称  参数2：交换机类型   fanout：广播型
    		//没有这个交换机会自动创建
    		channel.exchangeDeclare("logs", "fanout");
    
    		// 发送消息
    		channel.basicPublish("logs", "", null, "fanout type message".getBytes());
    		//释放资源
    		RabbitmqUtils.closeConnectionAndChanel(channel, connection);
    	}

新增了交换机，fanout类型  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAZm9yX2FfYmV0dGVyX2xpZmUg4oaR_size_20_color_FFFFFF_t_70_g_se_x_16]  
2、多个消费者

public static void main(String[] args) throws IOException {
    		// 获取连接对象
    		Connection connection = RabbitmqUtils.getConnection();
    		Channel channel = connection.createChannel();
    
    		// 通道绑定交换机
    		channel.exchangeDeclare("logs","fanout");
    
    		// 交换机绑定临时队列
    
    		// 生成临时队列
    		String queueName = channel.queueDeclare().getQueue();
    		// 绑定队列和交换机
    		channel.queueBind(queueName,"logs","");
    		// 消费消息
    		channel.basicConsume(queueName,true,new DefaultConsumer(channel){
    			@Override
    			public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
    				System.out.println("消费者1："+new String(body));
    			}
    		});
    
    	}

多个消费者都收到了消息  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAZm9yX2FfYmV0dGVyX2xpZmUg4oaR_size_15_color_FFFFFF_t_70_g_se_x_16]

#### 4、路由模型（Routing）订阅模型-Direct(直连) ####

> 1、队列与交换机锁定，不能是任意绑定了，而是要指定一个RoutingKey(路由key)  
> 2、 消息发送方在向Exchange发送消息时，也必须指定消息的RoutingKey。  
> 3、Exchange不再把消息交给每一个绑定的队列，而是根据消息的Routing key 进行判断，只有队列的Routing key 与消息的Routing key 完全一致，才  
> 会接收到消息流程

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAZm9yX2FfYmV0dGVyX2xpZmUg4oaR_size_6_color_FFFFFF_t_70_g_se_x_16 2]图解：  
`P`: 生产者，向Exchange发送消息，发送消息时，会指定一个routing key.  
`X`: Exchange(交换机)，接收生产者的消息，然后把消息递交给与routing key完全匹配的队列  
`C1`: 消费者，其所在队列指定了需要routing key为error的消息  
`C2`: 消费者，其所在队列指定了需要routing key为info、error、warning的消息

1、生产者  
发送routingKey 为 info的信息

public static void main(String[] args) throws IOException {
    		// 连接对象
    		Connection connection = RabbitmqUtils.getConnection();
    		//创建通道
    		Channel channel = connection.createChannel();
    		// 将通道声名指定的交换机
    		// 参数1：交换机名称  参数2：交换机类型   direct：路由模式
    		//没有这个交换机会自动创建
    		channel.exchangeDeclare("logs_direct", "direct");
    		// 发送消息
    		String routingKey = "info";   //发送info的信息
    		channel.basicPublish("logs_direct",routingKey,null,("基于routingKey:"+routingKey+"的direct模型").getBytes());
    		//关闭资源
    		RabbitmqUtils.closeConnectionAndChanel(channel,connection);
    	}

2、消费者1  
只接收 error 信息

public static void main(String[] args) throws IOException {
    		// 获取连接对象
    		Connection connection = RabbitmqUtils.getConnection();
    		Channel channel = connection.createChannel();
    
    		// 通道绑定交换机
    		channel.exchangeDeclare("logs_direct","direct");
    		// 生成临时队列
    		String queueName = channel.queueDeclare().getQueue();
    		// 绑定队列和交换机
    		// 这个队列只去找error的消息进行消费
    		channel.queueBind(queueName,"logs_direct","error");
    		// 获取消费消息
    		channel.basicConsume(queueName,true,new DefaultConsumer(channel){
    			@Override
    			public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
    				System.out.println("消费者1只拿error："+new String(body));
    			}
    		});
    	}

3、消费者2  
可以接收 info、error、warning信息

public static void main(String[] args) throws IOException {
    		// 获取连接对象
    		Connection connection = RabbitmqUtils.getConnection();
    		Channel channel = connection.createChannel();
    
    		// 通道绑定交换机
    		channel.exchangeDeclare("logs_direct","direct");
    		// 生成临时队列
    		String queueName = channel.queueDeclare().getQueue();
    		// 绑定队列和交换机
    		channel.queueBind(queueName,"logs_direct","error");
    		channel.queueBind(queueName,"logs_direct","info");
    		channel.queueBind(queueName,"logs_direct","warning");
    		// 获取消费消息
    		channel.basicConsume(queueName,true,new DefaultConsumer(channel){
    			@Override
    			public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
    				System.out.println("消费者2都拿："+new String(body));
    			}
    		});
    	}

运行只有消费者2接收到信息  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAZm9yX2FfYmV0dGVyX2xpZmUg4oaR_size_13_color_FFFFFF_t_70_g_se_x_16]

#### 5、Topic模型 ####

与direct模型相比，多了个可以使用通配符！，这种模型Routingkey一般都是由一个或多个单词组成，多个单词之间以"."分割，例如：`item.insert`

> `*`号 匹配一个1词 , 例`audit.*`  
> `#`号匹配一个或多个词 `audit.#`

![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAZm9yX2FfYmV0dGVyX2xpZmUg4oaR_size_8_color_FFFFFF_t_70_g_se_x_16]  
生产者

public static void main(String[] args) throws IOException {
    		Connection connection = RabbitmqUtils.getConnection();
    		Channel channel = connection.createChannel();
    		// 声明交换机类型 topic
    		channel.exchangeDeclare("topics","topic");
    
    		// 发布消息
    		String routingKey = "user.save";
    		channel.basicPublish("topics",routingKey,null,("这是topic动态路由模型，routingKey："+routingKey).getBytes());
    
    		//关闭资源
    		RabbitmqUtils.closeConnectionAndChanel(channel,connection);
    	}

消费者1（使用通配符\*）

public static void main(String[] args) throws IOException {
    		// 获取连接
    		Connection connection = RabbitmqUtils.getConnection();
    		Channel channel = connection.createChannel();
    
    		//声明交换机以及交换机类型
    		channel.exchangeDeclare("topics","topic");
    		// 创建一个临时队列
    		String queue = channel.queueDeclare().getQueue();
    
    		// 绑定队列和交换机  动态通配符形式 routingKey
    		channel.queueBind(queue,"topics","user.*");
    
    		// 消费消息
    		channel.basicConsume(queue,true,new DefaultConsumer(channel){
    			@Override
    			public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
    				System.out.println("消费者1："+new String(body));
    			}
    		});
    	}

![在这里插入图片描述][6b1d29f37632461d9e7400e918f9f56f.png]也可两边\*号  
![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAZm9yX2FfYmV0dGVyX2xpZmUg4oaR_size_20_color_FFFFFF_t_70_g_se_x_16]

消费者2（使用通配符\#）

public static void main(String[] args) throws IOException {
    		// 获取连接
    		Connection connection = RabbitmqUtils.getConnection();
    		Channel channel = connection.createChannel();
    
    		//声明交换机以及交换机类型
    		channel.exchangeDeclare("topics","topic");
    		// 创建一个临时队列
    		String queue = channel.queueDeclare().getQueue();
    
    		// 绑定队列和交换机  动态通配符形式 routingKey
    		channel.queueBind(queue,"topics","user.#");
    
    		// 消费消息
    		channel.basicConsume(queue,true,new DefaultConsumer(channel){
    			@Override
    			public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
    				System.out.println("消费者1："+new String(body));
    			}
    		});
    	}

![在这里插入图片描述][5bd12b42a4f64980800d35430819d24c.png]

### 二、整合springboot ###

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

yml配置

spring:
      application:
        name: rabbitmq-springboot
        
      rabbitmq:
        host: 服务器ip
        port: 5672
        username: emstest
        password: guest
        virtual-host: /ems

> 队列是在消费者建立，只有生产者没有消费者不会建立

#### 1、hello word ####

生产者

// 注入rabbitTemplate
    	@Autowired
    	private RabbitTemplate rabbitTemplate;
    
    	// hell word
    	@Test
    	public void helloWordTest(){
        
    		rabbitTemplate.convertAndSend("hello","hello word");
    	}

消费者

@Component
    // 消费监听 ,指定队列名称
    @RabbitListener(queuesToDeclare = @Queue("hello"))
    public class HelloCustomer {
        
    	
    	@RabbitHandler
    	public void receivel(String message){
        
    		System.out.println("message = " + message);
    	}
    }

默认持久、非独占、不自动删除  
![在这里插入图片描述][23dc522db638404b9079a10c6b4700dd.png]

#### 2、work模型 ####

生产者

// work
    	@Test
    	public void workTest(){
        
    		for (int i = 0; i < 10; i++) {
        
    			rabbitTemplate.convertAndSend("work","work 模型");
    		}
    
    	}

公平消费  
消费者

@Component
    // @RabbitListener也作用在方法上
    public class WorkCustomer {
        
    	
    	@RabbitListener(queuesToDeclare = @Queue("work"))
    	public void receivel1(String message){
        
    		System.out.println("message = " + message);
    	}
    
    	@RabbitListener(queuesToDeclare = @Queue("work"))
    	public void receivel2(String message){
        
    		System.out.println("message2 = " + message);
    	}
    }

![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAZm9yX2FfYmV0dGVyX2xpZmUg4oaR_size_20_color_FFFFFF_t_70_g_se_x_16 1]

#### 3、publish/Subscribe(广播) ####

生产者

// fanout
    	@Test
    	public void fanoutTest(){
        
    		rabbitTemplate.convertAndSend("logList","","fanout模型发的消息");
    	}

消费者

@RabbitListener(bindings = {
        @QueueBinding(value = @Queue,exchange = @Exchange(value = "logList",type = "fanout"))})
    	public void reveivel(String message){
        
    		System.out.println("message = " + message);
    	}
    
    	@RabbitListener(bindings = {
        @QueueBinding(value = @Queue,exchange = @Exchange(value = "logList",type = "fanout"))})
    	public void reveivel2(String message){
        
    		System.out.println("message1 = " + message);
    	}
    
    	@RabbitListener(bindings = {
        @QueueBinding(value = @Queue,exchange = @Exchange(value = "logList",type = "fanout"))})
    	public void reveivel3(String message){
        
    		System.out.println("message2 = " + message);
    	}

![在这里插入图片描述][a5ae316599c944c2a1f3040c997fcfd4.png]

#### 4、Routing模型 ####

生产者

// 路由模型
    	@Test
    	public void routeTest(){
        
    		rabbitTemplate.convertAndSend("direstList","info","发送info的key的路由消息");
    	}

消费者1： 接收info、erroe消息  
消费者2：只接收error消息

@RabbitListener(bindings = {
        @QueueBinding(value = @Queue,exchange = @Exchange(value = "direstList",type = "direct"),key = {
        "info","error"})})
    	public void receivel(String message){
        
    		System.out.println("message = " + message);
    	}
    
    	@RabbitListener(bindings = {
        @QueueBinding(value = @Queue,exchange = @Exchange(value = "direstList",type = "direct"),key = {
        "error"})})
    	public void receivel1(String message){
        
    		System.out.println("message1 = " + message);
    	}

发送info消息  
![在这里插入图片描述][47269066d1dc43bf97b20ca8fa5261a5.png]发送error消息  
![在这里插入图片描述][26af28ba12f04f4c9fb5e40d5fe2b872.png]

#### 5、Topic模型 ####

生产者

// topic   动态路由  订阅模式
    	@Test
    	public void topicTest(){
        
    		rabbitTemplate.convertAndSend("topicList","user.save","topic路由消息,use.save");
    	}

消费者1：能消费，user.save , user.\*（*代表通配符，任意一个字段）  
消费者2: 能消费，user.* \* , order.\# (\#号代表一个或多个字段)

@RabbitListener(bindings = {
        @QueueBinding(value = @Queue,exchange = @Exchange(type = "topic",name = "topicList"),key = {
        "user.save","user.*"})})
    	public void recevicel(String message){
        
    		System.out.println("message = " + message);
    	}
    
    	@RabbitListener(bindings = {
        @QueueBinding(value = @Queue,exchange = @Exchange(type = "topic",name = "topicList"),key = {
        "order.#","user.*"})})
    	public void recevicel1(String message){
        
    		System.out.println("message1 = " + message);
    	}

发送 user.save消息  
![在这里插入图片描述][f8c67a6618374bdcb98be71631b44801.png]  
发送order.save.update消息  
![在这里插入图片描述][dcf9924e21de4264ac58e035ec8e4121.png]

#### 6、发送对象 ####

![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAaG1i4oaR_size_20_color_FFFFFF_t_70_g_se_x_16]接收对象改为map,如果是实体类要实现Serializable序列化  
![在这里插入图片描述][e086167d64a0489fb052f5144d3b7623.png]

### 三、业务场景 ###

#### 1、异步 ####

如： 用户注册发送，注册邮件、注册短信，  
`传统做法`：  
1、串行 （先发送邮件、再发短信）。问题：持续时间长  
![在这里插入图片描述][806f5e7d006a425da22edd4c7a428364.png]

2、并行（将注册信息写入数据库后，同时发送邮件、短信），速度快、但不能满足高吞吐需求。

![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAZm9yX2FfYmV0dGVyX2xpZmUg4oaR_size_15_color_FFFFFF_t_70_g_se_x_16]

`消息队列做法`：  
![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAZm9yX2FfYmV0dGVyX2xpZmUg4oaR_size_19_color_FFFFFF_t_70_g_se_x_16]

将数据写入数据库、同时发送消息给发送邮件和注册，异步处理

#### 2、应用解耦 ####

如：双十一购物节，用户下单后、订单系统通知库存系统。  
`传统做法`:  
![在这里插入图片描述][0b49718d7bc046b2ac8d8a1517ebe24b.png]

订单系统调用库存系统接口。问题：库存接口故障，订单就会失败，而损失大量订单

`消息队列做法`  
![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAZm9yX2FfYmV0dGVyX2xpZmUg4oaR_size_13_color_FFFFFF_t_70_g_se_x_16]

订单系统：下单，订单系统完成持久化，将消息写入队列，返回下单成功给用户  
库存系统：订阅下单的消息，获取下单消息，进行库操作，就算库存系统故障，消息队列也能保证消息可靠投递，不会导致消息丢失。

#### 3、流量削峰 ####

如：秒杀活动、一般会因为流量过大，导致应用挂掉，一般在应用前端加入消息队列。  
作用：1、可以控制活动人数，超过一定阈值，订单直接丢弃  
2、可以缓解短时间的高流量压垮应用（应用程序按自己的最大处理能力获取订单）  
![在这里插入图片描述][0529c315bc5540cb89f9585f9e9cc2be.png]

1、用户的请求，服务器收到后，首先写入消息队列，加入消息队列长度最大值，则直接抛弃用户请求或跳转到错误页面  
2、秒杀业务根据消息队列中的请求信息，再做后续处理

### 四、集群 ###

#### 1、普通集群 ####

![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAZm9yX2FfYmV0dGVyX2xpZmUg4oaR_size_20_color_FFFFFF_t_70_g_se_x_16 2]

1、新建三个docker容器

docker run -d --hostname rabbit1 --name myrabbit1  -v /home/rabbitmq/data:/var/lib/rabbitmq -p 15671:15672 -p 5671:5672 rabbitmq
    
    docker run -d --hostname rabbit2 --name myrabbit2  -v /home/rabbitmq/data:/var/lib/rabbitmq -p 15672:15672 -p 5672:5672 --link myrabbit1:rabbit1 rabbitmq
    
    docker run -d --hostname rabbit3 --name myrabbit3  -v /home/rabbitmq/data:/var/lib/rabbitmq -p 15673:15672 -p 5673:5672 --link myrabbit1:rabbit1 --link myrabbit2:rabbit2 rabbitmq

2、三个都进入容器下载可视化工具

![步骤在上方][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAZm9yX2FfYmV0dGVyX2xpZmUg4oaR_size_16_color_FFFFFF_t_70_g_se_x_16]3、进入第一个mq容器重启

docker exec -it ef4a1f0fade7 /bin/bash
    rabbitmqctl stop_app
    rabbitmqctl reset
    rabbitmqctl start_app
    exit

4、进入第二个 和 第三个 mq容器执行

docker exec -it e36d94d40008 /bin/bash
    rabbitmqctl stop_app
    rabbitmqctl reset
    rabbitmqctl join_cluster --ram rabbit@rabbit1   //如遇到报错再执行上句、再继续执行
    rabbitmqctl start_app
    exit

5、进去mq可视化界面，overview面板中的Nodes可查看到节点信息。  
![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAZm9yX2FfYmV0dGVyX2xpZmUg4oaR_size_17_color_FFFFFF_t_70_g_se_x_16]  
6、测试，在mq上新建交换机、其余两个也出现新建的交换机  
![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAZm9yX2FfYmV0dGVyX2xpZmUg4oaR_size_20_color_FFFFFF_t_70_g_se_x_16 3]此时普通集群以构建完成

> 1、此种集群主节点down掉后，消费者也无法消费从节点的消息，不能做故障转移，只能当作备份。  
> 2、主节点正常，从节点则可以消费消息

#### 2、镜像集群（高可用）（推荐） ####

这种集群弥补第一种的缺陷，需在普通集群的基础下搭建（确保第一种集群可用）

> 镜像队列机制就是将队列在三个节点之间设置主从关系，消息会在三个节点之间进行自动同步，且如果其中一个节点不可用，并不会导致消息丢失或服务不可用的情况，提升mq集群的高可用性。

![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAZm9yX2FfYmV0dGVyX2xpZmUg4oaR_size_20_color_FFFFFF_t_70_g_se_x_16 4]1、配置集群架构  
![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAZm9yX2FfYmV0dGVyX2xpZmUg4oaR_size_20_color_FFFFFF_t_70_g_se_x_16 5]2、进入任意节点配置策略

docker exec -it ef4a1f0fade7 /bin/bash
    
    
    rabbitmqctl set_policy ha-all "^rabbitmq" '{"ha-mode":"all","ha-sync-mode":"automatic"}'

3、测试，新建一个rabbitmq开头的队列  
![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAZm9yX2FfYmV0dGVyX2xpZmUg4oaR_size_18_color_FFFFFF_t_70_g_se_x_16]

> 此时某个节点down掉（包括主节点），其余节点也能消费

将主节点down掉，节点自动切换  
![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAZm9yX2FfYmV0dGVyX2xpZmUg4oaR_size_18_color_FFFFFF_t_70_g_se_x_16 1]  
4、清除策略

rabbitmqctl clear_policy ha-all

### 五、与其他mq的区别 ###

![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAaG1i4oaR_size_20_color_FFFFFF_t_70_g_se_x_16 1]

[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6LS154y_5qKm_size_20_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/7554e7d5c3074577907b066152d6e2cb.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA6LS154y_5qKm,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6LS154y_5qKm_size_20_color_FFFFFF_t_70_g_se_x_16 1]: https://img-blog.csdnimg.cn/01ac882498234650a70a283b94da8590.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA6LS154y_5qKm,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6LS154y_5qKm_size_20_color_FFFFFF_t_70_g_se_x_16 2]: https://img-blog.csdnimg.cn/c374cb63fc174cf3ac8f4339fed13dda.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA6LS154y_5qKm,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6LS154y_5qKm_size_20_color_FFFFFF_t_70_g_se_x_16 3]: https://img-blog.csdnimg.cn/f2dcd3582e6244cbb6f7bbf17c9a4864.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA6LS154y_5qKm,size_20,color_FFFFFF,t_70,g_se,x_16
[963af96ed5a84e08b6bdcf783db2b70f.png]: https://img-blog.csdnimg.cn/963af96ed5a84e08b6bdcf783db2b70f.png
[613818ec4f724b3d89742bc3631904ab.png]: https://img-blog.csdnimg.cn/613818ec4f724b3d89742bc3631904ab.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAZm9yX2FfYmV0dGVyX2xpZmUg4oaR_size_6_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/1c346d6344cc4b39aef144b67b061864.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAZm9yX2FfYmV0dGVyX2xpZmUg4oaR,size_6,color_FFFFFF,t_70,g_se,x_16
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAZm9yX2FfYmV0dGVyX2xpZmUg4oaR_size_6_color_FFFFFF_t_70_g_se_x_16 1]: https://img-blog.csdnimg.cn/73c338d48d36415299f3f63be8d7d3a3.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAZm9yX2FfYmV0dGVyX2xpZmUg4oaR,size_6,color_FFFFFF,t_70,g_se,x_16
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAZm9yX2FfYmV0dGVyX2xpZmUg4oaR_size_20_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/0f40406683bc4c56b1072c31b192107a.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAZm9yX2FfYmV0dGVyX2xpZmUg4oaR,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAZm9yX2FfYmV0dGVyX2xpZmUg4oaR_size_15_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/805e9a6127484f86a92889a909f71e38.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAZm9yX2FfYmV0dGVyX2xpZmUg4oaR,size_15,color_FFFFFF,t_70,g_se,x_16
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAZm9yX2FfYmV0dGVyX2xpZmUg4oaR_size_6_color_FFFFFF_t_70_g_se_x_16 2]: https://img-blog.csdnimg.cn/41c9a7bd40fd445f9bde1a3da2b699f7.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAZm9yX2FfYmV0dGVyX2xpZmUg4oaR,size_6,color_FFFFFF,t_70,g_se,x_16
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAZm9yX2FfYmV0dGVyX2xpZmUg4oaR_size_13_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/263e58bf73c940aba07fa91602a6af22.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAZm9yX2FfYmV0dGVyX2xpZmUg4oaR,size_13,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAZm9yX2FfYmV0dGVyX2xpZmUg4oaR_size_8_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/21ddd0e28c5343689b542485a5397011.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAZm9yX2FfYmV0dGVyX2xpZmUg4oaR,size_8,color_FFFFFF,t_70,g_se,x_16
[6b1d29f37632461d9e7400e918f9f56f.png]: https://img-blog.csdnimg.cn/6b1d29f37632461d9e7400e918f9f56f.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAZm9yX2FfYmV0dGVyX2xpZmUg4oaR_size_20_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/355860171b5f45ed90df20aeef6a383f.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAZm9yX2FfYmV0dGVyX2xpZmUg4oaR,size_20,color_FFFFFF,t_70,g_se,x_16
[5bd12b42a4f64980800d35430819d24c.png]: https://img-blog.csdnimg.cn/5bd12b42a4f64980800d35430819d24c.png
[23dc522db638404b9079a10c6b4700dd.png]: https://img-blog.csdnimg.cn/23dc522db638404b9079a10c6b4700dd.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAZm9yX2FfYmV0dGVyX2xpZmUg4oaR_size_20_color_FFFFFF_t_70_g_se_x_16 1]: https://img-blog.csdnimg.cn/1f09b2d20ffe426a82107b1fe4e5d3e5.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAZm9yX2FfYmV0dGVyX2xpZmUg4oaR,size_20,color_FFFFFF,t_70,g_se,x_16
[a5ae316599c944c2a1f3040c997fcfd4.png]: https://img-blog.csdnimg.cn/a5ae316599c944c2a1f3040c997fcfd4.png
[47269066d1dc43bf97b20ca8fa5261a5.png]: https://img-blog.csdnimg.cn/47269066d1dc43bf97b20ca8fa5261a5.png
[26af28ba12f04f4c9fb5e40d5fe2b872.png]: https://img-blog.csdnimg.cn/26af28ba12f04f4c9fb5e40d5fe2b872.png
[f8c67a6618374bdcb98be71631b44801.png]: https://img-blog.csdnimg.cn/f8c67a6618374bdcb98be71631b44801.png
[dcf9924e21de4264ac58e035ec8e4121.png]: https://img-blog.csdnimg.cn/dcf9924e21de4264ac58e035ec8e4121.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAaG1i4oaR_size_20_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/93b1ade360f94d08a5419797e2e97ef9.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAaG1i4oaR,size_20,color_FFFFFF,t_70,g_se,x_16
[e086167d64a0489fb052f5144d3b7623.png]: https://img-blog.csdnimg.cn/e086167d64a0489fb052f5144d3b7623.png
[806f5e7d006a425da22edd4c7a428364.png]: https://img-blog.csdnimg.cn/806f5e7d006a425da22edd4c7a428364.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAZm9yX2FfYmV0dGVyX2xpZmUg4oaR_size_15_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/7401a14dee8d40309cbd24d912476a90.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAZm9yX2FfYmV0dGVyX2xpZmUg4oaR,size_15,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAZm9yX2FfYmV0dGVyX2xpZmUg4oaR_size_19_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/65be554f1945449893927b55bef4ddfb.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAZm9yX2FfYmV0dGVyX2xpZmUg4oaR,size_19,color_FFFFFF,t_70,g_se,x_16
[0b49718d7bc046b2ac8d8a1517ebe24b.png]: https://img-blog.csdnimg.cn/0b49718d7bc046b2ac8d8a1517ebe24b.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAZm9yX2FfYmV0dGVyX2xpZmUg4oaR_size_13_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/537baaee30da4af182e4ff502456d4e5.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAZm9yX2FfYmV0dGVyX2xpZmUg4oaR,size_13,color_FFFFFF,t_70,g_se,x_16
[0529c315bc5540cb89f9585f9e9cc2be.png]: https://img-blog.csdnimg.cn/0529c315bc5540cb89f9585f9e9cc2be.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAZm9yX2FfYmV0dGVyX2xpZmUg4oaR_size_20_color_FFFFFF_t_70_g_se_x_16 2]: https://img-blog.csdnimg.cn/64b664e98cab4b08a6d1b9f54a4c5f4d.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAZm9yX2FfYmV0dGVyX2xpZmUg4oaR,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAZm9yX2FfYmV0dGVyX2xpZmUg4oaR_size_16_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/d2dae7b20f7147cfbce512acf3e39def.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAZm9yX2FfYmV0dGVyX2xpZmUg4oaR,size_16,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAZm9yX2FfYmV0dGVyX2xpZmUg4oaR_size_17_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/c068857cba534db9bfcc26205e787e0c.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAZm9yX2FfYmV0dGVyX2xpZmUg4oaR,size_17,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAZm9yX2FfYmV0dGVyX2xpZmUg4oaR_size_20_color_FFFFFF_t_70_g_se_x_16 3]: https://img-blog.csdnimg.cn/a1c80083f0784548aa94fc2a7ed5fe93.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAZm9yX2FfYmV0dGVyX2xpZmUg4oaR,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAZm9yX2FfYmV0dGVyX2xpZmUg4oaR_size_20_color_FFFFFF_t_70_g_se_x_16 4]: https://img-blog.csdnimg.cn/803a650eafed40759ff97063c4bc5d6a.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAZm9yX2FfYmV0dGVyX2xpZmUg4oaR,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAZm9yX2FfYmV0dGVyX2xpZmUg4oaR_size_20_color_FFFFFF_t_70_g_se_x_16 5]: https://img-blog.csdnimg.cn/b8102265828049ebb9be0b064abc97be.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAZm9yX2FfYmV0dGVyX2xpZmUg4oaR,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAZm9yX2FfYmV0dGVyX2xpZmUg4oaR_size_18_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/00859e1e17a34641b530ebb97b0117c1.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAZm9yX2FfYmV0dGVyX2xpZmUg4oaR,size_18,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAZm9yX2FfYmV0dGVyX2xpZmUg4oaR_size_18_color_FFFFFF_t_70_g_se_x_16 1]: https://img-blog.csdnimg.cn/c2d503ab7e90413a9d046f02fd8d5e80.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAZm9yX2FfYmV0dGVyX2xpZmUg4oaR,size_18,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAaG1i4oaR_size_20_color_FFFFFF_t_70_g_se_x_16 1]: https://img-blog.csdnimg.cn/138b99bafc144991a08cb019b2cbdb68.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAaG1i4oaR,size_20,color_FFFFFF,t_70,g_se,x_16