springboot整合rabbitmq集群配置并实现消息确认

最新推荐文章于 2024-08-12 00:09:38 发布

Richard Chijq

最新推荐文章于 2024-08-12 00:09:38 发布

阅读量4.5k

点赞数

分类专栏： rabbitmq 文章标签： rabbitmq spring boot java

本文链接：https://blog.csdn.net/qq837993702/article/details/121695172

版权

rabbitmq 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

一，集群环境搭建

见文章：

Linux安装rabbitMq及elrang环境_qq837993702的博客-CSDN博客

RabbitMQ 集群环境搭建_qq837993702的博客-CSDN博客

二、pom文件配置

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.2.6.RELEASE</version>
    <relativePath/> <!-- lookup parent from repository -->
</parent>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

三、配置文件

spring.rabbitmq.host= 10.10.240.206
spring.rabbitmq.port= 5672
#集群模式ip:端口用，隔开
spring.rabbitmq.addresses=ip:端口,ip:端口,ip:端口
spring.rabbitmq.username= admin
spring.rabbitmq.password= 123456

#集群模式
spring.rabbitmq.mode=cluster
#单机模式
#spring.rabbitmq.mode=single
##是否启用 发布确认
spring.rabbitmq.publisher-confirms=true
## 是否启用发布返回
spring.rabbitmq.publisher-returns=true
# 表示消息确认方式，其有三种配置方式，分别是none、manual和auto；默认auto
spring.rabbitmq.listener.direct.acknowledge-mode=manual
spring.rabbitmq.listener.simple.acknowledge-mode=manual

四、RabbitConfig

1、RabbitTemplate 配置，实现集群模式和单点模式自由切换

package cn.edu.nfu.jw.conf;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.core.*;
import org.springframework.amqp.rabbit.config.SimpleRabbitListenerContainerFactory;
import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.boot.autoconfigure.amqp.RabbitProperties;
import org.springframework.boot.autoconfigure.amqp.SimpleRabbitListenerContainerFactoryConfigurer;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Scope;

import javax.annotation.Resource;


/*
 * @Author : chijiaqi
 * @CreateTime : 2020/4/14
 * @Description :
*/
/**
 Broker:它提供一种传输服务,它的角色就是维护一条从生产者到消费者的路线，保证数据能按照指定的方式进行传输,
 Exchange：消息交换机,它指定消息按什么规则,路由到哪个队列。
 Queue:消息的载体,每个消息都会被投到一个或多个队列。
 Binding:绑定，它的作用就是把exchange和queue按照路由规则绑定起来.
 Routing Key:路由关键字,exchange根据这个关键字进行消息投递。
 vhost:虚拟主机,一个broker里可以有多个vhost，用作不同用户的权限分离。
 Producer:消息生产者,就是投递消息的程序.
 Consumer:消息消费者,就是接受消息的程序.
 Channel:消息通道,在客户端的每个连接里,可建立多个channel.
 */
@Configuration
public class RabbitConfig {

    private final Logger logger = LoggerFactory.getLogger(this.getClass());

//    @Value("${spring.rabbitmq.host}")
//    private String host;
//
//    @Value("${spring.rabbitmq.port}")
//    private int port;

//    @Value("${spring.rabbitmq.username}")
//    private String username;
//
//    @Value("${spring.rabbitmq.password}")
//    private String password;
    @Resource
    private RabbitProperties rabbitProperties;


    @Bean("customContainerFactory")
    public SimpleRabbitListenerContainerFactory
    containerFactory(SimpleRabbitListenerContainerFactoryConfigurer configurer, ConnectionFactory
            connectionFactory) {
        SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
        factory.setConcurrentConsumers(DEFAULT_CONCURRENT);
        factory.setMaxConcurrentConsumers(DEFAULT_CONCURRENT);
        configurer.configure(factory, connectionFactory);
        return factory;
    }

    //单机节点
    @Bean
    @ConditionalOnProperty(name = "spring.rabbitmq.mode", havingValue = "single")
    public ConnectionFactory connectionFactorySingle(@Value("${spring.rabbitmq.host}") String host,@Value("${spring.rabbitmq.port}") int port) {
        CachingConnectionFactory connectionFactory = new CachingConnectionFactory(rabbitProperties.getHost(),rabbitProperties.getPort());
        connectionFactory.setUsername(rabbitProperties.getUsername());
        connectionFactory.setPassword(rabbitProperties.getPassword());
        connectionFactory.setVirtualHost("/");
        connectionFactory.setPublisherConfirms(rabbitProperties.isPublisherConfirms());
        connectionFactory.setPublisherReturns(rabbitProperties.isPublisherReturns());
        return connectionFactory;
    }
    //集群节点
    @Bean
    @ConditionalOnProperty(name = "spring.rabbitmq.mode", havingValue = "cluster")
    public ConnectionFactory connectionFactoryCluster(@Value("${spring.rabbitmq.addresses}") String addresses) {
        CachingConnectionFactory cachingConnectionFactory = new CachingConnectionFactory();
        cachingConnectionFactory.setAddresses(rabbitProperties.getAddresses());
        cachingConnectionFactory.setUsername(rabbitProperties.getUsername());
        cachingConnectionFactory.setPassword(rabbitProperties.getPassword());
        cachingConnectionFactory.setVirtualHost("/");
        cachingConnectionFactory.setPublisherConfirms(rabbitProperties.isPublisherConfirms());
        cachingConnectionFactory.setPublisherReturns(rabbitProperties.isPublisherReturns());
        logger.info("集群连接工厂设置完成，连接地址{}"+rabbitProperties.getAddresses());
        logger.info("集群连接工厂设置完成，连接用户{}"+rabbitProperties.getUsername());
        return cachingConnectionFactory;
    }

