(14)RabbitMQ与Spring的整合使用

最新推荐文章于 2024-08-06 10:16:50 发布

没头脑遇到不高兴

最新推荐文章于 2024-08-06 10:16:50 发布

阅读量1.5k

点赞数 5

分类专栏： RabbitMQ 文章标签： RabbitMQ与Spring的整合使用 spring-amqp和spring-rabbit使用介绍 RabbitTemplate使用介绍

本文链接：https://blog.csdn.net/u012988901/article/details/89499634

版权

RabbitMQ 专栏收录该内容

19 篇文章 21 订阅

订阅专栏

本节将会介绍一下RabbitMQ与Spring的整合使用：spring-amqp和spring-rabbit，RabbitTemplate、MessageListener的使用介绍，如何发送消息，如何接收消息，如何设置消费者ack确认，如何添加confirm和return回调。。。。。。

概述

从事Java开发的小伙伴一般都离不了Spring框架吧，本节就介绍一下RabbitMQ与Spring的整合使用。Spring官网的project中可以看到一个项目Spring AMQP。

项目详细介绍地址为https://spring.io/projects/spring-amqp，我们看到红线圈住的部分：该项目包含两部分，spring-amqp是基础抽象，而spring-rabbit是spring-amqp的一个具体的实现。Spring官方的提供的demo地址为https://github.com/spring-projects/spring-amqp-samples，官方参考文档地址为https://docs.spring.io/spring-amqp/docs/1.7.5.RELEASE/reference/html/，可以选择查看对应的版本的文档。

具体实现

项目GitHub地址 https://github.com/RookieMember/RabbitMQ-Learning.git。废话不多说，可以撸代码。项目采用maven构建，项目结构如下

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.wkp</groupId>
    <artifactId>rabbitmq-spring-demo</artifactId>
    <version>0.0.1</version>
    <packaging>war</packaging>
    <name>rabbitmq-spring-producer Maven Webapp</name>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.amqp</groupId>
            <artifactId>spring-rabbit</artifactId>
            <version>1.7.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>4.3.13.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.7</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.28</version>
        </dependency>
    </dependencies>
</project>

log4j日志配置如下

log4j.rootLogger=info,A1
log4j.logger.com.taotao = DEBUG
log4j.logger.org.mybatis = DEBUG
 
log4j.appender.A1=org.apache.log4j.ConsoleAppender
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.layout.ConversionPattern=%-d{yyyy-MM-dd HH:mm:ss,SSS} [%t] [%c]-[%p] %m%n

Spring配置文件rabbitmq-context.xml内容如下：spring-rabbit的常用配置都在里面，而且也都写了注释，就不再做过多的说明了。配置中包括重试策略，消息转换器，confirm回调，return回调等都是可选的，可以根据自己的需要进行配置。另外listener中还可以设置线程池等。。。。。。里面的配置还是挺多的，可以自己看看。

其实下面xml的配置都对应着相应的类，下面做个简单的说明：如果你是用的Spring4.x，并且用注解配置的话，就可以通过@Bean注解结合下面的类使用了，这样就不用写xml配置了，其实这个跟与SpringBoot的整合就比较像了。

<rabbit:connection-factory>对应CachingConnectionFactory，可以用来创建连接
<rabbit:admin>对应RabbitAdmin，可以声明交换机、队列、绑定
<rabbit:topic-exchange>对应TopicExchange表示topic类型交换机（其他类型的交换机不再一一列出）
<rabbit:queue>对应Queue，表示队列
<rabbit:binding>对应Binding，用于交换机与队列的绑定
<rabbit:template>对应RabbitTemplate，用于消息的发送等
<rabbit:listener-container>对应MessageListenerContainer，表示消息监听容器
<rabbit:listener>对应的是具体的消费者监听器，我是实现的ChannelAwareMessageListener

