【RabbitMQ笔记（四）】之Spring,SpringBoot整合RabbitMQ

怼烎@ 2023-10-07 15:05 54阅读 0赞

### 一． Spring整合RabbitMQ ###

#### （一） 概述 ####

所谓的用Spring来整合Rabbitmq，就是Rabbitmq所需要的一些配置先在配置文件中设置好，在代码中需要使用时直接注入到Spring容器中，这样就可以大大地减少代码量。

#### （二） Spring整合Rabbitmq生产者类 ####

##### 1. 导入依赖坐标 #####

导入Spring的坐标，以及rabbitmq整合的相关坐标。

<dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.1.17.RELEASE</version>
        </dependency>
    
        <dependency>
            <groupId>org.springframework.amqp</groupId>
            <artifactId>spring-rabbit</artifactId>
            <version>2.1.8.RELEASE</version>
        </dependency>
    
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.1.7.RELEASE</version>
        </dependency>
    </dependencies>
    
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.0</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

##### 2. rabbitmq的配置文件 #####

将连接rabbitmq所需要参数全部都配置到一个properties文件中，如ip地址，端口号，用户名，密码，虚拟机名称。

rabbitmq.host=192.168.211.100
    rabbitmq.port=5672
    rabbitmq.username=
    rabbitmq.password=
    rabbitmq.virtual-host=/

##### 3. Spring的核心配置文件 #####

###### （1）概述 ######

这个配置文件就将我们在使用rabbitmq时所用到的连接，交换机，队列等等都配置到了Spring容器中，这样，当我们需要使用这些组件时直接注入到容器中即可使用，非常方便。

###### （2） 加载配置文件 ######

我们之前抽去了rabbitmq的配置文件，而在Spring的配置文件中我们需要使用到rabbitmq的一些参数，因此我们需要加载rabbitmq.properties配置文件。

<context:property-placeholder location=”classpath:rabbitmq.properties”/>

###### （3） 定义rabbitmq connectionFactory ######

连接由连接工厂产生，因此我们需要定义一个连接工厂，该连接工厂的参数都是由rabbitmq.properties配置文件的参数提供的，用于连接到rabbitmq服务器。

<rabbit:connection-factory id="connectionFactory" host="${rabbitmq.host}"
                               port="${rabbitmq.port}"
                               username="${rabbitmq.username}"
                               password="${rabbitmq.password}"
                               virtual-host="${rabbitmq.virtual-host}"/>

###### （4） 定义管理交换机，队列的admin工厂 ######

交换机，队列都需要进行管理，因此设置一个管理的工厂就是我们上面定义的连接工厂。

<rabbit:admin connection-factory="connectionFactory"/>

###### （5） 定义持久化队列，不存在则自动创建 ######

这些队列会自动创建，如果没有被绑定到响应的交换机中，它们会默认绑定到默认的交换机，默认的交换机类型为direct，名称为“”，路由键为队列的名称。

<rabbit:queue id="spring_queue" name="spring_queue" auto-declare="true"/>
    <rabbit:queue id="spring_fanout_queue_1" name="spring_fanout_queue_1" auto-declare="true"/>
    <rabbit:queue id="spring_fanout_queue_2" name="spring_fanout_queue_2" auto-declare="true"/>

###### （6） 定义广播类型交换机，绑定队列 ######

广播类型的交换机，绑定不需要路由键。

<rabbit:fanout-exchange id="spring_fanout_exchange" name="spring_fanout_exchange" auto-declare="true">
        <rabbit:bindings>
            <rabbit:binding queue="spring_fanout_queue_1"/>
            <rabbit:binding queue="spring_fanout_queue_2"/>
        </rabbit:bindings>
    </rabbit:fanout-exchange>

###### （7） 定义用于Topic交换机的持久化队列与Topic交换机 ######

持久化队列的创建都是一样的，关键是不同交换机的创建是不同的，topic类型的交换机在绑定队列时需要设置路由键的规则。

