Quartz快速入门

最新推荐文章于 2024-06-17 07:15:00 发布
最新推荐文章于 2024-06-17 07:15:00 发布
阅读量770 收藏 3
点赞数 1
分类专栏： quartz任务调度 文章标签： quartz入门 quartz教程 quartz快速入门 quartz工具类 quartz学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37914588/article/details/104814374
版权

一、Quartz简介

1.quartz是开源且具有丰富特性的"任务调度库"，能够集成于任何的java应用。

2.quartz主要分为三大组件，分别是任务Job、触发器Trigger以及调度器Scheduler。

quartz体系架构图：

 

二、quartz三大组件简介

1.任务Job：即想要调用的任务类，需要实现org.quartz.job接口，并重写execute()方法，任务调度时会执行execute()方法。

2.触发器Trigger：即执行任务的触发器，当满足什么条件时会去执行你的任务Job，主要分为根据时长间隔执行的SimpleTrigger和根据日历执行的CronTrigger。

3.调度器Scheduler：即将Trigger和Job绑定之后，根据Trigger中的设定，负责进行Job调度的组件。

其它：

    1.一个调度器可以让多个触发器Trigger和任务Job绑定，而一个任务Job实例只能和一个触发器Trigger实例绑定，反过来也是如此。

 

三、案例入门

1.引入maven：

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

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

本文使用的是2.3.2版本，建议使用最新版本，如果需要日志可自行引入。

2.测试代码：

public class QuartzTest {


    public static void main(String[] args) throws SchedulerException {
        //1.调度器（Scheduler）
        SchedulerFactory schedulerfactory = new StdSchedulerFactory();
        //拿到调度器，调度器只需要一个即可，可以调度多个任务
        Scheduler scheduler = schedulerfactory.getScheduler();
        //2.Job实例（JobDetil）
        JobDetail jobDetail = JobBuilder.newJob(MyJob.class)
                .withIdentity("job", "default") //name:任务的名称，group：分组名
                .build();
        //3.触发器（Trigger）
        Trigger trigger = TriggerBuilder.newTrigger()
                .withIdentity("trigger", "default") //name:触发器名称，group：分组名
                .startNow() //马上执行一次，默认
                .withSchedule(SimpleScheduleBuilder.repeatSecondlyForTotalCount(20,2))//使用Simple触发器，执行20次，间隔2秒
                .build();
        //4.让Job和触发器关联
        scheduler.scheduleJob(jobDetail,trigger);
        //5.进行任务调度
        scheduler.start();
    }

    
    public static class MyJob implements Job {
        
        @Override
        public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
            //打印当前时间
            DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            String date = dateFormat.format(new Date());
            System.out.println(date);
        }
    }
}

3.执行结果：

    每两秒打印一次时间。

3.步骤说明：

通过上文，可以大概知道quartz的操作大概分为六步：

1.通过SchedulerFactory获取一个任务调度器Scheduler

2.实现org.quartz.job接口，并重写execute()方法为自己需要的任务调度逻辑。

3.通过JobBuilder.newJob()构建一个JobDetail（Job实例对象），并设置对应参数。

4.通过TriggerBuilder.newTrigger()构建一个触发器Trigger，并设置对应的参数。

5.通过Scheduler将JobDetail和Trigger绑定。

6.通过Scheduler的start()方法开始进行任务的调度。

 

四、参数传递

1.测试代码：

public class QuartzTest {


    public static void main(String[] args) throws SchedulerException{
        //1.调度器（Scheduler）
        SchedulerFactory schedulerfactory = new StdSchedulerFactory();
        //拿到调度器，调度器只需要一个即可，可以调度多个任务
        Scheduler scheduler = schedulerfactory.getScheduler();
        //2.Job实例（JobDetil）
        JobDataMap jobDetailMap = new JobDataMap();
        jobDetailMap.put("name","xuye");
        JobDetail jobDetail = JobBuilder.newJob(MyJob.class)
                .withIdentity("job", "default") //name:任务的名称，group：分组名
                .usingJobData(jobDetailMap) //传递参数
                .build();
        //3.触发器（Trigger）
        JobDataMap triggerMap = new JobDataMap();
        triggerMap.put("age",100);
        Trigger trigger = TriggerBuilder.newTrigger()
                .withIdentity("trigger", "default") //name:触发器名称，group：分组名
                .usingJobData(triggerMap)
                .startNow() //马上执行一次，默认
                .withSchedule(SimpleScheduleBuilder.repeatSecondlyForTotalCount(1,2))//使用Simple触发器，执行1次，间隔2秒
                .build();
        //4.让调度器关联Job和触发器
        scheduler.scheduleJob(jobDetail,trigger);
        scheduler.start();
    }

