<!-- Spring Boot 整合 Quartz -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-quartz</artifactId>
</dependency>
<!-- 數(shù)據(jù)庫依賴（以 MySQL 為例，用于任務(wù)持久化） -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
    <groupId>com.mysql</groupId>
    <artifactId>mysql-connector-j</artifactId>
    <scope>runtime</scope>
</dependency>

yaml
spring:
  # 數(shù)據(jù)庫配置（Quartz 任務(wù)將存儲到該庫）
  datasource:
    url: jdbc:mysql://localhost:3306/quartz_db?useSSL=false&serverTimezone=UTC&allowPublicKeyRetrieval=true
    username: root
    password: 123456
    driver-class-name: com.mysql.cj.jdbc.Driver
  # JPA 配置（可選，用于存儲業(yè)務(wù)結(jié)束時間，方便管理）
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true
# Quartz 配置（核心：數(shù)據(jù)庫持久化）
quartz:
  job-store-type: jdbc # 任務(wù)存儲類型：jdbc（數(shù)據(jù)庫），默認是 memory（內(nèi)存）
  jdbc:
    initialize-schema: always # 自動創(chuàng)建 Quartz 所需表（首次啟動用 always，后續(xù)改為 never）
  properties:
    org:
      quartz:
        scheduler:
          instanceName: pushScheduler
          instanceId: AUTO # 集群模式下自動分配實例ID
        jobStore:
          class: org.quartz.impl.jdbcjobstore.JobStoreTX
          driverDelegateClass: org.quartz.impl.jdbcjobstore.StdJDBCDelegate
          tablePrefix: QRTZ_ # Quartz 表前綴（自動創(chuàng)建的表會帶此前綴）
          isClustered: false # 單節(jié)點用 false，集群部署改為 true
          clusterCheckinInterval: 20000
        threadPool:
          class: org.quartz.simpl.SimpleThreadPool
          threadCount: 10 # 線程池大小

import jakarta.persistence.*;
import lombok.Data;
import java.time.LocalDateTime;
@Data
@Entity
@Table(name = "push_task")
public class PushTask {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id; // 自增ID
    @Column(name = "end_time", nullable = false)
    private LocalDateTime endTime; // 原始結(jié)束時間（如明天3點）
    @Column(name = "trigger_time", nullable = false)
    private LocalDateTime triggerTime; // 推送觸發(fā)時間（endTime -5分鐘）
    @Column(name = "quartz_job_id", unique = true, nullable = false)
    private String quartzJobId; // 關(guān)聯(lián) Quartz 的 JobDetail ID
    @Column(name = "task_desc")
    private String taskDesc; // 任務(wù)描述（如“訂單123超時提醒”）
    @Column(name = "status")
    private Integer status; // 狀態(tài)：0-未觸發(fā) 1-已觸發(fā) 2-已取消
}

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.time.LocalDateTime;
/**
 * 消息推送 Job（Quartz 任務(wù)）
 */