<rabbit:queue id="spring_topic_queue_star" name="spring_topic_queue_star" auto-declare="true"/>
    <rabbit:queue id="spring_topic_queue_well" name="spring_topic_queue_well" auto-declare="true"/>
    <rabbit:queue id="spring_topic_queue_well2" name="spring_topic_queue_well2" auto-declare="true"/>
    
    <rabbit:topic-exchange id="spring_topic_exchange" name="spring_topic_exchange" auto-declare="true">
        <rabbit:bindings>
            <rabbit:binding pattern="xx.*" queue="spring_topic_queue_star"/>
            <rabbit:binding pattern="xx.#" queue="spring_topic_queue_well"/>
            <rabbit:binding pattern="wxx.#" queue="spring_topic_queue_well2"/>
        </rabbit:bindings>
    </rabbit:topic-exchange>

###### （8） 定义rabbitTemplate对象 ######

最重要的一个对象是定义rabbitTemplate对象，该对象用于在代码中发送消息，只要我们将该对象注入到容器中就可以使用了。

<rabbit:template id=”rabbitTemplate” connection-factory=”connectionFactory”/>

##### 4. 测试生产者类 #####

在test包内进行测试。

###### （1） 导入注解@RunWith ######

测试需要使用注解

@RunWith(SpringJUnit4ClassRunner.class)

###### （2） 导入注解@ContextConfiguration ######

我们需要加载Spring的配置文件。因此，使用注解`@ContextConfiguration(location=”classpath:spring-rabbitmq-producer.xml”)`，括号内为配置文件的地址。

###### （3） 注入RabbitmqTemplate对象 ######

使用该对象来发送消息。

@Autowired
    private RabbitTemplate rabbitTemplate;

###### （4） 发送消息 ######

发送消息使用rabbitTemplate对象的convertAndSend方法，该方法有很多重载，任君选择。

简单模式：

rabbitTemplate.convertAndSend(“spring_queue”, “hello_world”);

广播模式：

rabbitTemplate.convertAndSend(“spring_fanout_exchange”, “”, “hello_fanout”);

通配符模式：

rabbitTemplate.convertAndSend(“spring_topic_exchange”, “xx.xx”, “hello_topic”);

#### （三） Spring整合rabbitmq消费者类 ####

##### 1. 配置pom.xml文件 #####

配置方法与生产者类相同。

##### 2. 配置Spring核心配置文件 #####

###### （1） 定义rabbitmq的连接工厂 ######

定义方法与生产者相同。

###### （2） 定义监听类的Bean对象 ######

Bean对象的id是自己定义的，class是监听类的全包名。

###### （3） 定义监听器的容器 ######

容器中存储着监听器，每个监听器监听着对应的队列。

<rabbit:listener-container connection-factory="connectionFactory" auto-declare="true">
        <rabbit:listener ref="springQueueListener" queue-names="spring_queue"/>
        <rabbit:listener ref="fanoutListener1" queue-names="spring_fanout_queue_1"/>
    </rabbit:listener-container>

##### 3. 创建监听类 #####

我们在Spring的配置文件中定义了监听类的Bean对象，监听类会一直持续地监听队列的消息，若有消息，就会调用回调函数，作出相应的操作。

监听类需要实现MessageListener接口，该接口有 重载方法onMessage，这个方法就是一个回调函数，负责响应监听者获取了队列中消息，作出相应的操作。

package com.rabbitmq.listener;
    
    import org.springframework.amqp.core.Message;
    import org.springframework.amqp.core.MessageListener;
    
    public class SpringQueueListener implements MessageListener {
        
        @Override
        public void onMessage(Message message) {
        
            System.out.println(new String(message.getBody()));
        }
    }

##### 4. 测试消费者类 #####

在测试类中进行测试。

#### （四） Spring配置文件详解 ####

##### 1. rabbit约束头 #####

Spring配置文件中导入了rabbit约束头以及rabbit约束文件，因此可以使用rabbit命名空间，如下所示：

<rabbit:connection-factory>

##### 2. 定义队列的属性 #####

定义队列时，我们会设置一些属性，与之前没有使用Spring时的代码参数差不多，如下所示：

id: bean的名称
    name: queue的名称
    auto-declare: 自动创建
    auto-delete: 自动删除，最后一个消费者和该队列断开连接后，自动删除队列。
    exclusive: 是否独占
    durable: 是否持久化

