RabbitMQ

同步调用：一次只能干一件事

同步调用的优点：
时效性高，可以立即得到结果

同步调用的问题：

耦合度高
性能下降
有额外的资源消耗
有级联失败的问题

异步通信：一次可以同时做很多事

优点：

耦合度低
性能提升
故障隔离
流量削峰

缺点：

依赖于Broker(事件代理者)的可靠性，安全性，性能提升能力
架构变得更加复杂

MQ(MessageQueue)

MQ就是消息队列，就是事件驱动架构中的Broker

常用的MQ:RabbitMQ,ActiveMQ,RocketMQ,Kafka

docker安装RabbitMq

第一步：拉取镜像

docker pull rabbitmq:3.8-management

第二步：启动rabbitmq

方式一：直接启动

docker run \
 -e RABBITMQ_DEFAULT_USER=hhh \
 -e RABBITMQ_DEFAULT_PASS=1234 \
 -v mq-plugins:/plugins \
 --name mq \
 --hostname mq \
 -p 15672:15672 \
 -p 5672:5672 \
 -d \
 rabbitmq:3.8-management

# 设置环境变量  用户名是 hhh
 -e RABBITMQ_DEFAULT_USER=hhh \
 # 设置环境变量  密码是 1234
 -e RABBITMQ_DEFAULT_PASS=1234 \
 # 挂载数据卷，如果没有该数据卷会自己创建
 -v mq-plugins:/plugins \
 # mq的名字
 --name mq \
 # 主机名 这里不配置也可以
 --hostname mq \
 # web可视化终端监控端口；mq的ui界面管理平台端口
 -p 15672:15672 \
 # 程序与mq交互的访问端口；发消息和收消息的端口
 -p 5672:5672 \
 # 后端运行
 -d \
 # 镜像名称
 rabbitmq:3.8-management

[root@localhost docker-compose]# docker ps -a
CONTAINER ID   IMAGE                     COMMAND                   CREATED          STATUS          PORTS                                                                                                                                                 NAMES
ea34ab693409   rabbitmq:3.8-management   "docker-entrypoint.s…"   45 seconds ago   Up 44 seconds   4369/tcp, 5671/tcp, 0.0.0.0:5672->5672/tcp, :::5672->5672/tcp, 15671/tcp, 15691-15692/tcp, 25672/tcp, 0.0.0.0:15672->15672/tcp, :::15672->15672/tcp   mq

启动成功

方式二：使用docker-compose创建并运行容器

我们先把之前创建的容器删除

docker rm -f mq

yml文件内容

version: "3.2"
services:
  mysql:
    image: mysql:5.7.25  #使用的镜像
    container_name: mysql_container #容器名字
    environment:
      MYSQL_ROOT_PASSWORD: 1234
    volumes:    #数据卷，绑定容器内的文件和宿主机文件
      - "/tmp/mysql/data:/var/lib/mysql"
      - "/tmp/mysql/conf/my.cnf:/etc/mysql/conf.d/my.cnf"
    ports:
      - "3306:3306"
  radditmq:
    image: rabbitmq:3.8-management
    container_name: mq
    environment:
      RABBITMQ_DEFAULT_USER: hhh
      RABBITMQ_DEFAULT_PASS: 1234
    volumes:
      - "mq-plugins:/plugins"
    ports:
      - "15672:15672"
      - "5672:5672"
volumes:
  mq-plugins: {} #要创建的数据卷

在yml文件所在目录使用命令

docker-compose up -d

[root@localhost docker-compose]# ll
总用量 4
-rw-r--r--. 1 root root 653 8月  19 12:06 docker-compose.yml
drwxr-xr-x. 2 root root  39 8月  18 21:35 myweb-service
[root@localhost docker-compose]# docker up -d

运行成功

[root@localhost docker-compose]# docker ps -a
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
1faf568f83de mysql:5.7.25 "docker-entrypoint.s…" 45 seconds ago Up 44 seconds 0.0.0.0:3306->3306/tcp, :::3306->3306/tcp, 33060/tcp mysql_container
ea34ab693409 rabbitmq:3.8-management "docker-entrypoint.s…" 45 seconds ago Up 44 seconds 4369/tcp, 5671/tcp, 0.0.0.0:5672->5672/tcp, :::5672->5672/tcp, 15671/tcp, 15691-15692/tcp, 25672/tcp, 0.0.0.0:15672->15672/tcp, :::15672->15672/tcp mq

