springboot定时任务

## 一、基于注解的定时任务

### 1、添加依赖

```xml

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-quartz</artifactId>
</dependency>
```

### 2、定义任务

```java
@Component
public class MyTask {

private static final Logger log = LoggerFactory.getLogger(MyTask.class);

// 每分钟执行一次
    @Scheduled(cron = "0 */1 * * * ?")
    public void task1() {
        log.info("MyTask.task1()：{}", LocalDateTime.now());
    }

// 每5秒执行一次
    @Scheduled(cron = "*/5 * * * * ?")
    public void task2() {
        log.info("MyTask.task2()：{}", LocalDateTime.now());
    }
}
```

### 3、配置

```
# 定时任务配置
spring.quartz.job-store-type=jdbc
spring.quartz.properties.org.quartz.jobStore.dataSource=quartzDataSource
spring.quartz.properties.org.quartz.jobStore.tablePrefix=QRTZ_
spring.quartz.properties.org.quartz.dataSource.quartzDataSource.driver=com.mysql.jdbc.Driver
spring.quartz.properties.org.quartz.dataSource.quartzDataSource.URL=jdbc:mysql://localhost:3306/quartz?characterEncoding=utf-8
spring.quartz.properties.org.quartz.dataSource.quartzDataSource.user=root
spring.quartz.properties.org.quartz.dataSource.quartzDataSource.password=
spring.quartz.properties.org.quartz.dataSource.quartzDataSource.maxConnections=5
```

## 二、基于接口的定时任务

### 1、添加依赖

```xml
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
```

### 2、添加注解

```java
@Configuration
public class ApplicationConfig {

//    @Bean
//    public SchedulerFactoryBean schedulerFactoryBean() throws IOException {
//        SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean();
//        schedulerFactoryBean.setJobFactory(new AdaptableJobFactory());
//        schedulerFactoryBean.setConfigLocation(new ClassPathResource("/quartz.properties"));
//        return schedulerFactoryBean;
//    }

@Bean
    public SchedulerFactoryBean schedulerFactoryBean(DataSource dataSource) throws IOException {
        SchedulerFactoryBean factory = new SchedulerFactoryBean();

factory.setDataSource(dataSource);
        // 用于quartz集群,QuartzScheduler 启动时更新己存在的Job
        factory.setOverwriteExistingJobs(true);
        // 延时启动，应用启动5秒后 QuartzScheduler 再启动
        factory.setStartupDelay(5);
        // 设置自动启动，默认为true
        factory.setAutoStartup(true);
        factory.setQuartzProperties(quartzProperties());
        // quartz参数
        Properties prop = new Properties();
        prop.put("org.quartz.scheduler.instanceName", "ServerScheduler");
        // 线程池配置
        prop.put("org.quartz.threadPool.class", "org.quartz.simpl.SimpleThreadPool");
        prop.put("org.quartz.threadPool.threadCount", "20");
        prop.put("org.quartz.threadPool.threadPriority", "5");
        // JobStore配置
        prop.put("org.quartz.jobStore.class", "org.quartz.impl.jdbcjobstore.JobStoreTX");
        // 集群配置
        prop.put("org.quartz.jobStore.isClustered", "true");
        prop.put("org.quartz.jobStore.clusterCheckinInterval", "15000");
        prop.put("org.quartz.jobStore.maxMisfiresToHandleAtATime", "1");
        prop.put("org.quartz.jobStore.txIsolationLevelSerializable", "true");
        prop.put("org.quartz.jobStore.misfireThreshold", "12000");
        prop.put("org.quartz.jobStore.tablePrefix", "QRTZ_");
        factory.setQuartzProperties(prop);
        return factory;
    }

@Bean
    public Properties quartzProperties() throws IOException {
        PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();
        propertiesFactoryBean.setLocation(new ClassPathResource("/quartz.properties"));
        propertiesFactoryBean.afterPropertiesSet();
        return propertiesFactoryBean.getObject();
    }

/**
     * 通过SchedulerFactoryBean获取Scheduler的实例
     */
    @Bean(name="scheduler")
    public Scheduler scheduler(SchedulerFactoryBean schedulerFactoryBean) {
        return schedulerFactoryBean.getScheduler();
    }

/**
     * 动态任务
     */
    @Bean
    public SpringBeanJobFactory springBeanJobFactory() {
        return new SpringBeanJobFactory();
    }

}
```

