// Quartz集群架構(gòu)示意圖（代碼表示）
/*
 * ┌─────────────────┐  ┌─────────────────┐  ┌─────────────────┐
 * │  Quartz Node 1  │  │  Quartz Node 2  │  │  Quartz Node 3  │
 * │ ┌─────────────┐ │  │ ┌─────────────┐ │  │ ┌─────────────┐ │
 * │ │  Scheduler  │ │  │ │  Scheduler  │ │  │ │  Scheduler  │ │
 * │ └─────────────┘ │  │ └─────────────┘ │  │ └─────────────┘ │
 * └────────┬────────┘  └────────┬────────┘  └────────┬────────┘
 *          │                    │                    │
 *          │                    │                    │
 *          v                    v                    v
 * ┌─────────────────────────────────────────────────────────┐
 * │                    共享數(shù)據(jù)庫存儲                        │
 * │ ┌───────────────┐ ┌───────────────┐ ┌───────────────┐   │
 * │ │ QRTZ_TRIGGERS │ │  QRTZ_JOBS   │ │ QRTZ_LOCKS   │   │
 * │ └───────────────┘ └───────────────┘ └───────────────┘   │
 * └─────────────────────────────────────────────────────────┘
 */

// Quartz數(shù)據(jù)庫表核心關(guān)系示意
public class QuartzSchema {
    /*
     * QRTZ_JOB_DETAILS - 存儲JobDetail信息
     * 字段: JOB_NAME, JOB_GROUP, DESCRIPTION, JOB_CLASS_NAME, IS_DURABLE...
     * 
     * QRTZ_TRIGGERS - 存儲Trigger信息
     * 字段: TRIGGER_NAME, TRIGGER_GROUP, JOB_NAME, JOB_GROUP, NEXT_FIRE_TIME...
     * 
     * QRTZ_CRON_TRIGGERS - 存儲Cron觸發(fā)器特定信息
     * 字段: TRIGGER_NAME, TRIGGER_GROUP, CRON_EXPRESSION...
     * 
     * QRTZ_FIRED_TRIGGERS - 存儲已觸發(fā)的Trigger信息
     * 字段: ENTRY_ID, TRIGGER_NAME, TRIGGER_GROUP, INSTANCE_NAME, FIRED_TIME...
     * 
     * QRTZ_SCHEDULER_STATE - 存儲集群中的調(diào)度器狀態(tài)
     * 字段: INSTANCE_NAME, LAST_CHECKIN_TIME, CHECKIN_INTERVAL...
     * 
     * QRTZ_LOCKS - 集群鎖信息
     * 字段: LOCK_NAME (如TRIGGER_ACCESS, JOB_ACCESS, CALENDAR_ACCESS...)
     */
}

// Maven依賴配置
/*
<dependencies>
    <!-- Spring Boot Starter Quartz -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-quartz</artifactId>
    </dependency>
    <!-- 數(shù)據(jù)庫驅(qū)動 (以MySQL為例) -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <scope>runtime</scope>
    </dependency>
    <!-- 數(shù)據(jù)源 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-jdbc</artifactId>
    </dependency>
</dependencies>
*/
// 數(shù)據(jù)庫初始化配置 (application.properties)
/*
# 自動初始化Quartz表結(jié)構(gòu)
spring.quartz.jdbc.initialize-schema=always
# 也可以設(shè)置為never，手動執(zhí)行SQL腳本
# spring.quartz.jdbc.initialize-schema=never
*/

// Spring Boot中的Quartz集群配置
@Configuration
public class QuartzClusterConfig {
    @Bean
    public SchedulerFactoryBean schedulerFactoryBean(DataSource dataSource, JobFactory jobFactory) {
        SchedulerFactoryBean factory = new SchedulerFactoryBean();
        // 設(shè)置數(shù)據(jù)源
        factory.setDataSource(dataSource);
        // 使用自定義JobFactory，支持Spring依賴注入
        factory.setJobFactory(jobFactory);
        // Quartz屬性配置
        Properties props = new Properties();
        props.put("org.quartz.scheduler.instanceName", "ClusteredScheduler");
        props.put("org.quartz.scheduler.instanceId", "AUTO"); // 自動生成實例ID
        // JobStore配置 - 使用JDBC存儲
        props.put("org.quartz.jobStore.class", "org.quartz.impl.jdbcjobstore.JobStoreTX");
        props.put("org.quartz.jobStore.driverDelegateClass", "org.quartz.impl.jdbcjobstore.StdJDBCDelegate");
        props.put("org.quartz.jobStore.dataSource", "quartzDataSource");
        // 集群配置
        props.put("org.quartz.jobStore.isClustered", "true");
        props.put("org.quartz.jobStore.clusterCheckinInterval", "20000"); // 故障檢測間隔(毫秒)
        // 線程池配置
        props.put("org.quartz.threadPool.class", "org.quartz.simpl.SimpleThreadPool");
        props.put("org.quartz.threadPool.threadCount", "10");
        props.put("org.quartz.threadPool.threadPriority", "5");
        factory.setQuartzProperties(props);
        // 啟動時延遲5秒，避免應(yīng)用未完全啟動時執(zhí)行定時任務(wù)
        factory.setStartupDelay(5);
        return factory;
    }
    // 自定義JobFactory，支持Spring依賴注入
    @Bean
    public JobFactory jobFactory(ApplicationContext applicationContext) {
        AutowiringSpringBeanJobFactory jobFactory = new AutowiringSpringBeanJobFactory();
        jobFactory.setApplicationContext(applicationContext);
        return jobFactory;
    }
}
// Spring Bean感知的JobFactory實現(xiàn)
public class AutowiringSpringBeanJobFactory extends SpringBeanJobFactory implements ApplicationContextAware {
    private transient AutowireCapableBeanFactory beanFactory;
    @Override
    public void setApplicationContext(ApplicationContext context) throws BeansException {
        beanFactory = context.getAutowireCapableBeanFactory();
    }
    @Override
    protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
        final Object job = super.createJobInstance(bundle);
        beanFactory.autowireBean(job); // 對Job實例進(jìn)行依賴注入
        return job;
    }
}