RabbitMQ消息模型

一.基本消息队列（BasicQueue）

生产者将消息发送到队列，消费者从队列中获取消息，队列是存储消息的缓冲区。

二. 工作消息队列（WorkQueue）

工作消息队列是基本消息队列的增强版，具有多个消费者消费队列的消息。假设消息队列中积压了多个消息，那么此时可以使用多个消费者来消费队列中的消息。效率要比基本消息队列模型高。

三.发布订阅（Publish、Subscribe）

1.Fanout Exchange：广播

将消息交给所有绑定到交换机的队列,生产者发送的消息，只能发送到交换机，交换机来决定要发给哪个队列，生产者无法决定。交换机把消息发送给绑定过的****所有队列.队列的消费者都能拿到消息。实现一条消息被多个消费者消费.

2.Direct Exchange：路由

在广播模式中，生产者发布消息，所有消费者都可以获取所有消息.

使用路由模式时，生产者向Exchange发送消息，发送消息时，会指定一个routing key

Exchange（交换机）接收生产者的消息后，就会把把消息递交给与routing key完全匹配的队列

3.topic Exchange：主题

1.Topic类型的Exchange与Direct相比，都是可以根据RoutingKey把消息路由到不同的队列。只不过Topic类型Exchange可以让队列在绑定Routing key 的时候使用通配符！

2.Routingkey 一般都是有一个或多个单词组成，多个单词之间以”.”分割，例如： item.insert

3.通配符规则：
#
：匹配一个或多个词
*
：匹配恰好1个词

SpringAMQP

第一步：先创建一个SpringBoot项目，然后在当前项目创建出两个新的模块，分别命名为publisher,consumer。

第二步：修改主项目的打包方式为pom,java版本为1.8,springboot版本为2.3.10.RELEASE，并导入amqp的依赖

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.10.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.hhh</groupId>
    <artifactId>spring_day10_mq</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>spring_day10_mq</name>
    <description>spring_day10_mq</description>
    <packaging>pom</packaging>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <!--AMQP依赖，包含RabbitMQ-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

第三步：让两个模块继承这个主项目的依赖，使用<parent>标签

注意：模块的<artifactId>publisher</artifactId>不能少

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.hhh</groupId>
        <artifactId>spring_day10_mq</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <artifactId>publisher</artifactId>
</project>

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.hhh</groupId>
        <artifactId>spring_day10_mq</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <artifactId>consumer</artifactId>
</project>

第四步：在两个子模块下的applicaton.yml文件下配置连接RabbitMQ的信息

logging:
  pattern:
    dateformat: MM-dd HH:mm:ss:SSS   #日志文件的格式
spring:
  rabbitmq:
    host: 192.168.230.100  # 主机名
    port: 5672 # 发送消息和接收消息的端口号
    virtual-host: / # 虚拟主机
    username: hhh # 用户名
    password: 1234 # 密码

使用SpringAMQP处理基本消息队列

第一步：在publisher模块中书写发送消息队列的类

@RunWith(SpringRunner.class)//TODO:是一个测试启动器，可以加载SpringBoot测试注解,让测试方法在Spring容器环境下执行
@SpringBootTest
public class BaseMessage {
    @Autowired
    RabbitTemplate rabbitTemplate;
    @Test
    public void simpleMessage(){
        //1.定义队列名字
        String queue="simple.queue";
        //2.定义消息内容
        String msg="你好，这是hhh发送的消息";
        //3.发送消息
        rabbitTemplate.convertAndSend(queue,msg);
    }
}

点击发送之后，可以发现消息队列的总数变成1

第二步：在consumer模块书写接收消息队列的类

//TODO:把这个交给Spring容器管理
@Component
public class BaseMessageListener {
    @RabbitListener(queues = "simple.queue")//只接受simple.queue队列的消息
    public void getBaseMassage(String msg){//定义参数来接收消息
        System.out.println(msg);
    }
}

启动SpringBoot引导类

接收成功，消息队列总数变成0

使用SpringAMQP处理工作消息队列

思路就是使用多个监听类，来接收同一个消息队列的消息

