Spring Quartz

Spring Quartz 特点： 
1. 默认多线程异步执行 
2. 一个任务在上一次调度未完成执行，下一次调度时间到时，会另起一个线程开始新的调度。在业务繁忙时，一个任务或许会有多个线程在执行，导致数据处理异常。 
3. 单任务同步：配置属性，可以使一个任务的一次调度在未完成时，而不会开启下一次调度 
4. 多个任务同时运行，任务之间没有直接的影响，多任务执行的快慢取决于CPU的性能 
5. SchedulerFactoryBean不能使用注解来配置？还是我没找到注解的方法？

Spring Task特点： 
1. 默认单线程同步执行 
2. 一个任务执行完上一次之后，才会执行下一次调度 
3. 多任务之间按顺序执行，一个任务执行完成之后才会执行另一个任务 
4. 多任务并行执行需要设置线程池 
5. 全程可以通过注解配置

1.RAM方式方式

引入pom

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

创建RAMJob

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.annotation.Resource;
import java.util.Date;

/**
 * @version 1.0
 * @description RAM定时操作，运行任务
 * @date 2018/7/19 15:21
 * @modified
 */
public class RAMJob implements Job{

    @Resource
    private Logger log =LoggerFactory.getLogger(RAMJob.class);
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        log.info("------------定时任务"+new  Date()+"------------");
    }
}

创建RAMQuartz

import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Date;

/**
 * @version 1.0
 * @description 定义定时任务
 * @date 2018/7/19 15:31
 * @modified
 */
public class RAMQuartz {
    private static Logger log = LoggerFactory.getLogger(RAMQuartz.class);

    public static void quartz() throws SchedulerException {
        //1.常见schedule工厂
        SchedulerFactory sf = new StdSchedulerFactory();
        //2.从工厂获取调度器实例
        Scheduler scheduler=sf.getScheduler();
        //3.创建jobDetail
        JobDetail jb=JobBuilder.newJob(RAMJob.class)
                .withDescription("this is a ram job") //job的描述
                .withIdentity("ramJob", "ramGroup") //job 的name和group
                .build();
        //任务运行的时间，SimpleSchedle类型触发器有效
        long time=  System.currentTimeMillis() + 3*1000L; //3秒后启动任务
        Date statTime = new Date(time);
        //4.创建Trigger
        //使用SimpleScheduleBuilder或者CronScheduleBuilder
        Trigger t = TriggerBuilder.newTrigger()
                .withDescription("this is a tigger")
                .withIdentity("ramTrigger", "ramTriggerGroup")
                //.withSchedule(SimpleScheduleBuilder.simpleSchedule())
                .startAt(statTime)  //默认当前时间启动
                .withSchedule(CronScheduleBuilder.cronSchedule("0/2 * * * * ?")) //两秒执行一次
                .build();
        //5.注册任务和定时器
        scheduler.scheduleJob(jb, t);
        //6.启动 调度器
        scheduler.start();
        log.info("启动时间 ： " + new Date());
    }
}

2.spring整合quartz

spring_quartz.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
       xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
    http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
    http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd">

    <!--
    Spring整合Quartz进行配置遵循下面的步骤：
    1：定义工作任务的Job
    2：定义触发器Trigger，并将触发器与工作任务绑定
    3：定义调度器，并将Trigger注册到Scheduler
 -->

    <!-- For times when you need more complex processing, passing data to the scheduled job -->
    <bean name="firstComplexJobDetail"    class="org.springframework.scheduling.quartz.JobDetailFactoryBean">
        <property name="jobClass" value="com.my.ssmmaven.util.quartz.FirstScheduledJob" />
        <property name="durability" value="true" />
    </bean>


    <bean name="secondComplexJobDetail"    class="org.springframework.scheduling.quartz.JobDetailFactoryBean">
        <property name="jobClass" value="com.my.ssmmaven.util.quartz.SecondScheduledJob" />
        <property name="durability" value="true" />
    </bean>
    <!--start                                  end-->


    <bean id="firstCronTrigger"  class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
        <property name="jobDetail" ref="firstComplexJobDetail" />
        <property name="cronExpression" value="0/5 * * ? * *" />

    </bean>


    <bean id="secondCronTrigger"  class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
        <property name="jobDetail" ref="secondComplexJobDetail" />
        <property name="cronExpression" value="0/5 * * ? * *" />
    </bean>

    <!--start                                  end-->

    <!-- Scheduler factory bean to glue together jobDetails and triggers to Configure Quartz Scheduler -->
    <bean  class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
        <property name="jobDetails">
            <list>
                <ref bean="firstComplexJobDetail" />
                <ref bean="secondComplexJobDetail" />
            </list>
        </property>


        <property name="triggers">
            <list>
                <ref bean="firstCronTrigger" />
                <ref bean="secondCronTrigger" />
            </list>
        </property>

        <!-- 设置延时启动  -->
        <!--<property name="startupDelay" value="30"/>-->
        <!--&lt;!&ndash; 设置自动启动  &ndash;&gt;-->
        <!--<property name="autoStartup" value="true"/>-->
        <!--<property name="applicationContextSchedulerContextKey" value="applicationContextKey"/>-->
        <!--<property name="configLocation" value="classpath:/quartz.properties"/>-->
    </bean>

    <!--配置调度执行的触发的时间-->
    <!--<bean id="myPrintTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean">-->
        <!--<property name="jobDetail" ref="myPrintDetail" />-->
        <!--<property name="cronExpression">-->
            <!--&lt;!&ndash; 不重复计数，只执行一次 &ndash;&gt;-->
            <!--<property name="repeatCount" value="0" />-->
        <!--</property>-->
    <!--</bean>-->
</beans>

任务类FirstScheduledJob、SecondScheduledJob

import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.quartz.QuartzJobBean;

/**
 * @version 1.0
 * @date 2018/7/19 17:53
 * @modified
 */
public class FirstScheduledJob extends QuartzJobBean {

    private Logger log = LoggerFactory.getLogger(RAMJob.class);
    @Override
    protected void executeInternal(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        log.info("------------------------FirstScheduledJob------------------------------");
    }
}

import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.quartz.QuartzJobBean;

/**
 * @version 1.0
 * @date 2018/7/19 17:54
 * @modified
 */
public class SecondScheduledJob  extends QuartzJobBean {

    private Logger log = LoggerFactory.getLogger(RAMJob.class);

    @Override
    protected void executeInternal(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        log.info("------------------------SecondScheduledJob------------------------------");

    }
}