    @Bean
    //必须是prototype类型
    @Scope("prototype")
    public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory) {
        RabbitTemplate template = new RabbitTemplate(connectionFactory);
        return template;
    }

}

2、rabbitmq交换机，队列等信息配置

package cn.edu.nfu.jw.eval.constant;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.DirectExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.rabbit.config.SimpleRabbitListenerContainerFactory;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.boot.autoconfigure.amqp.SimpleRabbitListenerContainerFactoryConfigurer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;


/*
 * @Author : chijiaqi
 * @CreateTime : 2020/4/14
 * @Description :
*/
@Configuration
public class RabbitMqConstant {

    private final Logger logger = LoggerFactory.getLogger(this.getClass());


    //学生评教写入用的交换机（直连交换机是一种带路由功能的交换机，一个队列会和一个交换机绑定）
    public static final String STU_EVAL_EXCHANGE_DIRECT = "stu-eval-mq-exchange_A";
    
    public static final String STU_EVAL_QUEUE_DIRECT = "StuEvalDirectQueue";

    public static final String STU_EVAL_ROUTINGKEY_DIRECT = "stu-eval-mq-routingKey_A";

    public static final int DEFAULT_CONCURRENT = 10;//多线程消费者数量，默认10

    @Bean("stuEvalContainerFactory")
    public SimpleRabbitListenerContainerFactory
    containerFactory(SimpleRabbitListenerContainerFactoryConfigurer configurer, ConnectionFactory
            connectionFactory) {
        SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
        factory.setConcurrentConsumers(DEFAULT_CONCURRENT);
        factory.setMaxConcurrentConsumers(DEFAULT_CONCURRENT);
        configurer.configure(factory, connectionFactory);
        return factory;
    }
    @Bean
    public DirectExchange stuEvalExchange() {
        return new DirectExchange(STU_EVAL_EXCHANGE_DIRECT);
    }
    /**
     * 获取队列A
     * @return
     */
    @Bean
    public Queue queueStuEval() {
        return new Queue(STU_EVAL_QUEUE_DIRECT, true); //队列持久
    }

    //一个交换机可以绑定多个消息队列，也就是消息通过一个交换机，可以分发到不同的队列当中去。

    @Bean
    public Binding bindingStuEval() {
        return BindingBuilder.bind(queueStuEval()).to(stuEvalExchange()).with(STU_EVAL_ROUTINGKEY_DIRECT);
    }

}

五、生产者实现（带发布确认）

     Map<String, Object> mqMessage = new HashMap<>();
     mqMessage.put("saveOrUpdate", "update");  
    //写数据这里改为发送mq
        mqMessage.put("evalJxbUser", evalJxbUser);
        mqMessage.put("evalJxbUserRecord", obj);
       /* 发送消息确认：用来确认生产者 producer 将消息发送到 broker ，broker 上的交换机 exchange 再投递给队列 queue的过程中，消息是否成功投递。

        消息从 producer 到 rabbitmq broker有一个 confirmCallback 确认模式。

        消息从 exchange 到 queue 投递失败有一个 returnCallback 退回模式。

        我们可以利用这两个Callback来确保消息的100%送达。*/
        // 消息返回, yml需要配置 publisher-returns: true
        rabbitTemplate.setReturnCallback((message, replyCode, replyText, exchange, routingKey) -> {
            String correlationId = message.getMessageProperties().getCorrelationIdString();
            log.info("学生评教发送mq失败：");
            throw new ServiceException(-1, "评教失败，消息发送失败");
        });
        // 消息确认, 需要配置 publisher-confirms: true
        rabbitTemplate.setConfirmCallback((correlationData, ack, cause) -> {
            if (!ack) {
                log.info("stuEvalDirectSender生产者消息发送失败" + cause + correlationData.toString());
                throw new ServiceException(-1, "评教失败，消息发送失败");
            } else {
                //发送成功后标记
                valueOps.set("stuEval:"+obj.getUserNo()+":"+obj.getEvalJxbInfoId(),"true");
                log.info("stuEvalDirectSender生产者消息发送成功 ");
            }
        });
        rabbitTemplate.convertAndSend(RabbitMqConstant.STU_EVAL_EXCHANGE_DIRECT, RabbitMqConstant.STU_EVAL_ROUTINGKEY_DIRECT, JSON.toJSONString(mqMessage));