    public static class MyJob implements Job {



        @Override
        public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
            //方式一,获取JobDetail和Trigger传递的所有参数信息，使用此方式则不能对其进行设值。
            JobDataMap jobDataMap = jobExecutionContext.getMergedJobDataMap();
            //方式二，获取JobDetail的Map参数
            JobDataMap jobDetailMap = jobExecutionContext.getJobDetail().getJobDataMap();
            //方式三，获取Trigger的Map参数
            JobDataMap triggerMap = jobExecutionContext.getTrigger().getJobDataMap();
            System.out.println("getMergedJobDataMap()方法中能获取到的key和value：\n"+getKeyAndValue(jobDataMap));
            System.out.println("getJobDetail().getJobDataMap()方法中能获取到的key和value：\n"+getKeyAndValue(jobDetailMap));
            System.out.println("getTrigger().getJobDataMap()方法中能获取到的key和value：\n"+getKeyAndValue(triggerMap));
        }

        private String getKeyAndValue(Map<String,Object> map) {
            StringBuilder sb = new StringBuilder();
            Set<Map.Entry<String, Object>> entries = map.entrySet();
            for(Map.Entry<String, Object> entry : entries) {
                sb.append(entry.getKey()+":"+entry.getValue().toString()+",");
            }
            return sb.toString();
        }
    }
}

2.执行结果：

3.说明：

    1.通过使用 JobDataMap对象，在JobBuilder和TriggerBuilder中调用usingJobData方法将JobDataMap设置进去。

    2.在org.quartz.job实现类中通过JobExecutionContext上文下环境获取对应的参数，主要有以下3个方法，

        1）jobExecutionContext.getMergedJobDataMap()：

             获取JobBuilder和TriggerBuilder中两个的Map参数，注意使用该方式只能获取值，不能设置值，因为是无效的。

        2）jobExecutionContext.getJobDetail().getJobDataMap()：

             获取JobDetail的Map参数，只能获取JobDetail的。

        3）jobExecutionContext.getTrigger().getJobDataMap()：

             获取Trigger的Map参数，只能获取Trigger的。

    3.建议：如果只获取值，则使用jobExecutionContext.getMergedJobDataMap()，如果需要获取值，并把值传递到下一个任务调度中，请使用JobDetail或Trigger的对应参数。

    4.jobExecutionContext.getMergedJobDataMap()不能设置原理说明：每次任务调度时，都会创建一个JobExecutionContext，而创建后会把JobDetail或Trigger的对应参数全部设置到一个新的Map中，如果进行设值，则下次创建的还是新创建一个Map，上一个JobExecutionContext的设值则变为无效。

 

五、JobDataMap持久化

1.测试代码：

public class QuartzTest {

    public static void main(String[] args) throws SchedulerException{
        //1.调度器（Scheduler）
        SchedulerFactory schedulerfactory = new StdSchedulerFactory();
        //拿到调度器，调度器只需要一个即可，可以调度多个任务
        Scheduler scheduler = schedulerfactory.getScheduler();
        //2.Job实例（JobDetil）
        JobDataMap jobDetailMap = new JobDataMap();
        jobDetailMap.put("count",0);
        JobDetail jobDetail = JobBuilder.newJob(MyJob.class)
                .withIdentity("job", "default") //name:任务的名称，group：分组名
                .usingJobData(jobDetailMap) //传递参数
                .build();
        //3.触发器（Trigger）
        Trigger trigger = TriggerBuilder.newTrigger()
                .withIdentity("trigger", "default") //name:触发器名称，group：分组名
                .startNow() //马上执行一次，默认
                .withSchedule(SimpleScheduleBuilder.repeatSecondlyForTotalCount(20,2))//使用Simple触发器，执行20次，间隔2秒
                .build();
        //4.让调度器关联Job和触发器
        scheduler.scheduleJob(jobDetail,trigger);
        scheduler.start();
    }

    public static class MyJob implements Job {
        
