# delay-message

**Repository Path**: qiuyu97/delay-message

## Basic Information

- **Project Name**: delay-message
- **Description**: 基于springboot实现的延迟消息的starter。目前基于DelayQueue、Redission、RabbitMq实现了三种方式。
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 1
- **Forks**: 0
- **Created**: 2023-05-06
- **Last Updated**: 2025-10-21

## Categories & Tags

**Categories**: Uncategorized

**Tags**: Java, 延迟消息

## README

# 延迟消息解决方案 (Delay Message)

## 📋 项目介绍

Delay Message 是一个高性能、可扩展的延迟消息解决方案，提供了简单易用的API和多种实现方式，可以轻松集成到Spring Boot项目中。该框架支持三种不同的延迟消息实现方式，满足不同场景下的需求，同时具有良好的可扩展性和配置灵活性。

### 🚀 核心特性

- **多模式支持**：提供SIMPLE（内存）、RABBITMQ、REDISSON三种实现模式
- **批量操作**：支持批量发送、删除和更新延迟消息，提高处理效率
- **消息重试**：内置可配置的重试机制，增强系统可靠性
- **优雅关闭**：支持应用程序优雅关闭，避免消息丢失
- **线程池优化**：可自定义线程池配置，适应不同并发需求
- **Spring Boot自动装配**：简单配置即可快速集成

## 🏗️ 架构设计

项目采用模块化设计，主要包含以下模块：

- **delay-message-core**：核心功能实现，包含接口定义、消息模型和各模式的实现类
- **delay-message-spring-boot-starter**：Spring Boot自动配置模块，提供自动装配功能
- **delay-message-demo**：示例项目，展示如何使用该框架

## 📦 快速开始

### 1. 添加依赖

在项目的`pom.xml`文件中添加以下依赖：

```xml
<dependency>
    <groupId>com.qiuyu</groupId>
    <artifactId>delay-message-spring-boot-starter</artifactId>
    <version>1.0.0-SNAPSHOT</version>
</dependency>
```

### 2. 定义事件枚举

创建自定义枚举实现`Event`接口，用于定义延迟事件：

```java
@Getter
@AllArgsConstructor
public enum BusinessEvent implements Event {
    ORDER_PAYMENT_TIMEOUT("orderPaymentTimeout", "订单支付超时", "orderPaymentTimeoutQueue"),
    EMAIL_DELAY_SEND("emailDelaySend", "邮件延迟发送", "emailDelaySendQueue"),
    INVENTORY_CHECK("inventoryCheck", "库存检查", "inventoryCheckQueue");

    private final String eventKey;
    private final String eventDesc;
    private final String queueName;
    
}
```

### 3. 创建消息处理器

实现`DelayMessageHandler`接口，处理特定事件的延迟消息：

```java
@Component
@Slf4j
public class OrderPaymentTimeoutHandler implements DelayMessageHandler {
    
    @Override
    public Event bind() {
        return BusinessEvent.ORDER_PAYMENT_TIMEOUT;
    }
    
    @Override
    public void handle(DelayMessage delayMessage) {
        log.info("处理订单支付超时消息: {}", delayMessage);
        // 实现订单支付超时逻辑，如取消订单、释放库存等
        try {
            // 处理业务逻辑
            String orderId = delayMessage.getBody2Bean(String.class);
            // 执行取消订单操作
        } catch (Exception e) {
            log.error("处理订单支付超时消息失败", e);
            // 异常会被重试机制捕获并处理
        }
    }
}
```

### 4. 发送延迟消息

注入`DelayMessageManager`并使用它发送延迟消息：

```java
@Service
public class OrderService {
    
    @Autowired
    private DelayMessageManager delayMessageManager;
    
    public void createOrder(Order order) {
        // 创建订单逻辑
        
        // 设置支付超时检查，30分钟后检查订单支付状态
        DelayMessage delayMessage = DelayMessage.builder()
                .event(BusinessEvent.ORDER_PAYMENT_TIMEOUT)
                .msgId("ORDER_TIMEOUT_" + order.getId())
                .body(JSONUtil.toJsonStr(order.getId()))
                .build();
                
        delayMessageManager.offer(delayMessage, 30, TimeUnit.MINUTES);
    }
}
```

