RabbitMQ消息可靠性投递解决方案 - 基于SpringBoot实现

最新推荐文章于 2024-06-01 13:11:26 发布
最新推荐文章于 2024-06-01 13:11:26 发布
阅读量209 收藏 2
点赞数
分类专栏： spring boot 文章标签： RabbitMQ SpringCloud Python Django flask

谈到消息的可靠性投递，无法避免的，在实际的工作中会经常碰到，比如一些核心业务需要保障消息不丢失，接下来我们看一个可靠性投递的流程图，说明可靠性投递的概念：

https://img2.mukewang.com/5b65729e0001439310630624.jpg

  • Step 1： 首先把消息信息(业务数据）存储到数据库中，紧接着，我们再把这个消息记录也存储到一张消息记录表里（或者另外一个同源数据库的消息记录表）

  • Step 2：发送消息到MQ Broker节点（采用confirm方式发送，会有异步的返回结果）

  • Step 3、4：生产者端接受MQ Broker节点返回的Confirm确认消息结果，然后进行更新消息记录表里的消息状态。比如默认Status = 0 当收到消息确认成功后，更新为1即可！

  • Step 5：但是在消息确认这个过程中可能由于网络闪断、MQ Broker端异常等原因导致 回送消息失败或者异常。这个时候就需要发送方（生产者）对消息进行可靠性投递了，保障消息不丢失，100%的投递成功！（有一种极限情况是闪断，Broker返回的成功确认消息，但是生产端由于网络闪断没收到，这个时候重新投递可能会造成消息重复，需要消费端去做幂等处理）所以我们需要有一个定时任务，（比如每5分钟拉取一下处于中间状态的消息，当然这个消息可以设置一个超时时间，比如超过1分钟 Status = 0 ，也就说明了1分钟这个时间窗口内，我们的消息没有被确认，那么会被定时任务拉取出来）

  • Step 6：接下来我们把中间状态的消息进行重新投递 retry send，继续发送消息到MQ ，当然也可能有多种原因导致发送失败

  • Step 7：我们可以采用设置最大努力尝试次数，比如投递了3次，还是失败，那么我们可以将最终状态设置为Status = 2 ，最后 交由人工解决处理此类问题（或者把消息转储到失败表中）。

以下为部分实现投递策略代码：

  • 数据库库表结构：订单表和消息记录表

-- 表 order 订单结构
CREATE TABLE IF NOT EXISTS `t_order` (
  `id` varchar(128) NOT NULL, -- 订单ID
  `name` varchar(128), -- 订单名称 其他业务熟悉忽略
  `message_id` varchar(128) NOT NULL, -- 消息唯一ID
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

-- 表 broker_message_log 消息记录结构
CREATE TABLE IF NOT EXISTS `broker_message_log` (
  `message_id` varchar(128) NOT NULL, -- 消息唯一ID
  `message` varchar(4000) DEFAULT NULL, -- 消息内容
  `try_count` int(4) DEFAULT '0', -- 重试次数
  `status` varchar(10) DEFAULT '', -- 消息投递状态  0 投递中 1 投递成功   2 投递失败
  `next_retry` timestamp NOT NULL DEFAULT '0000-00-00 00:00:00',  -- 下一次重试时间 或 超时时间
  `create_time` timestamp NOT NULL DEFAULT '0000-00-00 00:00:00', -- 创建时间
  `update_time` timestamp NOT NULL DEFAULT '0000-00-00 00:00:00', -- 更新时间
  PRIMARY KEY (`message_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

  • 整合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.bfxy</groupId>

    <artifactId>rabbitmq-springboot-producer</artifactId>

    <version>0.0.1-SNAPSHOT</version>

    <packaging>jar</packaging>

 

    <name>rabbitmq-springboot-producer</name>

    <description>rabbitmq-springboot-producer</description>

 

    <parent>

        <groupId>org.springframework.boot</groupId>

        <artifactId>spring-boot-starter-parent</artifactId>

        <version>2.0.2.RELEASE</version>

        <relativePath/> <!-- lookup parent from repository -->

    </parent>

 

    <properties>

        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>

        <java.version>1.8</java.version>

    </properties>

 

    <dependencies>

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-web</artifactId>

        </dependency> 

 

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-test</artifactId>

            <scope>test</scope>

        </dependency>

 

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-amqp</artifactId>

        </dependency>        

 

        <!-- 添加JDBC jar --> 

        <dependency>

          <groupId>org.mybatis.spring.boot</groupId>

          <artifactId>mybatis-spring-boot-starter</artifactId>

          <version>1.1.1</version>

        </dependency>

        <dependency>

          <groupId>tk.mybatis</groupId>

          <artifactId>mapper-spring-boot-starter</artifactId>

          <version>1.1.0</version>

        </dependency>    

        <dependency>

            <groupId>com.alibaba</groupId>

            <artifactId>druid</artifactId>

            <version>1.0.24</version>

        </dependency>

        <dependency>

            <groupId>mysql</groupId>

            <artifactId>mysql-connector-java</artifactId>

        </dependency>

        <!-- mybatis分页插件 -->

        <dependency>  

            <groupId>com.github.miemiedev</groupId>  

            <artifactId>mybatis-paginator</artifactId>  

            <version>1.2.17</version>  

            <exclusions>

                <exclusion>

                     <groupId>org.mybatis</groupId>

                    <artifactId>mybatis</artifactId>

                </exclusion>

            </exclusions>            

        </dependency>                    

        <dependency>

            <groupId>org.apache.commons</groupId>

            <artifactId>commons-lang3</artifactId>

        </dependency>

        <dependency>

            <groupId>commons-io</groupId>

            <artifactId>commons-io</artifactId>

            <version>2.4</version>

        </dependency>

        <dependency>

            <groupId>com.alibaba</groupId>

            <artifactId>fastjson</artifactId>

            <version>1.1.26</version>

        </dependency>    

        <dependency>

            <groupId>javax.servlet</groupId>

            <artifactId>javax.servlet-api</artifactId>

            <scope>provided</scope>    

        </dependency>  

                <dependency>

                    <groupId>log4j</groupId>

                    <artifactId>log4j</artifactId>

                    <version>1.2.17</version>

                </dependency>              

    </dependencies>

 

    <build>

        <plugins>

            <plugin>

                <groupId>org.springframework.boot</groupId>

                <artifactId>spring-boot-maven-plugin</artifactId>

            </plugin>

        </plugins>

    </build>

 

 

</project>

  • application.properties配置：

  • spring.rabbitmq.addresses=127.0.0.1:5672

    spring.rabbitmq.username=xibei

    spring.rabbitmq.password=xibei

    spring.rabbitmq.virtual-host=/

    spring.rabbitmq.connection-timeout=15000

     

    spring.rabbitmq.publisher-confirms=true

    spring.rabbitmq.publisher-returns=true

    spring.rabbitmq.template.mandatory=true

     

    server.servlet.context-path=/

    server.port=8001

     

    spring.http.encoding.charset=UTF-8

    spring.jackson.date-format=yyyy-MM-dd HH:mm:ss

    spring.jackson.time-zone=GMT+8

    spring.jackson.default-property-inclusion=NON_NULL

     

    spring.datasource.type=com.alibaba.druid.pool.DruidDataSource

    spring.datasource.url=jdbc:mysql://localhost:3306/test?characterEncoding=UTF-8&autoReconnect=true&zeroDateTimeBehavior=convertToNull&useUnicode=true

    spring.datasource.driver-class-name=com.mysql.jdbc.Driver

    spring.datasource.username=root

    spring.datasource.password=root

     

    mybatis.type-aliases-package=com.bfxy.springboot

    mybatis.mapper-locations=classpath:com/bfxy/springboot/mapping/*.xml

     

    logging.level.tk.mybatis=TRACE

  • 数据源druid.properties配置

##下面为连接池的补充设置，应用到上面所有数据源中

#初始化大小，最小，最大

druid.initialSize=5

druid.minIdle=10

druid.maxActive=300

#配置获取连接等待超时的时间

druid.maxWait=60000

#配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 

druid.timeBetweenEvictionRunsMillis=60000

#配置一个连接在池中最小生存的时间，单位是毫秒

druid.minEvictableIdleTimeMillis=300000

druid.validationQuery=SELECT 1 FROM DUAL

druid.testWhileIdle=true

druid.testOnBorrow=false

druid.testOnReturn=false

#打开PSCache，并且指定每个连接上PSCache的大小

druid.poolPreparedStatements=true

druid.maxPoolPreparedStatementPerConnectionSize=20

#配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙 

druid.filters=stat,wall,log4j

#通过connectProperties属性来打开mergeSql功能；慢SQL记录

druid.connectionProperties=druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000

#合并多个DruidDataSource的监控数据

druid.useGlobalDataSourceStat=true

  • 实体对象：

  • package com.bfxy.springboot.entity;

     

    import java.io.Serializable;

     

    public class Order implements Serializable {

     

        private static final long serialVersionUID = 9111357402963030257L;

     

        private String id;

     

        private String name;

     

        private String messageId;

     

        public String getId() {

            return id;

        }

     

        public void setId(String id) {

            this.id = id == null ? null : id.trim();

        }

     

        public String getName() {

            return name;

        }

     

        public void setName(String name) {

            this.name = name == null ? null : name.trim();

        }

     

        public String getMessageId() {

            return messageId;

        }

     

        public void setMessageId(String messageId) {

            this.messageId = messageId == null ? null : messageId.trim();

        }

    }

  • package com.bfxy.springboot.entity;

     

    import java.util.Date;

     

    public class BrokerMessageLog {

        private String messageId;

     

        private String message;

     

        private Integer tryCount;

     

        private String status;

     

        private Date nextRetry;

     

        private Date createTime;

     

        private Date updateTime;

     

        public String getMessageId() {

            return messageId;

        }

     

        public void setMessageId(String messageId) {

            this.messageId = messageId == null ? null : messageId.trim();

        }

     

        public String getMessage() {

            return message;

        }

     

        public void setMessage(String message) {

            this.message = message == null ? null : message.trim();

        }

     

        public Integer getTryCount() {

            return tryCount;

        }

     

        public void setTryCount(Integer tryCount) {

            this.tryCount = tryCount;

        }

     

        public String getStatus() {

            return status;

        }

     

        public void setStatus(String status) {

            this.status = status == null ? null : status.trim();

        }

     

        public Date getNextRetry() {

            return nextRetry;

        }

     

        public void setNextRetry(Date nextRetry) {

            this.nextRetry = nextRetry;

        }

     

        public Date getCreateTime() {

            return createTime;

        }

     

        public void setCreateTime(Date createTime) {

            this.createTime = createTime;

        }

     

        public Date getUpdateTime() {

            return updateTime;

        }

     

        public void setUpdateTime(Date updateTime) {

            this.updateTime = updateTime;

        }

    }

  • 数据库连接池代码：

  • package com.bfxy.springboot.config.database;

     

     

    import java.sql.SQLException;

     

    import javax.sql.DataSource;

     

    import org.slf4j.Logger;

    import org.slf4j.LoggerFactory;

    import org.springframework.beans.factory.annotation.Autowired;

    import org.springframework.context.annotation.Bean;

    import org.springframework.context.annotation.Configuration;

    import org.springframework.context.support.PropertySourcesPlaceholderConfigurer;

    import org.springframework.jdbc.datasource.DataSourceTransactionManager;

    import org.springframework.transaction.PlatformTransactionManager;

    import org.springframework.transaction.annotation.EnableTransactionManagement;

     

    import com.alibaba.druid.pool.DruidDataSource; 

     

    @Configuration

    @EnableTransactionManagement

    public class DruidDataSourceConfig {

         

        private static Logger logger = LoggerFactory.getLogger(DruidDataSourceConfig.class);

         

        @Autowired

        private DruidDataSourceSettings druidSettings;

         

        public static String DRIVER_CLASSNAME ;

         

        @Bean

        public static PropertySourcesPlaceholderConfigurer propertyConfigure(){

            return new PropertySourcesPlaceholderConfigurer();

        }    

         

        @Bean

        public DataSource dataSource() throws SQLException {

            DruidDataSource ds = new DruidDataSource();

            ds.setDriverClassName(druidSettings.getDriverClassName());

            DRIVER_CLASSNAME = druidSettings.getDriverClassName();

            ds.setUrl(druidSettings.getUrl());

            ds.setUsername(druidSettings.getUsername());

            ds.setPassword(druidSettings.getPassword());

            ds.setInitialSize(druidSettings.getInitialSize());

            ds.setMinIdle(druidSettings.getMinIdle());

            ds.setMaxActive(druidSettings.getMaxActive());

            ds.setTimeBetweenEvictionRunsMillis(druidSettings.getTimeBetweenEvictionRunsMillis());

            ds.setMinEvictableIdleTimeMillis(druidSettings.getMinEvictableIdleTimeMillis());

            ds.setValidationQuery(druidSettings.getValidationQuery());

            ds.setTestWhileIdle(druidSettings.isTestWhileIdle());

            ds.setTestOnBorrow(druidSettings.isTestOnBorrow());

            ds.setTestOnReturn(druidSettings.isTestOnReturn());

            ds.setPoolPreparedStatements(druidSettings.isPoolPreparedStatements());

            ds.setMaxPoolPreparedStatementPerConnectionSize(druidSettings.getMaxPoolPreparedStatementPerConnectionSize());

            ds.setFilters(druidSettings.getFilters());

            ds.setConnectionProperties(druidSettings.getConnectionProperties());

            logger.info(" druid datasource config : {} ", ds);

            return ds;

        }

     

        @Bean

        public PlatformTransactionManager transactionManager() throws Exception {

            DataSourceTransactionManager txManager = new DataSourceTransactionManager();

            txManager.setDataSource(dataSource());

            return txManager;

        }

         

    }

package com.bfxy.springboot.config.database;

 

import org.springframework.beans.factory.annotation.Value;

import org.springframework.boot.context.properties.ConfigurationProperties;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.PropertySource;

import org.springframework.context.support.PropertySourcesPlaceholderConfigurer;

import org.springframework.stereotype.Component;

 

@Component

@ConfigurationProperties(prefix="spring.datasource") 

@PropertySource("classpath:druid.properties")

public class DruidDataSourceSettings {

 

    private String driverClassName;

    private String url;

    private String username;

    private String password;

     

    @Value("${druid.initialSize}")

    private int initialSize;

     

    @Value("${druid.minIdle}")

    private int minIdle;

     

    @Value("${druid.maxActive}")

    private int maxActive;

     

    @Value("${druid.timeBetweenEvictionRunsMillis}")

    private long timeBetweenEvictionRunsMillis;

     

    @Value("${druid.minEvictableIdleTimeMillis}")

    private long minEvictableIdleTimeMillis;

     

    @Value("${druid.validationQuery}")

    private String validationQuery;

     

    @Value("${druid.testWhileIdle}")

    private boolean testWhileIdle;

     

    @Value("${druid.testOnBorrow}")

    private boolean testOnBorrow;

     

    @Value("${druid.testOnReturn}")

    private boolean testOnReturn;

     

    @Value("${druid.poolPreparedStatements}")

    private boolean poolPreparedStatements;

     

    @Value("${druid.maxPoolPreparedStatementPerConnectionSize}")

    private int maxPoolPreparedStatementPerConnectionSize;

     

    @Value("${druid.filters}")

    private String filters;

     

    @Value("${druid.connectionProperties}")

    private String connectionProperties;

     

    @Bean

    public static PropertySourcesPlaceholderConfigurer properdtyConfigure(){

        return new PropertySourcesPlaceholderConfigurer();

    }

     

    public String getDriverClassName() {

        return driverClassName;

    }

    public void setDriverClassName(String driverClassName) {

        this.driverClassName = driverClassName;

    }

    public String getUrl() {

        return url;

    }

    public void setUrl(String url) {

        this.url = url;

    }

    public String getUsername() {

        return username;

    }

    public void setUsername(String username) {

        this.username = username;

    }

    public String getPassword() {

        return password;

    }

    public void setPassword(String password) {

        this.password = password;

    }

    public int getInitialSize() {

        return initialSize;

    }

    public void setInitialSize(int initialSize) {

        this.initialSize = initialSize;

    }

    public int getMinIdle() {

        return minIdle;

    }

    public void setMinIdle(int minIdle) {

        this.minIdle = minIdle;

    }

    public int getMaxActive() {

        return maxActive;

    }

    public void setMaxActive(int maxActive) {

        this.maxActive = maxActive;

    }

    public long getTimeBetweenEvictionRunsMillis() {

        return timeBetweenEvictionRunsMillis;

    }

    public void setTimeBetweenEvictionRunsMillis(long timeBetweenEvictionRunsMillis) {

        this.timeBetweenEvictionRunsMillis = timeBetweenEvictionRunsMillis;

    }

    public long getMinEvictableIdleTimeMillis() {

        return minEvictableIdleTimeMillis;

    }

    public void setMinEvictableIdleTimeMillis(long minEvictableIdleTimeMillis) {

        this.minEvictableIdleTimeMillis = minEvictableIdleTimeMillis;

    }

    public String getValidationQuery() {

        return validationQuery;

    }

    public void setValidationQuery(String validationQuery) {

        this.validationQuery = validationQuery;

    }

    public boolean isTestWhileIdle() {

        return testWhileIdle;

    }

    public void setTestWhileIdle(boolean testWhileIdle) {

        this.testWhileIdle = testWhileIdle;

    }

    public boolean isTestOnBorrow() {

        return testOnBorrow;

    }

    public void setTestOnBorrow(boolean testOnBorrow) {

        this.testOnBorrow = testOnBorrow;

    }

    public boolean isTestOnReturn() {

        return testOnReturn;

    }

    public void setTestOnReturn(boolean testOnReturn) {

        this.testOnReturn = testOnReturn;

    }

    public boolean isPoolPreparedStatements() {

        return poolPreparedStatements;

    }

    public void setPoolPreparedStatements(boolean poolPreparedStatements) {

        this.poolPreparedStatements = poolPreparedStatements;

    }

    public int getMaxPoolPreparedStatementPerConnectionSize() {

        return maxPoolPreparedStatementPerConnectionSize;

    }

    public void setMaxPoolPreparedStatementPerConnectionSize(

            int maxPoolPreparedStatementPerConnectionSize) {

        this.maxPoolPreparedStatementPerConnectionSize = maxPoolPreparedStatementPerConnectionSize;

    }

    public String getFilters() {

        return filters;

    }

    public void setFilters(String filters) {

        this.filters = filters;

    }

    public String getConnectionProperties() {

        return connectionProperties;

    }

    public void setConnectionProperties(String connectionProperties) {

        this.connectionProperties = connectionProperties;

    }

     

}

package com.bfxy.springboot.config.database;

 

import javax.sql.DataSource;

 

import org.apache.ibatis.session.SqlSessionFactory;

import org.mybatis.spring.SqlSessionFactoryBean;

import org.mybatis.spring.SqlSessionTemplate;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import org.springframework.core.io.support.PathMatchingResourcePatternResolver;

import org.springframework.core.io.support.ResourcePatternResolver;

 

@Configuration

public class MybatisDataSourceConfig {

     

    @Autowired

    private DataSource dataSource;

     

    @Bean(name="sqlSessionFactory")

    public SqlSessionFactory sqlSessionFactoryBean() {

        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();

        bean.setDataSource(dataSource);

        // 添加XML目录

        ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();

        try {

            bean.setMapperLocations(resolver.getResources("classpath:com/bfxy/springboot/mapping/*.xml"));

            SqlSessionFactory sqlSessionFactory = bean.getObject();

            sqlSessionFactory.getConfiguration().setCacheEnabled(Boolean.TRUE);

             

            return sqlSessionFactory;

        } catch (Exception e) {

            throw new RuntimeException(e);

        }

    }

 

    @Bean

    public SqlSessionTemplate sqlSessionTemplate(SqlSessionFactory sqlSessionFactory) {

        return new SqlSessionTemplate(sqlSessionFactory);

    }

 

}

package com.bfxy.springboot.config.database;

 

import org.mybatis.spring.mapper.MapperScannerConfigurer;

import org.springframework.boot.autoconfigure.AutoConfigureAfter;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

 

@Configuration

@AutoConfigureAfter(MybatisDataSourceConfig.class)

public class MybatisMapperScanerConfig {

     

    @Bean

    public MapperScannerConfigurer mapperScannerConfigurer() {

        MapperScannerConfigurer mapperScannerConfigurer = new MapperScannerConfigurer();

        mapperScannerConfigurer.setSqlSessionFactoryBeanName("sqlSessionFactory");

        mapperScannerConfigurer.setBasePackage("com.bfxy.springboot.mapper");

        return mapperScannerConfigurer;

    }

 

}

  • 定时任务配置代码：

  • package com.bfxy.springboot.config.task;

     

    import java.util.concurrent.Executor;

    import java.util.concurrent.Executors;

     

    import org.springframework.context.annotation.Bean;

    import org.springframework.context.annotation.Configuration;

    import org.springframework.scheduling.annotation.EnableScheduling;

    import org.springframework.scheduling.annotation.SchedulingConfigurer;

    import org.springframework.scheduling.config.ScheduledTaskRegistrar;

     

    @Configuration

    @EnableScheduling

    public class TaskSchedulerConfig implements SchedulingConfigurer {

     

        @Override

        public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {

            taskRegistrar.setScheduler(taskScheduler());

        }

         

        @Bean(destroyMethod="shutdown")

        public Executor taskScheduler(){

            return Executors.newScheduledThreadPool(100);

        }

     

    }

  • 常量类：

package com.bfxy.springboot.constant;

 

public final class Constants {

 

    public static final String ORDER_SENDING = "0"; //发送中

     

    public static final String ORDER_SEND_SUCCESS = "1"; //成功

     

    public static final String ORDER_SEND_FAILURE = "2"; //失败

     

    public static final int ORDER_TIMEOUT = 1; /*分钟超时单位：min*/

}

  • 消息记录表核心业务：

package com.bfxy.springboot.mapper;

 

import java.util.Date;

 

import org.apache.ibatis.annotations.Param;

 

import com.bfxy.springboot.entity.BrokerMessageLog;

import com.sun.tools.javac.util.List;

 

public interface BrokerMessageLogMapper {

    /**

     * 查询消息状态为0(发送中) 且已经超时的消息集合

     * @return

     */

    List<BrokerMessageLog> query4StatusAndTimeoutMessage();

     

    /**

     * 重新发送统计count发送次数 +1

     * @param messageId

     * @param updateTime

     */

    void update4ReSend(@Param("messageId")String messageId, @Param("updateTime")Date updateTime);

    /**

     * 更新最终消息发送结果 成功 or 失败

     * @param messageId

     * @param status

     * @param updateTime

     */

    void changeBrokerMessageLogStatus(@Param("messageId")String messageId, @Param("status")String status, @Param("updateTime")Date updateTime);

 

 

     

}

  • 对应的SQL代码：

    <select id="query4StatusAndTimeoutMessage" resultMap="BaseResultMap">

          <![CDATA[  

          select message_id, message, try_count, status, next_retry, create_time, update_time

              from broker_message_log bml 

              where status = '0'

              and next_retry <= sysdate() 

          ]]> 

    </select>

   

  <update id="update4ReSend" >

    update broker_message_log bml

    set bml.try_count = bml.try_count + 1,

      bml.update_time = #{updateTime, jdbcType=TIMESTAMP}

    where bml.message_id = #{messageId,jdbcType=VARCHAR}

  </update>

   

  <update id="changeBrokerMessageLogStatus" >

    update broker_message_log bml

    set bml.status = #{status,jdbcType=VARCHAR},

          bml.update_time = #{updateTime, jdbcType=TIMESTAMP}

    where bml.message_id = #{messageId,jdbcType=VARCHAR}  

  </update>

  • 核心发送代码：orderService

  • package com.bfxy.springboot.service;

     

    import java.util.Date;

     

    import org.apache.commons.lang3.time.DateUtils;

    import org.springframework.beans.factory.annotation.Autowired;

    import org.springframework.stereotype.Service;

     

    import com.bfxy.springboot.constant.Constants;

    import com.bfxy.springboot.entity.BrokerMessageLog;

    import com.bfxy.springboot.entity.Order;

    import com.bfxy.springboot.mapper.BrokerMessageLogMapper;

    import com.bfxy.springboot.mapper.OrderMapper;

    import com.bfxy.springboot.producer.RabbitOrderSender;

    import com.bfxy.springboot.utils.FastJsonConvertUtil;

     

    @Service

    public class OrderService {

     

        @Autowired

        private OrderMapper orderMapper;

         

        @Autowired

        private BrokerMessageLogMapper brokerMessageLogMapper;

         

        @Autowired

        private RabbitOrderSender rabbitOrderSender;

         

        public void createOrder(Order order) throws Exception {

            // 使用当前时间当做订单创建时间（为了模拟一下简化）

            Date orderTime = new Date();

            // 插入业务数据

            orderMapper.insert(order);

            // 插入消息记录表数据

            BrokerMessageLog brokerMessageLog = new BrokerMessageLog();

            // 消息唯一ID

            brokerMessageLog.setMessageId(order.getMessageId());

            // 保存消息整体 转为JSON 格式存储入库

            brokerMessageLog.setMessage(FastJsonConvertUtil.convertObjectToJSON(order));

             // 设置消息状态为0 表示发送中

            brokerMessageLog.setStatus("0");

             // 设置消息未确认超时时间窗口为 一分钟 

            brokerMessageLog.setNextRetry(DateUtils.addMinutes(orderTime, Constants.ORDER_TIMEOUT));

            brokerMessageLog.setCreateTime(new Date());

            brokerMessageLog.setUpdateTime(new Date());

            brokerMessageLogMapper.insert(brokerMessageLog);

            // 发送消息

            rabbitOrderSender.sendOrder(order);

        }

         

    }

  • MQ消息发送核心代码：

package com.bfxy.springboot.producer;

 

import java.util.Date;

 

import org.springframework.amqp.rabbit.core.RabbitTemplate;

import org.springframework.amqp.rabbit.core.RabbitTemplate.ConfirmCallback;

import org.springframework.amqp.rabbit.support.CorrelationData;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Component;

 

import com.bfxy.springboot.constant.Constants;

import com.bfxy.springboot.entity.Order;

import com.bfxy.springboot.mapper.BrokerMessageLogMapper;

import com.bfxy.springboot.mapper.OrderMapper;

 

@Component

public class RabbitOrderSender {

 

    //自动注入RabbitTemplate模板类

    @Autowired

    private RabbitTemplate rabbitTemplate;  

     

    @Autowired

    private BrokerMessageLogMapper brokerMessageLogMapper;

     

    //回调函数: confirm确认

    final ConfirmCallback confirmCallback = new RabbitTemplate.ConfirmCallback() {

        @Override

        public void confirm(CorrelationData correlationData, boolean ack, String cause) {

            System.err.println("correlationData: " + correlationData);

            String messageId = correlationData.getId();

            if(ack){

                //如果confirm返回成功 则进行更新

                brokerMessageLogMapper.changeBrokerMessageLogStatus(messageId, Constants.ORDER_SEND_SUCCESS, new Date());

            } else {

                //失败则进行具体的后续操作:重试 或者补偿等手段

                System.err.println("异常处理...");

            }

        }

    };

     

    //发送消息方法调用: 构建自定义对象消息

    public void sendOrder(Order order) throws Exception {

        rabbitTemplate.setConfirmCallback(confirmCallback);

        //消息唯一ID

        CorrelationData correlationData = new CorrelationData(order.getMessage_id());

        rabbitTemplate.convertAndSend("order-exchange", "order.ABC", order, correlationData);

    }

     

}

  • 消息重试、最大努力尝试策略（定时任务）：

  • package com.bfxy.springboot.task;

     

    import java.util.Date;

    import java.util.List;

     

    import org.springframework.beans.factory.annotation.Autowired;

    import org.springframework.scheduling.annotation.Scheduled;

    import org.springframework.stereotype.Component;

     

    import com.bfxy.springboot.constant.Constants;

    import com.bfxy.springboot.entity.BrokerMessageLog;

    import com.bfxy.springboot.entity.Order;

    import com.bfxy.springboot.mapper.BrokerMessageLogMapper;

    import com.bfxy.springboot.producer.RabbitOrderSender;

    import com.bfxy.springboot.utils.FastJsonConvertUtil;

     

    @Component

    public class RetryMessageTasker {

     

         

        @Autowired

        private RabbitOrderSender rabbitOrderSender;

         

        @Autowired

        private BrokerMessageLogMapper brokerMessageLogMapper;

         

        @Scheduled(initialDelay = 5000, fixedDelay = 10000)

        public void reSend(){

            //pull status = 0 and timeout message 

            List<BrokerMessageLog> list = brokerMessageLogMapper.query4StatusAndTimeoutMessage();

            list.forEach(messageLog -> {

                if(messageLog.getTryCount() >= 3){

                    //update fail message 

                    brokerMessageLogMapper.changeBrokerMessageLogStatus(messageLog.getMessageId(), Constants.ORDER_SEND_FAILURE, new Date());

                } else {

                    // resend 

                    brokerMessageLogMapper.update4ReSend(messageLog.getMessageId(),  new Date());

                    Order reSendOrder = FastJsonConvertUtil.convertJSONToObject(messageLog.getMessage(), Order.class);

                    try {

                        rabbitOrderSender.sendOrder(reSendOrder);

                    } catch (Exception e) {

                        e.printStackTrace();

                        System.err.println("-----------异常处理-----------");

                    }

                }            

            });

        }

    }

  • 测试发送订单：

     

  • 代码如下：

    @Autowired

    private RabbitOrderSender rabbitOrderSender;

     

    @Test

    public void testSender2() throws Exception {

         Order order = new Order();

         order.setId("2018080400000001");

         order.setName("测试订单");

         order.setMessage_id(System.currentTimeMillis() + "$" + UUID.randomUUID().toString());

         rabbitOrderSender.sendOrder(order);

    }

  • 监控台查看消息：

 

  • 发送成功！ 现在测试 发送订单并且入库（业务库和消息记录库）

    @Autowired

    private OrderService orderService;

     

    @Test

    public void testCreateOrder() throws Exception {

         Order order = new Order();

         order.setId("2018080400000002");

         order.setName("测试创建订单");

         order.setMessageId(System.currentTimeMillis() + "$" + UUID.randomUUID().toString());

        orderService.createOrder(order);

    }

  • 发送成功 并且入库OK:业务表 和 消息记录表均有数据 且status状态=1 为成功！

  • 业务表：

https://img1.mukewang.com/5b659a0d0001294d07120154.jpg

  • 消息记录表：

https://img2.mukewang.com/5b659a6d00012db711880122.jpg

  • 测试失败情况：修改路由KEY为 无法路由即可！

https://img3.mukewang.com/5b659b5500010e4b13480264.jpg

  • 这样消息就算失败的情况了。然后ACK的时候就会走异常处理，消息记录表如下：

    https://img1.mukewang.com/5b659c0600012c4a16350393.jpg

  • 最后我们测试重试策略：直接启动生产者应用，开启定时任务，重试几次后，库表信息变化如下:

    https://img1.mukewang.com/5b659ef10001656613700204.jpg

  • 最终重试3次 失败结果更新 status = 2

来源：

https://www.imooc.com/article/49814

 

 

老姥
关注
专栏目录
Springboot整合RabbitMQ可靠性传输
unclecoco的博客
08-06 756
Springboot整合RabbitMQ可靠性传输(分布式事务部分实现方案） 开发环境：rabbitmq-server-3.6.10、otp_win64_19.3(erlang版本); 1.RabbitMQ安装问题 在安装过程中，可能遇到以下问题： 如果同时安装了activemq和rabbitmq，默认配置下会启动失败，这是由于activemq也同时支持多种协议：tcp、amqp、stomp、m...
RabbitMQ实现消息可靠投递
baobao的博客
07-08 1234
本文从本人博客搬运，原文格式更加美观，可以移步原文阅读：RabbitMQ实现消息可靠投递 实际开发中，我们经常需要保证消息由生产者发送到消费者接收并消费的整个过程中，消息不丢失，这就需要在RabbitMQ中实现消息的可靠投递。主要包含以下两部分： 发送端可靠性：指生产者发送消息到RabbitMQ Broker这个过程中保证消息不丢失 接收端可靠性：指RabbitMQ Broker将消息发送给消费者并且消费者正确处理消息的这个过程中保证消息不丢失 发送端可靠性 发送端可靠性主要包含3个方面： 消息抵达交
rabbitmq可靠性投递_RabbitMQ消息可靠性投递解决方案 - 基于SpringBoot实现
weixin_39633954的博客
12-22 182
谈到消息的可靠性投递，无法避免的，在实际的工作中会经常碰到，比如一些核心业务需要保障消息不丢失，接下来我们看一个可靠性投递的流程图，说明可靠性投递的概念：Step 1： 首先把消息信息(业务数据)存储到数据库中，紧接着，我们再把这个消息记录也存储到一张消息记录表里(或者另外一个同源数据库的消息记录表)Step 2：发送消息到MQ Broker节点(采用confirm方式发送，会有异步的返回结果)S...
SpringBoot整合RabbitMQ-消息可靠性投递
diaohudou1168的博客
01-22 492
本系列是学习SpringBoot整合RabbitMQ的练手，包含服务安装，RabbitMQ整合SpringBoot2.x，消息可靠性投递实现等三篇博客。 　　学习路径：https://www.imooc.com/learn/1042RabbitMQ消息中间件极速入门与实战 　　项目源码：https://github.com/ZbLeaning/Boot-RabbitMQ ...
rabbitmq+springboot实现消息可靠投递
zwjzone的博客
05-08 1175
最详细，最全面，无bug版消息可靠投递策略演示
RabbitMQ高级特性-消息可靠性投递
听雪楼
12-26 2761
消息如何保障100%的投递成功 什么是生产端的可靠性投递 保障消息的成功发出 保障MQ节点的成功接收 发送端收到MQ节点(Broker)的确认应答 完善的消息补偿机制 可靠性投递的解决方案 消息落库, 对消息状态进行标记 将消息落入数据库中, 对消息状态进行标记, 消息状态发生变更时, 更新标记信息 对失败消息进行轮询重发, 设置轮询次数 消息入库 消息发送 消费端消息确...
RabbitMQ 补偿机制、消息幂等性解决方案
Trouvailless的博客
04-15 711
1. 场景 先看这么几个面试题： 如何保证消息的可靠性投递？即如何确定消息是否发送成功？ 如果失败如何处理（补偿机制）？ 如何保证消息不被重复消费？或者说，如何保证消息消费时的幂等性？ 2.消息的可靠性投递 消息确认 消息确认包括主要生产者发送确认和消费者接受确认，因为发送消息的过程中我们是无法确认消息是否能路由等，一旦消息丢失我们就无法处理，所以需要确认消息，避免消息丢失。 2.1 生产者确认 我们知道生产者与消费者是完全隔离的，不做任何配置的情况下，生产者是不知道消息是否真正到达...
rabbitMQ 可靠性消息投递
qq_42572322的博客
09-06 353
参考(16条消息) RabbitMQ消息100%可靠性投递的解决方案实现(一)_eluanshi12的博客-CSDN博客_rabbitmq可靠性投递 可靠性消息： 在使用RabbitMQ时，作为消息发送方希望杜绝消息丢失或者投递失败的场景。RabbitMQ为我们提供了两种方式用来控制消息的投递可靠性。 confirm模式： 生产者发送消息到交换机的时机上使用 return模式 交换机转发给queue的时机上使用 confirm模式代码实现： 1加入起步依赖 <!--rabbi
springboot之rabbitmq实现消息可靠性
weixin_44390164的博客
09-24 372
1. 生产者模块通过publisher confirm机制实现消息可靠性 1.1 生产者模块导入rabbitmq相关依赖 <!--AMQP依赖，包含RabbitMQ--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency&
SpringBoot Rabbitmq 消息发送手动确认demo
10-30
SpringBoot Rabbitmq 消息发送手动确认demo,通过实现RabbitTemplate.ConfirmCallback 的confirm方法来手动确认
Springboot整合RabbitMQ 消息的可靠投递
Nov17的博客
03-08 350
Springboot整合RabbitMQ 消息的可靠投递 一、前言 在使用 RabbitMQ 的时候，作为消息发送方希望杜绝任何消息丢失或者投递失败场景。RabbitMQ 为我们提供了两种方式用来控制消息的投递可靠性模式。 confirm 确认模式 return 退回模式 先了解rabbitmq 整个消息投递的路径：producer—>rabbitmq broker—>exchange—>queue—>consumer 消息从 producer 到 exchang
rabbitmq 消息可靠性投递解决方案
三3三的博客
02-23 341
确保mq消息成功投递的解决方案 消息首先进行写盘操作，并赋予一个状态值(未投递-0，投递成功-1)，之后进行消息投递，等待MQ Broker返回消息确认接收命令，知道接收到成功命令，再将消息状态值改为投递成功，否则默认消息投递失败，消息的状态值不变。 投递失败消息处理方式 设置一个分布式定时任务（如果是多个服务，使用单点任务容易出现消息重复抓取的问题），定期去抓取消息状态值为0的消息，对消息进行轮询投递。设置一个消息投递过期时间，若消息投递之后3分钟或5分钟内没有收到消息确认接收命令，则用定时任务进
SpringBoot集成RabbitMQ---保证消息可靠性
xiaoping__的博客
04-29 2444
SpringBoot集成RabbitMQ—保证消息可靠性 在我们使用RabbitMQ消息队列时，使用生产者发送消息，可能出现发送失败，rabbitMQ宕机，一个消息重复发送等问题，一旦出现这种问题，如果不进行相应处理，就可能导致消息丢失，消费者重复消费一条信息等问题，消息就变得不可靠了，进而影响我们的业务逻辑。所以我们要对可能出现的问题进行相应的操作，来保证消息的可靠性。下面我们来介绍在生产端实现消息可靠性投递，消费端幂等性操作两种实现方式。 本篇文章是springboot集成RabbitMQ中保证消息可靠
SpringBoot整合RabbitMQ入门学习（二）[保证消息的可靠性]
红烧大熊猫的博客
01-14 628
SpringBoot整合RabbitMQ入门学习（二）  使用RabbitMQ过程中，消费者对消息处理时，难免会出现异常情况。但是消息往往都是非常关键的，为保证数据的完整性，RabbitMQ有两种机制可以保证消息的高可用性。事务机制和 confirm 机制，本文用confirm机制来探讨RabbitMQ的消息高可用性。 一、情景分析 1.生产者弄丢了数据 生产者将数据发送到 RabbitMQ 的时...
RabbitMQ三、springboot整合rabbitmq（消息可靠性、高级特性）
最新发布
学习笔记
06-01 1197
主要对rabbitmq的消息可靠性、高级特性进行阐述说了，理解rabbitmq的用法
如何保证RabbitMQ的高可用
m0_60524086的博客
04-24 2009
如何保证RabbitMQ的高可用
springboot rabbitmq高可用消息确认消费实战
一砖一瓦
03-01 837
RabbitMQ的高可用主要体现在消息的发送、传输和接收的过程中，可以保证消息成功发送、不会丢失，以及被确认消费/不重复消费。 - 对于消息是否发送成功，主要是针对生产者端的消息生产确认机制； - 对于消息不会丢失，主要是rabbitmq消息持久化机制； - 对于消息确认消费/不重复消费，主要是针对消费者端对消息的确认消费机制。
springBoot使用rabbitmq并保证消息可靠性
卷心菜投手
01-04 2826
1、rabbitmq在springboot中使用 2、rabbitmq数据可靠性投递
SpringBoot2与RabbitMQ整合实现可靠性消息投递
资源摘要信息:"SpringBoot整合RabbitMQ以实现消息队列的可靠性投递" 消息队列（MQ）是一种应用程序之间的通信方法，主要用于处理跨应用程序或服务的异步通信。RabbitMQ是一个开源的消息代理软件，实现了高级消息...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值