        @Override
        public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
            //获取JobDetail的Map参数
            JobDataMap jobDetailMap = jobExecutionContext.getJobDetail().getJobDataMap();
            Integer count = (Integer) jobDetailMap.get("count");
            ++count;
            System.out.println("当前执行次数："+count);
            jobDetailMap.put("count",count);
        }

    }
}

2.执行结果：

3.说明：

    1.我们想要统计执行次数，但每次获取到的JobDetail参数Map都是新的。

    2.如果想要JobDetail和Trigger的Map参数都是持久化，只需要在该Job实例的类上加上注@PersistJobDataAfterExecution即可。

    3.修改如下：

    4.新的测试结果：

    5.JobDetail和Trigger的效果一致，Trigger代码就不多写，如果使用jobExecutionContext.getMergedJobDataMap()，只能获取JobDetail和Trigger的Map数据，并不能设值，上文已经说明原理，可自行测试。

 

六、自动注入

1.测试代码：

public class QuartzTest {

    public static void main(String[] args) throws SchedulerException{
        //1.调度器（Scheduler）
        SchedulerFactory schedulerfactory = new StdSchedulerFactory();
        //拿到调度器，调度器只需要一个即可，可以调度多个任务
        Scheduler scheduler = schedulerfactory.getScheduler();
        //2.Job实例（JobDetil）
        JobDataMap jobDetailMap = new JobDataMap();
        jobDetailMap.put("name","xuye");
        JobDetail jobDetail = JobBuilder.newJob(MyJob.class)
                .withIdentity("job", "default") //name:任务的名称，group：分组名
                .usingJobData(jobDetailMap) //传递参数
                .build();
        //3.触发器（Trigger）
        JobDataMap triggerMap = new JobDataMap();
        triggerMap.put("age",100);
        Trigger trigger = TriggerBuilder.newTrigger()
                .withIdentity("trigger", "default") //name:触发器名称，group：分组名
                .usingJobData(triggerMap)
                .startNow() //马上执行一次，默认
                .withSchedule(SimpleScheduleBuilder.repeatSecondlyForTotalCount(1,2))//使用Simple触发器，执行1次，间隔2秒
                .build();
        //4.让调度器关联Job和触发器
        scheduler.scheduleJob(jobDetail,trigger);
        scheduler.start();
    }
    
    public static class MyJob implements Job {

        private String name;
        
        private Integer age;

        @Override
        public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
            System.out.println("name:"+name+",age："+age);
        }

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

2.执行结果：

  

3.说明：