## ⚙️ 配置说明

在`application.yml`中进行配置：

```yaml
delay-message:
  enabled: true              # 是否启用延迟消息功能
  mode: rabbitmq             # 延迟消息模式：simple(内存), rabbitmq, redisson
  thread-pool:               # 线程池配置
    core-pool-size: 8        # 核心线程数，默认CPU核心数*2
    max-pool-size: 16        # 最大线程数，默认CPU核心数*4
    queue-capacity: 500      # 队列容量
    keep-alive-time: 60      # 线程空闲时间(秒)
    allow-core-thread-time-out: false  # 是否允许核心线程超时
  retry-config:              # 重试配置
    enabled: true            # 是否启用重试
    max-retry-count: 3       # 最大重试次数
    retry-interval-ms: 2000  # 重试间隔(毫秒)

# 根据选择的模式，配置相应的依赖服务
spring:
  redis:                     # Redisson模式需要
    host: 127.0.0.1
    port: 6379
    database: 0
  rabbitmq:                  # RabbitMQ模式需要
    host: 127.0.0.1
    port: 5672
    username: guest
    password: guest
```

## 📚 API使用指南

### 单条消息操作

```java
// 发送延迟消息
delayMessageManager.offer(delayMessage, delayTime, timeUnit);

// 删除延迟消息
delayMessageManager.remove(delayMessage);

// 更新延迟消息的延迟时间
delayMessageManager.update(delayMessage, newDelayTime, timeUnit);
```

### 批量操作 (推荐用于高并发场景)

```java
// 批量发送具有相同延迟的消息
List<DelayMessage> messages = new ArrayList<>();
// 添加消息...
delayMessageManager.offerBatch(messages, delayTime, timeUnit);

// 批量发送具有不同延迟的消息
Map<DelayMessage, Long> messageDelayMap = new LinkedHashMap<>();
// 添加消息和对应延迟...
delayMessageManager.offerBatch(messageDelayMap, timeUnit);

// 批量删除消息
Map<DelayMessage, Boolean> removeResults = delayMessageManager.removeBatch(messages);

// 批量更新消息延迟
Map<DelayMessage, Boolean> updateResults = delayMessageManager.updateBatch(messageDelayMap, timeUnit);
```

### 便捷的消息创建

```java
// 使用构建器创建消息
DelayMessage message = DelayMessage.builder()
    .event(event)
    .msgId("自定义消息ID")
    .body("消息内容")
    .build();
```

## 🔧 模式选择指南

| 模式 | 优点 | 缺点 | 适用场景 |
|------|------|------|----------|
| SIMPLE | 配置简单，无外部依赖 | 不支持持久化，仅适用于单机部署 | 开发测试环境，非关键业务 |
| RABBITMQ | 支持持久化，高可靠，分布式 | 需要部署RabbitMQ服务 | 生产环境，需要高可靠性 |
| REDISSON | 配置简单，支持分布式 | 依赖Redis，需考虑持久化配置 | 中小规模应用，Redis已作为基础设施 |

## 💡 最佳实践

1. **合理设置消息ID**：使用业务唯一标识作为消息ID，便于后续追踪和管理
2. **消息内容序列化**：建议使用JSON格式序列化复杂对象
3. **异常处理**：在处理器中适当捕获异常，避免影响整体服务
4. **资源清理**：对于不再需要的延迟消息，及时调用remove方法删除
5. **配置优化**：根据实际业务量调整线程池和重试参数

## 🤝 参与贡献

欢迎贡献代码、报告问题或提出建议：

1. Fork 本仓库
2. 新建 Feat_xxx 分支
3. 提交代码
4. 新建 Pull Request

## 📄 许可证

本项目采用MIT许可证。