springboot整合quartz（一）

基本的quartz用法

引入quartz的包

创建一个JobQuartz类，并实现Job接口重写execute接口

public class JobQuartz implements Job {

    public JobQuartz() {
    }

    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("定时任务执行了"+sdf.format(new Date()));
    }
}

 创建一个TestQuartz类，用来测试

public class TestQuartz {

    public static void main(String[] args) {
        /**
         * 表示一个具体的可执行的调度程序
         */
        JobDetail jobDetail = newJob(JobQuartz.class).withIdentity("myJob", "group1").build();
        //定义一个Trigger
        Trigger trigger = TriggerBuilder.newTrigger().withIdentity("trigger1", "group1")
                            //scheduler启动后立刻执行
                            .startNow()
                            //每个5秒钟执行一次
                            .withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(5)
                                 //重复执行
                                .repeatForever()
                            ).build();


        //创建scheduler
        try {
            Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
            scheduler.scheduleJob(jobDetail, trigger);
            scheduler.start();
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }
}

启动项目，控制台打印结果。说明测试成功。

 quartz传参

如果我们需要在JobDetail给Job中传递参数时

修改JobDetail代码以及Job类代码

JobDetail jobDetail = newJob(JobQuartz.class).withIdentity("myJob", "group1")
                .usingJobData("jobSays", "Hello World!")
                .usingJobData("myFloatValue", 3.141f)
                .build();

@Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        /**
         * 获取到参数的map集合
         * 然后根据key来获取值
         */
        JobDataMap jobDataMap = context.getJobDetail().getJobDataMap();
        String jobSays = jobDataMap.get("jobSays").toString();
        float myFloatValue = Float.parseFloat(jobDataMap.get("myFloatValue").toString());
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("定时任务执行了"+sdf.format(new Date())+"jobSays值为"+jobSays+"myFloatValue值为"+myFloatValue);
    }

 打印结果为：说明我们已经成功的获取到了JobDetail中传过来的值

如果你希望jobSays和myFloatValue的值可以自动注入

修改JobQuartz接口代码如下，同样可以获取到JobDetail中传过来的值

public class JobQuartz implements Job {

    private String jobSays;

    private float myFloatValue;

    public JobQuartz() {
    }

    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        /**
         * 获取到参数的map集合
         * 然后根据key来获取值
         */
        //JobDataMap jobDataMap = context.getJobDetail().getJobDataMap();
        //String jobSays = jobDataMap.get("jobSays").toString();
        //float myFloatValue = Float.parseFloat(jobDataMap.get("myFloatValue").toString());
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("定时任务执行了"+sdf.format(new Date())+"jobSays值为"+jobSays+"myFloatValue值为"+myFloatValue);
    }

    public String getJobSays() {
        return jobSays;
    }

    public void setJobSays(String jobSays) {
        this.jobSays = jobSays;
    }

    public float getMyFloatValue() {
        return myFloatValue;
    }

    public void setMyFloatValue(float myFloatValue) {
        this.myFloatValue = myFloatValue;
    }
}

Job状态与并发

我们经常会遇到这种情况，比如说定时任务的间隔为5秒，但是具体任务花费了10秒。此时定时任务会如何执行呢？

修改JobQuartz代码和TestQuartz。我们让定时任务每次执行时休眠8秒，然后定时任务的间隔时间为5秒

 看执行结果会发现，仍然是每5秒执行一次。但是如果我们想让上一次任务没有执行完时，不会执行下一次的任务呢？

@DisallowConcurrentExecution

将该注解加到job类上，告诉Quartz不要并发地执行同一个job定义（这里指特定的job类）的多个实例。

用上面的列子来说明就是：

如果上一个job任务没有执行完成，那么下一个任务就不会执行(对于同一个JobDetail来说)

如果同一个job绑定到不同的JobDetail上面，那么多个JobDetail之间是可以并发执行的

@PersistJobDataAfterExecution

将该注解加在job类上，告诉Quartz在成功执行了job类的execute方法后（没有发生任何异常），更新JobDetail中JobDataMap的数据，使得该job（即JobDetail）在下一次执行的时候，JobDataMap中是更新后的数据，而不是更新前的旧数据。

我们继续修改JobQuartz代码如下，我们将jobSays的值修改为：update

@DisallowConcurrentExecution
@PersistJobDataAfterExecution
public class JobQuartz implements Job {

   /* private String jobSays;

    private float myFloatValue;*/

    public JobQuartz() {
    }

    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        /**
         * 获取到参数的map集合
         * 然后根据key来获取值
         */
        JobDataMap jobDataMap = context.getJobDetail().getJobDataMap();
        String jobSays = jobDataMap.get("jobSays").toString();
        float myFloatValue = Float.parseFloat(jobDataMap.get("myFloatValue").toString());
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        try {
            System.out.println("定时任务执行了"+sdf.format(new Date())+"jobSays值为"+jobSays+"myFloatValue值为"+myFloatValue);
            jobDataMap.put("jobSays","update");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

 控制台的打印结果，会发现我们成功的将jobSays的值修改为：update

使用了@PersistJobDataAfterExecution注解，我们强烈建议你同时使用@DisallowConcurrentExecution注解，因为当同一个job（JobDetail）的两个实例被并发执行时，由于竞争，JobDataMap中存储的数据很可能是不确定的。