Quartz高级特性

cheniy2025/8/15大约 3 分钟

Quartz高级特性

前置知识

在学习本教程之前，请确保您已经：

掌握Quartz的基础知识
了解数据库基础操作
熟悉Spring框架
了解分布式系统基础

持久化存储

1. 数据库配置

数据库配置示例

# application.yml
spring:
  quartz:
    job-store-type: jdbc # 使用JDBC存储
    jdbc:
      initialize-schema: always # 自动初始化表结构
    properties:
      org.quartz.jobStore.class: org.quartz.impl.jdbcjobstore.JobStoreTX
      org.quartz.jobStore.driverDelegateClass: org.quartz.impl.jdbcjobstore.StdJDBCDelegate
      org.quartz.jobStore.tablePrefix: QRTZ_
      org.quartz.jobStore.isClustered: false
      org.quartz.jobStore.useProperties: true

2. 表结构说明

Quartz数据库主要包含以下表：

QRTZ_JOBS: 存储作业信息
QRTZ_TRIGGERS: 存储触发器信息
QRTZ_SIMPLE_TRIGGERS: 简单触发器信息
QRTZ_CRON_TRIGGERS: Cron触发器信息
QRTZ_SCHEDULER_STATE: 调度器状态信息

集群配置

1. 基本配置

集群配置示例

spring:
  quartz:
    properties:
      org.quartz.jobStore.isClustered: true # 开启集群
      org.quartz.jobStore.clusterCheckinInterval: 20000 # 检查间隔（毫秒）
      org.quartz.scheduler.instanceId: AUTO # 自动生成实例ID
      org.quartz.scheduler.instanceName: MyClusteredScheduler

2. 集群原理

任务分配：集群中的节点共享数据库中的任务
故障转移：当一个节点失效，其他节点接管任务
负载均衡：任务在可用节点间分配

Spring集成

1. 注解方式

@Component
public class AnnotationJob {
    @Scheduled(cron = "0 0/5 * * * ?")
    public void scheduledTask() {
        // 任务逻辑
    }
}

2. 配置方式

Spring配置示例

@Configuration
public class QuartzSpringConfig {
    @Bean
    public JobDetailFactoryBean jobDetail() {
        JobDetailFactoryBean factoryBean = new JobDetailFactoryBean();
        factoryBean.setJobClass(SpringJob.class);
        factoryBean.setDurability(true);
        factoryBean.setRequestsRecovery(true);
        return factoryBean;
    }
    
    @Bean
    public CronTriggerFactoryBean trigger(JobDetail jobDetail) {
        CronTriggerFactoryBean factoryBean = new CronTriggerFactoryBean();
        factoryBean.setJobDetail(jobDetail);
        factoryBean.setCronExpression("0 0/5 * * * ?");
        return factoryBean;
    }
    
    @Bean
    public SchedulerFactoryBean scheduler(Trigger trigger) {
        SchedulerFactoryBean factoryBean = new SchedulerFactoryBean();
        factoryBean.setTriggers(trigger);
        return factoryBean;
    }
}

动态任务管理

1. 任务操作API

@Service
@Slf4j
public class JobService {
    @Autowired
    private Scheduler scheduler;
    
    public void addJob(String jobName, String cronExpression) throws SchedulerException {
        JobDetail jobDetail = JobBuilder.newJob(DynamicJob.class)
                .withIdentity(jobName)
                .build();
                
        CronTrigger trigger = TriggerBuilder.newTrigger()
                .withIdentity(jobName + "_trigger")
                .withSchedule(CronScheduleBuilder.cronSchedule(cronExpression))
                .build();
                
        scheduler.scheduleJob(jobDetail, trigger);
    }
    
    public void pauseJob(String jobName) throws SchedulerException {
        scheduler.pauseJob(JobKey.jobKey(jobName));
    }
    
    public void resumeJob(String jobName) throws SchedulerException {
        scheduler.resumeJob(JobKey.jobKey(jobName));
    }
    
    public void deleteJob(String jobName) throws SchedulerException {
        scheduler.deleteJob(JobKey.jobKey(jobName));
    }
}

高级特性

1. 任务链

任务链示例

@Slf4j
public class ChainedJob implements Job {
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        // 当前任务逻辑
        log.info("Current job executed");
        
        // 触发下一个任务
        try {
            Scheduler scheduler = context.getScheduler();
            JobDetail nextJob = JobBuilder.newJob(NextJob.class)
                    .withIdentity("nextJob")
                    .build();
                    
            Trigger nextTrigger = TriggerBuilder.newTrigger()
                    .withIdentity("nextTrigger")
                    .startNow()
                    .build();
                    
            scheduler.scheduleJob(nextJob, nextTrigger);
        } catch (SchedulerException e) {
            throw new JobExecutionException(e);
        }
    }
}

2. 任务优先级

Trigger trigger = TriggerBuilder.newTrigger()
    .withIdentity("highPriorityTrigger")
    .withPriority(10) // 较高的优先级
    .build();

3. 任务并发控制

@DisallowConcurrentExecution // 禁止并发执行
@PersistJobDataAfterExecution // 数据持久化
public class NonConcurrentJob implements Job {
    @Override
    public void execute(JobExecutionContext context) {
        // 任务逻辑
    }
}

监控和管理

1. 任务状态监控

监控示例代码

@Service
@Slf4j
public class JobMonitorService {
    @Autowired
    private Scheduler scheduler;
    
    public List<JobStatus> getAllJobStatus() throws SchedulerException {
        List<JobStatus> jobStatusList = new ArrayList<>();
        
        for (String group : scheduler.getJobGroupNames()) {
            for (JobKey jobKey : scheduler.getJobKeys(GroupMatcher.groupEquals(group))) {
                List<? extends Trigger> triggers = scheduler.getTriggersOfJob(jobKey);
                for (Trigger trigger : triggers) {
                    Trigger.TriggerState triggerState = scheduler.getTriggerState(trigger.getKey());
                    jobStatusList.add(new JobStatus(jobKey.getName(), triggerState.name()));
                }
            }
        }
        
        return jobStatusList;
    }
}

@Data
@AllArgsConstructor
class JobStatus {
    private String jobName;
    private String status;
}