关于消息转换器我使用的是Jackson2JsonMessageConverter，其实一般发个简单文本或者json字符串消息就够日常使用了，如果想要发一些复杂的消息内容也可以自定义消息转换器，实现MessageConverter接口即可。

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:rabbit="http://www.springframework.org/schema/rabbit"
       xsi:schemaLocation="http://www.springframework.org/schema/rabbit
	http://www.springframework.org/schema/rabbit/spring-rabbit-1.7.xsd
	http://www.springframework.org/schema/beans
	http://www.springframework.org/schema/beans/spring-beans-4.1.xsd">

    <!-- 定义RabbitMQ的连接工厂 publisher-confirms="true"表示通过该连接工厂创建的连接支持publisher confirm-->
    <rabbit:connection-factory id="connectionFactory" host="127.0.0.1" port="5672" username="wkp" password="123456"
                               virtual-host="/myvhost" connection-timeout="5000" publisher-confirms="true"/>

    <!-- MQ的管理，包括队列、交换器等 auto-startup="true"表示如果交换机，队列，绑定不存在时可以自动声明-->
    <rabbit:admin auto-startup="true" connection-factory="connectionFactory"/>

    <!--topic类型交换机，自动声明-->
    <rabbit:topic-exchange name="spring_topic_exchange" auto-declare="true">
        <rabbit:bindings>
            <rabbit:binding pattern="test.*" queue="spring_myqueue"></rabbit:binding>
        </rabbit:bindings>
    </rabbit:topic-exchange>

    <!--<rabbit:direct-exchange name="spring_direct_exchange">
        <rabbit:bindings>
            <rabbit:binding  queue="spring_myqueue" key="test_routingKey"></rabbit:binding>
        </rabbit:bindings>
    </rabbit:direct-exchange>

    <rabbit:fanout-exchange name="spring_fanout_exchange">
        <rabbit:bindings>
            <rabbit:binding queue="spring_myqueue"></rabbit:binding>
        </rabbit:bindings>
    </rabbit:fanout-exchange>-->

    <!-- 定义队列，自动声明 -->
    <rabbit:queue name="spring_myqueue" auto-declare="true"/>

    <!-- 定义Rabbit模板，指定连接工厂以及定义exchange -->
    <rabbit:template id="rabbitTemplate" connection-factory="connectionFactory"
                     confirm-callback="confirmCallBackHandler" mandatory="true"
                     return-callback="returnCallBackHandler" retry-template="retryTemplate"/>

    <!--重试模板:出现连接失败等错误时可以重试-->
    <bean id="retryTemplate" class="org.springframework.retry.support.RetryTemplate">
        <!--重试回退策略，指的是每次重试是立即重试还是等待一段时间后重试-->
        <!--ExponentialBackOffPolicy 指数回退策略-->
        <property name="backOffPolicy">
            <bean class="org.springframework.retry.backoff.ExponentialBackOffPolicy">
                <property name="initialInterval" value="200"/>
                <property name="maxInterval" value="30000"/>
            </bean>
        </property>
        <!--SimpleRetryPolicy 简单重试策略，固定次数-->
        <property name="retryPolicy">
            <bean class="org.springframework.retry.policy.SimpleRetryPolicy">
                <property name="maxAttempts" value="5"/>
            </bean>
        </property>
    </bean>

    <!--消费队列监听 设置消费者手动ack，消息转换器(不设置默认为SimpleMessageConverter) -->
    <rabbit:listener-container connection-factory="connectionFactory" acknowledge="manual"
                               message-converter="jsonMessageConverter">
        <rabbit:listener ref="consumerHandler" queue-names="spring_myqueue"/>
    </rabbit:listener-container>
    <!-- 消费队列监听-还可以设置预抓取消息数量，线程池等
        <rabbit:listener-container connection-factory="connectionFactory" concurrency="1"
                                   max-concurrency="2" prefetch="1" task-executor="taskExecutor">
            <rabbit:listener ref="consumerHandler" queue-names="spring_myqueue"/>
        </rabbit:listener-container>
    -->
    <!--消费者处理类-->
    <bean id="consumerHandler" class="com.wkp.consumer.ConsumerHandler"/>
    <!--confirm回调处理类-->
    <bean id="confirmCallBackHandler" class="com.wkp.producer.ConfirmCallBackHandler"/>
    <!--return回调处理类-->
    <bean id="returnCallBackHandler" class="com.wkp.producer.ReturnCallBackHandler"/>
    <!-- 消息转换器,消息对象json转换类 -->
    <bean id="jsonMessageConverter" class="org.springframework.amqp.support.converter.Jackson2JsonMessageConverter"/>
