Spring 整合RabbitMQ

Spring 整合RabbitMQ

• 创建生产者和消费者工程(相同的步骤)

  1. 导包

         <dependencies>
             <!--spring 上下文-->
             <dependency>
                 <groupId>org.springframework</groupId>
                 <artifactId>spring-context</artifactId>
                 <version>5.1.7.RELEASE</version>
             </dependency>
     
             <!-- spring 整合rabbit-->
             <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)

     rabbitmq.host=192.168.20.146
     rabbitmq.port=5672
     rabbitmq.username=test
     rabbitmq.password=test
     rabbitmq.virtual-host=/test
     

---

• 生产者
  • 创建在resources包下创建spring-rabbitmq-producer.xml文件

    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xmlns:context="http://www.springframework.org/schema/context"
           xmlns:rabbit="http://www.springframework.org/schema/rabbit"
           xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans.xsd
           http://www.springframework.org/schema/context
           https://www.springframework.org/schema/context/spring-context.xsd
           http://www.springframework.org/schema/rabbit
           http://www.springframework.org/schema/rabbit/spring-rabbit.xsd">
           
           <!--加载配置文件-->
        <context:property-placeholder location="classpath:/rabbitmq.properties"/>
    
    	 <!-- 定义rabbitmq connectionFactory 也就是工厂加载配置文件里面的内容 -->
        <rabbit:connection-factory id="connectionFactory" host="${rabbitmq.host}"
                                   port="${rabbitmq.port}"
                                   username="${rabbitmq.username}"
                                   password="${rabbitmq.password}"
                                   virtual-host="${rabbitmq.virtual-host}"/>
    
    	
        <!--定义管理交换机、队列-->
        <!--封装之后的admin的工厂-->
        <rabbit:admin connection-factory="connectionFactory"/>
      
    	 <!--定义持久化队列，不存在则自动创建；不绑定到交换机则绑定到默认交换机
        默认交换机类型为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"/>
    
        <!--定义广播类型交换机；并绑定上述两个队列-->
        <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>
    
    	<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~通配符；*匹配一个单词，#匹配多个单词 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
        <!--定义广播交换机中的持久化队列，不存在则自动创建-->
        <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="yang.*" queue="spring_topic_queue_star"/>
                <rabbit:binding pattern="yang.#" queue="spring_topic_queue_well"/>
                <rabbit:binding pattern="test.#" queue="spring_topic_queue_well2"/>
            </rabbit:bindings>
        </rabbit:topic-exchange>
        
    	<!--定义rabbitTemplate对象操作可以在代码中方便发送消息-->
        <rabbit:template id="rabbitTemplate" connection-factory="connectionFactory"/>
    

  • 在测试类中写代码

    1. 简单的HelloWorld模式

       //运行器
       @RunWith(SpringJUnit4ClassRunner.class)
       //加载配置文件
       @ContextConfiguration(locations = "classpath:spring-rabbitmq-producer.xml")
       public class ProducerTest {
       
           //1. 注入RabbitmqTemplate
           @Autowired
           private RabbitTemplate rabbitTemplate;
       
           //简单的HelloWorld模式
           @Test
           public void testHelloWorld() {
               //发送消息
               //spring_queue是刚刚的spring-rabbitmq-producer.xml文件定义的
               rabbitTemplate.convertAndSend("spring_queue","hello world spring...");
           }
       }
       

       1.1 运行之后(所以的队列和交换机都会创建出来,因为我们配置文件定义了)
       1.2 并且我们那个spring_queue队列会有一条消息(刚刚发送了)
       

    2. fanout模式

       public void testFanout() {
       //第一次参数是交换机,第二个参数是Routing Key 因为是fanout可以省略 第三个参数是消息内容
          rabbitTemplate.convertAndSend("spring_fanout_exchange","","spring fanout...");
       }
       

       2.1运行之后我们的两个消息队列都有消息了(因为是广播)
       

    3. direct模式

       3.1 由于刚刚没有在spring-rabbitmq-producer.xml文件指定配置,所以需要增加

       <!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~Direct；指定队列收到消息~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
           <rabbit:queue id="spring_direct_queue_1" name="spring_direct_queue_1" auto-declare="true"/>
           <rabbit:queue id="spring_direct_queue_2" name="spring_direct_queue_2" auto-declare="true"/>
       
           <!-- 定义Direct类型交换机-->
           <rabbit:direct-exchange id="spring_direct_exchange" name="spring_direct_exchange" auto-declare="true">
               <rabbit:bindings>
                   <rabbit:binding queue="spring_direct_queue_1" key="yes"/>
                   <rabbit:binding queue="spring_direct_queue_2" key="no"/>
               </rabbit:bindings>
           </rabbit:direct-exchange>
       

       3.2 发送消息(Rounting key 为yes的消息 no的就省略了)

       @Test
           public void testDirect() {
               //第一次参数是交换机,第二个参数是Routing Key 因为是fanout可以省略 第三个参数是消息内容
               rabbitTemplate.convertAndSend("spring_direct_exchange","yes","spring direct yes...");
           }
       

       3.3 运行之后就有一条有消息了

    4. topic模式
       4.1 发送yang.#的(另外两个省略)

       @Test
           public void testTopic() {
               rabbitTemplate.convertAndSend("spring_topic_exchange","yang.hehe.haha","spring topic  ...");
           }
       

       4.2 运行之后,三个队列只有其中一个队列的通配符匹配
       