publisher模块中发送消息的类

@Test
    public void workMessage(){
        //1.定义队列名字
        String queue="simple.queue";
        //2.定义消息
        String msg="这是工作消息";
        //3.发送消息
        for(int i=0;i<50;i++){
            rabbitTemplate.convertAndSend(queue,msg+i);
        }
    }

consumer模块中接收消息的类

public class BaseMessageListener {
    @RabbitListener(queues = "simple.queue")
    public void getWorkMessage1(String msg) throws InterruptedException {
        System.out.println("这是消费者1:"+msg);
        Thread.sleep(20);//休息20毫秒
    }
    @RabbitListener(queues = "simple.queue")
    public void getWorkMessage2(String msg) throws InterruptedException {
        System.out.println("这是消费者2:"+msg);
        Thread.sleep(50);//休息50毫秒
    }
}

启动后发现这两个消费者类是平分了这些消息

是因为消息队列会把消息分配平均交给负责监听此消息队列的类，这样做的弊端就是，有的消费者类很快就能执行完，而有可能会很满，导致效率底下，所以我们可以进行修改

在consumer模块中的application.yml文件中添加prefetch

spring:
  rabbitmq:
    host: 192.168.230.100   #主机名
    port: 5672        #用于发送信息和接收信息的端口号
    virtual-host: /    #虚拟主机
    username: hhh    #用户名
    password: 1234 #密码
    listener:
      simple:
        prefetch: 1

prefetch:
预取:**每次将队列中的消息发送给消费者一个消息，等消费者处理完后再继续给一个消息**
这样一来，处理消息快的消费者就会处理更多的消息
不修改之前，是把消息队列里的消息进行平分

可以发现处理快的消费者就可以处理更多的消息

使用SpringAMQP处理发布订阅之广播

在广播模式下，消息发送流程是这样的：

1）可以有多个队列

2）每个队列都要绑定到Exchange（交换机）

3）生产者发送的消息，只能发送到交换机，交换机来决定要发给哪个队列，生产者无法决定

4）交换机把消息发送给绑定过的所有队列

5）订阅队列的消费者都能拿到消息

因此我们要

创建一个交换机 itcast.fanout，类型是Fanout

创建两个队列fanout.queue1和fanout.queue2，绑定到交换机itcast.fanout

publisher模块中发送消息的类

@RunWith(SpringRunner.class)
@SpringBootTest
public class FanoutMessage {
    @Autowired
    private RabbitTemplate rabbitTemplate;
    @Test
    public void test(){
        //定义交换机名字
        String exchangeName="hhh.fanout";
        //定义消息
        String msg="你好呀，fanout";
        //发送消息
//第二个参数是RoutingKey,因为这里使用的广播类型（让于其绑定的消息队列都收到消息），所以设置为空
        rabbitTemplate.convertAndSend(exchangeName,"",msg);
    }
}

consumer模块中接收消息的类

@Component
public class FanoutListener {
    //这里创建了一个消息队列fanout.queue1，和一个fanout类型的交换机（如果本来存在就不会重新创建），并且绑定
    //绑定的同时也指定了这个类监听消息队列fanout.queue1
    @RabbitListener(bindings = @QueueBinding(value = @Queue("fanout.queue1"),
        exchange = @Exchange(name="hhh.fanout",type = ExchangeTypes.FANOUT)
    ))
    public void getFanoutMessage1(String msg){
        System.out.println("这是消费者1:"+msg);
    }
    @RabbitListener(bindings = @QueueBinding(value = @Queue("fanout.queue2"),
            exchange =@Exchange(name="hhh.fanout",type = ExchangeTypes.FANOUT)
    ))
    public void getFanoutMessage2(String msg){
        System.out.println("这是消费者2:"+msg);
    }
}

结果：两个消费者（都与交换机进行绑定）都可以接收到消息

我们也可以使用配置类来创建交换机和队列，并绑定

