消息幂等性处理实现

消息幂等性处理实现

1. 基于数据库实现幂等性

@Service
@Slf4j
public class MessageProcessor {
    @Autowired
    private JdbcTemplate jdbcTemplate;

    public void processMessageWithDB(String messageId, String content) {
        // 1. 查询消息是否已处理
        String sql = "SELECT COUNT(*) FROM message_record WHERE message_id = ?";
        int count = jdbcTemplate.queryForObject(sql, Integer.class, messageId);
        if (count > 0) {
            log.info("Message already processed, messageId: {}", messageId);
            return;
        }
        // 2. 处理业务逻辑
        try {
            // 执行业务处理
            processBusinessLogic(content);
            // 3. 记录消息处理状态
            String insertSql = "INSERT INTO message_record (message_id, status, create_time) VALUES (?, ?, ?)";
            jdbcTemplate.update(insertSql, messageId, "SUCCESS", new Date());
        } catch (Exception e) {
            // 记录失败状态
            String insertSql = "INSERT INTO message_record (message_id, status, create_time, error_msg) VALUES (?, ?, ?, ?)";
            jdbcTemplate.update(insertSql, messageId, "FAILED", new Date(), e.getMessage());
            throw e;
        }
    }
}

2. 基于Redis实现幂等性

@Service
@Slf4j
public class RedisMessageProcessor {
    @Autowired
    private StringRedisTemplate redisTemplate;
    private static final String MESSAGE_CONSUMED_KEY_PREFIX = "mq:consumed:";
    private static final long EXPIRE_TIME = 24 * 60 * 60; // 24小时过期

    public void processMessageWithRedis(String messageId, String content) {
        String consumeKey = MESSAGE_CONSUMED_KEY_PREFIX + messageId;
        // 1. 使用Redis的setNX命令实现幂等性检查
        Boolean setSuccess = redisTemplate.opsForValue()
                .setIfAbsent(consumeKey, "1", EXPIRE_TIME, TimeUnit.SECONDS);
        if (Boolean.FALSE.equals(setSuccess)) {
            log.info("Message already processed, messageId: {}", messageId);
            return;
        }
        try {
            // 2. 处理业务逻辑
            processBusinessLogic(content);
        } catch (Exception e) {
            // 3. 处理失败时，删除Redis标记
            redisTemplate.delete(consumeKey);
            throw e;
        }
    }

    private void processBusinessLogic(String content) {

    }
}

3. 基于业务唯一标识实现幂等性

@Service
public class BusinessIdempotentProcessor {
    @Autowired
    private OrderService orderService;

    public void processOrder(OrderMessage orderMessage) {
        // 1. 从消息中提取业务唯一标识
        String orderNo = orderMessage.getOrderNo();
        // 2. 查询订单是否已存在
        if (orderService.isOrderExists(orderNo)) {
            log.info("Order already exists, orderNo: {}", orderNo);
            return;
        }
        // 3. 使用数据库唯一索引保证幂等性
        try {
            Order order = new Order();
            order.setOrderNo(orderNo); // orderNo字段有唯一索引
            order.setAmount(orderMessage.getAmount());
            order.setStatus(OrderStatus.CREATED);
            orderService.createOrder(order);
        } catch (DuplicateKeyException e) {
            log.info("Order already processed, orderNo: {}", orderNo);
        }
    }
}

4. 分布式锁实现幂等性

@Service
public class DistributedLockProcessor {
    @Autowired
    private RedissonClient redissonClient;

    public void processMessageWithLock(String messageId, String content) {
        String lockKey = "mq:lock:" + messageId;
        RLock lock = redissonClient.getLock(lockKey);
        try {
            // 1. 尝试获取分布式锁
            boolean locked = lock.tryLock(5, 10, TimeUnit.SECONDS);
            if (!locked) {
                log.warn("Failed to acquire lock for messageId: {}", messageId);
                return;
            }
            // 2. 检查消息是否已处理
            if (isMessageProcessed(messageId)) {
                return;
            }
            // 3. 处理业务逻辑
            processBusinessLogic(content);
            // 4. 记录处理状态
            markMessageAsProcessed(messageId);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new RuntimeException("Processing interrupted", e);
        } finally {
            // 5. 释放锁
            if (lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }
    }
}

5. 幂等性处理最佳实践

1. 选择合适的幂等性实现方案：
   • 对于高并发场景，推荐使用Redis或分布式锁
   • 对于对数据一致性要求高的场景，推荐使用数据库唯一索引
   • 对于有业务唯一标识的场景，推荐使用业务唯一标识