### 3、配置

### 4、定义任务

```java
@Component
public class MyJob implements Job {

@Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        System.out.println("定时任务开始执行：" + LocalDateTime.now());
    }
}
```

### 5、动态添加任务

```java
@Service
public class QuartzService {

@Autowired
    private Scheduler scheduler;

/**
     * 添加任务
     *
     * @param jobName
     * @param jobGroup
     * @param triggerName
     * @param triggerGroup
     * @param jobClass
     * @param cron
     * @throws Exception
     */
    public void addJob(String jobName, String jobGroup,
                       String triggerName, String triggerGroup,
                       Class jobClass, String cron) throws Exception {
        // 任务名称和组构成任务key
        JobDetail jobDetail = JobBuilder.newJob(jobClass).withIdentity(jobName, jobGroup).build();

// 触发器
        Trigger trigger = TriggerBuilder.newTrigger().withIdentity(triggerName, triggerGroup)
                .startNow()
                .withSchedule(CronScheduleBuilder.cronSchedule(cron))
                .build();

scheduler.scheduleJob(jobDetail, trigger);
    }
}
```

```java
@Controller
public class QuartzController {

@Autowired
    private QuartzService quartzService;

@RequestMapping("/startCron")
    @ResponseBody
    public String startCron() throws Exception {
        quartzService.addJob("job1", "group1",
                "trigger1", "triggerGroup1",
                MyJob.class, "0/5 * * * * ?");
        return "定时任务启动成功!";
    }

}
```

## 三、定时任务的参数传递

```java
@Component
public class MyTask {

private static final Logger log = LoggerFactory.getLogger(MyTask.class);

// 每分钟执行一次
    @Scheduled(cron = "0 */1 * * * ?")
    public void task1(String param1, Integer param2) {
        log.info("MyTask.task1()：{}，param1：{}，param2：{}", LocalDateTime.now(), param1, param2);
    }

}
```

```java
@Component
public class MyJob implements Job {

@Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        String param1 = jobExecutionContext.getMergedJobDataMap().getString("param1");
        Integer param2 = jobExecutionContext.getMergedJobDataMap().getInt("param2");
        System.out.println("定时任务开始执行：" + LocalDateTime.now() + "，param1：" + param1 + "，param2：" + param2);
    }
}
```

```java
@Service
public class QuartzService {

@Autowired
    private Scheduler scheduler;

/**
     * 添加任务
     *
     * @param jobName
     * @param jobGroup
     * @param triggerName
     * @param triggerGroup
     * @param jobClass
     * @param cron
     * @param jobData
     * @throws Exception
     */
    public void addJob(String jobName, String jobGroup,
                       String triggerName, String triggerGroup,
                       Class jobClass, String cron,
                       JobDataMap jobData) throws Exception {
        // 任务名称和组构成任务key
        JobDetail jobDetail = JobBuilder.newJob(jobClass).withIdentity(jobName, jobGroup).setJobData(jobData).build();

scheduler.scheduleJob(jobDetail, trigger);
    }
}
```

```java
@Controller
public class QuartzController {

@Autowired
    private QuartzService quartzService;

@RequestMapping("/startCron")
    @ResponseBody
    public String startCron() throws Exception {
        JobDataMap jobDataMap = new JobDataMap();
        jobDataMap.put("param1", "参数1");
        jobDataMap.put("param2", 2);
        quartzService.addJob("job1", "group1",
                "trigger1", "triggerGroup1",
                MyJob.class, "0/5 * * * * ?",
                jobDataMap);
        return "定时任务启动成功!";
    }

}
```