// SpringBoot自動配置示例 (application.yml)
/*
spring:
  quartz:
    job-store-type: jdbc # 使用JDBC存儲
    jdbc:
      initialize-schema: always # 自動初始化表結(jié)構(gòu)
    properties:
      org.quartz.scheduler.instanceName: ClusteredScheduler
      org.quartz.scheduler.instanceId: AUTO
      org.quartz.jobStore.class: org.quartz.impl.jdbcjobstore.JobStoreTX
      org.quartz.jobStore.driverDelegateClass: org.quartz.impl.jdbcjobstore.StdJDBCDelegate
      org.quartz.jobStore.isClustered: true
      org.quartz.jobStore.clusterCheckinInterval: 20000
      org.quartz.threadPool.class: org.quartz.simpl.SimpleThreadPool
      org.quartz.threadPool.threadCount: 10
      org.quartz.threadPool.threadPriority: 5
  datasource:
    url: jdbc:mysql://localhost:3306/quartz_db?useSSL=false
    username: root
    password: password
    driver-class-name: com.mysql.cj.jdbc.Driver
*/

// 冪等性Job設(shè)計示例
@Component
public class IdempotentBatchJob implements Job {
    @Autowired
    private JobExecutionRepository repository;
    @Autowired
    private BatchProcessor batchProcessor;
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        // 獲取任務(wù)標(biāo)識
        JobKey jobKey = context.getJobDetail().getKey();
        String executionId = jobKey.getName() + "-" + System.currentTimeMillis();
        // 創(chuàng)建執(zhí)行記錄
        JobExecution execution = new JobExecution();
        execution.setExecutionId(executionId);
        execution.setJobName(jobKey.getName());
        execution.setStartTime(new Date());
        execution.setStatus("RUNNING");
        try {
            // 保存執(zhí)行記錄，同時作為分布式鎖檢查
            if (!repository.saveIfNotExists(execution)) {
                // 任務(wù)正在其他節(jié)點執(zhí)行，跳過本次執(zhí)行
                return;
            }
            // 獲取上次執(zhí)行點位
            String lastProcessedId = repository.getLastProcessedId(jobKey.getName());
            // 增量處理數(shù)據(jù)
            ProcessResult result = batchProcessor.processBatch(lastProcessedId, 1000);
            // 更新處理點位
            repository.updateLastProcessedId(jobKey.getName(), result.getLastId());
            // 更新執(zhí)行狀態(tài)
            execution.setStatus("COMPLETED");
            execution.setEndTime(new Date());
            execution.setProcessedItems(result.getProcessedCount());
            repository.update(execution);
        } catch (Exception e) {
            // 更新執(zhí)行失敗狀態(tài)
            execution.setStatus("FAILED");
            execution.setEndTime(new Date());
            execution.setErrorMessage(e.getMessage());
            repository.update(execution);
            throw new JobExecutionException(e);
        }
    }
}

// 自定義負(fù)載均衡策略示例
@Component
public class ResourceAwareJobListener implements JobListener {
    @Autowired
    private ResourceChecker resourceChecker;
    @Override
    public String getName() {
        return "resourceAwareJobListener";
    }
    @Override
    public void jobToBeExecuted(JobExecutionContext context) {
        // 獲取當(dāng)前節(jié)點ID
        String instanceId = context.getScheduler().getSchedulerInstanceId();
        // 獲取任務(wù)所需資源
        JobDataMap dataMap = context.getJobDetail().getJobDataMap();
        String requiredResource = dataMap.getString("requiredResource");
        // 檢查當(dāng)前節(jié)點是否適合執(zhí)行該任務(wù)
        if (!resourceChecker.isResourceAvailable(instanceId, requiredResource)) {
            // 如果資源不可用，拋出異常阻止執(zhí)行
            throw new JobExecutionException("Required resource not available on this node");
        }
    }
    @Override
    public void jobExecutionVetoed(JobExecutionContext context) {
        // 實現(xiàn)必要的邏輯
    }
    @Override
    public void jobWasExecuted(JobExecutionContext context, JobExecutionException jobException) {
        // 實現(xiàn)必要的邏輯
    }
}
// 注冊全局Job監(jiān)聽器
@Configuration
public class QuartzListenerConfig {
    @Autowired
    private ResourceAwareJobListener resourceAwareJobListener;
    @Bean
    public SchedulerListener schedulerListener() {
        return new CustomSchedulerListener();
    }
    @PostConstruct
    public void registerListeners() throws SchedulerException {
        Scheduler scheduler = schedulerFactoryBean.getScheduler();
        scheduler.getListenerManager().addJobListener(resourceAwareJobListener);
    }
}

