Quartz

最新推荐文章于 2025-07-03 16:41:16 发布

原创最新推荐文章于 2025-07-03 16:41:16 发布 · 503 阅读

CC 4.0 BY-SA版权

本文详细介绍了Quartz框架下四种不同的任务调度方式：SimpleTrigger、CalendarIntervalTrigger、DailyTimeIntervalTrigger和CronTrigger。通过示例代码，展示了如何配置和使用这些触发器来执行定时任务，包括任务的创建、调度策略的设定以及任务的管理和删除。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

文章目录

1.job
2.TaskManagement
3.Task

依赖

<dependency>
    <groupId>org.quartz-scheduler</groupId>
    <artifactId>quartz</artifactId>
    <version>2.3.0</version>
</dependency>

1.job

package quartz.job;

import org.quartz.*;

import java.text.SimpleDateFormat;
import java.util.Date;

public class HelloWorldJob implements Job {

    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        JobKey key = jobExecutionContext.getJobDetail().getKey();
        
        String message1 = jobExecutionContext.getMergedJobDataMap().getString("message1");
        String message2  = (String) jobExecutionContext.getMergedJobDataMap().get("message2");
        
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String strDate = simpleDateFormat.format(new Date());
        System.out.println("Job名称：" + key.getName()
                + "   Job分组：" + key.getGroup()
                + "   message1：" + message1
                + "   message2：" + message2
                + "   执行时间：" + strDate);
    }

}

2.TaskManagement

package quartz.task;

import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;

import java.util.Date;

public class TaskManagement {

    Scheduler scheduler = null;
    SchedulerFactory schedulerFactory = new StdSchedulerFactory();

    private static class TaskManagementHolder {
        private static TaskManagement Instance = new TaskManagement();
    }

    public static TaskManagement getInstance() {
        return TaskManagementHolder.Instance;
    }

