精华内容
下载资源
问答
  • 定时任务Quartz

    2018-11-15 14:13:01
    只需基本的spring包即可 注:要是项目报错 java.lang.ClassNotFoundException: org.springframework.web.context.ContextLoaderListener 缺少jar包,这个jar包在以上压缩包中就有
  • 定时任务 quartz

    千次阅读 2019-07-04 23:40:37
    Quartz有四个核心接口Job、JobDetail、Trigger和Scheduler。Trigger主要有CronTrigger(表达式触发)和SimpleTrigger(简单触发)两...将需要完成的任务写在execute()方法中。一个job可以有多个trigger,一个trigg...

    Quartz有四个核心接口Job、JobDetail、Trigger和Scheduler。Trigger主要有CronTrigger(表达式触发)和SimpleTrigger(简单触发)两个接口,表达式触发的功能更强大,在开发时使用比较广泛,Job是一个实现org.quartz.Job接口的java类。将需要完成的任务写在execute()方法中。一个job可以有多个trigger,一个trigger只能有一个job。JobDetail包含了Job的调度策略和调度方案。Scheduler是对定时任务进行调度的控制器。Quartz的运行原理如图所示。

    Scheduler是整个任务调度的总部,里面注册了很多的JobDetail和trigger。Trigger主要用来设置调度参数,用来设置多久进行一次任务调度。当Scheduler容器启动时,JobDetail和Trigger会在scheduler容器上进行注册。注册后,JobDetail和Trigger将会组成的一对装配好的作业。在Scheduler中有一个线程池,按照Trigger中配置的规则,为每个作业开启一个线程来并行执行。 

    SimpleTrigger

    应用小demo

    public class HelloJob implements Job{
        public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
            System.out.println(new Date());
        }
    }
    =================================================================
    
    package job;
    
    import org.quartz.JobDetail;
    import org.quartz.Scheduler;
    import org.quartz.SchedulerFactory;
    import org.quartz.Trigger;
    import org.quartz.impl.StdSchedulerFactory;
    import java.util.Date;
    import static org.quartz.DateBuilder.evenSecondDate;
    import static org.quartz.JobBuilder.newJob;
    import static org.quartz.TriggerBuilder.newTrigger;
    
    /**
     * created by reedfan on 2019/7/4 0004
     */
    public class SimpleExample {
        public void run() throws Exception {
            System.out.println("------- Initializing ----------------------");
            // 定义调度器
            SchedulerFactory sf = new StdSchedulerFactory();
            Scheduler sched = sf.getScheduler();
            System.out.println("------- Initialization Complete -----------");
            // 获取当前时间的下一秒钟
            Date runTime = evenSecondDate(new Date());
            System.out.println("------- Scheduling Job  -------------------");
            // 定义job
            // 在quartz中,有组的概念,组+job名称 唯一的
            JobDetail job = newJob(HelloJob.class).withIdentity("job1", "group1").build();
            // 定义触发器,在下一秒钟启动
            Trigger trigger = newTrigger().withIdentity("trigger1", "group1").startAt(runTime).build();
            // 将job注册到调度器
            sched.scheduleJob(job, trigger);
            System.out.println(job.getKey() + " will run at: " + runTime);
            // 启动调度器
            sched.start();
            System.out.println("------- Started Scheduler -----------------");
            // 等待5秒
            System.out.println("------- Waiting 5 seconds... -------------");
            try {
                // wait 65 seconds to show job
                Thread.sleep(5L * 1000L);
                // executing...
            } catch (Exception e) {
                //
            }
            // 关闭调度器
            System.out.println("------- Shutting Down ---------------------");
            sched.shutdown(true);
            System.out.println("------- Shutdown Complete -----------------");
        }
    
        public static void main(String[] args) throws Exception {
            SimpleExample example = new SimpleExample();
            example.run();
    
        }
    }
    

    运行结果

     

    CronTrigger

    quartz表达式生成器

    package job;
    
    import org.quartz.JobDetail;
    import org.quartz.Scheduler;
    import org.quartz.SchedulerFactory;
    import org.quartz.Trigger;
    import org.quartz.impl.StdSchedulerFactory;
    import java.util.Date;
    
    import static org.quartz.CronScheduleBuilder.cronSchedule;
    import static org.quartz.DateBuilder.evenSecondDate;
    import static org.quartz.JobBuilder.newJob;
    import static org.quartz.TriggerBuilder.newTrigger;
    
    /**
     * created by reedfan on 2019/7/4 0004
     */
    public class SimpleExample {
        public void run() throws Exception {
            System.out.println("------- Initializing ----------------------");
            // 定义调度器
            SchedulerFactory sf = new StdSchedulerFactory();
            Scheduler sched = sf.getScheduler();
            System.out.println("------- Initialization Complete -----------");
            // 获取当前时间的下一秒钟
            Date runTime = evenSecondDate(new Date());
            System.out.println("------- Scheduling Job  -------------------");
            // 定义job
            // 在quartz中,有组的概念,组+job名称 唯一的
            JobDetail job = newJob(HelloJob.class).withIdentity("job1", "group1").build();
            // 定义触发器,在下一钟启动
          //  Trigger trigger = newTrigger().withIdentity("trigger1", "group1").startAt(runTime).build();
            // 将job注册到调度器
    
            // 定义触发器,每2秒执行一次
            Trigger trigger = newTrigger().withIdentity("trigger1", "group1")
                    .withSchedule(cronSchedule("0/2 * * * * ?")).build();
    
            sched.scheduleJob(job, trigger);
            System.out.println(job.getKey() + " will run at: " + runTime);
            // 启动调度器
            sched.start();
            System.out.println("------- Started Scheduler -----------------");
            // 等待5秒
            System.out.println("------- Waiting 10 seconds... -------------");
            try {
                // wait 10 seconds to show job
                Thread.sleep(10L * 1000L);
                // executing...
            } catch (Exception e) {
                //
            }
            // 关闭调度器
            System.out.println("------- Shutting Down ---------------------");
            sched.shutdown(true);
            System.out.println("------- Shutdown Complete -----------------");
        }
    
        public static void main(String[] args) throws Exception {
            SimpleExample example = new SimpleExample();
            example.run();
    
        }
    }
    

     

    展开全文
  • 定时任务quartz

    2017-08-20 21:39:10
    由于我们是做传统教育行业的,然后教育行业的新生入学,评教等业务都牵涉到了一个定时任务的需求,刚开始有人提议说直接使用队列,但是后来经过衡量,决定使用quartz这个框架来实现这个定时任务的需求。 选它的...

    最近在项目选型的时候,我们遇到了一个场景,由于我们是做传统教育行业的,然后教育行业的新生入学,评教等业务都牵涉到了一个定时任务的需求,刚开始有人提议说直接使用队列,但是后来经过衡量,决定使用quartz这个框架来实现这个定时任务的需求。


    选它的原因:

    这个技术已经比较的成熟,也有不少的可供参考的资料,后期好维护。


    好了,废话不多说,直接进入咱们的正题,quartz这个框架可以说是为了定时任务量身打造的一个框架,这个框架的核心类主要是Job,Trigger,Scheduler这仨。


    我直接上源码你就知道一个单纯的定时任务有多容易就实现了吧。

    首先建立maven工程,引入jar包

    <?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>com.tgb.quartz</groupId>
        <artifactId>com.tgb.quartz</artifactId>
        <version>1.0-SNAPSHOT</version>
    
        <dependencies> 
    <!-- https://mvnrepository.com/artifact/org.quartz-scheduler/quartz -->
            <dependency>
                <groupId>org.quartz-scheduler</groupId>
                <artifactId>quartz</artifactId>
                <version>2.2.1</version>
            </dependency>
    
        </dependencies>
    
    </project>
    接着建立自己的job类,实现Job接口。把自己要实现的业务逻辑放入execute方法中,我这里就直接是打印一个helloworld了。

    public class HelloJob implements Job {
        public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
            Date date= new Date();
            SimpleDateFormat simpleDateFormat= new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            System.out.println( simpleDateFormat.format(date));
            //编写具体的业务逻辑
            System.out.println("hello world");
        }
    }
    最后在新建一个自己的任务调度类HelloScheduler
    public class HelloScheduler {
        public static void main(String[] args) {
            //创建一个JobDetai实例,将该实例与HelloJob绑定
            JobDetail jobDetail= JobBuilder.newJob(HelloJob.class)
                    .withIdentity("myJob","groupOne")
                    .build();
    
    
            //创建一个Trigger触发器
            Trigger trigger= TriggerBuilder.newTrigger()
                    .withIdentity("myTrigger","groupOne")
                    //触发器从此刻执行
                    .startNow()
                    .withSchedule(SimpleScheduleBuilder
                            .simpleSchedule()
                            //执行间隔为2秒
                            .withIntervalInSeconds(2)
                            //执行时间为永久
                            .repeatForever()).build();
    
            //创建Scheduler任务调度实例
            SchedulerFactory schedulerFactory= new StdSchedulerFactory();
            try {
                Scheduler scheduler= schedulerFactory.getScheduler();
                scheduler.start();
                //将触发器和任务装配进任务调度容器中
                scheduler.scheduleJob(jobDetail,trigger);
                Date date= new Date();
                SimpleDateFormat simpleDateFormat= new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                System.out.println( simpleDateFormat.format(date));
            }catch (Exception e){
                e.printStackTrace();
            }
    
        }
    }
    最后看执行效果:

    就这些,有木有很简单。这次只是简单的实现了一个小的定时任务的demo,一门技术往往不难,难的复杂的通常都
    是业务,在现实场景中quartz框架往往都是和spring配合使用的,在下篇博客中会有展示,欢迎各位博友拍砖。


    展开全文
  • 定时任务quartz及教程

    2017-06-13 09:13:16
    定时任务quartz
  • 定时任务quartz jar包

    2014-02-28 14:28:43
    定时任务quartz jar包,可以用于对多个任务进度的管理
  • 自留demo,java定时任务quartz的基本实现,对应博客https://blog.csdn.net/jing12062011/article/details/82758536
  • spring定时任务quartz

    2018-07-25 17:15:00
    spring定时任务quartz 背景介绍  使用spring做项目,需要定时的完成一系列的任务动作处理,执行相应的代码逻辑,使用spring的Quartz组件可以完成定时任务的功能,作者强烈推荐使用Quartz 2.x版本。 原理如下: ...

    spring定时任务quartz

    背景介绍

      使用spring做项目,需要定时的完成一系列的任务动作处理,执行相应的代码逻辑,使用spring的Quartz组件可以完成定时任务的功能,作者强烈推荐使用Quartz 2.x版本。

    原理如下:

    一、环境介绍

      IDE:eclipse

      JDK:1.8

      Maven:3.5

    二、搭建步骤

      1、使用eclipse新创建Maven项目:

      2、选择项目存放路径

      3、项目类型选择为Web类型

      4、填写项目包信息

      5、完成,编写代码

    三、核心代码说明

      1、首先编写WEB.XML文件的配置,填写对应bean文件的监听文件

      

      2、编写对应的bean信息内容,也就是applicationContext.xml文件的内容

      

      说明:

        这里只截取了Quartz 2.x版本的配置,具体版本1.x的可以参见具体代码,代码可以在文章后面找到。

        这里先添一个springframework的scheduling的定时任务触发器,默认这执行exampleJob2的触发器,然后添加exampleJob2的触发器exampleJob2trigger,具体的设定好任务名称及任务引用bean id,并配置定时器的出发周期,再次添加触发器执行的任务类,及类执行方法,这里采用属性值注入方法,最后添加执行exampleJob2的执行任务类bean的具体实现类。

      3、Pom文件如下

      

      主要是在springframework框架上增加了Quartz的Scheduler包,主类包quartz和quzrtz-jobs包。

      4、exampleJob2的实现类如下

      

      这里比较简单,不像Quartz 1.x版本样还需要继承于QuartzJobBean,重写对应的方法了。

    四、测试运行

       运行项目会看到定时任务的输出信息

    2018-07-25 17:10:40执行ExampleJob2
    2018-07-25 17:10:50执行ExampleJob2
    2018-07-25 17:11:00执行ExampleJob2
    2018-07-25 17:11:10执行ExampleJob2
    2018-07-25 17:11:20执行ExampleJob2

     

    五、代码地址

      https://github.com/verylove/spring-notes/tree/master/spring-quartz

    转载于:https://www.cnblogs.com/verylove/p/9367120.html

    展开全文
  • Java 定时任务quartz实现方式

    千次阅读 2020-04-30 11:28:44
    Java 定时任务quartz1. java自带 java.util.Timer 实现定时任务2. 使用线程池(ScheduledThreadPool-java.util.concurrent.ScheduledExecutorService)实现定时任务3. 使用注解@Scheduled实现定时任务4. 使用Quartz...

    1. java自带 java.util.Timer 实现定时任务

    Timer timer = new Timer();
    timer.schedule(new TimerTask() {
        @Override
        public void run() {
            System.out.println("schedule--------------" + System.currentTimeMillis());
        }
    }, 10 * 1000, 3 * 1000);// 10秒后执行,执行频率为3秒一次
    
    • schedule(TimerTask task, Date time):安排在指定的时间执行指定的任务。
    • schedule(TimerTask task, Date firstTime, long period) :安排指定的任务在指定的时间开始进行重复的固定延迟执行。
    • schedule(TimerTask task, long delay) :安排在指定延迟后执行指定的任务。
    • schedule(TimerTask task, long delay, long period) :安排指定的任务从指定的延迟后开始进行重复的固定延迟执行。
    • scheduleAtFixedRate(TimerTask task, Date firstTime, long period):安排指定的任务在指定的时间开始进行重复的固定速率执行。
    • scheduleAtFixedRate(TimerTask task, long delay, long period):安排指定的任务在指定的延迟后开始进行重复的固定速率执行。

    2. 使用线程池(ScheduledThreadPool-java.util.concurrent.ScheduledExecutorService)实现定时任务

    ScheduledExecutorService service = Executors.newScheduledThreadPool(1);
    service.scheduleAtFixedRate(new Runnable() {
        @Override
        public void run() {
            System.out.println("--------------" + System.currentTimeMillis());
        }
    }, 10, 3, TimeUnit.SECONDS);// 10秒后执行,执行频率为3秒一次
    

    3. 使用注解@Scheduled实现定时任务

    注解@Scheduled属性有:

    1. cron : cron的表达式
    2. zone : 解析cron表达式的时区
    3. fixedDelay : 方法之间以毫秒为单位执行带注释的方法,返回延迟,以毫秒为单位
    4. fixedDelayString : 方法之间以毫秒为单位执行带注释的方法,返回延迟,以毫秒为单位
    5. fixedRate : 周期(以毫秒为单位)
    6. fixedRateString : 周期(以毫秒为单位)
    7. initialDelay : 在第一次执行a之前要延迟的毫秒数,初始延迟(以毫秒为单位)
    8. initialDelayString : 在第一次执行a之前要延迟的毫秒数,初始延迟(以毫秒为单位)
    @Component
    public class SpringScheduled {
        // 10秒后开始执行,每隔3秒执行一次
        @Scheduled(initialDelay = 10 * 1000, fixedRate = 3 * 1000)
        public void execute() {
            System.out.println("------------" + System.currentTimeMillis());
        }
    }
    

    4. 使用Quartz定时任务调度器

    4.1 Quartz 特点

    1. 具有强大的调度功能,与Spring容易集成,形成灵活的调度功能。
    2. 调度环境的持久化机制:可以保存并恢复调度现场,即使系统因为故障关闭,任务调度现场的数据并不会丢失。
    3. 灵活的应用方式:可以灵活的定义触发器调度时间表,并可对触发器与任务进行关联映射(通过Name和Group形式为一个的JobKey)。
    4. 分布式与集群能力

    4.2 核心概念

          Quartz核心概念包括:调度器(Scheduler)、任务(Job)、触发器(Trigger)。

          任务:表示一个具体的可执行的调度程序,Job (实现Job接口的具体类)是这个可执行程调度程序所要执行的内容,另外 JobDetail 还包含了这个任务调度的方案和策略。

          调度器:一个调度容器,一个调度容器中可以注册多个 JobDetail 和 Trigger。当 Trigger 与 JobDetail 组合,就可以被 Scheduler 容器调度了。

          触发器:可配置调度参数。

    4.3 常用对象

    1. Job:一个接口,只有一个 execute(JobExecutionContext context) 方法,用于编写具体的任务业务逻辑。当调度器需要执行 job 时创建实例,调用完成后释放 job 实例。
    2. JobDetail:描述 Job 实列的详细信息。name:job名称;group:job组。默认值为default;jobClass:job接口实现类的class;jobDataMap:存储Job实例的状态信息,调度器使用这些信息添加 Job 实例。
    3. JobExecutionContext:Job能通过 JobExecutionContext 访问 Quartz 运行环境以及 Job 的明细数据,当 Scheduler 调用 Job 时能将数据传递给 execute() 方法。
    4. JobDataMap:是一个JDK中Map接口实例,在任务调度时存在于 JobExecutionContext 中,可将参数对象传递给在运行的 Job 实例;而且,它自身有方便的方法可存取基本数据类型。
    5. Trigger:触发器,可设置首次被触发事件 startTime,不再被触发事件 endTime。
    6. ScheduleBuilder:设置任务执行计划,如多久执行一次,是否重复执行,延迟多久执行等。
    7. Scheduler:调度器,管理任务调取容器。

    4.4 实例代码

    创建一个 Job 实现类,用于编写具体业务逻辑

    import org.quartz.*;
    
    import java.time.LocalDateTime;
    import java.time.format.DateTimeFormatter;
    
    public class TestJob implements Job {
        @Override
        public void execute(JobExecutionContext context) throws JobExecutionException {
            LocalDateTime nowTime = LocalDateTime.now();
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss");
            System.out.println("---------" + formatter.format(nowTime));
            // 获取Scheduler
            Scheduler scheduler = context.getScheduler();
            // 获取Trigger
            Trigger trigger = context.getTrigger();
            // 通过Trigger获取JobDataMap参数
            JobDataMap triggerJobData = trigger.getJobDataMap();
            // 获取JobDetail
            JobDetail jobDetail = context.getJobDetail();
            // 通过JobDetail获取JobDetail参数
            JobDataMap jobDetailData = jobDetail.getJobDataMap();
            // 合并获取JobDataMap,存在键值相同的,取Trigger JobDataMap的值
            JobDataMap mergedJobDataMap = context.getMergedJobDataMap();
        }
    }
    

    具体调度实现代码

    import org.quartz.*;
    import org.quartz.impl.StdSchedulerFactory;
    
    public class TestScheduled {
        public static void main(String[] args) throws SchedulerException {
            // 创建一个Trigger实例
            JobDataMap triggerData = new JobDataMap();
            triggerData.put("trigger1", "我是trigger1");
            triggerData.put("trigger2", "我是trigger2");
            // 创建一个Schedule实例(每个10秒执行一次)
            ScheduleBuilder scheduleBuilder =  CronScheduleBuilder.cronSchedule("0/10 * * * * ?");
            /*ScheduleBuilder scheduleBuilder = SimpleScheduleBuilder
                    .repeatSecondlyForever(10)   //每个10秒执行一次
                    .repeatForever();   //重复执行*/
            Trigger trigger = TriggerBuilder.newTrigger()   // 获取trigger类
                    .withIdentity("triggerName", "triggerGroup")    // 任务唯一标识和组别
                    .withDescription("triggerDescription")  // 描述
                    .usingJobData(triggerData)   // 自定义参数
                    .startNow() // 立即执行,startAt(Date triggerStartTime) -> 某个特定时间开始执行
                                // endAt(Date triggerEndTime) -> 某个特定时间结束执行
                    .withSchedule(scheduleBuilder)  // 设置执行计划
                    .build();
            // 创建一个jobDetil实例,该实例与 Job Class绑定
            JobDataMap jobData = new JobDataMap();
            jobData.put("job1", "我是job1");
            jobData.put("job2", "我是job2");
            JobDetail jobDetail = JobBuilder.newJob(TestJob.class)
                    .withIdentity("jobName", "jobGroup")
                    .withDescription("jobDescription")
                    .usingJobData(jobData)
                    .build();
            // 创建Scheduler实例:javaWeb项目可以通过注入方式创建Scheduler实例,如(@Autowired private Scheduler scheduler;)
            SchedulerFactory schedulerFactory = new StdSchedulerFactory();
            Scheduler scheduler = schedulerFactory.getScheduler();
            scheduler.scheduleJob(jobDetail, trigger);
            scheduler.start();  // 执行
        }
    }
    

    4.5 具体对象和方法

    4.5.1 ScheduleBuilder的具体对象和常用方法:

    1. CronScheduleBuilder(常用):它为触发器定义了基于 cronexpress 的调度。该对象的主要通过 Cron表达式 来进行创建,底层代码基本都是将对应参数转换为 Cron表达式 后进行创建。

    • cronSchedule(String cronExpression):通过指定 Cron表达式 创建对象

    2. SimpleScheduleBuilder:它为触发器定义了基于严格/文字间隔的调度。能指定触发的间隔时间和执行次数;

    • build():构建实际的触发器
    • simpleSchedule():static 方法,获取一个 SimpleScheduleBuilder 对象
    • repeatForever():指定触发器将无限重复。
    • withRepeatCount(int triggerRepeatCount):设置重复执行次数
    • repeat___lyForever():设置对应时间单位执行一次,无限重复
    • repeat___lyForever(int):设置当前 对应时间单位 * int 执行一次,无限重复
    • withIntervalIn____s(int/long):根据对应时间单位设置执行间隔

    3. CalendarIntervalScheduleBuilder:它为触发器定义基于间隔的日历时间(天、周、月、年)调度。

    • build():构建实际的触发器
    • calendarIntervalSchedule():创建一个 CalendarIntervalScheduleBuilder。
    • preserveHourOfDayAcrossDaylightSavings(boolean preserveHourOfDay):如果间隔是一天或更长的时间,这个属性(设置为 true )将导致触发器的触发总是在一天的同一时间发生,( startTime 的时间),而不考虑夏令时转换。
    • withInterval(int timeInterval, DateBuilder.IntervalUnit unit):指定要生成的触发器的时间单位和间隔。
    • withIntervalIn___s(int intervalInDays):在 IntervalUnit 中指定一个 interval。所产生的触发器将重复对应时间单位。

    4. DailyTimeIntervalScheduleBuilder:此生成器为您提供了一个额外的方便方法来设置触发器的 endTimeOfDay。

    • build():构建实际的触发器
    • dailyTimeIntervalSchedule():创建一个 DailyTimeIntervalScheduleBuilder。
    • endingDailyAfterCount(int count):使用 count、interval 和 starTimeOfDay 计算和设置 endTimeOfDay。
    • endingDailyAt(TimeOfDay timeOfDay):设置此触发器的每日开始时间,以在给定的时间结束每天的触发。
    • onDaysOfTheWeek(onDaysOfWeek):将触发器设置为在一周中的特定日期触发。
    • onEveryDay():触发时间为一周中的任何一天。
    • onMondayThroughFriday():把周一到周五的日子设为触发时间。
    • onSaturdayAndSunday():触发时间为星期六和星期天。
    • startingDailyAt(TimeOfDay timeOfDay):设置触发开始每天在给定的时间。
    • withInterval(int timeInterval, DateBuilder.IntervalUnit unit):指定要生成的触发器的时间单位和间隔。
    • withIntervalIn____s(int):在 IntervalUnit 中指定一个 interval。所产生的触发器将重复的时间。
    • withRepeatCount(int repeatCount):设置间隔重复的次数。

    4.5.2 TriggerBuilder

          用于实例化触发器。构建器将始终保持自身处于有效状态,并为随时调用 build() 设置合理的缺省值。

    • newTrigger():创建一个新的 TriggerBuilder,用于定义触发器的规范。
    • build():构建触发器
    • endAt(Date triggerEndTime):设置触发器不再触发的时间——即使它的时间表还有剩余的重复。
    • startAt(Date triggerStartTime):根据为触发器配置的计划,设置触发器应该启动的时间——触发器可能启动,也可能不启动。
    • startNow():将触发器应该启动的时间设置为当前时刻—触发器可能启动,也可能不启动—这取决于为触发器配置的调度。
    • forJob:设置生成的触发器触发的作业的标识。
    • modifiedByCalendar(String calName):设置应该应用于此触发器的日程安排的日历的名称。
    • usingJobData:设置触发器的 JobDataMap。
    • withDescription(String triggerDescription):设置给定的(有意义的)触发器描述。
    • withIdentity:使用具有给定名称和组的 TriggerKey 来标识触发器。
    • withPriority(int triggerPriority):设置触发器的优先级。
    • withSchedule(ScheduleBuilder<SBT> schedBuilder):设置 ScheduleBuilder,它将用于定义触发器的调度。

    4.5.3 Scheduler

          这是Quartz调度器的主接口

          调度器维护 JobDetails 和触发器的注册表。一旦注册,调度器就负责在相关的触发器触发时(当它们的计划时间到达时)执行作业。

          Scheduler 实例由 SchedulerFactory 生成。已经创建/初始化的调度器可以通过生成它的工厂找到并使用。创建调度器之后,它处于“备用”模式,必须先调用其 start() 方法,然后才会触发任何作业。

          作业将由“客户端程序”创建,方法是定义一个实现作业接口的类。然后创建 JobDetail 对象(也由客户机创建)来定义作业的单个实例。然后,可以通过 scheduleJob(JobDetail,Trigger)addJob(JobDetail, boolean)方法向调度器注册JobDetail实例。

          然后可以定义触发器来根据给定的调度触发单个作业实例。SimpleTrigger 对于一次性触发非常有用,或者在某个特定的时刻触发,在它们之间有一个给定的延迟,可以重复 N 次。CronTrigger 允许基于日、周、月、月的时间进行调度。

          作业和触发器具有与它们关联的名称和组,这些名称和组应该在单个调度器中惟一地标识它们。“组”功能对于创建作业和 Triggerss 的逻辑分组或分类可能很有用。如果您不需要为给定的触发器作业分配组,那么您可以使用这个接口上定义的 DEFAULT_GROUP 常量。

          存储的作业也可以通过 triggerJob(String jobName, String jobGroup) 函数“手动”触发。

          客户端程序也可能对 Quartz 提供的“listener”接口感兴趣。JobListener 接口提供作业执行的通知。TriggerListener接口提供触发器触发的通知。SchedulerListener 接口提供调度器事件和错误的通知。侦听器可以通过 ListenerManager 接口与本地调度器关联。

    • addCalendar(String calName, Calendar calendar, boolean replace, boolean updateTriggers):将给定的日历添加(注册)到调度程序。
    • addJob(JobDetail jobDetail, boolean replace):将给定的作业添加到调度器—没有关联的触发器。
    • checkExists(JobKey jobKey):确定调度程序中是否已经存在具有给定标识符的作业。
    • checkExists(TriggerKey triggerKey):确定调度程序中是否已经存在具有给定标识符的触发器。
    • clear():清除(删除!)所有调度数据-所有作业,触发日历。
    • deleteCalendar(String calName):从调度程序中删除已标识的日历
    • deleteJob(JobKey jobKey):从调度程序中删除已标识的作业—以及任何关联的触发器。
    • deleteJobs(List<JobKey> jobKeys):从调度程序中删除已标识的作业—以及任何关联的触发器。
    • getCalendar(String calName):获取具有给定名称的日历实例。
    • getCalendarNames():获取所有已注册日历的名称。
    • getContext():返回调度器的调度器上下文。
    • getCurrentlyExecutingJobs():返回 JobExecutionContext 对象的列表,这些对象表示当前在此调度器实例中执行的所有作业。
    • getJobDetail(JobKey jobKey):使用给定的键获取作业实例的 JobDetail。
    • getJobGroupNames():获取所有已知 JobDetail 组的名称。
    • getJobKeys(GroupMatcher<JobKey> matcher):获取匹配组中所有 JobDetails 的键。
    • getListenerManager():获取调度程序的 ListenerManager 的引用,可以通过该引用注册侦听器。
    • getMetaData():获取描述调度器实例的设置和功能的 SchedulerMetaData 对象。
    • getPausedTriggerGroups():获取所有暂停的触发组的名称。
    • getSchedulerInstanceId():返回调度程序的实例Id。
    • getSchedulerName():返回调度程序的名称。
    • getTrigger(TriggerKey triggerKey):使用给定的键获取触发器实例。
    • getTriggerGroupNames():获取所有已知触发器组的名称。
    • getTriggerKeys(GroupMatcher<TriggerKey> matcher):获取给定组中所有触发器的名称。
    • getTriggerKeys(GroupMatcher<TriggerKey> matcher):获取给定组中所有触发器的名称。
    • getTriggersOfJob(JobKey jobKey):获取与标识的 JobDetail 关联的所有触发器。
    • getTriggerState(TriggerKey triggerKey):获取标识的触发器的当前状态。
    • interrupt(JobKey jobKey):在这个调度器实例中,请求中断标识的作业的所有当前正在执行的实例,这些实例必须是 InterruptableJob 接口的实现者。
    • interrupt(String fireInstanceId):在这个调度器实例中请求标识的正在执行的作业实例的中断,该实例必须是 InterruptableJob 接口的实现者。
    • isInStandbyMode():报告调度程序是否处于备用模式。
    • isShutdown():报告调度程序是否已关闭。
    • isStarted():调度程序是否已启动。
    • pauseAll():暂停所有触发器——类似于在每个组上调用 pauseTriggerGroup(group),但是,在使用此方法之后,必须调用 resumeAll() 来清除调度器的“记住”状态,即所有新触发器将在添加时暂停。
    • pauseJob(JobKey jobKey):使用给定的键暂停 JobDetail ——通过暂停它的所有当前触发器。
    • pauseJobs(GroupMatcher<JobKey> matcher):暂停匹配组中的所有 JobDetails—通过暂停它们的所有触发器。
    • pauseTrigger(TriggerKey triggerKey):使用给定的键暂停触发器。
    • pauseTriggers(GroupMatcher<TriggerKey> matcher):暂停匹配组中的所有触发器。
    • rescheduleJob(TriggerKey triggerKey, Trigger newTrigger):使用给定的键删除触发器,并存储新的给定的触发器——它必须与相同的作业相关联(新的触发器必须指定作业名称和组)——但是,新的触发器不需要与旧的触发器具有相同的名称。
    • resumeAll():恢复(非暂停)所有触发器-类似于调用 resumeTriggerGroup(组) 对每个组。
    • resumeJob(JobKey jobKey):使用给定的键恢复(取消暂停) JobDetail。
    • resumeJobs(GroupMatcher<JobKey> matcher):恢复(非暂停)匹配组中的所有 JobDetails。
    • resumeTrigger(TriggerKey triggerKey):使用给定的键恢复(取消暂停)触发器。
    • resumeTriggers(GroupMatcher<TriggerKey> matcher):恢复(取消暂停)匹配组中的所有触发器。
    • scheduleJob(JobDetail jobDetail, Trigger trigger):将给定的 JobDetail 添加到调度器中,并将给定的触发器与之关联。
    • scheduleJob(Trigger trigger):使用由触发器的设置标识的作业调度给定的触发器。
    • scheduleJobs(Map<JobDetail,List<Trigger>> triggersAndJobs, boolean replace):使用相关的一组触发器调度所有给定的作业。
    • setJobFactory(JobFactory factory):设置负责生成作业类实例的 JobFactory。
    • shutdown():停止调度器的触发器触发,并清理与调度器关联的所有资源。
    • shutdown(boolean waitForJobsToComplete):停止调度器的触发器触发,并清理与调度器关联的所有资源。根据 waitForJobsToComplete 判断是否等全部任务执行完后再停止、清理
    • standby():暂时停止调度程序的触发器触发。
    • start():启动引发触发器的调度器线程。
    • startDelayed(int seconds):在指定的秒数之后调用 {#start()}。
    • triggerJob(JobKey jobKey):触发标识的 JobDetail (现在执行它)。
    • triggerJob(JobKey jobKey, JobDataMap data):触发标识的 JobDetail (现在执行它)。并传递需要的 JobDataMap。
    • unscheduleJob(TriggerKey triggerKey):从调度程序中删除指定的触发器。
    • unscheduleJobs(List<TriggerKey> triggerKeys):从调度程序中删除所有指示的触发器。

    4.5.4 StdSchedulerFactory

          SchedulerFactory的实现,它根据属性文件的内容完成创建 Quartz 的调度器(Scheduler) 实例的所有工作。

          默认情况下,一个名为 quartz.properties 的属性文件,属性是从“当前工作目录”加载的。如果失败,那么加载位于 org/quartz 包中的 quartz.properties 文件(作为资源)。如果希望使用这些默认值以外的文件,则必须定义系统属性 org.quartz.properties 。属性指向您想要的文件。

          或者,您可以通过在调用 getScheduler() 之前调用 initialize(xx) 方法来显式地初始化工厂。

          有关文件中可用的各种设置的信息,请参阅与Quartz一起发布的示例属性文件。完整的配置文档可以在 http://www.quartz-scheduler.org/docs/configuration/index.html 找到。

          指定的 JobStore、ThreadPool 和其他 SPI 类的实例将按名称创建,然后在配置文件中为它们指定的任何附加属性将通过调用等效的“set”方法在实例上设置。例如,如果属性文件包含属性 org.quartz.jobStore.myProp = 10。然后在 JobStore 类实例化之后,setMyProp() 方法将被调用。在调用属性的 setter 方法之前,将类型转换为基本Java类型(int、long、float、double、boolean和String)。

          一个属性可以通过指定一个遵循 $@other.property.name 约定的值来引用另一个属性的值,例如,要将调度器的实例名引用为其他属性的值,可以使用 $@org.quartz.scheduler.instanceName

    • StdSchedulerFactory():创建一个未初始化的 StdSchedulerFactory。
    • StdSchedulerFactory(Properties props):创建通过 initialize(Properties) 初始化的 StdSchedulerFactory。
    • StdSchedulerFactory(String fileName):创建通过 initialize(fileName) 初始化的 StdSchedulerFactory。
    • getAllSchedulers():返回所有已知调度器(由任何 StdSchedulerFactory 实例生成)。
    • getDefaultScheduler():返回默认调度器,如果它还不存在,则创建它。
    • getScheduler():返回此工厂生成的调度器。
    • getScheduler(String schedName):返回具有给定名称的调度器(如果它存在(如果它已经被实例化))。
    • initialize():使用 Properties 文件的内容和覆盖系统属性初始化ScheduerFactory。
    • initialize(InputStream propertiesStream):使用用给定属性文件的 InputStream 初始化SchedulerFactory。
    • initialize(Properties props):使用给定 Properties 对象的内容初始化ScheduerFactory。
    • initialize(String filename):使用给定名称的 Properties 文件的内容初始化 SchedulerFactory。

    4.5.5 JobDetail

          传递给定 Job 实例的详细属性。JobDetails将使用JobBuilder创建/定义。

          Quartz 并不存储 Job 类的实际实例,而是允许您通过使用 JobDetail 来定义 Job 类的实例。

           Job 具有与其关联的名称和组,这些名称和组应该在单个调度器中惟一地标识它们。

          触发器(Trigger)是调度 Job 的“机制”。许多 Trigger 可以指向同一 Job,但单个Trigger只能指向一个 Job。

    • getDescription():返回由其创建者(如果有的话)提供给 Job 实例的描述。
    • getJobBuilder():获得一个配置为生成与此 JobDetail 相同的 JobBuilder。
    • getJobClass():获取将要执行的作业的实例。
    • getJobDataMap():获取与作业关联的 JobDataMap。
    • getKey():返回 JobKey。
    • isConcurrentExectionDisallowed():是否禁止同时执行。
    • isDurable():Job 孤立后是否应该继续存储(没有 Trigger 指向它)。
    • isPersistJobDataAfterExecution():执行后是否保存 Job 数据。
    • requestsRecovery():指示调度器(Scheduler),如果遇到“recovery恢复”或“fail-over故障转移”情况,是否应重新执行 Job。

    上面的方法,JobDetail 接口实现类 JobDetailImpl 都有之对应的 setter 方法。

    4.5.6 JobBuilder

          JobBuilder 用于实例化 JobDetails。

          构建器将始终保持自身处于有效状态,并为随时调用 build() 设置合理的缺省值。例如,如果您没有调用 withIdentity(..),将为您生成一个作业名。

    • newJob():创建用于定义 JobDetail 的 JobBuilder。
    • ofType(Class<? extends Job> jobClazz):设置将在触发器触发与此 JobDetail 关联时实例化并执行的类。
    • newJob(Class<? extends Job> jobClass):创建用于定义 JobDetail 的 JobBuilder,并设置要执行的作业的类名。是 newJob() 和 ofType() 方法的合成。
    • build():生成此 JobBuilder 定义的 JobDetail 实例。
    • requestRecovery():指示调度器,如果遇到“恢复”或“故障转移”情况,应重新执行 Job。
    • requestRecovery(boolean jobShouldRecover):指示调度器,如果遇到“恢复”或“故障转移”情况,是否应重新执行 Job。true -> 重新执行,false -> 不重新执行。
    • storeDurably():作业孤立后应该继续存储(没有触发器指向它)。
    • storeDurably(boolean jobDurability):作业孤立后应该继续存储(没有触发器指向它)。true -> 继续存储,false -> 不继续存储。
    • usingJobData:设置 JobDetail 的 JobDataMap
    • withDescription(String jobDescription):设置作业的给定(有意义的)描述。
    • withIdentity(JobKey jobKey):使用 JobKey 来标识 JobDetail。
    展开全文
  • spring多个定时任务quartz配置
  • 最近项目中在使用企业级定时任务Quartz,在使用过程中,发现一个问题就是我们如何防止定时任务的并发?
  • 分布式定时任务Quartz之Hello World(一) 文章目录分布式定时任务Quartz之Hello World(一)一、定时任务框架汇总二、分布式框架对比三、Quartz框架四、Quartz初次使用4.1. 引入依赖4.2. 定义一个简单的`Job`4.3. ...
  • 一、定时任务Quartz1、Quartz的含义2、Quartz中核心类的关系3、实现定时任务的步骤二、JavaMail 一、定时任务Quartz 1、Quartz的含义 2、Quartz中核心类的关系 3、实现定时任务的步骤 二、JavaMail JavaMail...
  • 若依后台管理框架-定时任务quartz使用 最近使用了quartz定时任务,小结一下。基于若依后台管理框架ruoyi-quartz模块,这也为我们以后定时任务方面的处理提供了思路,比如引入ruoyi-quartz模块,方便的用页面管理...
  • springboot中整合分布式定时任务Quartz的模本范例。参考这个配置,十分简便 两个bean配置,一个properties文件,一个sql文件,使用的为mysql. QRTZ_tables_mysql_innodb.sql # # In your Quartz properties file,...
  • 定时任务 Quartz java

    2019-07-26 17:48:15
    博文: quartz详解2:quartz由浅入深 Quartz 2 定时任务(一):基本使用指南 java调度框架Quartz(一) springboot集成quartz TODO
  • spring 定时任务 quartz 基于 MethodInvokingJobDetailFactoryBean 实现 依赖包 如下 <dependencies> <dependency> <groupId>org.springframework.boot</groupId>...
  • java定时任务Quartz整理

    千次阅读 2020-10-11 17:43:23
    quartz是一种基于java实现的任务调度框架,可以定时自动的执行你想要执行的任何任务quartz官网:http://www.quartz-scheduler.org/ Quartz的组成 任务Job(你要做什么事?) job就是你想要实现的任务类,每...
  • 至于Quartz到底是什么,可以看我上一篇转载的文章,或者百度。下面直接举例: 1.Spring配置Quartz a.需要导入quartz的jar包:  quartz-2.1.7.jar b.【Spring配置文件ApplicationContext.xml】 ...
  • 定时任务quartz中的job注入spring bean时null的问题 在使用quartz作定时任务的时候难免会注入spring中的管理的bean,如果不作处理,就会出现java.lang.NullPointerException的异常 序言 我们知道quartz中实现一...
  • Spring中定时任务Quartz集群配置学习 原来配置的Quartz是通过spring配置文件生效的,发现在非集群式的服务器上运行良好,但是将工程部署到水平集群服务器上去后改定时功能不能正常运行,没有任何错误日志,于是从...
  • spring的定时任务quartz

    2017-08-31 03:39:43
    现在的需求是,更新主账号下面的从账号密码,定时任务我已经配好了,服务器一启动就自动执行,但是我修改的时候是需要修改已配置好的账号,然后默认是没配置账号,这种应该怎么实现
  • 定时任务quartz原理以及配置

    千次阅读 2018-08-06 17:28:06
    前些日子有业务需要定时任务,经过了解选择了quartz quartz是一个用java实现的开源调度任务框架,有这么几个好处 1.配置方便,支持多任务 2.业务-定时可控,灵活配置,随时更改 3.支持分布式集群 下面是核心...
  • Java定时任务Quartz

    千次阅读 2018-06-02 22:58:15
    1.概要 Quartz是由OpenSymphony提供的强大的开源任务调度框架。官网地址:http://www.quartz-scheduler.org/,纯Java实现。强大的调度功能:很容易与Spring集成,提供调度运行环境的持久化机制,保存并恢复任务调度...
  • Spring 3整合Quartz 2实现定时任务一:常规整合 Spring 3整合Quartz 2实现定时任务二:动态添加任务 Spring 3整合Quartz 2实现定时任务三:动态暂停 恢复 修改和删除任务
  • 我想要在spring的集成框架中使用spring ,...Quartz实现动态定时任务 Spring 3整合Quartz 2实现定时任务二:动态添加 Spring 3整合Quartz 2实现定时任务三:动态暂停 恢复 修改和删除任务 原创]在线Cron表达式生成  ...
  • Java定时任务Quartz

    千次阅读 2018-06-03 15:21:48
    1.浅谈Trigger2.浅谈CronTrigger3.Quartz实际应用4.总结
  • 学更好的别人,做更好的自己。——《微卡智享》本文长度为3657字,预计阅读8分钟前言关于Quartz的使用在《项目实战|C#Socket通讯方式改造(二)--利用Quartz实现定时任务...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 13,408
精华内容 5,363
关键字:

定时任务quartz