@Configuration
public class FanoutConfig {
    //创建fanoutExchange交换机，并交给IoC容器，bean id 为getFanoutExchange
    @Bean
    public FanoutExchange getFanoutExchange(){
        return new FanoutExchange("hhh.fanout");
    }
    //创建消息队列1，并交给IoC容器，bean id 为getQueue1
    @Bean
    public Queue getQueue1(){
        return new Queue("fanout.queue1");
    }
    //创建消息队列2，并交给IoC容器，bean id 为getQueue2
    @Bean
    public Queue getQueue2(){
        return new Queue("fanout.queue2");
    }
    //TODO:将消息队列绑定到交换机上
    //TODO:注意：由于SpringBoot会帮我们创建交换器类型，和Queue类型的bean,而我们又自己创建了相同类型的bean
    //我们这里要指定bean的名字，不然Spring自动装配就会报错，不知道要装配哪个bean
    //TODO:因此我们要让Spring根据bean的id来进行注入
    @Bean
    public Binding bindingQueue1ToExchange(FanoutExchange getFanoutExchange,Queue getQueue1){
       return BindingBuilder.bind(getQueue1).to(getFanoutExchange);
    }
    @Bean
    public Binding bindingQueue2ToExchange(FanoutExchange getFanoutExchange,Queue getQueue2){
        return BindingBuilder.bind(getQueue2).to(getFanoutExchange);
    }
}

@Component
public class FanoutListener {
    //这里创建了一个消息队列fanout.queue1，和一个fanout类型的交换机（如果本来存在就不会重新创建），并且绑定
    //绑定的同时也指定了这个类监听消息队列fanout.queue1
   /* @RabbitListener(bindings = @QueueBinding(value = @Queue("fanout.queue1"),
        exchange = @Exchange(name="hhh.fanout",type = ExchangeTypes.FANOUT)
    ))*/
    @RabbitListener(queues = "fanout.queue1")
    public void getFanoutMessage1(String msg){
        System.out.println("这是消费者1:"+msg);
    }
    /*@RabbitListener(bindings = @QueueBinding(value = @Queue("fanout.queue2"),
            exchange =@Exchange(name="hhh.fanout",type = ExchangeTypes.FANOUT)
    ))*/
    @RabbitListener(queues = "fanout.queue2")
    public void getFanoutMessage2(String msg){
        System.out.println("这是消费者2:"+msg);
    }
}

使用SpringAMQP处理发布订阅之路由

在Direct模型下：

队列与交换机的绑定，不能是任意绑定了，而是要指定一个RoutingKey（路由key）

消息的发送方在向 Exchange发送消息时，也必须指定消息的 RoutingKey。

Exchange不再把消息交给每一个绑定的队列，而是根据消息的Routing Key进行判断，只有队列的Routingkey与消息的 Routing key完全一致，才会接收到消息

consumer模块中接收消息的类

@Configuration
public class DirectMessageListener {
    @RabbitListener(bindings = @QueueBinding(value = @Queue("direct.queue1"),
        exchange = @Exchange(name="hhh.direct",type= ExchangeTypes.DIRECT),
            key = {"yellow","red"} //指定这个消息队列绑定的RouterKey
    ))
    public void getDirectMessage1(String msg){
        System.out.println("这是消费者1:"+msg);
    }
    @RabbitListener(bindings = @QueueBinding(value = @Queue("direct.queue"),
        exchange = @Exchange(name="hhh.direct",type=ExchangeTypes.DIRECT),
            key={"yellow","blue"} //指定这个消息队列绑定的RouterKey
    ))
    public void getDirectMessage2(String msg){
        System.out.println("这是消费者2:"+msg);
    }
}

publisher模块中发送消息的类

@RunWith(SpringRunner.class)
@SpringBootTest
public class DirectMessage {
    @Autowired
    private RabbitTemplate rabbitTemplate;
    @Test
    public void test(){
        //定义交换机名字
        String exchangeName="hhh.direct";
        //定义消息
        String msg="你好，direct";
        //发送消息，指定发送给RouterKey为yellow的消息队列
        rabbitTemplate.convertAndSend(exchangeName,"yellow",msg);
    }
}

结果：两个消费者都收到了消息队列，因为他们都有yellow这个RouterKey

使用SpringAMQP处理发布订阅之主题

Topic
类型的
Exchange
与
Direct
相比，都是可以根据
RoutingKey
把消息路由到不同的队列。只不过
Topic
类型
Exchange
可以让队列在绑定
Routing key
的时候使用通配符！
Routingkey
一般都是有一个或多个单词组成，多个单词之间以”.”分割，例如：
item.insert
通配符规则：
#
：匹配一个或多个词
*
：匹配不多不少恰好1个词

