1
2
3
4
5
6
7
8
9
10
11
12
13
14
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableScheduling;
 
@SpringBootApplication
@EnableScheduling //开启定时任务
public class ScheduledDemoApplication
{
    public static void main(String[] args)
    {
        SpringApplication.run(ScheduledDemoApplication.class, args);
    }
}

1
2
3
4
5
6
7
// 也可以使用占位符
// @Schedule(cron="${startTime}")
@Schedule(cron="0 30 2 * * ?")
 public void task() {
 	// do somthing
 }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
package org.springframework.scheduling.annotation;
 
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Repeatable;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
 
@Target({ElementType.METHOD, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Repeatable(Schedules.class)
public @interface Scheduled {
    String CRON_DISABLED = "-";
 
    String cron() default "";
 
    String zone() default "";
 
    long fixedDelay() default -1L;
 
    String fixedDelayString() default "";
 
    long fixedRate() default -1L;
 
    String fixedRateString() default "";
 
    long initialDelay() default -1L;
 
    String initialDelayString() default "";
}

1
2
3
4
5
6
7
8
9
10
11
import org.quartz.Job;

public class CustomJob implements Job{

    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        // do something 
    }
    
} 

1
2
3
4
5
6
7
8
9
10
11
12
13
Trigger trigger = TriggerBuilder.newTrigger()
        .withIdentity("triggerName", "triggerGroupName") // 触发器信息
        .withSchedule(SimpleScheduleBuilder.simpleSchedule() // 指定具体的触发器类型
        .withIntervalInSeconds(1)) // 间隔1秒执行
        .startNow() // 立即生效
        .startAt(start) // 开始执行时间
        .endAt(end) // 结束执行时间
        .build();

// 需要注意的时，startNow() 和 startAt() 方法因为修改的时同一个变量
// 所以只有一个会生效，那个在后边那个就被使用
 

1
2
3
4
5
JobDetail jobDetail = JobBuilder.newJob(CustomJob.class) // job具体执行类
        .withIdentity("jobName", "jobGroupName") // job信息
        .setJobData(new JobDataMap(map)) // 任务参数
        .build(); 

1
2
3
4
5
6
7
8
9
10
11
12
Scheduler scheduler = new SchedulerFactory().getScheduler();
scheduler.scheduleJob(jobDetail, trigger);
// or IOC 注入 
@Autowire
private Scheduler scheduler; 

// 启动调度器
scheduler.startUp(); 

1
2
3
4
5
public <SBT extends T> TriggerBuilder<SBT> withSchedule(ScheduleBuilder<SBT> schedBuilder) {
    this.scheduleBuilder = schedBuilder;
    return (TriggerBuilder<SBT>) this;
}

1
2
3
4
5
6
7
8
SimpleTrigger simpleTrigger = TriggerBuilder.newTrigger()
        .withIdentity("tiggerName") // 认证信息
        .withSchedule(SimpleScheduleBuilder.simpleSchedule() 
        .withIntervalInMinutes(10) // 每10分钟执行一次
        .repeatForever()) // 无限重复
        .startNow() // 立即生效
        .build();

1
2
3
4
5
6
CronTrigger cronTrigger = TriggerBuilder.newTrigger()
        .withIdentity("cronTrigger") // 认证信息
        .withSchedule(CronScheduleBuilder.cronSchedule("0 0/20 10-12 * * ?")) //设置cron 
//        .withSchedule(CronScheduleBuilder.cronSchedule(new CronExpression("")))
        .build();

1
2
3
4
5
6
7
8
9
10
11
12
13
DailyTimeIntervalTrigger dailyTimeIntervalTrigger = TriggerBuilder.newTrigger()
        .withIdentity("dailyTimeIntervalTrigger ") // 认证信息
        .withSchedule(DailyTimeIntervalScheduleBuilder
                .dailyTimeIntervalSchedule()
                .startingDailyAt(TimeOfDay.hourAndMinuteOfDay(h, m)) // 从h点m分开始
                .endingDailyAt(TimeOfDay.hourAndMinuteOfDay(h, m)) // 到h点m分结束
                .withIntervalInSeconds(600) // 间隔10分钟执行
                .onDaysOfTheWeek(2, 3, 4)) // 每周一 二 三 执行
        .build();

// onDaysOfTheWeek() 方法接收可变数组，参数值为 1-7
// 其中1代表周日，2代表周一，以此类推 

1
2
3
4
5
6
7
 CalendarIntervalTrigger calendarIntervalTrigger = TriggerBuilder.newTrigger()
        .withIdentity("")
        .withSchedule(CalendarIntervalScheduleBuilder.calendarIntervalSchedule()
        .withIntervalInMonths(3)) // 每三个月执行一次
        .startNow()
        .build();

1
2
3
JobDataMap jobDataMap = new JobDataMap(Map<k,v> map);
TriggerBuilder.newTrigger().usingJobData(jobDataMap).build(); 

1
2
3
4
5
6
JobDetail jobDetail = JobBuilder.newJob(CustomJob.class)
        .setJobData(new JobDataMap(map))
        .usingJobData("key", "value")
        .withIdentity(config.getJobName(), config.getJobGroupName())
        .build();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import org.quartz.Job;

public class CustomJob implements Job{

    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        // 从jobDetail 中获取数据
        JobDataMap dataMap = context.getJobDetail().getJobDataMap();
        // 从trigger中获取数据
        // JobDataMap dataMap = context.getTrigger().getJobDataMap();
        Object value = dataMap.get("key");
    }
    
}  

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
@Autowired
private Scheduler scheduler;

public void demo() {
  
  // 往调度器中添加一个任务
  scheduler.scheduleJob(jobDetail, trigger);
  
  // 指定触发器
  TriggerKey triggerKey = new TriggerKey("tiggerName", "triggerGroupName");
  
  // 暂停触发器
  scheduler.pauseTrigger(triggerKey);
  // 恢复触发器
  scheduler.resumeTrigger(triggerKey);
  // 移除触发器
  scheduler.unscheduleJob(triggerKey);
  // 删除任务
  scheduler.deleteJob(JobKey.jobKey(jobName, jobGroupName));
  
}