Java应用中处理Webhook请求的服务停机重试策略：无消息队列解决方案

CREATE TABLE webhook_tasks (
    id VARCHAR(36) PRIMARY KEY,
    payload TEXT NOT NULL,
    status VARCHAR(20) NOT NULL,
    target_url VARCHAR(255) NOT NULL,
    last_retry_time TIMESTAMP,
    retry_count INT DEFAULT 0,
    created_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    error_details TEXT
);

-- 为提高查询效率，可以为status和last_retry_time字段添加索引
CREATE INDEX idx_webhook_tasks_status_retry_time ON webhook_tasks (status, last_retry_time);

import java.time.LocalDateTime;
import java.util.UUID;

public class WebhookTaskService {

    // 假设通过Spring Data JPA或其他ORM框架注入
    private WebhookTaskRepository webhookTaskRepository;

    public void scheduleWebhookCall(String dataToSendJson, String targetUrl) {
        WebhookTask task = new WebhookTask();
        task.setId(UUID.randomUUID().toString());
        task.setPayload(dataToSendJson);
        task.setStatus(WebhookTask.TaskStatus.PENDING);
        task.setTargetUrl(targetUrl);
        task.setCreatedTime(LocalDateTime.now());
        task.setUpdatedTime(LocalDateTime.now());
        task.setRetryCount(0);
        webhookTaskRepository.save(task); // 持久化到数据库
        System.out.println("Webhook task scheduled: " + task.getId());
    }
}

// WebhookTask 实体类示例
public class WebhookTask {
    public enum TaskStatus {
        PENDING, IN_PROGRESS, SUCCESS, FAILED
    }
    // ... 字段定义及Getter/Setter ...
    private String id;
    private String payload;
    private TaskStatus status;
    private String targetUrl;
    private LocalDateTime lastRetryTime;
    private int retryCount;
    private LocalDateTime createdTime;
    private LocalDateTime updatedTime;
    private String errorDetails;
    // ... 构造函数等 ...
}

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate; // 或 WebClient
import java.time.LocalDateTime;
import java.util.List;
import java.util.concurrent.TimeUnit;

@Service
public class WebhookRetryScheduler {

    private final WebhookTaskRepository webhookTaskRepository;
    private final RestTemplate restTemplate; // 用于发送HTTP请求

    // 最大重试次数
    private static final int MAX_RETRIES = 5; 
    // 初始重试间隔（秒），用于指数退避
    private static final long INITIAL_RETRY_DELAY_SECONDS = 5; 

    public WebhookRetryScheduler(WebhookTaskRepository webhookTaskRepository, RestTemplate restTemplate) {
        this.webhookTaskRepository = webhookTaskRepository;
        this.restTemplate = restTemplate;
    }

    @Scheduled(fixedDelay = 10000) // 每10秒执行一次
    public void processPendingWebhooks() {
        // 查询所有处于PENDING或FAILED状态且已到重试时间的任务
        List<WebhookTask> tasksToProcess = webhookTaskRepository
                .findTasksToRetry(LocalDateTime.now());

        for (WebhookTask task : tasksToProcess) {
            // 避免并发问题，可以将状态先更新为IN_PROGRESS
            task.setStatus(WebhookTask.TaskStatus.IN_PROGRESS);
            task.setLastRetryTime(LocalDateTime.now());
            task.setRetryCount(task.getRetryCount() + 1);
            webhookTaskRepository.save(task); // 更新任务状态

            try {
                // 模拟发送HTTP请求到App A
                System.out.println("Attempting to send webhook " + task.getId() + " to " + task.getTargetUrl() + 
                                   ", retry count: " + task.getRetryCount());
                restTemplate.postForEntity(task.getTargetUrl(), task.getPayload(), String.class);

                // 请求成功
                task.setStatus(WebhookTask.TaskStatus.SUCCESS);
                task.setErrorDetails(null); // 清除错误信息
                System.out.println("Webhook " + task.getId() + " sent successfully.");

            } catch (Exception e) {
                // 请求失败
                task.setErrorDetails(e.getMessage());
                if (task.getRetryCount() < MAX_RETRIES) {
                    task.setStatus(WebhookTask.TaskStatus.FAILED); // 标记为失败，等待下次重试
                    System.err.println("Webhook " + task.getId() + " failed, will retry. Error: " + e.getMessage());
                } else {
                    // 达到最大重试次数，标记为最终失败，可能需要人工介入
                    task.setStatus(WebhookTask.TaskStatus.FAILED); 
                    System.err.println("Webhook " + task.getId() + " failed after max retries. Error: " + e.getMessage());
                    // TODO: 触发告警
                }
            } finally {
                task.setUpdatedTime(LocalDateTime.now());
                webhookTaskRepository.save(task); // 更新最终状态
            }
        }
    }

    // 假设WebhookTaskRepository是一个Spring Data JPA Repository
    public interface WebhookTaskRepository extends org.springframework.data.jpa.repository.JpaRepository<WebhookTask, String> {
        // 查询所有PENDING或FAILED状态，且重试次数未达上限，并且已过重试间隔的任务
        @org.springframework.data.jpa.repository.Query("SELECT t FROM WebhookTask t WHERE " +
                "(t.status = 'PENDING' OR (t.status = 'FAILED' AND t.retryCount < :maxRetries AND t.lastRetryTime < :retryThreshold)) " +
                "ORDER BY t.createdTime ASC")
        List<WebhookTask> findTasksToRetry(@org.springframework.data.repository.query.Param("retryThreshold") LocalDateTime retryThreshold,
                                           @org.springframework.data.repository.query.Param("maxRetries") int maxRetries);

        default List<WebhookTask> findTasksToRetry(LocalDateTime now) {
            // 计算重试阈值：对于PENDING任务立即重试，对于FAILED任务根据指数退避计算
            // 这里的查询逻辑可以更复杂，例如结合retry_count计算每个任务的retryThreshold
            // 简化处理，假设findTasksToRetry方法内部会处理重试间隔
            // 实际应用中，可以根据task.retryCount和INITIAL_RETRY_DELAY_SECONDS计算出每个任务的下一个重试时间
            // 并在查询时，筛选出 last_retry_time + calculated_delay < now 的任务
            return findTasksToRetry(now.minusSeconds(INITIAL_RETRY_DELAY_SECONDS), MAX_RETRIES); // 简单示例，实际需更精细
        }
    }
}