六、消费者实现（实现消息手动确认）

package cn.edu.nfu.jw.eval.listener;

import cn.edu.nfu.jw.eval.constant.RabbitMqConstant;
import cn.edu.nfu.jw.eval.dao.EvalJxbUserMapper;
import cn.edu.nfu.jw.eval.dao.EvalJxbUserRecordMapper;
import cn.edu.nfu.jw.eval.dao.EvalJxbUserRecordTargetMapper;
import cn.edu.nfu.jw.eval.domain.EvalJxbUser;
import cn.edu.nfu.jw.eval.domain.EvalJxbUserRecord;
import cn.edu.nfu.jw.eval.domain.EvalJxbUserRecordTarget;
import cn.edu.nfu.jw.exception.ServiceException;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.rabbitmq.client.Channel;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.io.IOException;
import java.util.Map;
/*

*
 * 学生评教消费

*/

@Component
@RabbitListener(queues = RabbitMqConstant.STU_EVAL_QUEUE_DIRECT
        , containerFactory = "stuEvalContainerFactory")//监听的队列名称 StuEvalDirectQueue
@Transactional(transactionManager = "jwTransactionManager")
public class StuEvalDirectReceiver {
    private static final Log log = LogFactory.getLog(StuEvalDirectReceiver.class);
    @Resource
    private EvalJxbUserRecordMapper<EvalJxbUserRecord> dao;
    @Resource
    private EvalJxbUserRecordTargetMapper<EvalJxbUserRecordTarget> evalJxbUserRecordTargetMapper;
    @Resource
    private EvalJxbUserMapper<EvalJxbUser> evalJxbUserMapper;
    @Resource
    private RedisTemplate<String, String> redisTemplate;
    @RabbitHandler
    public void process(String jsonStr, Channel channel, Message message) throws IOException {
        log.info("StuEvalDirectReceiver消费者收到消息  : " + jsonStr);
        try {
            Map<String,Object> mqMessage = JSON.parseObject(jsonStr, Map.class);
            Boolean o = false,o2 = false;
            EvalJxbUser evalJxbUser = JSONObject.parseObject(((JSONObject) mqMessage.get("evalJxbUser")).toJSONString(),EvalJxbUser.class);
            EvalJxbUserRecord obj = JSONObject.parseObject(((JSONObject) mqMessage.get("evalJxbUserRecord")).toJSONString(),EvalJxbUserRecord.class);
            if (mqMessage.get("saveOrUpdate") != null&&"save".equals(mqMessage.get("saveOrUpdate"))) {
                o = evalJxbUserMapper.save(evalJxbUser);
            } else {
                o = evalJxbUserMapper.update(evalJxbUser);
            }
            o2 = dao.save(obj);
            //保存评教选项记录
            for (EvalJxbUserRecordTarget evalJxbXsRecordTarget : obj.getEvalRecordTargetList()) {
                evalJxbXsRecordTarget.setEvalRecordId(obj.getId());
                evalJxbXsRecordTarget.setUuser(obj.getUuser());
            }
            evalJxbUserRecordTargetMapper.bitchSave(obj.getEvalRecordTargetList());
            if (o&&o2) {//消费完成，删除标记
                redisTemplate.delete("stuEval:"+obj.getUserNo()+":"+obj.getEvalJxbInfoId());
                log.info(obj.getUserNo() + "：学生评教保存成功！");
                 /** 确认一条消息：<br>
                 * channel.basicAck(deliveryTag, false); <br>
                 * deliveryTag:该消息的index <br>
                 * multiple：是否批量.true:将一次性ack所有小于deliveryTag的消息 <br>*/

                channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
                log.info("StuEvalDirectReceiver消费者消费消息  : " + jsonStr);
            } else {
                log.error("保存学生评教信息失败！"+obj.getUserNo());
            }
        } catch (Exception e) {
            //消费者处理出了问题，需要告诉队列信息消费失败，失败后重新入队
            /* *
             * 拒绝确认消息:<br>
             * channel.basicNack(long deliveryTag, boolean multiple, boolean requeue) ; <br>
             * deliveryTag:该消息的index<br>
             * multiple：是否批量.true:将一次性拒绝所有小于deliveryTag的消息。<br>
             * requeue：被拒绝的是否重新入队列 <br>
*/


            try {
                //nack返回false，并重新回到队列
                channel.basicNack(message.getMessageProperties().getDeliveryTag(),
                        false, true);
            } catch (IOException ioException) {//防止内存溢出，这里不再重新入队
                log.error("重新放入队列失败，失败原因:"+e.getMessage(),e);
            }
            log.error("保存学生评教信息，从MQ队列里面获取信息保存异常，异常信息为：" + e.getMessage(), e);
            throw new ServiceException(-1, "保存学生评教信息，从MQ队列里面获取信息保存异常,异常信息为：" + e.getMessage());
        }
    }

}