---

• 消费者
  • 创建在resources包下创建spring-rabbitmq-consumer.xml文件

	<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:rabbit="http://www.springframework.org/schema/rabbit"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       https://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/rabbit
       http://www.springframework.org/schema/rabbit/spring-rabbit.xsd">
    <!--加载配置文件-->
    <context:property-placeholder location="classpath:/rabbitmq.properties"/>

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

    <bean id="springQueueListener" class="com.yang.rabbitmq.listener.SpringQueueListener"/>
    <bean id="fanoutListener1" class="com.yang.rabbitmq.listener.FanoutListener1"/>
    <bean id="fanoutListener2" class="com.yang.rabbitmq.listener.FanoutListener2"/>
    <bean id="directListener1" class="com.yang.rabbitmq.listener.DirectListener1"/>
    <bean id="directListener2" class="com.yang.rabbitmq.listener.DirectListener2"/>
    <bean id="topicListenerStar" class="com.yang.rabbitmq.listener.TopicListenerStar"/>
    <bean id="topicListenerWell" class="com.yang.rabbitmq.listener.TopicListenerWell"/>
    <bean id="topicListenerWell2" class="com.yang.rabbitmq.listener.TopicListenerWell2"/>

    <!-- 监听器容器-->
    <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 ref="fanoutListener2" queue-names="spring_fanout_queue_2"/>
        <rabbit:listener ref="directListener1" queue-names="spring_direct_queue_1"/>
        <rabbit:listener ref="directListener2" queue-names="spring_direct_queue_2"/>
        <rabbit:listener ref="topicListenerStar" queue-names="spring_topic_queue_star"/>
        <rabbit:listener ref="topicListenerWell" queue-names="spring_topic_queue_well"/>
        <rabbit:listener ref="topicListenerWell2" queue-names="spring_topic_queue_well2"/>
    </rabbit:listener-container>
</beans>

1. 按照定义的路径写监听器(com.yang.rabbitmq.listener.SpringQueueListener)

   1. 实现MessageListener接口

   2. 直接输入监听的内容

      public class SpringQueueListener implements MessageListener {
          @Override
          public void onMessage(Message message) {
              System.out.println(new String(message.getBody()));
          }
      }
      

   3. 为了方便直接使用测试类来加载配置文件就行了

      @RunWith(SpringJUnit4ClassRunner.class)
      @ContextConfiguration(locations = "classpath:spring-rabbitmq-consumer.xml")
      public class ConsumerTest {
      
          @Test
          public void test() {
              //因为是监听器,以后的后是不停止的,所以就加载一直运行着
              while(true) {
      
              }
          }
      }
      
      

   4. 运行结果(配置文件里面的其他先注释掉因为还没写,会报错)
      

• 关于其他的监听器也是一样的写,这里就省略了!

• 注: 如果是中文的话,不知道其他人会不会,我是会出现乱码的,所以需要在new String里面指定UTF-8的编码

  System.out.println(new String(message.getBody(), StandardCharsets.UTF_8));
  
  

---

• 配置文件解释

<!--
	id: bean的名称
	name: queue的名称
	auto-declare: 自动创建
	其他一些:
		auto-delete: 自动删除. 最后一个消费者和该队列断开连接后,自动删除队列
		exclusive: 是否独占
		durable: 是否持久化
 -->
 <rabbit:queue id="spring_queue" name="spring_queue" auto-declare="true"/>

<!--
	id: bean的名称
	name: exchange 的名称
	auto-declare: 自动创建
	其他一些:
		auto-delete: 是否自动删除
		durable: 是否持久化
		internal: 是否内部使用
 -->
<rabbit:fanout-exchange id="spring_fanout_exchange" name="spring_fanout_exchange" auto-declare="true">