// 索引優(yōu)化和表維護示例
/*
-- 常用索引優(yōu)化(部分?jǐn)?shù)據(jù)庫已默認(rèn)創(chuàng)建)
CREATE INDEX idx_qrtz_ft_job_group ON QRTZ_FIRED_TRIGGERS(JOB_GROUP);
CREATE INDEX idx_qrtz_ft_job_name ON QRTZ_FIRED_TRIGGERS(JOB_NAME);
CREATE INDEX idx_qrtz_t_next_fire_time ON QRTZ_TRIGGERS(NEXT_FIRE_TIME);
CREATE INDEX idx_qrtz_t_state ON QRTZ_TRIGGERS(TRIGGER_STATE);
-- 數(shù)據(jù)清理存儲過程示例
DELIMITER $$
CREATE PROCEDURE clean_quartz_history()
BEGIN
    -- 設(shè)置安全期限 (30天前)
    SET @cutoff_date = DATE_SUB(NOW(), INTERVAL 30 DAY);
    -- 刪除過期的觸發(fā)歷史
    DELETE FROM QRTZ_FIRED_TRIGGERS 
    WHERE SCHED_TIME < UNIX_TIMESTAMP(@cutoff_date) * 1000;
    -- 可以根據(jù)需要添加其他清理邏輯
END$$
DELIMITER ;
-- 創(chuàng)建定期執(zhí)行的事件
CREATE EVENT clean_quartz_history_event
ON SCHEDULE EVERY 1 DAY
DO CALL clean_quartz_history();
*/
// 數(shù)據(jù)源和連接池配置
@Bean
public DataSource quartzDataSource() {
    HikariConfig config = new HikariConfig();
    config.setJdbcUrl("jdbc:mysql://localhost:3306/quartz_db");
    config.setUsername("root");
    config.setPassword("password");
    // 連接池大小 = (節(jié)點數(shù) * 線程數(shù)) + 額外連接
    config.setMaximumPoolSize(50);
    config.setMinimumIdle(10);
    // 設(shè)置連接超時
    config.setConnectionTimeout(30000);
    config.setIdleTimeout(600000);
    return new HikariDataSource(config);
}

// Quartz集群監(jiān)控配置
@Configuration
public class QuartzMonitoringConfig {
    @Bean
    public JobExecutionHistoryListener jobHistoryListener(MeterRegistry registry) {
        return new JobExecutionHistoryListener(registry);
    }
}
// 任務(wù)執(zhí)行監(jiān)控實現(xiàn)
public class JobExecutionHistoryListener implements JobListener {
    private final MeterRegistry registry;
    private final Map<String, Timer> jobTimers = new ConcurrentHashMap<>();
    public JobExecutionHistoryListener(MeterRegistry registry) {
        this.registry = registry;
    }
    @Override
    public String getName() {
        return "jobExecutionHistoryListener";
    }
    @Override
    public void jobToBeExecuted(JobExecutionContext context) {
        // 記錄任務(wù)開始執(zhí)行
        context.put("executionStartTime", System.currentTimeMillis());
    }
    @Override
    public void jobWasExecuted(JobExecutionContext context, JobExecutionException exception) {
        String jobName = context.getJobDetail().getKey().toString();
        long startTime = (long) context.get("executionStartTime");
        long executionTime = System.currentTimeMillis() - startTime;
        // 記錄執(zhí)行時間
        Timer timer = jobTimers.computeIfAbsent(jobName, 
            k -> Timer.builder("quartz.job.execution.time")
                    .tag("job", jobName)
                    .register(registry));
        timer.record(executionTime, TimeUnit.MILLISECONDS);
        // 記錄執(zhí)行結(jié)果
        Counter.builder("quartz.job.execution.count")
               .tag("job", jobName)
               .tag("success", exception == null ? "true" : "false")
               .register(registry)
               .increment();
        // 還可以記錄更多指標(biāo)...
    }
    @Override
    public void jobExecutionVetoed(JobExecutionContext context) {
        Counter.builder("quartz.job.execution.vetoed")
               .tag("job", context.getJobDetail().getKey().toString())
               .register(registry)
               .increment();
    }
}