     1.如需使用自动注入，只需要org.quartz.job实现类中提供和其对应的属性名的set方法即可。

 

七、常用API

1.StdSchedulerFactory

    

方法名说明
Scheduler getScheduler()
获取一个调度器 
Scheduler
void initialize(Properties props)
初始化SchedulerFactory
Collection<Scheduler> getAllSchedulers()
获取所有的Scheduler

2.Scheduler

方法名说明
Date scheduleJob(JobDetail jobDetail, Trigger trigger)
将JobDetail和Trigger绑定
void triggerJob(JobKey jobKey)
通过JobKey立马执行一个Job
void triggerJob(JobKey jobKey, JobDataMap data)
通过JobKey立马执行一个Job，并传递参数
void start()
开始调度所有的任务，如果是暂停后调用则为重启
void shutdown()
马上关闭所有任务
void shutdown(boolean waitForJobsToComplete)
是否等待任务执行完关闭，true等待，false不等待
void standby()
暂停所有任务Job，通过start()方法重启
void pauseJob(JobKey jobKey)
通过JobKey暂停某个Job
void resumeJob(JobKey jobKey)
通过JobKey唤醒某个暂停的Job
void pauseTrigger(TriggerKey triggerKey)
暂停某个Trigger的所有Job
void resumeTrigger(TriggerKey triggerKey)
唤醒某个暂停的Trigger的Job

3.JobBuilder

方法名说明
JobBuilder newJob(Class <? extends Job> jobClass)：静态方法
加载Job的实例
JobBuilder withIdentity(String name, String group)
设置该 
JobDetail的名字和分组
JobBuilder usingJobData(String dataKey, String value)
传递参数，通过key和value
JobBuilder usingJobData(JobDataMap newJobDataMap)
传递参数，通过JobDataMap
JobDetail build()
按照之前的参数设置，构建一个JobDetail

 

4.JobDetail

方法名说明
JobDataMap getJobDataMap()
获取该JobDetail的JobDataMap
JobKey getKey()
获取该JobDetail的JobKey

 

5.TriggerBuilder

方法名说明
TriggerBuilder<Trigger> newTrigger：静态方法
加载一个Trigger
TriggerBuilder<T> withIdentity(String name, String group)
设置该 
Trigger的名字和分组
TriggerBuilder<T> usingJobData(String dataKey, String value)
传递参数，通过key和value
TriggerBuilder<T> usingJobData(JobDataMap newJobDataMap)
传递参数，通过JobDataMap
TriggerBuilder<SBT> withSchedule(ScheduleBuilder<SBT> schedBuilder)
关联一个ScheduleBuilder，通常是SimpleScheduleBuilder或CronScheduleBuilder
T build()
按照之前的参数设置，构建一个Trigger

6.Trigger

方法名说明
JobDataMap getJobDataMap()
获取该JobDetail的JobDataMap
 Date getNextFireTime()
获取下一次执行时间
TriggerKey getKey()
获取该Trigger的TriggerKey
Date getEndTime()
获取结束时间
Date getStartTime()
获取开始时间

7.SimpleScheduleBuilder

方法名说明
SimpleScheduleBuilder repeatSecondlyForever(int seconds)：静态方法

 

构建一个重复执行，按秒
SimpleScheduleBuilder repeatSecondlyForTotalCount(int count, int seconds)：静态方法
重复执行，间隔按秒，并且执行一定的次数。
类似上面2个重复执行的静态方法还有按分钟，按小时，因为内容过多便不写出来，方法名都是类似的。
 
SimpleScheduleBuilder withRepeatCount(int triggerRepeatCount)
重复执行的次数，注意：如果是1，则执行2次，因为运行立马执行一次，以此类推。

8.CronScheduleBuilder

方法名说明
CronScheduleBuilder cronSchedule(String cronExpression)：静态方法

 

根据cron表达式构建一个CronScheduleBuilder

 

9.CronExpression

方法名说明
boolean isValidExpression(String cronExpression)：静态方法

 

校验Cron表达式
CronExpression(String cronExpression)
构造函数，检验一个Cron表达式，如果不通过则抛出异常，该异常信息包含不通过的原因

 

八、Cron表达式

Cron表达式被用来配置CronTrigger实例，Cron表达式是一个由7个子表达式（第7个可以省略）组成的字符串。一般格式如下：* * * * * ？或* * * * * ？*，每个子表达式的代表一个日期细节，具体如下：

位置说明允许值允许的特殊字符
1Seconds 秒0-59, / * -
2Minutes 分钟0-59, / * -
3Hours 小时0-23, / * -
4Day-of-Month 月中的天1-31, / * - ? L W C
5 Month 月1-12或英文JAN-DEC, / * -
6Day-of-Week 周中的天1-7或英文SUN-SAT, / * - ? L C #
7Year (optional field) 年（可选）1970-2099（一般不写）, / * -

特殊字符含义说明：

字符含义
,（逗号）表示多个值，如秒中使用逗号分隔5,10,20，则表示在5秒、10秒、20秒执行，理解为或。
?表示不指定值，用于第四（月中的天）和第六位（周中的天），因为第四位和第六位是冲突的，如果第四位有值则第六位必须为?，反过来也是如此。
*表示所有可能的值，如果秒中使用*则表示60秒的每一秒都执行，小时上使用*则表示24小时的每个小时都执行。
-表示区间，如小时上用6-8，则表示6,7,8点都会执行。
/表示间隔，如在秒中使用0/20，则表示每隔20秒执行一次。
#表示月中的第几个周几，如6#3，表示该月第三周的周五（国外的周日=我们的周一）
W指定离给定日期最近的工作日(周一到周五)
L用在第四位（月中的天）表示一个月中的最后一天，用在第六位（周中的天）表示该月最后一个星期X，如用在第六位6L，则表示这个月的最后一个周五

九、Trigger触发器

Trigger触发器主要分为两大类：Simple触发器（通过SimpleScheduleBuilder关联）和Cron触发器（通过CronScheduleBuilder关联），上文案例中已经介绍了SimpleScheduleBuilder的使用和API设置，下面看CronScheduleBuilder的使用。

1.测试代码：

public class QuartzTest {


