@EnableScheduling // @EnableScheduling 在配置類上使用，開啟計劃任務(wù)的支持
@Component(value="myClass")// 由spring管理
public class MyClass {
 
    @Scheduled(cron= "0 0 0 * * ?")//0 0 12 * * ? 每天12點觸發(fā)0 0 0/1 * * ?  0 0 0 * * ?
    public void myTask() {
        // 業(yè)務(wù)邏輯
        ...
    }
}

org.springframework.scheduling.config.ContextLifecycleScheduledTaskRegistrar
 
public void onApplicationEvent(ContextRefreshedEvent event) {
    if (event.getApplicationContext() != this.applicationContext) {
        return;
    }
    // 定時任務(wù)執(zhí)行入口方法綁定到容器生命周期上
    scheduleTasks();
}

org.springframework.scheduling.config.ScheduledTaskRegistrar
protected void scheduleTasks() {
    ...
    if (this.triggerTasks != null) {
        for (TriggerTask task : this.triggerTasks) {
            // 執(zhí)行初始化完成的task和Trigger
            this.scheduledFutures.add(this.taskScheduler.schedule(
                    task.getRunnable(), task.getTrigger()));
        }
    }
    ...
}

org.springframework.scheduling.TaskScheduler
ScheduledFuture schedule(Runnable task, Trigger trigger);

org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler
public ScheduledFuture schedule(Runnable task, Trigger trigger) {
    ScheduledExecutorService executor = getScheduledExecutor();
    try {
        ErrorHandler errorHandler =
                (this.errorHandler != null ? this.errorHandler : TaskUtils.getDefaultErrorHandler(true));
        // 調(diào)用具體的實現(xiàn)方法.schedule()
        return new ReschedulingRunnable(task, trigger, executor, errorHandler).schedule();
    }
    catch (RejectedExecutionException ex) {
        throw new TaskRejectedException("Executor [" + executor + "] did not accept task: " + task, ex);
    }
}

private <V> ScheduledFuture<V> schedule(final ScheduledFutureTask<V> task) {
    if (task == null) {
        throw new NullPointerException("task");
    } else {
        if (this.inEventLoop()) {
            this.delayedTaskQueue.add(task);
        } else {
            // 此處就是真正的線程執(zhí)行方法
            this.execute(new Runnable() {
                public void run() {
                    SingleThreadEventExecutor.this.delayedTaskQueue.add(task);
                }
            });
        }
 
        return task;
    }
}

org.springframework.scheduling.annotation.ScheduledAnnotationBeanPostProcessor
 
// BeanPostProcessor生命周期方法，spring加載的時候會執(zhí)行
public Object postProcessAfterInitialization(final Object bean, String beanName) {
        Class<?> targetClass = AopUtils.getTargetClass(bean);
    if (!this.nonAnnotatedClasses.containsKey(targetClass)) {
        final Set<Method> annotatedMethods = new LinkedHashSet<Method>(1);
        ReflectionUtils.doWithMethods(targetClass, new MethodCallback() {
            public void doWith(Method method) throws IllegalArgumentException, IllegalAccessException {
                Scheduled scheduled = AnnotationUtils.getAnnotation(method, Scheduled.class);
                if (scheduled != null) {
                    // @Scheduled的真正解析方法，具體解析細(xì)節(jié)和參數(shù)參看源碼
                    // 解析后添加到ScheduledTaskRegistrar里
                    // 全部任務(wù)解析完成，執(zhí)行ScheduledTaskRegistrar，具體實現(xiàn)參看[1.2.2 調(diào)用鏈路]章節(jié)
                    processScheduled(scheduled, method, bean);
                    annotatedMethods.add(method);
                }
            }
        });
        if (annotatedMethods.isEmpty()) {
            this.nonAnnotatedClasses.put(targetClass, Boolean.TRUE);
        }
    }
    return bean;
}

// 實例化一個調(diào)度器工廠，每個應(yīng)用只有唯一一個工廠實例
SchedulerFactory schedFact = new org.quartz.impl.StdSchedulerFactory();
// 實例化一個調(diào)度器
Scheduler sched = schedFact.getScheduler();
// 啟動，只有啟動了調(diào)度器Quartz才會去執(zhí)行任務(wù)
sched.start();
 
// 實例化一個任務(wù)
JobDetail job = newJob(HelloJob.class)
  .withIdentity("myJob", "group1")
  .build();
 
// 實例化一個任務(wù)觸發(fā)器,立刻觸發(fā)，每40s執(zhí)行一次
Trigger trigger = newTrigger()
  .withIdentity("myTrigger", "group1")
  .startNow()
  .withSchedule(simpleSchedule()
      .withIntervalInSeconds(40)
      .repeatForever())
  .build();
 
// 調(diào)度任務(wù)
sched.scheduleJob(job, trigger);

<context-param>
   <param-name>quartz:config-file</param-name>
   <param-value>/some/path/my_quartz.properties</param-value>
</context-param>
<context-param>
   <param-name>quartz:shutdown-on-unload</param-name>
   <param-value>true</param-value>
</context-param>
<context-param>
   <param-name>quartz:start-on-load</param-name>
   <param-value>true</param-value>
</context-param>
 
<listener>
   <listener-class>
       org.quartz.ee.servlet.QuartzInitializerListener
   </listener-class>
</listener>

// 執(zhí)行ServletContextListener.contextInitialized的容器生命周期方法
public void contextInitialized(ServletContextEvent sce) {
    ...
    // 根據(jù)自定義的配置文件加載SchedulerFactory
    if (configFile != null) {
        factory = new StdSchedulerFactory(configFile);
    } else {
        factory = new StdSchedulerFactory();
    }
    
    // 加載scheduler
    scheduler = factory.getScheduler();
    
    // 啟動scheduler
    scheduler.start();
    log.info("Scheduler has been started...");
    ...
}   

1. StdSchedulerFactory.getScheduler()
public Scheduler getScheduler() throws SchedulerException {
    if (cfg == null) {
        // 根據(jù)不同的配置方式加載對應(yīng)配置
        initialize();
    }
    ... 
    // 加載實例（加載Scheduler整個上下文環(huán)境）
    sched = instantiate();
    return sched;
}

private Scheduler instantiate() throws SchedulerException {
 
    // 校驗初始化
    if (cfg == null) {
        initialize();
    }
    
    // 獲取 Scheduler
    // 加載 ThreadPool
    // 加載 JobStore
    // 加載 DataSources
    // 加載 SchedulerPlugins
    // 加載 JobListeners
    // 加載 TriggerListeners
    // 加載 ThreadExecutor
    
    // 構(gòu)造QuartzScheduler
    qs = new QuartzScheduler(rsrcs, schedCtxt, idleWaitTime, dbFailureRetry);
    Scheduler scheduler = instantiate(rsrcs, qs);
    qs.initialize();
    
    // 返回實例化好的scheduler
    return scheduler;
}