### 二． SpringBoot整合RabbitMQ生产者 ###

#### （一） 创建SpringBoot工程 ####

添加一个maven模块。

#### （二） 配置pom.xml ####

SpringBoot项目需要在pom.xml中继承父工程依赖，以及rabbitmq的依赖包。

<parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.1.4.RELEASE</version>
        </parent>
    
        <dependencies>
            <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>
            </dependency>
    </dependencies>

#### （三） 配置application.yml ####

application.yml中配置了连接rabbitmq的连接参数，直接输入rabbitmq就会有提示，不用担心找不到参数名称的问题。

spring:
      rabbitmq:
        host: 192.168.211.100
        port: 5672
        username: 
        password: 
        virtual-host: /

#### （四） 创建启动类 ####

创建SpringBoot项目的入口，即 启动类。

package com.rabbitmq;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    
    @SpringBootApplication
    public class ProducerApplication {
        
        public static void main(String[] args) {
        
            SpringApplication.run(ProducerApplication.class);
        }
    }

#### （五） 创建配置类 ####

Spring将交换机，队列等配置在xml文件中，SpringBoot将它们配置在一个配置类中，使用注解的方式。

##### 1. 首先在该配置类上添加@Configuration表示这是一个配置类 #####

##### 2. 配置交换机 #####

添加一个方法，返回交换机对象，并且在该方法上添加@Bean(“bootExchange”)注解，表示这是一个id为bootExchange的Bean对象。

那么，交换机对象如何生成呢？通过ExchangeBuilder可以创建多种类型的交换机，同时可以设置它的属性，最终通过build()函数生成交换机。

public static final String EXCHANGE_NAME = "boot_topic_exchange";
    public Exchange bootExchange(){
        
        return ExchangeBuilder.topicExchange(EXCHANGE_NAME).durable(true).build();
    }

##### 3. 配置队列 #####

同理，使用同样的方法配置队列。

public static final String QUEUE_NAME = "boot_queue";
    @Bean("bootQueue")
    public Queue bootQueue(){
        
        return QueueBuilder.durable(QUEUE_NAME).build();
    }

##### 4. 绑定交换机和队列 #####

同样的，添加注解@Bean，不过这次不需要id，因为这个绑定关系是不需要注入进去的。要绑定交换机和队列，就需要知道具体的交换机和队列的名称，因此，我们需要在该函数的参数中传入交换机和队列，并且用@Qualifier注解通过id进行区分不同的交换机和队列。

函数体的内容是使用BindingBuiler的bind方法绑定队列和交换机，以及后面的属性设置。

@Bean
    public Binding bingQueueExchange(@Qualifier("bootQueue")Queue queue, @Qualifier("bootExchange")Exchange exchange){
        
        return BindingBuilder.bind(queue).to(exchange).with("boot.#").noargs();
    }

#### （六）测试生产者类 ####

定义完所有的配置后，我们可以编写代码进行测试生产者发送消息的情况了，在test包下创建一个测试类，通过注解的方式进行注入rabbitTemplate，使用该对象发送消息。

@SpringBootTest
    @RunWith(SpringRunner.class)
    public class ProducerTest {
        
    
        @Autowired
        private RabbitTemplate rabbitTemplate;
    
        @Test
        public void test(){
        
            rabbitTemplate.convertAndSend(EXCHANGE_NAME, "boot.haha", "hello_world");
        }
    
    }

### 三． SpringBoot整合RabbitMQ消费者 ###

消费者中同样要配置pom.xml，application.yml文件，但是不需要设置配置类。同时消费者还要设置监听类，对相应的队列进行监听工作。

使用注解@Component表示这是一个Bean对象，创建一个监听方法，在其上添加注解@RabbitListener，在该注解的参数中需要传入监听的队列的名称（不是id）。在该监方法的参数中传入一个Message对象，该消息对象用于存储从队列中监听到的消息，用于方法体中的操作。

@Component
    public class RabbitMQListener{
        
    	@RabbitListener(queue=”boot_queue”)
    	public void ListenerQueue(Message message){
        
    		System.out.println(message);
    	}
    
    }

注意，这个监听类要和入口类在同一个包下才能被扫描到。