@Component
public class PushMessageJob implements Job {
    private static final Logger logger = LoggerFactory.getLogger(PushMessageJob.class);
    @Autowired
    private PushTaskRepository pushTaskRepository; // 后續(xù)定義的 DAO 接口
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        // 1. 從 Job 上下文獲取參數(shù)（ quartzJobId + 任務(wù)描述 ）
        String quartzJobId = context.getJobDetail().getKey().getName();
        String taskDesc = (String) context.getJobDetail().getJobDataMap().get("taskDesc");
        String triggerTimeDate = (String) context.getJobDetail().getJobDataMap().get("triggerTime");
        LocalDateTime triggerTime = null;
        if (null != triggerTimeDate) {
            triggerTime = LocalDateTime.parse(triggerTimeDate);
        }
        try {
            // 2. 核心：執(zhí)行消息推送（替換為你的實際邏輯：短信、APP推送、郵件等）
            doPush(taskDesc, triggerTime);
            // 3. 更新業(yè)務(wù)任務(wù)狀態(tài)為“已觸發(fā)”
            pushTaskRepository.updateStatusByQuartzJobId(1, quartzJobId);
            logger.info("消息推送成功！quartzJobId：{}，任務(wù)描述：{}，觸發(fā)時間：{}",
                    quartzJobId, taskDesc, triggerTime);
        } catch (Exception e) {
            logger.error("消息推送失??！quartzJobId：{}", quartzJobId, e);
            // 可選：拋出異常觸發(fā) Quartz 重試（需配置重試策略）
            throw new JobExecutionException("推送失敗，觸發(fā)重試", e, true);
        }
    }
    /**
     * 實際推送邏輯（根據(jù)業(yè)務(wù)需求替換）
     */
    private void doPush(String taskDesc, LocalDateTime triggerTime) {
        // 示例1：打印日志（實際場景替換為第三方推送接口）
        System.out.printf("[推送通知] 任務(wù)描述：%s，觸發(fā)時間：%s，內(nèi)容：即將到達結(jié)束時間（提前5分鐘提醒）%n",
                taskDesc, triggerTime);
        // 示例2：調(diào)用 HTTP 推送接口（如極光推送）
        // RestTemplate restTemplate = new RestTemplate();
        // String pushUrl = "https://api.jpush.cn/v3/push";
        // PushRequest request = new PushRequest();
        // request.setContent("即將到達結(jié)束時間：" + taskDesc);
        // restTemplate.postForObject(pushUrl, request, String.class);
    }
}

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.transaction.annotation.Transactional;
import java.time.LocalDateTime;
public interface PushTaskRepository extends JpaRepository<PushTask, Long> {
    // 根據(jù) QuartzJobId 查詢?nèi)蝿?wù)
    PushTask findByQuartzJobId(String quartzJobId);
    // 更新任務(wù)狀態(tài)
    @Modifying
    @Transactional
    @Query("update PushTask t set t.status = :status where t.quartzJobId = :quartzJobId")
    int updateStatusByQuartzJobId(Integer status, String quartzJobId);
    // 根據(jù)狀態(tài)和觸發(fā)時間查詢未執(zhí)行的任務(wù)（服務(wù)重啟后恢復(fù)任務(wù)用）
    @Query("select t from PushTask t where t.status = 0 and t.triggerTime > :now")
    List<PushTask> findUnTriggeredTasks(LocalDateTime now);
}

