rabbitmq学习笔记

RabbitMQ

1. AMQP 简介
   进程之间传递异步消息的一种网络协议（是什么）

   生产者生产消息给交换机，交换机根据消息里面的路由键将消息推给匹配的队列，消费者从指定的队列拿消息，或者被动接受。（流程）

2. RabbitMQ 简介
   Erlang写的一个实现了AMQP协议的软件（是什么）

抢红包、秒杀活动、下订单、消息分发、处理耗时任务、流量削峰、应用耦合（应用）

3. RabbitMQ 原理
   消息：包含消息头（routing-key、priority、delivery-mode）和消息体
   routing-key:Exchange根据routing-key选择消息发给哪一个/几个队列

   可以是 rk1 => q1;rk2 => q2 ;rk3 => q3
   这种direct类型的，一个key对应一个队列，默认的就是这种

   还可以是 没有routing-key，
   这种finout类型的，来了消息就发送给所有队列

   还可以是 *.l.k; 3.l.k; 7.m.k
   这种topic类型的，来一个消息头 routing-key是1.l.k就进黑洞，扔掉。
   来一个3.l.k的消息，就发给 第一个，星.l.k和3.l.k这两个队列！！

priority：消息处理的优先级
delivery-mode:队列是否一直存在，AD自动删除，D一直在

5. Erlang 安装

6. 安装 RabbitMQ

7. RabbitMQ 账户管理
   https://blog.csdn.net/qq_32097903/article/details/113036712
   安装rabbitmq完成。在这篇文章中。

8. 交换器
   direct
   代码项目截图
   maven项目
   
   创建一个maven项目amqp_rabbitmq
   pom.xml配置

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.bjsxt</groupId>
    <artifactId>amqp_rabbit</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>amqp_rabbit_consumer</module>
        <module>amqp_rabbit_publisher</module>
    </modules>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>2.2.5.RELEASE</version>
                <scope>import</scope>
                <type>pom</type>
            </dependency></dependencies>
    </dependencyManagement>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

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

消费者
创建子模块amqp_rabbit_consumer
创建消费者InfoLogConsumer，编写消费消息的方法
重点是用了@RabbitLisener这个注解，会创建出交换器、队列、路由键

package com.bjsxt.rabbitmq.consumer;

import org.springframework.amqp.rabbit.annotation.*;
import org.springframework.stereotype.Component;

@RabbitListener(bindings={
        @QueueBinding(
                value = @Queue(value="log-info-queue",autoDelete = "false"),
                exchange = @Exchange(value = "log-ex-direct",type="direct",autoDelete = "false"),
                key="direct-rk-info"
        )
})
@Component
public class LogInfoConsumer {
    @RabbitHandler
    public void onMessage(String msg) {
        System.out.println("LogInfoConsumer 消费消息："+msg);
    }
}

package com.bjsxt.rabbitmq.consumer;

import org.springframework.amqp.rabbit.annotation.Exchange;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.QueueBinding;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class LogConsumers {
    @RabbitListener(bindings={
            @QueueBinding(
                    value = @Queue(value="log-error-queue",autoDelete = "false"),
                    exchange = @Exchange(value = "log-ex-direct",type="direct",autoDelete = "false"),
                    key="direct-rk-error"
            )
    })
    public void onErrorMessage(String msg) {
        System.out.println("错误日志消息消费 "+msg);
    }
    @RabbitListener(bindings={
            @QueueBinding(
                    value = @Queue(value="log-warn-queue",autoDelete = "false"),
                    exchange = @Exchange(value = "log-ex-direct",type="direct",autoDelete = "false"),
                    key="direct-rk-warn"
            )
    })
    public void onWarnMessage(String msg) {
        System.out.println("警告日志消息消费 "+msg);
    }
}

创建配置文件application.yml，用来链接rabbitmq

spring:
  rabbitmq:
    host: localhost
    port: 5672 #tcp port
    username: qst
    password: qst
    virtual-host: /

生产者
建立子模块amqp_rabbit_publisher
建立生产消息的类
LogMessageSender
重点是引入了amqp模板操作rabbitmq，发送消息时调用这个模板发送的

package com.bjsxt.rabbit.sender;

import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class LogMessageSender {
    @Autowired
    private AmqpTemplate template;

    public void sendMessage(String exchange,String routingKey,String message){
        this.template.convertAndSend(exchange,routingKey,message);
    }
}

创建启动模块的类

package com.bjsxt;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class RabbitPublisherApp {
    public static void main(String[] args) {
        SpringApplication.run(RabbitPublisherApp.class，args);
    }
}

别忘了配置文件，用来是的生产者和rabbitmq连接上

spring:
  rabbitmq:
    host: localhost
    username: qst
    password: qst

如果想要有多个消费者处理消息
如果是一台服务器上直接复制一个消费者启动类，分别启动。如果是异机，直接分别部署代码启动。

运行结果截图：
建立测试类

package com.bjsxt.test;

import com.bjsxt.rabbit.sender.LogMessageSender;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@SpringBootTest
@RunWith(SpringRunner.class)
public class TestPublisher {
    @Autowired
    private LogMessageSender sender;
    private String exchange = "log-ex-direct";
    private String errorLogRk = "direct-rk-error";
    private String infoLogRk = "direct-rk-info";
    private String warnLogRk = "direct-rk-warn";

    @Test
    public void testPublisher(){
        for(int i =0;i<10;i++) {
            this.sender.sendMessage(this.exchange,this.infoLogRk,"info log content is "+i);
            this.sender.sendMessage(this.exchange,this.errorLogRk,"error log content is "+i);
            this.sender.sendMessage(this.exchange,this.warnLogRk,"warn log content is "+i);
        }
    }
}

先运行RabbitConsumerApp，运行成功了

界面上显示交换器和队列名称，证明注解创建了交换器和队列

交换器多了一个

队列增加三个

然后启动RabbitPublisherApp,生产者

然后启动测试类

推送数据给交换器，数据包含，交换器名称，路由键（这两个就是消息头），消息体
查看控制台（消费者）

查看控制台（生产者）
已经结束
查看rabbitmq界面
交换器

队列

关闭测试

消息消费者仍然从队列中取数据

一段时间后队列中的消息被消费完

此时消费者仍然在运行中，等待着接受消息数据。

总结：

rabbitmq使用方式，先下载安装erlang，在下载安装rabbitmq，配置好账号，密码，授权，角色。

rabbitmq流程，基于amqp协议，因此就是amqp建议的流程，就是，消息发送者将消息发送给交换器。消息包含消息头，消息体，消息头中包含路由键。交换器根据路由键将消息转发给对应的消息队列。消费者消费。

实现，消费者知晓消息队列，交换器，路由键。当启动一个消费者，会根据rabbitmq注解创建交换器，路邮件，消息队列。当启动一个测试类，调用生产者发送消息接口，源源不断发送消息（交换器，路由键，消息体）给rabbitmq。
rabbitmq的交换器接收消息，根据路邮件，将消息转发给消息队列，消费者消费消息。