Quartz基本使用

时间：2023-03-09 16:44:40
Quartz基本使用

1.Quartz概述:简单的说就是java的一个定时任务的框架，没有那么复杂的解释，跟前端的定时器一样。在了解它之前，首先熟悉几个概念。

2.基本概念

2.1 Job：表示一个工作，要执行的具体内容。此接口中只有一个方法      void execute(JobExecutionContext context)

2.2 JobDetail：JobDetail 表示一个具体的可执行的调度程序， Job 是这个可执行程调度程序所要执行的内容，另外 JobDetail 还包含了这个任务调度的方案和策略。

2.3 Trigger 代表一个调度参数的配置，什么时候去调。

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

解释：
l 编写 job 实现业务，要做什么具体事情问题。
l 使用 JobDetail 包装 job，是任务对象，可以被调度
l 使用 Trigger （触发器对象）定制什么时候去调用某任务对象。
l 使用 Scheduler 结合任务对象和触发器对象，很像一个大管家。

3.运行原理

Quartz基本使用

下面实例：开启大管家，启动，关闭

引入相应的jar包

  <dependencies>

        <dependency>

            <groupId>org.quartz-scheduler</groupId>

            <artifactId>quartz</artifactId>

            <version>2.2.3</version>

        </dependency>

        <dependency>

            <groupId>org.quartz-scheduler</groupId>

            <artifactId>quartz-jobs</artifactId>

            <version>2.2.3</version>

        </dependency>

        <!-- slf4j log4j -->

        <dependency>

            <groupId>org.slf4j</groupId>

            <artifactId>slf4j-log4j12</artifactId>

            <version>1.7.7</version>

        </dependency>

<dependency>

            <groupId>junit</groupId>

            <artifactId>junit</artifactId>

            <version>4.11</version>

            <scope>test</scope>

        </dependency>

    </dependencies>

Job：

package com.quartz.job;

import org.quartz.Job;

import org.quartz.JobExecutionContext;

import org.quartz.JobExecutionException;

public class HelloJob implements Job {

    /*

     * set方法

     * */

    private String message;

    private Float math;

    public String getMessage() {

        return message;

    }

    public void setMessage(String message) {

        this.message = message;

    }

    public Float getMath() {

        return math;

    }

    public void setMath(Float math) {

        this.math = math;

    }

    @Override

    public void execute(JobExecutionContext context)throws JobExecutionException {

        /*String mes = (String) context.getJobDetail().getJobDataMap().get("message");

        System.out.println("jobdetail's message:  "+mes);

        Float ms = (Float) context.getTrigger().getJobDataMap().get("math");

        System.out.println("trigger's math:  "+ms);*/

        System.out.println("jobdetail's message:  "+message);

        System.out.println("trigger's math:  "+math);

        System.out.println("业务逻辑处理中...");

    }

}

jobdetail,Trigger ,Scheduler :

package com.quartz.scheduler;

import org.quartz.CronScheduleBuilder;

import org.quartz.CronTrigger;

import org.quartz.JobBuilder;

import org.quartz.JobDetail;

import org.quartz.Scheduler;

import org.quartz.SchedulerException;

import org.quartz.SimpleScheduleBuilder;

import org.quartz.SimpleTrigger;

import org.quartz.Trigger;

import org.quartz.TriggerBuilder;

import org.quartz.impl.StdSchedulerFactory;

import com.quartz.job.HelloJob;

public class TestQuartz {

    public static void main(String[] args) throws SchedulerException, InterruptedException {

//        定义jobdetail

        JobDetail jb = JobBuilder.newJob(HelloJob.class)

                .withIdentity("myjob", "group1")

                .usingJobData("message", "hello,Myjobdetail")

                .build();

        System.out.println("jobDetail's name:  "+jb.getKey().getName());

        System.out.println("jobDetail's group:  "+jb.getKey().getGroup());

        System.out.println("jobDetail's jobclass:  "+jb.getJobClass().getName());

//        定义trigger

        CronTrigger trigger = TriggerBuilder.newTrigger()

                .withIdentity("mytrigger","group1")

                .startNow()

                .usingJobData("math", 3.15f)

//                .withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(2).repeatForever())

                .withSchedule(CronScheduleBuilder.cronSchedule("* * * * * ? *"))

                .build();

//        创建scheduler

        StdSchedulerFactory ssf = new StdSchedulerFactory();

        Scheduler sc = ssf.getScheduler();

        sc.start();

        sc.scheduleJob(jb, trigger);

//        两秒挂起

        Thread.sleep(2000L);

        sc.standby();

        Thread.sleep(2000L);

        sc.start();

//        sc.shutdown(false); //直接关闭Scheduler

//        sc.shutdown(true);  //执行完所有的job后关闭Scheduler

    }

}

这里需要理解一下standBy（），该方法是让scheduler挂起，要想开始直接调用start（）方法。shutdown（false）该方法是shutdown（）直接关闭scheduler，而shutdown（true）表示等待执行完所有的job后关闭Scheduler。

相关文章