import org.quartz.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.time.LocalDateTime;
import java.util.List;
import java.util.UUID;
@Service
public class DynamicQuartzService {
    @Autowired
    private Scheduler scheduler;
    @Autowired
    private PushTaskRepository pushTaskRepository;
    // 任務(wù)組名（統(tǒng)一分組，方便管理）
    private static final String JOB_GROUP = "PUSH_JOB_GROUP";
    private static final String TRIGGER_GROUP = "PUSH_TRIGGER_GROUP";
    /**
     * 核心方法：添加推送任務(wù)（自動計算提前5分鐘觸發(fā)）
     *
     * @params endTime   原始結(jié)束時間（如明天3點）
     * @params triggerTime   觸發(fā)時間（如明天2點）
     * @params taskDesc  任務(wù)描述（如“訂單123超時提醒”）
     * @return 保存的業(yè)務(wù)任務(wù)
     */
       public PushTask addPushTask(LocalDateTime endTime, LocalDateTime triggerTime,String taskDesc) throws SchedulerException {
        PaAssert.notNull(endTime, "結(jié)束時間不能為空！");
        PaAssert.notNull(triggerTime, "觸發(fā)時間不能為空！");
        // 校驗結(jié)束時間
        LocalDateTime now = LocalDateTime.now();
        if (endTime.isBefore(now) || endTime.isEqual(now)) {
            throw new IllegalArgumentException("結(jié)束時間必須晚于當前時間！");
        }
        if (triggerTime.isBefore(now) || triggerTime.isEqual(now)) {
            throw new IllegalArgumentException("觸發(fā)時間必須晚于當前時間！");
        }
        // 3. 生成唯一的 QuartzJobId（避免重復(fù)）
        String quartzJobId = "PUSH_JOB_" + UUID.randomUUID().toString().replace("-", "");
        // 4. 構(gòu)建 Quartz JobDetail（綁定 PushMessageJob）
        JobDetail jobDetail = JobBuilder.newJob(PushMessageJob.class)
                .withIdentity(quartzJobId, JOB_GROUP) // 任務(wù)ID：quartzJobId，組名：JOB_GROUP
                .usingJobData("taskDesc", taskDesc)
                .usingJobData("triggerTime", String.valueOf(triggerTime))
                .storeDurably() // 持久化（無觸發(fā)器時也保留）
                .build();
        // 5. 構(gòu)建 CronTrigger（根據(jù) triggerTime 生成 Cron 表達式）
        String cronExpression = buildCronExpression(triggerTime);
        CronTrigger trigger = TriggerBuilder.newTrigger()
                .withIdentity(quartzJobId, TRIGGER_GROUP)
                .forJob(jobDetail)
                .withSchedule(CronScheduleBuilder.cronSchedule(cronExpression)
                        .withMisfireHandlingInstructionFireAndProceed()) // 錯過觸發(fā)時立即執(zhí)行
                .startNow()
                // 關(guān)鍵：觸發(fā)時間+1分鐘，確保僅執(zhí)行一次（避免循環(huán)或重復(fù)觸發(fā)）
                .endAt(Date.from(triggerTime.plusMinutes(1).atZone(ZoneId.systemDefault()).toInstant()))
                .build();
        // 6. 注冊任務(wù)到 Quartz 調(diào)度器
        scheduler.scheduleJob(jobDetail, trigger);
        // 7. 保存業(yè)務(wù)任務(wù)到數(shù)據(jù)庫（關(guān)聯(lián) QuartzJobId）
        PushTask pushTask = new PushTask();
        pushTask.setEndTime(endTime);
        pushTask.setTriggerTime(triggerTime);
        pushTask.setQuartzJobId(quartzJobId);
        pushTask.setTaskDesc(taskDesc);
        pushTask.setStatus(0); // 0-未觸發(fā)
        return pushTaskRepository.save(pushTask);
    }
    /**
     * 刪除推送任務(wù)（同時刪除 Quartz 任務(wù)和業(yè)務(wù)任務(wù)）
     * @param quartzJobId 任務(wù)ID（添加任務(wù)時返回的 quartzJobId）
     */
    public void deletePushTask(String quartzJobId) throws SchedulerException {
        // 1. 停止并刪除 Quartz 任務(wù)
        JobKey jobKey = JobKey.jobKey(quartzJobId, JOB_GROUP);
        TriggerKey triggerKey = TriggerKey.triggerKey(quartzJobId, TRIGGER_GROUP);
        scheduler.pauseTrigger(triggerKey); // 暫停觸發(fā)器
        scheduler.unscheduleJob(triggerKey); // 移除觸發(fā)器
        scheduler.deleteJob(jobKey); // 刪除任務(wù)
        // 2. 更新業(yè)務(wù)任務(wù)狀態(tài)為“已取消”
        pushTaskRepository.updateStatusByQuartzJobId(2, quartzJobId);
    }
    /**
     * 服務(wù)重啟后恢復(fù)未觸發(fā)的任務(wù)（關(guān)鍵：避免任務(wù)丟失）
     */
    public void restoreUnTriggeredTasks() throws SchedulerException {
        // 1. 查詢數(shù)據(jù)庫中“未觸發(fā)”且“觸發(fā)時間未到”的任務(wù)
        List<PushTask> unTriggeredTasks = pushTaskRepository.findUnTriggeredTasks(LocalDateTime.now());
        if (unTriggeredTasks.isEmpty()) {
            return;
        }
        // 2. 重新注冊這些任務(wù)到 Quartz
        for (PushTask task : unTriggeredTasks) {
            String quartzJobId = task.getQuartzJobId();
            LocalDateTime triggerTime = task.getTriggerTime();
            String taskDesc = task.getTaskDesc();
            // 構(gòu)建 JobDetail
            JobDetail jobDetail = JobBuilder.newJob(PushMessageJob.class)
                    .withIdentity(quartzJobId, JOB_GROUP)
                    .usingJobData("taskDesc", taskDesc)
                    .usingJobData("triggerTime", String.valueOf(triggerTime))
                    .storeDurably()
                    .build();
            // 構(gòu)建 Trigger
            String cronExpression = buildCronExpression(triggerTime);
            CronTrigger trigger = TriggerBuilder.newTrigger()
                    .withIdentity(quartzJobId, TRIGGER_GROUP)
                    .forJob(jobDetail)
                    .withSchedule(CronScheduleBuilder.cronSchedule(cronExpression))
                    .startNow()
                    .build();
            // 注冊任務(wù)
            scheduler.scheduleJob(jobDetail, trigger);
        }
        System.out.printf("恢復(fù)未觸發(fā)的推送任務(wù)數(shù)量：%d%n", unTriggeredTasks.size());
    }
    /**
     * 工具方法：將 LocalDateTime 轉(zhuǎn)換為 Cron 表達式（精準到秒）
     * Cron 格式：秒 分 時 日 月 周 年（年可選）
     * 例：2025-11-01 02:55:00 → 0 55 2 1 11 ? 2025
     */
    private String buildCronExpression(LocalDateTime triggerTime) {
        int second = triggerTime.getSecond(); // 秒（0）
        int minute = triggerTime.getMinute(); // 分（0）
        int hour = triggerTime.getHour();     // 時（16）
        int day = triggerTime.getDayOfMonth();// 日（21）
        int month = triggerTime.getMonthValue();// 月（11，LocalDateTime 直接是 1-12，無需+1）
        int year = triggerTime.getYear();     // 年（2025）
        // Cron 格式：秒 分 時 日 月 ? 年 → 周字段用 ?，避免與日沖突
        return String.format("%d %d %d %d %d ? %d",
                second, minute, hour, day, month, year);
    }
}