举例：
item.#
：能够匹配
item.spu.insert
或者
item.spu
item.*
：只能匹配
item.spu

consumer模块中接收消息的类

@RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "topic.queue1"),
            exchange = @Exchange(name = "hhh.topic", type = ExchangeTypes.TOPIC),
            key = "china.#" //key = "china.#" 表示路由key只要以china开始都会接收
    ))
    public void listenTopicQueue1(String msg) {
        System.out.println("消费者接收到topic.queue1的消息：【" + msg + "】");
    }
    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "topic.queue2"),
            exchange = @Exchange(name = "hhh.topic", type = ExchangeTypes.TOPIC),
            key = "#.news" //表示路由key只要以news结尾都会接收
    ))
    public void listenTopicQueue2(String msg) {
        System.out.println("消费者接收到topic.queue2的消息：【" + msg + "】");
    }

publisher模块中发送消息的类

 @Test
    public void testSendTopicExchange() {
        // 交换机名称
        String exchangeName = "itcast.topic";
        // 消息
        String message = "你好，topic";
        // 发送消息
        rabbitTemplate.convertAndSend(exchangeName, "china.news", message);
    }

配置JSON转换器

默认情况下Spring采用的序列化方式是JDK序列化，JDK序列化存在下列问题：

数据体积过大

有安全漏洞

可读性差

我们希望消息体的体积更小、可读性更高，因此可以使用JSON方式来做序列化和反序列化。

在主项目的pom.xml文件中导入依赖

<dependency>
    <groupId>com.fasterxml.jackson.dataformat</groupId>
    <artifactId>jackson-dataformat-xml</artifactId>
    <version>2.9.10</version>
</dependency>

在两个子模块中书写配置类，将MessageConverter交给IoC容器

/*
    消息转换器
 */
@Configuration
public class MessageConverterConfig {
    @Bean//将json转换器对象放到IoC容器
    public MessageConverter jsonMessageConverter(){
        return new Jackson2JsonMessageConverter();
    }
}

标签： java 开发语言 mybatis

本文转载自: https://blog.csdn.net/luosuss/article/details/141320598
版权归原作者 落落落sss 所有，如有侵权，请联系我们删除。

同步调用：一次只能干一件事

异步通信：一次可以同时做很多事

MQ(MessageQueue)

docker安装RabbitMq

第一步：拉取镜像

第二步：启动rabbitmq

方式一：直接启动

方式二：使用docker-compose创建并运行容器

RabbitMQ消息模型

一.基本消息队列（BasicQueue）

二. 工作消息队列（WorkQueue）

三.发布订阅（Publish、Subscribe）

1.Fanout Exchange：广播

2.Direct Exchange：路由

3.topic Exchange：主题

SpringAMQP

第一步：先创建一个SpringBoot项目，然后在当前项目创建出两个新的模块，分别命名为publisher,consumer。

第二步：修改主项目的打包方式为pom,java版本为1.8,springboot版本为2.3.10.RELEASE，并导入amqp的依赖

第三步：让两个模块继承这个主项目的依赖，使用<parent>标签

第四步：在两个子模块下的applicaton.yml文件下配置连接RabbitMQ的信息

使用SpringAMQP处理基本消息队列

第一步：在publisher模块中书写发送消息队列的类

第二步： 在consumer模块书写接收消息队列的类

使用SpringAMQP处理工作消息队列

publisher模块中发送消息的类

consumer模块中接收消息的类

在consumer模块中的application.yml文件中添加prefetch

使用SpringAMQP处理发布订阅之广播

publisher模块中发送消息的类

consumer模块中接收消息的类

我们也可以使用配置类来创建交换机和队列，并绑定

使用SpringAMQP处理发布订阅之路由

consumer模块中接收消息的类

publisher模块中发送消息的类

使用SpringAMQP处理发布订阅之主题

consumer模块中接收消息的类

publisher模块中发送消息的类

配置JSON转换器

在主项目的pom.xml文件中导入依赖

在两个子模块中书写配置类，将MessageConverter交给IoC容器

发表评论

“RabbitMQ”的评论:

关于作者

overfit同步小助手

相关阅读

文章导航

第二步：在consumer模块书写接收消息队列的类