【springboot开发】定时任务

前言：springboot提供了两种实现定时任务的方法，@scheduled注解和Quartz。前者适用于简单的定时任务，Quartz方法更加灵活多变。

1. @Scheduled注解

在启动类添加@EnableScheduling

@SpringBootApplication
@EnableCaching  // 开启缓存
@EnableScheduling	// 开启定时
public class BuildBaseFrameApplication {

    private static ApplicationContext context;

    public static ApplicationContext getContext() {
        return context;
    }

    public static void main(String[] args) {
        SpringApplication.run(BuildBaseFrameApplication.class, args);
    }

}

定义schedule任务，这里使用cron表达式，每隔10s执行一次：

@Component
public class SchedulerTask {

    private static final Logger loggger = LoggerFactory.getLogger(SchedulerTask.class);

    @Scheduled(cron = "*/10 * * * * ?")
    private void taskCron(){
        SimpleDateFormat dataFormat = new SimpleDateFormat("HH:mm:ss");

        loggger.info("现在时间 schedule: " + dataFormat.format(new Date()));
    }
}

除此外还可以用@Scheduled(fixedRate=10000)指定时间间隔是10s。

2. Quartz定时器

2.1 Quartz介绍

2.1.1 主要功能

• 持久化：把任务和状态持久化到数据库
• 任务管理：对调度任务进行有效管理
• 集群：借助关系数据库和JDBC任务存储支持集群

2.1.2 基本概念

• Job：接口，在实现接口的execute方法中编写任务
• JobDetail：任务实现类
• Trigger：描述触发任务执行的时间触发规则
• Scheduler：接口，承载任务和触发器
  

2.2 Springboot集成

Springboot中实现Quartz有两种方法：SimpleJob和CronSchedule。不用在启动类上使用@EnableScheduling。

2.2.1 添加依赖

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

2.2.2 SimpleJob

（1）创建Job
在executeInternal中定义任务内容。

public class SimpleJob extends QuartzJobBean {
     private static final Logger logger = LoggerFactory.getLogger(SimpleJob.class);

     private String name;

     public void setName(String name){
         this.name = name;
     }

     @Override
    protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
         logger.info("Hello"+this.name);

     }
}

（2）创建scheduler
里面包含一个JobDetail和Trigger，把（1）中定义的任务内容放入JobDetail，然后在Trigger中定义触发规则。

@Configuration
public class SimpleSchedule {
    @Bean
    public JobDetail simpleJobDetail(){
        return JobBuilder.newJob(SimpleJob.class)
                .withIdentity("simplejob")  // 用于标识区分不同的job
                .usingJobData("name","test")    // 动态传入Job任务中的参数
                .storeDurably()
                .build();
    }

    @Bean
    public Trigger simpleJobTrigger(){
        SimpleScheduleBuilder simpleScheduleBuilder = SimpleScheduleBuilder.simpleSchedule()
                .withIntervalInSeconds(10)  // 每十秒触发
                .repeatForever();

        return TriggerBuilder.newTrigger()
                .forJob(simpleJobDetail())
                .withIdentity("simpleTrigger")
                .withSchedule(simpleScheduleBuilder)
                .build();
    }
}

运行结果：

2.2.3 Cron定时任务

（1）定义Job
这一步和SimpleJob是一样的

public class CronJob extends QuartzJobBean {
    private static final Logger logger = LoggerFactory.getLogger(SimpleJob.class);

    private String name;

    public void setName(String name){
        this.name = name;
    }

    @Override
    protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
        logger.info("Hello！ "+this.name);

    }
}

（2）创建scheduler
和simplejob唯一的区别是trigger设置时间间隔用的是Cron表达式

@Configuration
public class CronSchedule {
    @Bean
    public JobDetail cronJobDetail(){
        return JobBuilder.newJob(CronJob.class)
                .withIdentity("cronjob")  // 用于标识区分不同的job
                .usingJobData("name","cronTest")    // 动态传入Job任务中的参数
                .storeDurably()
                .build();
    }

    @Bean
    public Trigger simpleJobTrigger(){
        CronScheduleBuilder scheduleBuilder= CronScheduleBuilder.cronSchedule("0/10 * * * * ?");

        return TriggerBuilder.newTrigger()
                .forJob(cronJobDetail())
                .withIdentity("simpleTrigger")
                .withSchedule(scheduleBuilder)
                .build();
    }
}

运行结果：