import org.quartz.SchedulerException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.ApplicationRunner;
import org.springframework.stereotype.Component;
@Component
public class TaskRestoreRunner implements ApplicationRunner {
    @Autowired
    private DynamicQuartzService dynamicQuartzService;
    @Override
    public void run(ApplicationArguments args) throws SchedulerException {
        // 服務(wù)啟動后，恢復(fù)未觸發(fā)的任務(wù)
        dynamicQuartzService.restoreUnTriggeredTasks();
    }
}

import org.quartz.SchedulerException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.web.bind.annotation.*;
import java.time.LocalDateTime;
@RestController
@RequestMapping("/push")
public class PushTaskController {
    @Autowired
    private DynamicQuartzService dynamicQuartzService;
    /**
     * 添加推送任務(wù)
     * @param endTime 結(jié)束時間（格式：yyyy-MM-dd HH:mm:ss，如 2025-11-01 03:00:00）
     * @param taskDesc 任務(wù)描述
     */
    @PostMapping("/add")
    public PushTask addTask(
            @RequestParam @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") LocalDateTime endTime,
            @RequestParam String taskDesc) throws SchedulerException {
        return dynamicQuartzService.addPushTask(endTime, taskDesc);
    }
    /**
     * 刪除推送任務(wù)
     * @param quartzJobId 任務(wù)ID（添加任務(wù)時返回的 quartzJobId）
     */
    @PostMapping("/delete")
    public String deleteTask(@RequestParam String quartzJobId) throws SchedulerException {
        dynamicQuartzService.deletePushTask(quartzJobId);
        return "任務(wù)刪除成功！quartzJobId：" + quartzJobId;
    }
}