三、Quartz-简单实现

一、基于spring通过XML配置实现简单任务调度

1.引入依赖包

    <dependencies>
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
            <version>2.3.0</version>
        </dependency>
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.2</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.7.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>5.0.6.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>5.0.7.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>5.0.7.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</artifactId>
            <version>5.0.7.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>5.0.7.RELEASE</version>
        </dependency>
    </dependencies>

2.创建具体实现任务的类

public class MyTask{
    public void doSimpleTriggerTask() {
        System.out.println("run doSimpleTriggerTask："+new Date());
    }

    public void doCronTriggerTask() {
        System.out.println("run doCronTriggerTask："+new Date());
    }
}

3.进行Spring容器配置

在资源目录下创建spring.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans ...>

    <!--创建执行对象-->
    <bean id="myTask" class="com.timer.MyTask"/>

    <!--创建Job，这里试用了一下spring提供的MethodInvokingJobDetailFactoryBean-->
    <bean id="jobOne" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
        <property name="targetObject" ref="myTask"/>
        <property name="targetMethod" value="doSimpleTriggerTask"/>
        <!-- 不允许并发-->
        <property name="concurrent" value="false"/>
    </bean>
    <bean id="jobTwo" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
        <property name="targetObject" ref="myTask"/>
        <property name="targetMethod" value="doCronTriggerTask"/>
        <!-- 不允许并发-->
        <property name="concurrent" value="false"/>
    </bean>

    <!--创建简单触发器-->
    <bean id="simpleTrigger" class="org.springframework.scheduling.quartz.SimpleTriggerFactoryBean">
        <!--注入任务-->
        <property name="jobDetail" ref="jobOne"/>
        <!--任务延迟执行时间-->
        <property name="startDelay" value="0"/>
        <!--任务执行周期-->
        <property name="repeatInterval" value="2000"/>
    </bean>

    <!--创建复杂触发器-->
    <bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
        <!--注入任务-->
        <property name="jobDetail" ref="jobTwo"/>
        <!--设置任务执行公式-->
        <property name="cronExpression" value="0 20 15 L * ?"/>
    </bean>

    <!--创建任务调度器工厂-->
    <bean lazy-init="false" id="scheduleFactory" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
        <!--注入触发器-->
        <property name="triggers">
            <list>
                <ref bean="simpleTrigger"/>
                <ref bean="cronTrigger"/>
            </list>
        </property>
        <!--是否自动启动，当为web项目，交给tomcat管理时，可以设为true，但需要在bean标签中添加lazy-init="false"属性关闭懒加载-->
        <property name="autoStartup" value="false"/>
    </bean>
</beans>

4.在main方法中进行启动

public class TaskTest {

    public static void main(String[] args) {
        try {
            ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
            Scheduler scheduler = (Scheduler) applicationContext.getBean("scheduleFactory");

            scheduler.start();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

二、编程方式实现简单任务调度

1.导入依赖包

    <dependencies>
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
            <version>2.3.0</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-simple</artifactId>
            <version>1.7.25</version>
        </dependency>
    </dependencies>

2.创建任务类

@PersistJobDataAfterExecution
public class MyJob implements Job {
    private static final Logger logger = LoggerFactory.getLogger(MyJob.class);

    public void execute(JobExecutionContext context){
        //获取任务名和任务组名
        JobDetail jobDetail = context.getJobDetail();
        logger.info("Job name and group:" + jobDetail.getKey());
        //获取Job状态信息
        Integer count = (Integer)jobDetail.getJobDataMap().get("count");
        logger.info("Count:" + count);
        //修改状态信息，测试@PersistJobDataAfterExecution带来的持久化效果
        jobDetail.getJobDataMap().put("count", count + 1);

        //获取调度器名
        Scheduler scheduler = context.getScheduler();
        try {
            logger.info("Scheduler name:" + scheduler.getSchedulerName());
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }
}

3.创建Quartz工具类

public class QuartzUtil {
    private static Logger logger = LoggerFactory.getLogger(QuartzUtil.class);

    /**
     * 创建任务详情对象
     * @return 任务详情对象
     */
    public static JobDetail createJobDetail() {
        //通过JobBuilder创建JobDetail
        JobDetail jobDetail = JobBuilder.newJob(MyJob.class)
                //设置任务名和任务组名组成任务唯一标识
                .withIdentity("myJob", "groupOne")
                //使用Job状态
                .usingJobData("count", 0)
                //构建JobDetail
                .build();
        logger.info("create JobDetail......");
        return jobDetail;
    }

    /**
     * 创建调度器
     * @return 调度器
     */
    public static Scheduler createScheduler(JobDetail jobDetail, Trigger trigger) {
        //创建调度工厂
        StdSchedulerFactory factory = new StdSchedulerFactory();
        //创建属性对象
        Properties props = new Properties();
        //线程池定义
        props.put(StdSchedulerFactory.PROP_THREAD_POOL_CLASS, "org.quartz.simpl.SimpleThreadPool");
        //设置Scheduler的线程数
        props.put("org.quartz.threadPool.threadCount", "10");
        Scheduler scheduler = null;
        try {
            //进行属性初始化
            factory.initialize(props);
            //创建Scheduler
            scheduler = factory.getScheduler();
            //设置触发器和执行的任务详情
            scheduler.scheduleJob(jobDetail, trigger);
            logger.info("create Scheduler......");
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
        return scheduler;
    }

    /**
     * 创建触发器-SimpleTrigger
     * @return 触发器
     */
    public static Trigger createSimpleTrigger() {
        Trigger simpleTrigger =  newTrigger()
                //通过名字、组名唯一标识
                .withIdentity("simpleTrigger","groupOne")
                //设置开始时间，可为0，标识触发则执行
                .startAt(futureDate(5, DateBuilder.IntervalUnit.SECOND))
                //设置调度器属性
                .withSchedule(simpleSchedule()
                        //设置间隔时间为1秒
                        .withIntervalInSeconds(5)
                        //设置重复次数20次
                        .withRepeatCount(20))
                //指定执行的任务
                .forJob("myJob", "groupOne")
                //创建触发器
                .build();
        logger.info("create SimpleTrigger......");
        return simpleTrigger;
    }

    /**
     * 创建触发器-CronTrigger
     * @return 触发器
     */
    public static Trigger createCronTrigger() {
        Trigger cronTrigger = newTrigger()
                //设置触发器唯一标识
                .withIdentity("cronTrigger", "groupOne")
                //设置开始时间
                .startNow()
                //设置调度属性
                .withSchedule(cronSchedule("0 42 10 * * ?")
                        //设置时间区域
                        .inTimeZone(TimeZone.getTimeZone("Asia/Shanghai")))
                //设置执行任务
                .forJob("cronJob", "groupOne")
                //创建触发器
                .build();
        logger.info("create CronTrigger......");
        return cronTrigger;
    }
}

3.在主任务中进行测试

public class QuartzTest {
    public static void main(String[] args) {
        //获取任务详情
        JobDetail jobDetail = QuartzUtil.createJobDetail();
        //获取触发器
        Trigger simpleTrigger = QuartzUtil.createSimpleTrigger();
        //获取调度器
        Scheduler scheduler = QuartzUtil.createScheduler(jobDetail, simpleTrigger);
        try {
            // 开启调度器
            scheduler.start();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}