    private TaskManagement() {
        try {
            scheduler = schedulerFactory.getScheduler();
            scheduler.start();

            System.out.println("任务调度器初始化成功");
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }

    public void scheduleJob(JobDetail jobDetail, Trigger trigger) {
        try {
            scheduler.scheduleJob(jobDetail, trigger);
            // 启动
            if (!scheduler.isShutdown()) {
                scheduler.start();
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * @param cls        执行类
     * @param identity   标识
     * @param jobDataMap map信息
     * @param start		   开始时间
     * @param schedule   调度策略
     */
    public void addJob(Class cls, String identity, JobDataMap jobDataMap, Date start, ScheduleBuilder schedule) {
        try {
            JobDetail jobDetail = JobBuilder.newJob(cls)
                    .withIdentity(identity).usingJobData(jobDataMap).build();
            Trigger trigger = TriggerBuilder.newTrigger().withIdentity(identity).startAt(start).withSchedule(schedule).build();
            scheduler.scheduleJob(jobDetail, trigger);
            // 启动
            if (!scheduler.isShutdown()) {
                scheduler.start();
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    // 删除任务
    public void remove(String taskID) {
        Trigger trigger = TriggerBuilder.newTrigger().withIdentity(taskID)
                .build();
        try {
            //移除触发器
            scheduler.unscheduleJob(trigger.getKey());
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
        JobKey jobKey = new JobKey(taskID);
        try {
            scheduler.deleteJob(jobKey);
        } catch (SchedulerException e) {
            e.printStackTrace();
        }

    }

    /**
     * 暂停任务调度
     */
    public void stop() {
        if (scheduler != null) {
            try {
                scheduler.shutdown();
            } catch (SchedulerException e) {
                e.printStackTrace();
            }
        }
    }


}

3.Task

3.1 SimpleTrigger

package quartz.test;

import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;
import quartz.job.HelloWorldJob;
import quartz.task.TaskManagement;

import java.util.Date;

public class SimpleTriggerTest {

    public static void main(String[] args) {
        SimpleTriggerTest simpleTriggerTest = new SimpleTriggerTest();
        simpleTriggerTest.simpleTriggerUseTwo();
    }

    /**
     * SimpleTrigger初级-学习
     */
    public void simpleTriggerLearn() {
        try {
            //创建Scheduler工厂
            SchedulerFactory schedulerFactory = new StdSchedulerFactory();

            //从工厂中获取调度器实例
            Scheduler scheduler = schedulerFactory.getScheduler();

            //创建Job
            JobDataMap jobDataMap = new JobDataMap();
            jobDataMap.put("message1", "Hello");
            jobDataMap.put("message2", "World");

            /**
             * 关于name和group
             * JobDetail和Trigger都有name和group。
             * name是它们在这个sheduler里面的唯一标识。如果我们要更新一个JobDetail定义，只需要设置一个name相同的JobDetail实例即可。
             * group是一个组织单元，sheduler会提供一些对整组操作的API，比如 scheduler.resumeJobs()。
             */
            JobDetail helloWorldJob = JobBuilder.newJob(HelloWorldJob.class)
                    .withDescription("helloWorldJob测试")
                    .withIdentity("helloWorldJob", "helloWorldJobGroup")
                    .usingJobData(jobDataMap)
                    .build();

            //创建Trigger
            /**
             SimpleTrigger
             一个quartz简单的触发器。指定从某一个时间开始，以一定的时间间隔（单位是毫秒）执行的任务。
             它适合的任务类似于：9:00 开始，每隔1小时，每隔几分钟，每隔几秒钟执行一次。
             它的属性有：
             repeatInterval：重复间隔
             repeatCount：重复次数。实际执行次数是 repeatCount+1。因为在startTime的时候一定会执行一次。
             */
            // 在当前时间15秒后运行
            Date nowDate = new Date();
            System.out.println("当前时间：" + nowDate);
            Date startTime = DateBuilder.nextGivenSecondDate(nowDate,15);
            System.out.println("startTime:"+startTime);
            // 创建一个SimpleTrigger实例，指定该Trigger在Scheduler中所属组及名称。
            // 接着设置调度的时间规则.当前时间15秒后运行，每10秒运行一次，共运行5次(.repeatForever()一直执行)
            SimpleTrigger simpleTrigger = TriggerBuilder.newTrigger()
                    .withDescription("SimpleTrigger测试")
                    .withIdentity("SimpleTrigger", "SimpleTriggerGroup")
                    .startAt(startTime)
                    .withSchedule(
                            SimpleScheduleBuilder.simpleSchedule()
                                    .withIntervalInSeconds(10)
                                    .withRepeatCount(5))
                    .build();

            scheduler.scheduleJob(helloWorldJob, simpleTrigger);
            // 调度启动
            scheduler.start();

        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }

    /**
     * SimpleTrigger中级-使用
     */
    public void simpleTriggerUse() {

        //获得调度任务管理器
        TaskManagement taskManagement = TaskManagement.getInstance();
        //创建Job
        JobDataMap jobDataMap = new JobDataMap();
        jobDataMap.put("message1", "Hello");
        jobDataMap.put("message2", "World");

        JobDetail helloWorldJob = JobBuilder.newJob(HelloWorldJob.class)
                .withDescription("helloWorldJob测试")
                .withIdentity("helloWorldJob", "helloWorldJobGroup")
                .usingJobData(jobDataMap)
                .build();

        //创建Trigger
        // 在当前时间15秒后运行
        Date nowDate = new Date();
        System.out.println("当前时间：" + nowDate);
        Date startTime = DateBuilder.nextGivenSecondDate(nowDate,15);
        System.out.println("startTime:"+startTime);

        //调度策略：接着设置调度的时间规则.当前时间15秒后运行，每10秒运行一次，共运行5次
        SimpleScheduleBuilder simpleScheduleBuilder= SimpleScheduleBuilder.simpleSchedule();
        simpleScheduleBuilder.withIntervalInSeconds(10);
        simpleScheduleBuilder.withRepeatCount(5);
        // 创建一个SimpleTrigger实例，指定该Trigger在Scheduler中所属组及名称。
        SimpleTrigger simpleTrigger = TriggerBuilder.newTrigger()
                .withDescription("SimpleTrigger测试")
                .withIdentity("SimpleTrigger", "SimpleTriggerGroup")
                //默认在当前时间启动
                .startAt(startTime)
                .withSchedule(simpleScheduleBuilder)
                .build();

        //将调度任务加入调度管理中
        taskManagement.scheduleJob(helloWorldJob, simpleTrigger);
    }

    /**
     * impleTrigger高级-调度管理
     */
    public void simpleTriggerUseTwo() {
        //获得调度任务管理器
        TaskManagement taskManagement = TaskManagement.getInstance();

        JobDataMap jobDataMap = new JobDataMap();
        jobDataMap.put("message1", "Hello");
        jobDataMap.put("message2", "World");

        // 在当前时间15秒后运行
        Date nowDate = new Date();
        System.out.println("当前时间：" + nowDate);
        Date startTime = DateBuilder.nextGivenSecondDate(nowDate,15);
        System.out.println("startTime：" + startTime);

        // 调度策略：接着设置调度的时间规则.当前时间15秒后运行，每10秒运行一次，共运行5次
        SimpleScheduleBuilder simpleScheduleBuilder= SimpleScheduleBuilder.simpleSchedule();
        simpleScheduleBuilder.withIntervalInSeconds(10);
        simpleScheduleBuilder.withRepeatCount(0);

        //将调度任务加入调度管理中
        taskManagement.addJob(HelloWorldJob.class, "HelloWorld", jobDataMap, startTime, simpleScheduleBuilder);
    }
}

3.2 CalendarIntervalTrigger

package quartz.test;

import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;
import quartz.job.HelloWorldJob;
import quartz.task.TaskManagement;

import java.util.Date;

public class CalendarIntervalTriggerTest {

    public static void main(String[] args) {
        CalendarIntervalTriggerTest calendarIntervalTriggerTest = new CalendarIntervalTriggerTest();
        calendarIntervalTriggerTest.calendarIntervalTriggerUseTwo();
    }

    /**
     * CalendarIntervalTrigger初级-学习
     */
    public void calendarIntervalTriggerLearn() {
        try {
            //创建Scheduler工厂
            SchedulerFactory schedulerFactory = new StdSchedulerFactory();

            //从工厂中获取调度器实例
            Scheduler scheduler = schedulerFactory.getScheduler();

            //创建Job
            JobDataMap jobDataMap = new JobDataMap();
            jobDataMap.put("message1", "Hello");
            jobDataMap.put("message2", "World");

            /**
             * 关于name和group
             * JobDetail和Trigger都有name和group。
             * name是它们在这个sheduler里面的唯一标识。如果我们要更新一个JobDetail定义，只需要设置一个name相同的JobDetail实例即可。
             * group是一个组织单元，sheduler会提供一些对整组操作的API，比如 scheduler.resumeJobs()。
             */
            JobDetail helloWorldJob = JobBuilder.newJob(HelloWorldJob.class)
                    .withDescription("helloWorldJob测试")
                    .withIdentity("helloWorldJob", "helloWorldJobGroup")
                    .usingJobData(jobDataMap)
                    .build();

            //创建Trigger
            /**
             类似于SimpleTrigger，指定从某一个时间开始，以一定的时间间隔执行的任务。
             但是不同的是SimpleTrigger指定的时间间隔为毫秒，没办法指定每隔一个月执行一次（每月的时间间隔不是固定值），
             而CalendarIntervalTrigger支持的间隔单位有秒，分钟，小时，天，月，年，星期。
             相较于SimpleTrigger有两个优势：
             1、更方便，比如每隔1小时执行，你不用自己去计算1小时等于多少毫秒。
             2、支持不是固定长度的间隔，比如间隔为月和年。但劣势是精度只能到秒。
             它适合的任务类似于：9:00 开始执行，并且以后每周 9:00 执行一次
             它的属性有:
             interval：执行间隔
             intervalUnit：执行间隔的单位（秒，分钟，小时，天，月，年，星期）
             */
            // 在当前时间15秒后运行
            Date nowDate = new Date();
            System.out.println("当前时间：" + nowDate);
            Date startTime = DateBuilder.nextGivenSecondDate(nowDate,15);
            System.out.println("startTime:"+startTime);
            // 每10秒执行(.withIntervalInWeeks(1)==>每周执行1次)
            CalendarIntervalTrigger calendarIntervalTrigger = TriggerBuilder.newTrigger()
                    .withDescription("CalendarIntervalTrigger测试")
                    .withIdentity("calendarIntervalTrigger", "calendarIntervalTriggerGroup")
                    .startAt(startTime)
                    .withSchedule(
                        CalendarIntervalScheduleBuilder
                                .calendarIntervalSchedule()
                                .withInterval(10, DateBuilder.IntervalUnit.SECOND))
                    .build();

            scheduler.scheduleJob(helloWorldJob, calendarIntervalTrigger);
            // 调度启动
            scheduler.start();

        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }

    /**
     * CalendarIntervalTrigger中级-使用
     */
    public void calendarIntervalTriggerUse() {
        //获得调度任务管理器
        TaskManagement taskManagement = TaskManagement.getInstance();

        //创建Job
        JobDataMap jobDataMap = new JobDataMap();
        jobDataMap.put("message1", "Hello");
        jobDataMap.put("message2", "World");

        JobDetail helloWorldJob = JobBuilder.newJob(HelloWorldJob.class)
                .withDescription("helloWorldJob测试")
                .withIdentity("helloWorldJob", "helloWorldJobGroup")
                .usingJobData(jobDataMap)
                .build();

        //创建Trigger
        // 在当前时间15秒后运行
        Date nowDate = new Date();
        System.out.println("当前时间：" + nowDate);
        Date startTime = DateBuilder.nextGivenSecondDate(nowDate,15);
        System.out.println("startTime:"+startTime);

        //调度策略，每10秒执行
        CalendarIntervalScheduleBuilder calendarIntervalScheduleBuilder
                = CalendarIntervalScheduleBuilder.calendarIntervalSchedule();
        calendarIntervalScheduleBuilder.withInterval(10, DateBuilder.IntervalUnit.SECOND);

        CalendarIntervalTrigger calendarIntervalTrigger = TriggerBuilder.newTrigger()
                .withIdentity("calendarIntervalTrigger", "calendarIntervalTriggerGroup")
                .startAt(startTime)
                .withSchedule(calendarIntervalScheduleBuilder)
                .build();

        //将调度任务加入调度管理中
        taskManagement.scheduleJob(helloWorldJob, calendarIntervalTrigger);

    }

    /**
     * CalendarIntervalTrigger高级-调度管理
     */
    public void calendarIntervalTriggerUseTwo() {
        //获得调度任务管理器
        TaskManagement taskManagement = TaskManagement.getInstance();

        JobDataMap jobDataMap = new JobDataMap();
        jobDataMap.put("message1", "Hello");
        jobDataMap.put("message2", "World");

        // 在当前时间15秒后运行
        Date nowDate = new Date();
        System.out.println("当前时间：" + nowDate);
        Date startTime = DateBuilder.nextGivenSecondDate(nowDate,15);
        System.out.println("startTime：" + startTime);

        //调度策略，每10秒执行
        CalendarIntervalScheduleBuilder calendarIntervalScheduleBuilder
                = CalendarIntervalScheduleBuilder.calendarIntervalSchedule();
        calendarIntervalScheduleBuilder.withInterval(10, DateBuilder.IntervalUnit.SECOND);

        //将调度任务加入调度管理中
        taskManagement.addJob(HelloWorldJob.class, "HelloWorld", jobDataMap, startTime, calendarIntervalScheduleBuilder);
    }

}

3.3 DailyTimeIntervalTrigger

package quartz.test;

import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;
import quartz.job.HelloWorldJob;
import quartz.task.TaskManagement;

import java.util.Date;

import static java.util.Calendar.*;


public class DailyTimeIntervalTriggerTest {

    public static void main(String[] args) {
        DailyTimeIntervalTriggerTest dailyTimeIntervalTriggerTest = new DailyTimeIntervalTriggerTest();
        dailyTimeIntervalTriggerTest.dailyTimeIntervalTriggerUseTwo();
    }

    /**
     * DailyTimeIntervalTrigger初级-学习
     */
    public void dailyTimeIntervalTriggerLearn() {
        try {
            //创建Scheduler工厂
            SchedulerFactory schedulerFactory = new StdSchedulerFactory();

            //从工厂中获取调度器实例
            Scheduler scheduler = schedulerFactory.getScheduler();

            //创建Job
            JobDataMap jobDataMap = new JobDataMap();
            jobDataMap.put("message1", "Hello");
            jobDataMap.put("message2", "World");

            /**
             * 关于name和group
             * JobDetail和Trigger都有name和group。
             * name是它们在这个sheduler里面的唯一标识。如果我们要更新一个JobDetail定义，只需要设置一个name相同的JobDetail实例即可。
             * group是一个组织单元，sheduler会提供一些对整组操作的API，比如 scheduler.resumeJobs()。
             */
            JobDetail helloWorldJob = JobBuilder.newJob(HelloWorldJob.class)
                    .withDescription("helloWorldJob测试")
                    .withIdentity("helloWorldJob", "helloWorldJobGroup")
                    .usingJobData(jobDataMap)
                    .build();

            //创建Trigger
            /**
             指定每天的某个时间段内，以一定的时间间隔执行任务。并且它可以支持指定星期。
             它适合的任务类似于：指定每天9:00 至 18:00 ，每隔70秒执行一次，并且只要周一至周五执行。
             它的属性有:
             startTimeOfDay：每天开始时间
             endTimeOfDay：每天结束时间
             daysOfWeek：需要执行的星期
             interval：执行间隔
             intervalUnit：执行间隔的单位（秒，分钟，小时，天，月，年，星期）
             repeatCount：重复次数
             */
            // 在当前时间15秒后运行
            Date nowDate = new Date();
            System.out.println("当前时间：" + nowDate);
            Date startTime = DateBuilder.nextGivenSecondDate(nowDate,15);
            System.out.println("startTime:"+startTime);

            //调度策略
            DailyTimeIntervalScheduleBuilder dailyTimeIntervalScheduleBuilder
                    = DailyTimeIntervalScheduleBuilder.dailyTimeIntervalSchedule();
            dailyTimeIntervalScheduleBuilder.startingDailyAt(TimeOfDay.hourAndMinuteOfDay(9, 0)); // 9：00开始
            dailyTimeIntervalScheduleBuilder.endingDailyAt(TimeOfDay.hourAndMinuteOfDay(16, 0)); // 16：00 结束
            dailyTimeIntervalScheduleBuilder.onDaysOfTheWeek(MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY); // 周一至周五执行
            dailyTimeIntervalScheduleBuilder.withIntervalInSeconds(10); // 每间隔10秒执行一次
            dailyTimeIntervalScheduleBuilder.withRepeatCount(100); // 最多重复100次（实际执行100+1次）

            DailyTimeIntervalTrigger dailyTimeIntervalTrigger = TriggerBuilder.newTrigger()
                    .withDescription("DailyTimeIntervalTrigger测试")
                    .withIdentity("DailyTimeIntervalTrigger", "DailyTimeIntervalTriggerGroup")
                    .startAt(startTime)
                    .withSchedule(dailyTimeIntervalScheduleBuilder)
                    .build();

            scheduler.scheduleJob(helloWorldJob, dailyTimeIntervalTrigger);
            // 调度启动
            scheduler.start();

        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }

    /**
     * DailyTimeIntervalTrigger中级-使用
     */
    public void dailyTimeIntervalTriggerUse() {
        //获得调度任务管理器
        TaskManagement taskManagement = TaskManagement.getInstance();

        //创建Job
        JobDataMap jobDataMap = new JobDataMap();
        jobDataMap.put("message1", "Hello");
        jobDataMap.put("message2", "World");

        JobDetail helloWorldJob = JobBuilder.newJob(HelloWorldJob.class)
                .withDescription("helloWorldJob测试")
                .withIdentity("helloWorldJob", "helloWorldJobGroup")
                .usingJobData(jobDataMap)
                .build();

        //创建Trigger
        // 在当前时间15秒后运行
        Date nowDate = new Date();
        System.out.println("当前时间：" + nowDate);
        Date startTime = DateBuilder.nextGivenSecondDate(nowDate,15);
        System.out.println("startTime:"+startTime);
        //调度策略
        DailyTimeIntervalScheduleBuilder dailyTimeIntervalScheduleBuilder
                = DailyTimeIntervalScheduleBuilder.dailyTimeIntervalSchedule();
        dailyTimeIntervalScheduleBuilder.startingDailyAt(TimeOfDay.hourAndMinuteOfDay(9, 0)); // 9：00开始
        dailyTimeIntervalScheduleBuilder.endingDailyAt(TimeOfDay.hourAndMinuteOfDay(16, 0)); // 16：00 结束
        dailyTimeIntervalScheduleBuilder.onDaysOfTheWeek(MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY); // 周一至周五执行
        dailyTimeIntervalScheduleBuilder.withIntervalInSeconds(10); // 每间隔10秒执行一次
        dailyTimeIntervalScheduleBuilder.withRepeatCount(100); // 最多重复100次（实际执行100+1次）

        DailyTimeIntervalTrigger dailyTimeIntervalTrigger = TriggerBuilder.newTrigger()
                .withDescription("DailyTimeIntervalTrigger测试")
                .withIdentity("DailyTimeIntervalTrigger", "DailyTimeIntervalTriggerGroup")
                .startAt(startTime)
                .withSchedule(dailyTimeIntervalScheduleBuilder)
                .build();

        //将调度任务加入调度管理中
        taskManagement.scheduleJob(helloWorldJob, dailyTimeIntervalTrigger);
    }

    /**
     * DailyTimeIntervalTrigger高级-调度管理
     */
    public void dailyTimeIntervalTriggerUseTwo() {
        //获得调度任务管理器
        TaskManagement taskManagement = TaskManagement.getInstance();

        //JobMap
        JobDataMap jobDataMap = new JobDataMap();
        jobDataMap.put("message1", "Hello");
        jobDataMap.put("message2", "World");

        //创建Trigger
        // 在当前时间15秒后运行
        Date nowDate = new Date();
        System.out.println("当前时间：" + nowDate);
        Date startTime = DateBuilder.nextGivenSecondDate(nowDate,15);
        System.out.println("startTime:"+startTime);
        //调度策略
        DailyTimeIntervalScheduleBuilder dailyTimeIntervalScheduleBuilder
                = DailyTimeIntervalScheduleBuilder.dailyTimeIntervalSchedule();
        dailyTimeIntervalScheduleBuilder.startingDailyAt(TimeOfDay.hourAndMinuteOfDay(9, 0)); // 9：00开始
        dailyTimeIntervalScheduleBuilder.endingDailyAt(TimeOfDay.hourAndMinuteOfDay(16, 0)); // 16：00 结束
        dailyTimeIntervalScheduleBuilder.onDaysOfTheWeek(MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY); // 周一至周五执行
        dailyTimeIntervalScheduleBuilder.withIntervalInSeconds(10); // 每间隔10秒执行一次
        dailyTimeIntervalScheduleBuilder.withRepeatCount(100); // 最多重复100次（实际执行100+1次）

        //将调度任务加入调度管理中
        taskManagement.addJob(HelloWorldJob.class, "HelloWorld", jobDataMap, startTime, dailyTimeIntervalScheduleBuilder);
    }

}

3.4 CronTrigger

package quartz.test;

import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;
import quartz.job.HelloWorldJob;
import quartz.task.TaskManagement;

import java.util.Date;

public class CronTriggerTest {

    public static void main(String[] args) {
        CronTriggerTest cronTriggerTest = new CronTriggerTest();
        cronTriggerTest.cronTriggerUseTwo();
    }

    /**
     * CronTrigger初级-学习
     */
    public void cronTriggerLearn() {
        try {
            //创建Scheduler工厂
            SchedulerFactory schedulerFactory = new StdSchedulerFactory();

            //从工厂中获取调度器实例
            Scheduler scheduler = schedulerFactory.getScheduler();

            //创建Job
            JobDataMap jobDataMap = new JobDataMap();
            jobDataMap.put("message1", "Hello");
            jobDataMap.put("message2", "World");

            /**
             * 关于name和group
             * JobDetail和Trigger都有name和group。
             * name是它们在这个sheduler里面的唯一标识。如果我们要更新一个JobDetail定义，只需要设置一个name相同的JobDetail实例即可。
             * group是一个组织单元，sheduler会提供一些对整组操作的API，比如 scheduler.resumeJobs()。
             */
            JobDetail helloWorldJob = JobBuilder.newJob(HelloWorldJob.class)
                    .withDescription("helloWorldJob测试")
                    .withIdentity("helloWorldJob", "helloWorldJobGroup")
                    .usingJobData(jobDataMap)
                    .build();

            //创建Trigger
            /**
             适合于更复杂的任务，它支持类型于Linux Cron的语法（并且更强大）。基本上它覆盖了以上三个Trigger的绝大部分能力（但不是全部）
             CronTrigger 允许设定非常复杂的触发时间表。
             然而有时也许不得不使用两个或多个 SimpleTrigger 来满足你的触发需求，这时候你仅仅需要一个CronTrigger 实例就够了
             */
            // 在当前时间15秒后运行
            Date nowDate = new Date();
            System.out.println("当前时间：" + nowDate);
            Date startTime = DateBuilder.nextGivenSecondDate(nowDate,15);
            System.out.println("startTime:"+startTime);
            // 每10秒执行
            CronTrigger cronTrigger = TriggerBuilder.newTrigger()
                    .withIdentity("cronTrigger", "cronTriggerGroup")
                    .withSchedule(
                    CronScheduleBuilder.cronSchedule("/10 * * * * ?"))
                    .build();

            scheduler.scheduleJob(helloWorldJob, cronTrigger);
            // 调度启动
            scheduler.start();

        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }

    /**
     * CronTrigger中级-使用
     */
    public void cronTriggerUse() {
        //获得调度任务管理器
        TaskManagement taskManagement = TaskManagement.getInstance();

        //创建Job
        JobDataMap jobDataMap = new JobDataMap();
        jobDataMap.put("message1", "Hello");
        jobDataMap.put("message2", "World");

        JobDetail helloWorldJob = JobBuilder.newJob(HelloWorldJob.class)
                .withDescription("helloWorldJob测试")
                .withIdentity("helloWorldJob", "helloWorldJobGroup")
                .usingJobData(jobDataMap)
                .build();

        //创建Trigger
        // 在当前时间15秒后运行
        Date nowDate = new Date();
        System.out.println("当前时间：" + nowDate);
        Date startTime = DateBuilder.nextGivenSecondDate(nowDate,15);
        System.out.println("startTime:"+startTime);
        //调度策略：每10秒执行
        CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule("/10 * * * * ?");

        CronTrigger cronTrigger = TriggerBuilder.newTrigger()
                .withIdentity("cronTrigger", "cronTriggerGroup")
                .withSchedule(cronScheduleBuilder)
                .build();

        //将调度任务加入调度管理中
        taskManagement.scheduleJob(helloWorldJob, cronTrigger);
    }

    /**
     * CronTrigger高级-调度管理
     */
    public void cronTriggerUseTwo() {
        //获得调度任务管理器
        TaskManagement taskManagement = TaskManagement.getInstance();

        //JobMap
        JobDataMap jobDataMap = new JobDataMap();
        jobDataMap.put("message1", "Hello");
        jobDataMap.put("message2", "World");

        // 在当前时间15秒后运行
        Date nowDate = new Date();
        System.out.println("当前时间：" + nowDate);
        Date startTime = DateBuilder.nextGivenSecondDate(nowDate,15);
        System.out.println("startTime:"+startTime);

        //调度策略：每10秒执行
        CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule("/10 * * * * ?");

        //将调度任务加入调度管理中
        taskManagement.addJob(HelloWorldJob.class, "HelloWorld", jobDataMap, startTime, cronScheduleBuilder);
    }

}

Cron表达式
原文链接：https://www.cnblogs.com/drift-ice/p/3817269.html

位置	时间域	允许值	特殊值
1	秒	0-59	- * /
2	分钟	0-59	- * /
3	小时	0-23	- * /
4	日期	1-31	- * ? / L W C
5	月份	1-12	- * /
6	星期	1-7	- * ? / L C #
7	年份（可选）	1-31	- * /

星号(*)：可用在所有字段中，表示对应时间域的每一个时刻，例如，在分钟字段时，表示“每分钟”；

问号（?）：该字符只在日期和星期字段中使用，它通常指定为“无意义的值”，相当于点位符；

减号(-)：表达一个范围，如在小时字段中使用“10-12”，则表示从10到12点，即10,11,12；

逗号(,)：表达一个列表值，如在星期字段中使用“MON,WED,FRI”，则表示星期一，星期三和星期五；

斜杠(/)：x/y表达一个等步长序列，x为起始值，y为增量步长值。如在分钟字段中使用0/15，则表示为0,15,30和45秒，而5/15在分钟字段中表示5,20,35,50，你也可以使用*/y，它等同于0/y；

L：该字符只在日期和星期字段中使用，代表“Last”的意思，但它在两个字段中意思不同。L在日期字段中，表示这个月份的最后一天，如一月的31号，非闰年二月的28号；如果L用在星期中，则表示星期六，等同于7。但是，如果L出现在星期字段里，而且在前面有一个数值X，则表示“这个月的最后X天”，例如，6L表示该月的最后星期五；

W：该字符只能出现在日期字段里，是对前导日期的修饰，表示离该日期最近的工作日。例如15W表示离该月15号最近的工作日，如果该月15号是星期六，则匹配14号星期五；如果15日是星期日，则匹配16号星期一；如果15号是星期二，那结果就是15号星期二。但必须注意关联的匹配日期不能够跨月，如你指定1W，如果1号是星期六，结果匹配的是3号星期一，而非上个月最后的那天。W字符串只能指定单一日期，而不能指定日期范围；

LW组合：在日期字段可以组合使用LW，它的意思是当月的最后一个工作日；

井号(#)：该字符只能在星期字段中使用，表示当月某个工作日。如6#3表示当月的第三个星期五(6表示星期五，#3表示当前的第三个)，而4#5表示当月的第五个星期三，假设当月没有第五个星期三，忽略不触发；

C：该字符只在日期和星期字段中使用，代表“Calendar”的意思。它的意思是计划所关联的日期，如果日期没有被关联，则相当于日历中所有日期。例如5C在日期字段中就相当于日历5日以后的第一天。1C在星期字段中相当于星期日后的第一天。

Cron表达式对特殊字符的大小写不敏感，对代表星期的缩写英文大小写也不敏感。

一些例子：

表示式	说明
0 0 12 * * ?	每天12点运行
0 15 10 ? * *	每天10:15运行
0 15 10 * * ?	每天10:15运行
0 15 10 * * ? *	每天10:15运行
0 15 10 * * ? 2008	在2008年的每天10：15运行
0 * 14 * * ?	每天14点到15点之间每分钟运行一次，开始于14:00，结束于14:59。
0 0/5 14 * * ?	每天14点到15点每5分钟运行一次，开始于14:00，结束于14:55。
0 0/5 14,18 * * ?	每天14点到15点每5分钟运行一次，此外每天18点到19点每5钟也运行一次。
0 0-5 14 * * ?	每天14:00点到14:05，每分钟运行一次。
0 10,44 14 ? 3 WED	3月每周三的14:10分到14:44，每分钟运行一次。
0 15 10 ? * MON-FRI	每周一，二，三，四，五的10:15分运行。
0 15 10 15 * ?	每月15日10:15分运行。
0 15 10 L * ?	每月最后一天10:15分运行。
0 15 10 ? * 6L	每月最后一个星期五10:15分运行。
0 15 10 ? * 6L 2007-2009	在2007,2008,2009年每个月的最后一个星期五的10:15分运行。
0 15 10 ? * 6#3	每月第三个星期五的10:15分运行。