    public static void main(String[] args) throws SchedulerException{
        //1.调度器（Scheduler）
        SchedulerFactory schedulerfactory = new StdSchedulerFactory();
        //拿到调度器，调度器只需要一个即可，可以调度多个任务
        Scheduler scheduler = schedulerfactory.getScheduler();
        //2.Job实例（JobDetil）
        JobDetail jobDetail = JobBuilder.newJob(MyJob.class)
                .withIdentity("job", "default") //name:任务的名称，group：分组名
                .build();
        //3.触发器（Trigger）
        Trigger trigger = TriggerBuilder.newTrigger()
                .withIdentity("trigger", "default") //name:触发器名称，group：分组名
                .startNow() //马上执行一次
                .withSchedule(CronScheduleBuilder.cronSchedule("0/3 * * * * ?"))//使用Cron触发器
                .build();
        //4.让Job和触发器关联
        scheduler.scheduleJob(jobDetail,trigger);
        scheduler.start();
    }


    public static class MyJob implements Job {

        @Override
        public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
            //打印当前时间
            DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            String date = dateFormat.format(new Date());
            System.out.println(date);
        }
    }
}

2.执行结果：

    cron表达式为：0/3 * * * * ? 即从0秒开始，每间隔3秒执行一次。

 

十、StdSchedulerFactory的配置

上文中介绍了StdSchedulerFactory的API，其中就有一个initialize(Properties props)方法，对StdSchedulerFactory进行初始化，常用的配置的属性名和值如下：

属性名说明
org.quartz.threadPool.class使用哪个线程池（要实现org.quartz.spi.ThreadPool接口的线程池），一般用org.quartz.simpl.SimpleThreadPool
org.quartz.threadPool.threadCount 线程池线程数量，根据自己情况定，最好不要超过100
org.quartz.threadPool.threadPriority 线程优先级，1-10，数字越小优先级越高，一般用5即可。
org.quartz.scheduler.instanceName
调度器的名字
org.quartz.scheduler.instanceId
为调度器创建一个Key值，这个Key必须在所有调度器中唯一，一般填写AUTO，让quartz自动生成。
org.quartz.jobStore.class
任务调度存储（需要实现org.quartz.spi.JobStore接口的实例），一般用org.quartz.impl.jdbcjobstore.JobStoreTX

 

十一、工具类

上文大致把quartz基本内容概述完毕，下一篇博客将会进行高级内容概述，在此之前，先奉上本人自己写的一个quartz任务调度工具类，能够及其方便的根据间隔或corn表达式调度任意一个类的某个方法，代码如下：

public class SchedulerUtils {

    private static StdSchedulerFactory schedulerfactory = new StdSchedulerFactory();



    public static final int SECONDS = 1;

    public static final int MINUTES = 2;

    public static final int HOURS = 3;


    private static String CLASS_KEY = "CLASS-KEY";
    private static String METHOD_KEY = "METHOD-KEY";
    private static String PARAMS_KEY = "PARAMS-KEY";

    /**
     * 初始化StdSchedulerFactory
     * @param map 初始化参数
     * @throws SchedulerException
     */
    public static void init(Map<String,String> map) throws SchedulerException {
        Properties properties = new Properties();
        for(Map.Entry<String, String> entry : map.entrySet()) {
            properties.setProperty(entry.getKey(),entry.getValue());
        }
        init(properties);
    }

    public static void init(Properties properties) throws SchedulerException {
        schedulerfactory.initialize(properties);
    }

    /**
     *  按Cron表达式定时执行
     * @param clazzName 全类名
     * @param methodName 方法名
     * @param args 方法参数
     * @param cron cron表达式
     * @throws Exception
     */
    public static void executeJobCron(String clazzName, String methodName, List<Object> args,String cron) throws Exception {
        executeJobCron(clazzName,methodName,args,cron,null,null);
    }

    /**
     *  按Cron表达式定时执行
     * @param clazzName 全类名
     * @param methodName 方法名
     * @param args 方法参数
     * @param cron cron表达式
     * @param startDate 开始时间，如果马上开始填写null或 new Date()即可
     * @param endDate 结束时间，如果没有结束时间则填写null即可
     * @throws Exception
     */
    public static void executeJobCron(String clazzName, String methodName, List<Object> args,String cron,Date startDate,Date endDate) throws Exception {
        JobDetail jobDetail = jobDetailHandle(clazzName, methodName, args);
        Trigger trigger = cronTriggerTimeHandle(cron,startDate,endDate);
        Scheduler scheduler = getScheduler();
        scheduler.scheduleJob(jobDetail,trigger);
        scheduler.start();
    }