</beans>

消费者处理类如下：这里消费者是手动ack确认的。

package com.wkp.consumer;

import com.rabbitmq.client.Channel;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageProperties;
import org.springframework.amqp.rabbit.core.ChannelAwareMessageListener;

import java.util.Map;

public class ConsumerHandler implements ChannelAwareMessageListener {

    Logger logger = LoggerFactory.getLogger(ConsumerHandler.class);

    @Override
    public void onMessage(Message message, Channel channel) throws Exception {

        String msg = new String(message.getBody(),"utf-8");
        MessageProperties pros = message.getMessageProperties();
        Map<String, Object> headers = pros.getHeaders();
        String routingKey = pros.getReceivedRoutingKey();
        logger.info("消费者收到消息:{},routingKey:{},headers:{}",msg,routingKey,headers);
        //消费者ack确认
        channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
    }

}

confirm确认回调处理类如下：ack为true表示投递成功，为false表示投递失败（可以重新投递或者记录数据库），CorrelationData参数为发消息时指定的一个唯一ID，可以与发送的消息做关联，表示该消息已经成功发到了RabbitMQ上了，用于做消息可靠性投递。对confirm机制不了解的话可以参考《(10)RabbitMQ生产者确认：事务与confirm机制》

package com.wkp.producer;

import com.wkp.consumer.ConsumerHandler;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.rabbit.support.CorrelationData;

/**
 * 做消息可靠性投递
 */
public class ConfirmCallBackHandler implements RabbitTemplate.ConfirmCallback {

    Logger logger = LoggerFactory.getLogger(ConfirmCallBackHandler.class);

    @Override
    public void confirm(CorrelationData correlationData, boolean ack, String cause) {
        //根据回调的correlationDataId判断发送的哪条消息投递成功，哪条没有成功
        String correlationDataId =null;
        if(correlationData!=null){
            correlationDataId = correlationData.getId();
        }
        if(ack){
            logger.info("CONFIRM机制:消息投递成功:correlationId:{}",correlationDataId);
        }else{
            //TODO 消息投递失败,重新投递
            logger.warn("CONFIRM机制:消息投递失败:correlationId:{},cause:{}",correlationDataId,cause);
        }
    }
}

return回调处理类：当消息无法被路由时会触发return回调处理，并将发送的消息返回。对return机制不了解的话可以参考《(11)RabbitMQ的mandatory、immediate和ReturnListener》

package com.wkp.producer;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.core.RabbitTemplate;

/**
 * 消息路由失败
 */
public class ReturnCallBackHandler implements RabbitTemplate.ReturnCallback {

    Logger logger = LoggerFactory.getLogger(ConfirmCallBackHandler.class);

    @Override
    public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
        String msg = new String(message.getBody());
        logger.warn("RETURN机制:消息路由失败,msg:{},replyCode:{},replyText:{},exchange:{},routingKey:{}",msg,replyCode,replyText,exchange,routingKey);
    }

}

测试类如下：RabbitTemplate发送消息的方法常用的有send和convertAndSend（两个方法都提供了非常多的重载的方法），可以结合自己的需求使用对应的方法。发送消息时可以设置属性及header信息，还有消息编码、contenttype等。

package com.wkp.test;

import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.serializer.SerializerFeature;
import com.wkp.consumer.ConsumerHandler;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.AmqpException;
import org.springframework.amqp.core.*;
import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.core.RabbitAdmin;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.rabbit.listener.MessageListenerContainer;
import org.springframework.amqp.rabbit.support.CorrelationData;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import javax.annotation.Resource;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={"classpath:rabbitmq-context.xml"})
public class ProducerTest {