    public static void executeJob(String clazzName, String methodName, List<Object> args, int timeUnit, int interval, Date endDate) throws Exception{
        executeJob(clazzName,methodName,args,timeUnit,interval,-1,null,endDate);
    }


    public static void executeJob(String clazzName, String methodName, List<Object> args, int timeUnit, int interval)  throws Exception{
        executeJob(clazzName,methodName,args,timeUnit,interval,-1,null,null);
    }

    public static void executeJob(String clazzName, String methodName, List<Object> args, int timeUnit, int interval, int count)  throws Exception{
        executeJob(clazzName,methodName,args,timeUnit,interval,count,null,null);
    }


    /**
     *  按照间隔时间定时执行
     * @param clazzName 全类名
     * @param methodName 方法名
     * @param args 方法参数
     * @param timeUnit 时间单位，参考本类属性定义
     * @param interval 间隔长度
     * @param count 执行总数，如果执行总数和结束时间都有，则按结束时间。
     * @param startDate 开始时间，如果马上开始填写null或 new Date()即可
     * @param endDate 结束时间，如果没有结束时间则填写null即可
     * @throws Exception
     */
    public static void executeJob(String clazzName, String methodName, List<Object> args, int timeUnit, int interval, int count,Date startDate,Date endDate)  throws Exception {
        JobDetail jobDetail = jobDetailHandle(clazzName, methodName, args);
        Trigger trigger = simpleTriggerTimeHandle(timeUnit,interval, count,startDate,endDate);
        Scheduler scheduler = getScheduler();
        scheduler.scheduleJob(jobDetail,trigger);
        scheduler.start();
    }

    private static JobDetail jobDetailHandle(String clazzName, String methodName, List<Object> args) throws NoSuchMethodException, ClassNotFoundException {
        JobDataMap jobDataMap = new JobDataMap();
        Class clazz = Class.forName(clazzName);
        Method method = findMethod(clazz,methodName,args);
        jobDataMap.put(CLASS_KEY,clazz);
        jobDataMap.put(METHOD_KEY,method);
        jobDataMap.put(PARAMS_KEY,args);
        JobDetail jobDetail = JobBuilder.newJob(TaskJob.class)
                .withIdentity("job")
                .usingJobData(jobDataMap)
                .build();
        return jobDetail;
    }

    private static Trigger simpleTriggerTimeHandle(int timeUnit, int interval, int count, Date startDate,Date emdDate) {
        TriggerBuilder<Trigger> triggerBuilder = TriggerBuilder.newTrigger()
                .withIdentity("simpleTrigger");
        if(startDate == null) {
            startDate = new Date();
        }
        triggerBuilder.startAt(startDate);
        triggerBuilder.endAt(emdDate);
        if(count > 0) {
            switch (timeUnit) {
                case SECONDS : triggerBuilder.withSchedule(SimpleScheduleBuilder.repeatSecondlyForTotalCount(count,interval));
                    break;
                case MINUTES : triggerBuilder.withSchedule(SimpleScheduleBuilder.repeatMinutelyForTotalCount(count,interval));
                    break;
                case HOURS : triggerBuilder.withSchedule(SimpleScheduleBuilder.repeatHourlyForTotalCount(count,interval));
                    break;
            }
        }
        return triggerBuilder.build();
    }

    private static Trigger cronTriggerTimeHandle(String cron,Date startDate,Date emdDate) throws ParseException {
        new CronExpression(cron);
        if(startDate == null) {
            startDate = new Date();
        }
        Trigger trigger =  TriggerBuilder.newTrigger()
                .withIdentity("cronTrigger")
                .startAt(startDate)
                .endAt(emdDate)
                .withSchedule(CronScheduleBuilder.cronSchedule(cron))
                .build();
        return trigger;
    }

    private static Scheduler getScheduler() throws SchedulerException {
        return schedulerfactory.getScheduler();
    }