    Logger logger = LoggerFactory.getLogger(ProducerTest.class);

    @Resource
    private RabbitTemplate rabbitTemplate;
    //CorrelationData中包含一个id(我们可以自定义，将其与发送的消息相关联)，当开启了confirm机制后，会收到包含该参数的回调，用于消息可靠性投递，可选的
    private CorrelationData corrData=new CorrelationData(String.valueOf(System.currentTimeMillis()));

    /**
     * 发送简单文本消息
     */
    @Test
    public void test_sendTextMsg1(){
        //1 创建消息
        //可以添加一些消息属性
        MessageProperties messageProperties = new MessageProperties();
        messageProperties.getHeaders().put("desc", "信息描述..");
        messageProperties.getHeaders().put("type", "自定义消息类型..");
        Message message = new Message("send简单文本消息".getBytes(), messageProperties);
        rabbitTemplate.send("spring_topic_exchange","test.add", message,corrData);
    }

    /**
     * 发送简单文本消息
     */
    @Test
    public void test_sendTextMsg2(){
        //可以设置消息属性，可选的
        MessagePostProcessor mp=new MessagePostProcessor() {
            @Override
            public Message postProcessMessage(Message message) throws AmqpException {
                logger.info("------发消息时添加额外的设置---------");
                message.getMessageProperties().getHeaders().put("desc", "额外修改的信息描述");
                message.getMessageProperties().getHeaders().put("attr", "额外新加的属性");
                return message;
            }
        };
        rabbitTemplate.convertAndSend("spring_topic_exchange","test.add","convertAndSend简单文本消息", mp, corrData);
    }

    /**
     * 发送json文本消息
     */
    @Test
    public void test_sendJsonStringMsg(){
        JSONObject json = new JSONObject();
        json.put("name", "张三");
        json.put("age", 20);
        rabbitTemplate.convertAndSend("spring_topic_exchange","test.add",json.toJSONString(),corrData);
    }

    /**
     * 发送json消息
     */
    @Test
    public void test_sendJsonObjMsg(){
        JSONObject json = new JSONObject();
        json.put("name", "李四");
        json.put("age", 36);
        byte[] bytes = JSONObject.toJSONBytes(json, SerializerFeature.WriteDateUseDateFormat, SerializerFeature.WriteMapNullValue);
        MessageProperties props=new MessageProperties();
        props.setContentType(MessageProperties.CONTENT_TYPE_JSON);
        Message message=new Message(bytes, props);
        rabbitTemplate.send("spring_topic_exchange","test.add", message, corrData);
    }

    /**
     * 测试消息无法被路由，触发return回调
     */
    @Test
    public void test_return_noRoute(){
        rabbitTemplate.convertAndSend("spring_topic_exchange","errorKey","无法路由的消息",corrData);
    }

}

运行test_sendTextMsg1（）方法，可以看到控制台有如下输出：可以看到消费者收到了消息，confirm回调也触发了。

消费者收到消息:send简单文本消息,routingKey:test.add,headers:{spring_listener_return_correlation=dd87b185-dbfb-4a34-b782-44e663a1f9f0, type=自定义消息类型.., desc=信息描述..}
CONFIRM机制:消息投递成功:correlationId:1556161128811

运行test_return_noRoute（）方法，可以看到控制台有如下输出：可以看到消费者没有收到消息，触发了return回调表示消息无法被路由，另外confirm回调也触发了。

RETURN机制:消息路由失败,msg:无法路由的消息,replyCode:312,replyText:NO_ROUTE,exchange:spring_topic_exchange,routingKey:errorKey
CONFIRM机制:消息投递成功:correlationId:1556161346932

更多的测试方法输出结果就不一一贴出了，关于RabbitMQ与Spring的整合就介绍到这里，下一节将会介绍与SpringBoot的整合。