    private static Method findMethod(Class clazz,String methodName,List<Object> args) throws NoSuchMethodException {
        Method method;
        if(args != null && !args.isEmpty()) {
            Class<?>[] paramsTypes = getMethodParamsType(args);
            method = clazz.getDeclaredMethod(methodName,paramsTypes);
        }else {
            method = clazz.getDeclaredMethod(methodName);
        }
        return method;
    }


    private static Class<?>[] getMethodParamsType(List<Object> methodParams) {
        Class<?>[] classs = new Class<?>[methodParams.size()];
        int index = 0;
        for (Object os : methodParams)
        {
            classs[index] = os.getClass();
            index++;
        }
        return classs;
    }

    public static class TaskJob implements Job {

        private Map<Class,Object> objectMap = new ConcurrentHashMap<Class, Object>();

        @Override
        public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
            JobDataMap dataMap = jobExecutionContext.getMergedJobDataMap();
            Class clazz = (Class) dataMap.get(CLASS_KEY);
            Object object;
            try {
                object = getObject(clazz);
                Method method = (Method) dataMap.get(METHOD_KEY);
                Parameter[] parameters = method.getParameters();
                if (parameters.length > 0) {
                    List<Object> args = (List<Object>) dataMap.get(PARAMS_KEY);
                    Object[] objects = args.toArray();
                    method.invoke(object, objects);
                }else {
                    method.invoke(object);
                }
            }catch (Exception e) {
                e.printStackTrace();
            }
        }

        private Object getObject(Class clazz) throws IllegalAccessException, InstantiationException {
            Object object = objectMap.get(clazz);
            if(object == null) {
                object = clazz.newInstance();
                objectMap.put(clazz,object);
            }
            return object;
        }
    }
}

        

许夜3
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Quartz 快速入门指南
miaozhihao的博客
12-22 600
Quartz 快速入门指南 下载与安装 配置 开始一个简单的应用
Quartz 框架快速入门
04-09
Quartz 框架快速入门 在前面两篇文章中简单介绍了在java应用程序中如何使用Quartz框架，这一篇中我们将看到如何在web环境下通过配置文件来完成Quartz的后台作业调度，而不必手工去创建Trigger和Scheduler
Quartz 快速入门
qq_40208605的博客
07-01 169
建立 maven 项目导入 quartz 坐标 入门案例：http://www.quartz-scheduler.org/documentation/quartz-2.1.x/quick-start.html 案例一： 案例二： SimpleTrigger 使用 必须掌握 JobDetail 和 Trigger 两个对象 Job 工作任务...
任务调度之Quartz
励志成为一名优秀的全能型软件开发工程师。
06-17 1072
既然可以在配置文件配置，当然也可以用@Bean注解配置。在配置类上加上@Configuration让Spring读取到。@Bean.usingJobData("msb", "涛哥").build();@Bean");.build();运行 spring-quartz工程的com.msb.quartz.QuartzTest。
Spring Boot集成Quartz快速入门Demo
HBLOG
04-23 570
1.Quartz介绍  Quartz是OpenSymphony开源的一个项目，是一个由Java编写的开源作业调度框架。特点支持分布式高可用，我们需要某个定时任务在多个节点中只有某个节点可以执行时，就需要Quartz来实现，否则使用@Scheduled等方式会造成所有节点都执行一遍。支持持久化，Quartz有专门的数据表来实现定时任务的持久化。支持多任务调度和管理，Quartz可以在数据库中存储多个...
任务调度框架Quartz快速入门
2401_84010457的博客
03-31 952
超重要API==========Scheduler 和调度程序交互的主要API生命周期从SchedulerFactoru创建它开始，到调用shutdown方法结束。一旦Scheduler创建，任何关于scheduling相关的事，他都为所欲为：添加、删除、列出所有的Jobs和triggers、暂停触发器等。在start方法之前，不会做任何事情。Job 你希望被调度器调度的任务组件接口。当Job的触发器触发时，调度程序的工作线程将调用execute方法。该方法接收一个JobExecutionContext对象
Quartz快速入门案例
希冀
10-30 662
Quartz任务调度 一.Quartz概念 Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目，它可以与J2EE与J2SE应用程序相结合也可以单独使用。 quartz是开源且具有丰富特性的"任务调度库"，能够集成于任何的java应用，小到独立的应用，大至电子商业系统。quartz能够创建亦简单亦复杂的调度，以执行上十、上百，甚至上万的任务。任务job被定义为标准的java组件，能够执行任何你想要实现的功能。quartz调度框架包含许多企业级的特性，如JTA事务、集
quartz快速入门
zhengdesheng19930211的博客
03-21 577
概述 了解Quartz体系结构 Quartz对任务调度的领域问题进行了高度的抽象，提出了调度器、任务和触发器这3个核心的概念，并在org.quartz通过接口和类对重要的这些核心概念进行描述： ●Job：是一个接口，只有一个方法void execute(JobExecutionContext context)，开发者实现该接口定义运行任务，JobExecutionContext类提供了调度上
QuartZ 快速入门
ck-wizard的学习之路
06-09 417
本文章是基于 QuartZ2.x的Document编写的. 1.下载QuartZ.jar 下载地址:http://www.quartz-scheduler.org/downloads/ 或者去Maven 搜索进行下载. 2.安装QuartZ.jar QuartZ有许多Jar包,主要的jar包为quartz-all-xxx.jar,导入到自己的依赖中.就可以使用基础功能了. 3.
Quartz快速入门案例，SpringBoot整合Quartz
qq_44073614的博客
11-28 511
Quartz整体架构 QuickStart HelloJob.class package com.example.quartzspringbootdemo.first; import org.quartz.Job; import org.quartz.JobExecutionContext; import org.quartz.JobExecutionException; public class HelloJob implements Job { @Override public v
Quartz快速入门（非常详细）
Li_CSDN_Li的博客
04-14 707
1、简介 Quartz是Job scheduling（作业调度）领域的一个开源项目，Quartz既可以单独使用也可以跟spring框架整合使用，在实际开发中一般会使用后者。使用Quartz可以开发一个或者多个定时任务，每个定时任务可以单独指定执行的时间，例如每隔1小时执行一次、每个月第一天上午10点执行一次、每个月最后一天下午5点执行一次等。 官网：http://www.quartz-schedu...
Quartz框架快速入门
10-31
### Quartz框架快速入门详解 #### 一、Quartz框架简介 Quartz是一个开源的作业调度框架，用于开发Java应用程序。它提供了强大的触发器（Trigger）机制用于关联作业（Job），同时还具备灵活的表达式用于配置定时...
Quartz框架快速入门.pdf
10-05
Quartz框架是一款强大的开源任务调度库，广泛应用于Java环境下的定时任务管理。要开始使用Quartz，首先需要在项目中引入必要的依赖。基础依赖是quartz-<version>.jar，这是Quartz的核心库。除此之外，根据你的需求，...
Quartz 框架快速入门（一）
05-29
NULL 博文链接：https://wangrl.iteye.com/blog/1125327
chromedriver-mac-arm64_126.0.6465.0.zip
07-31
chromedriver-mac-arm64_126.0.6465.0.zip
chromedriver-mac-x64_122.0.6235.0.zip
最新发布
07-31
chromedriver-mac-x64_122.0.6235.0.zip
chromedriver-mac-x64_122.0.6188.0.zip
07-31
chromedriver-mac-x64_122.0.6188.0.zip
【JCR2区】基于matlab阿基米德算法优化最小二乘法AOA-LSSVM数据分类【含Matlab源码 6004期】.zip
07-31
CSDN海神之光上传的代码均可运行，亲测可用，换数据就行，适合小白； 1、代码压缩包内容 主函数：main.m； 数据； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，可私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开除main.m的其他m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主或扫描博主博客文章底部QQ名片； 4.1 CSDN博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作 智能优化算法优化最小二乘法支持向量机LSSVM分类预测系列程序定制或科研合作方向： 4.4.1 遗传算法GA/蚁群算法ACO优化LSSVM 4.4.2 粒子群算法PSO/蛙跳算法SFLA优化LSSVM 4.4.3 灰狼算法GWO/狼群算法WPA优化LSSVM 4.4.4 鲸鱼算法WOA/麻雀算法SSA优化LSSVM 4.4.5 萤火虫算法FA/差分算法DE优化LSSVM 4.4.6 其他优化算法优化LSSVM
Quartz框架入门教程：创建Job与execute方法解析
"Quartz框架快速入门" Quartz框架是一个开源的作业调度库，它提供了强大的任务调度能力，能够按照预定义的时间表执行Java任务。在快速入门Quartz框架的过程中，首先需要下载Quartz的二进制版本，例如quartz-...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值