spring结合quartz实现定时调度

quartz所需jar包

<!-- 定时任务quartz -->
<dependency>
    <groupId>org.quartz-scheduler</groupId>
    <artifactId>quartz</artifactId>
    <version>2.2.2</version>
</dependency>
<dependency>
    <groupId>org.quartz-scheduler</groupId>
    <artifactId>quartz-jobs</artifactId>
    <version>2.2.2</version>
</dependency> 
<!--spring相关包-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>4.2.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>4.2.5.RELEASE</version>
        </dependency>
        <!-- 添加Spring-core包 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>4.2.5.RELEASE</version>
        </dependency>
        <!-- 添加spring-context包 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>4.2.5.RELEASE</version>
        </dependency>
        <!-- 添加spring-tx包 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>4.2.5.RELEASE</version>
        </dependency>
        <!-- 添加spring-jdbc包 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>4.2.5.RELEASE</version>
        </dependency>
        <!-- 添加spring-test包 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>4.2.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>4.2.5.RELEASE</version>
        </dependency>
        <!-- springmvc json -->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.5.1</version>
        </dependency>
        <dependency>
            <groupId>org.codehaus.jackson</groupId>
            <artifactId>jackson-mapper-asl</artifactId>
            <version>1.9.13</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-core</artifactId>
            <version>2.5.1</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-annotations</artifactId>
            <version>2.5.1</version>
        </dependency>
<!-- 添加mybatis的核心包 -->
<dependency>
     <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.2.8</version>
        </dependency>
        <!-- 添加mybatis与Spring整合的核心包 -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.2.2</version>
        </dependency>

        <!-- 添加mysql驱动包 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.37</version>
        </dependency>

方式一：

通过配置文件【spring-quartz.xml】设置定时任务的定时周期：


<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       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.xsd">
    <!-- 定时器工作调度的bean -->
    <bean id="backupLogJob" class="com.suninfo.job.BackupLogJob" />
    <!-- job的配置开始 -->
    <bean id="myJobDetail"
          class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
        <property name="targetObject">
            <ref bean="backupLogJob" />
        </property>
        <property name="targetMethod">
            <value>work</value>
        </property>
    </bean>
    <!-- 调度的配置 -->
    <bean id="crontestJobTrigger" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
        <property name="jobDetail">
            <ref bean="myJobDetail" />
        </property>
        <property name="cronExpression">
            <value>0/10 * * * * ?</value>
        </property>
    </bean>
    <!-- 启动触发器的配置 -->
    <bean name="startQuertz" lazy-init="false" autowire="no"
          class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
        <property name="triggers">
            <list>
                <ref bean="crontestJobTrigger" />
            </list>
        </property>
    </bean>
</beans>

定时任务监听类BackupLogJob：


package com.suninfo.job;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class BackupLogJob implements Job {
    private static final Logger log = LoggerFactory.getLogger(BackupLogJob.class);
    @Override
    public void execute( JobExecutionContext context ) throws JobExecutionException {
        try {
            String backUpUuid = ( String )context.getMergedJobDataMap().get( "backupUuid" );
            log.debug( "接收到任务["+backUpUuid+"]" );
            JobContext.backupSettingService.backupLogforSchedule( backUpUuid );
        } catch( Exception e ) {
            e.printStackTrace();
        }
    }
}

方式二：

使用自带的机制通过JDBC实现定时，quartz.properties配置，启动quartz时，会自动加载


org.quartz.scheduler.instanceName = MonitorScheduler
org.quartz.scheduler.instanceId = AUTO
#Quartz项目每次启动后都会检查官网Quartz是否存在新版本,属性为true来跳过更新检查。
org.quartz.scheduler.skipUpdateCheck=true

#连接池配置
org.quartz.threadPool.class = org.quartz.simpl.SimpleThreadPool    
org.quartz.threadPool.threadCount = 50      
org.quartz.threadPool.threadPriority = 5
org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread = true  
#分布式配置
org.quartz.jobStore.isClustered=false
org.quartz.jobStore.clusterCheckinInterval=10000
org.quartz.jobStore.maxMisfiresToHandleAtATime=1 
#============================================================================
# JDBC
#============================================================================
org.quartz.jobStore.class = org.quartz.impl.jdbcjobstore.JobStoreTX
org.quartz.jobStore.driverDelegateClass:org.quartz.impl.jdbcjobstore.StdJDBCDelegate
org.quartz.jobStore.useProperties:true
org.quartz.jobStore.dataSource:qzDS
org.quartz.jobStore.tablePrefix = QRTZ_
org.quartz.jobStore.misfireThreshold=180000

#org.quartz.dataSource.qzDS.connectionProvider.class:org.quartz.utils.PoolingConnectionProvider
org.quartz.dataSource.qzDS.connectionProvider.class:com.suninfo.util.base.QuartzConnectionProvider
org.quartz.dataSource.qzDS.driver:com.mysql.jdbc.Driver
org.quartz.dataSource.qzDS.URL:jdbc:mysql://localhost:13507/siem_scheduledb?useUnicode=true&characterEncoding=UTF-8
org.quartz.dataSource.qzDS.user:siem_admin
org.quartz.dataSource.qzDS.password:sIem_43@SH&%
org.quartz.dataSource.qzDS.maxConnection:30
org.quartz.dataSource.qzDS.validationQuery: select 0
org.quartz.dataSource.qzDS.validateOnCheckout=false

siem_scheduledb库


SET FOREIGN_KEY_CHECKS=0;
-- ----------------------------
-- Table structure for qrtz_blob_triggers
-- ----------------------------
DROP TABLE IF EXISTS `qrtz_blob_triggers`;
CREATE TABLE `qrtz_blob_triggers` (
  `SCHED_NAME` varchar(120) NOT NULL,
  `TRIGGER_NAME` varchar(200) NOT NULL,
  `TRIGGER_GROUP` varchar(200) NOT NULL,
  `BLOB_DATA` blob,
  PRIMARY KEY (`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`),
  CONSTRAINT `qrtz_blob_triggers_ibfk_1` FOREIGN KEY (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`) REFERENCES `qrtz_triggers` (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

-- ----------------------------
-- Table structure for qrtz_calendars
-- ----------------------------
DROP TABLE IF EXISTS `qrtz_calendars`;
CREATE TABLE `qrtz_calendars` (
  `SCHED_NAME` varchar(120) NOT NULL,
  `CALENDAR_NAME` varchar(200) NOT NULL,
  `CALENDAR` blob NOT NULL,
  PRIMARY KEY (`SCHED_NAME`,`CALENDAR_NAME`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

-- ----------------------------
-- Table structure for qrtz_cron_triggers
-- ----------------------------
DROP TABLE IF EXISTS `qrtz_cron_triggers`;
CREATE TABLE `qrtz_cron_triggers` (
  `SCHED_NAME` varchar(120) NOT NULL,
  `TRIGGER_NAME` varchar(200) NOT NULL,
  `TRIGGER_GROUP` varchar(200) NOT NULL,
  `CRON_EXPRESSION` varchar(200) NOT NULL,
  `TIME_ZONE_ID` varchar(80) DEFAULT NULL,
  PRIMARY KEY (`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`),
  CONSTRAINT `qrtz_cron_triggers_ibfk_1` FOREIGN KEY (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`) REFERENCES `qrtz_triggers` (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

-- ----------------------------
-- Table structure for qrtz_fired_triggers
-- ----------------------------
DROP TABLE IF EXISTS `qrtz_fired_triggers`;
CREATE TABLE `qrtz_fired_triggers` (
  `SCHED_NAME` varchar(120) NOT NULL,
  `ENTRY_ID` varchar(95) NOT NULL,
  `TRIGGER_NAME` varchar(200) NOT NULL,
  `TRIGGER_GROUP` varchar(200) NOT NULL,
  `INSTANCE_NAME` varchar(200) NOT NULL,
  `FIRED_TIME` bigint(13) NOT NULL,
  `SCHED_TIME` bigint(13) NOT NULL,
  `PRIORITY` int(11) NOT NULL,
  `STATE` varchar(16) NOT NULL,
  `JOB_NAME` varchar(200) DEFAULT NULL,
  `JOB_GROUP` varchar(200) DEFAULT NULL,
  `IS_NONCONCURRENT` varchar(1) DEFAULT NULL,
  `REQUESTS_RECOVERY` varchar(1) DEFAULT NULL,
  PRIMARY KEY (`SCHED_NAME`,`ENTRY_ID`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

-- ----------------------------
-- Table structure for qrtz_job_details
-- ----------------------------
DROP TABLE IF EXISTS `qrtz_job_details`;
CREATE TABLE `qrtz_job_details` (
  `SCHED_NAME` varchar(120) NOT NULL,
  `JOB_NAME` varchar(200) NOT NULL,
  `JOB_GROUP` varchar(200) NOT NULL,
  `DESCRIPTION` varchar(250) DEFAULT NULL,
  `JOB_CLASS_NAME` varchar(250) NOT NULL,
  `IS_DURABLE` varchar(1) NOT NULL,
  `IS_NONCONCURRENT` varchar(1) NOT NULL,
  `IS_UPDATE_DATA` varchar(1) NOT NULL,
  `REQUESTS_RECOVERY` varchar(1) NOT NULL,
  `JOB_DATA` blob,
  PRIMARY KEY (`SCHED_NAME`,`JOB_NAME`,`JOB_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

-- ----------------------------
-- Table structure for qrtz_locks
-- ----------------------------
DROP TABLE IF EXISTS `qrtz_locks`;
CREATE TABLE `qrtz_locks` (
  `SCHED_NAME` varchar(120) NOT NULL,
  `LOCK_NAME` varchar(40) NOT NULL,
  PRIMARY KEY (`SCHED_NAME`,`LOCK_NAME`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

-- ----------------------------
-- Table structure for qrtz_paused_trigger_grps
-- ----------------------------
DROP TABLE IF EXISTS `qrtz_paused_trigger_grps`;
CREATE TABLE `qrtz_paused_trigger_grps` (
  `SCHED_NAME` varchar(120) NOT NULL,
  `TRIGGER_GROUP` varchar(200) NOT NULL,
  PRIMARY KEY (`SCHED_NAME`,`TRIGGER_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

-- ----------------------------
-- Table structure for qrtz_scheduler_state
-- ----------------------------
DROP TABLE IF EXISTS `qrtz_scheduler_state`;
CREATE TABLE `qrtz_scheduler_state` (
  `SCHED_NAME` varchar(120) NOT NULL,
  `INSTANCE_NAME` varchar(200) NOT NULL,
  `LAST_CHECKIN_TIME` bigint(13) NOT NULL,
  `CHECKIN_INTERVAL` bigint(13) NOT NULL,
  PRIMARY KEY (`SCHED_NAME`,`INSTANCE_NAME`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

-- ----------------------------
-- Table structure for qrtz_simple_triggers
-- ----------------------------
DROP TABLE IF EXISTS `qrtz_simple_triggers`;
CREATE TABLE `qrtz_simple_triggers` (
  `SCHED_NAME` varchar(120) NOT NULL,
  `TRIGGER_NAME` varchar(200) NOT NULL,
  `TRIGGER_GROUP` varchar(200) NOT NULL,
  `REPEAT_COUNT` bigint(7) NOT NULL,
  `REPEAT_INTERVAL` bigint(12) NOT NULL,
  `TIMES_TRIGGERED` bigint(10) NOT NULL,
  PRIMARY KEY (`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`),
  CONSTRAINT `qrtz_simple_triggers_ibfk_1` FOREIGN KEY (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`) REFERENCES `qrtz_triggers` (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

-- ----------------------------
-- Table structure for qrtz_simprop_triggers
-- ----------------------------
DROP TABLE IF EXISTS `qrtz_simprop_triggers`;
CREATE TABLE `qrtz_simprop_triggers` (
  `SCHED_NAME` varchar(120) NOT NULL,
  `TRIGGER_NAME` varchar(200) NOT NULL,
  `TRIGGER_GROUP` varchar(200) NOT NULL,
  `STR_PROP_1` varchar(512) DEFAULT NULL,
  `STR_PROP_2` varchar(512) DEFAULT NULL,
  `STR_PROP_3` varchar(512) DEFAULT NULL,
  `INT_PROP_1` int(11) DEFAULT NULL,
  `INT_PROP_2` int(11) DEFAULT NULL,
  `LONG_PROP_1` bigint(20) DEFAULT NULL,
  `LONG_PROP_2` bigint(20) DEFAULT NULL,
  `DEC_PROP_1` decimal(13,4) DEFAULT NULL,
  `DEC_PROP_2` decimal(13,4) DEFAULT NULL,
  `BOOL_PROP_1` varchar(1) DEFAULT NULL,
  `BOOL_PROP_2` varchar(1) DEFAULT NULL,
  PRIMARY KEY (`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`),
  CONSTRAINT `qrtz_simprop_triggers_ibfk_1` FOREIGN KEY (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`) REFERENCES `qrtz_triggers` (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

-- ----------------------------
-- Table structure for qrtz_triggers
-- ----------------------------
DROP TABLE IF EXISTS `qrtz_triggers`;
CREATE TABLE `qrtz_triggers` (
  `SCHED_NAME` varchar(120) NOT NULL,
  `TRIGGER_NAME` varchar(200) NOT NULL,
  `TRIGGER_GROUP` varchar(200) NOT NULL,
  `JOB_NAME` varchar(200) NOT NULL,
  `JOB_GROUP` varchar(200) NOT NULL,
  `DESCRIPTION` varchar(250) DEFAULT NULL,
  `NEXT_FIRE_TIME` bigint(13) DEFAULT NULL,
  `PREV_FIRE_TIME` bigint(13) DEFAULT NULL,
  `PRIORITY` int(11) DEFAULT NULL,
  `TRIGGER_STATE` varchar(16) NOT NULL,
  `TRIGGER_TYPE` varchar(8) NOT NULL,
  `START_TIME` bigint(13) NOT NULL,
  `END_TIME` bigint(13) DEFAULT NULL,
  `CALENDAR_NAME` varchar(200) DEFAULT NULL,
  `MISFIRE_INSTR` smallint(2) DEFAULT NULL,
  `JOB_DATA` blob,
  PRIMARY KEY (`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`),
  KEY `SCHED_NAME` (`SCHED_NAME`,`JOB_NAME`,`JOB_GROUP`),
  CONSTRAINT `qrtz_triggers_ibfk_1` FOREIGN KEY (`SCHED_NAME`, `JOB_NAME`, `JOB_GROUP`) REFERENCES `qrtz_job_details` (`SCHED_NAME`, `JOB_NAME`, `JOB_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

核心代码如下：

Job实体类


package com.wutongyu.util.schedule;
import java.io.Serializable;
import java.util.Map;
/**
 * 任务详情model
 */
public class JobInfo implements Serializable {
    private static final long serialVersionUID = -7594942396353015695L;
    private String id;
    private String jobGroupName;
    private String jobName;
    private String jobClassName;
    private String jobKey;
    private Map<String, String> args;
    private String rate;
    private String times;
    private String triggerType;
    private String second;
    private String minutes;
    private String hour;
    private String month;
    private String day;
    private String week;
    private String triggerStatus;
    private String desc;
    //get set 方法。。。。。
}

ReportJob 类


package com.wutongyu.job;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class ReportJob implements Job {
    private static final Logger log = LoggerFactory.getLogger(ReportJob.class);
    public void execute( JobExecutionContext context ) throws JobExecutionException {
        try {
            //
            String reportId = ( String )context.getMergedJobDataMap().get( "reportUuid" );
            // 将需要处理的任务加入list列表
            JobQueue.getTaskQueue().add( reportId+"_"+"report" );
            log.debug( "接收到报表任务["+reportId+"]" );
            //同时生成pdf和html
            JobContext.reportJobService.executeJob(reportId,"pdf");
            JobContext.reportJobService.executeJob(reportId,"html");
        } catch( Exception e ) {
            e.printStackTrace();
        }
    }
}

1 简单调度
添加定时任务代码段


public void addReportJob(String reportId) {
        //从实体中获取定时的时间
        ReportTemplate reportTemplate=reportTemplateService.getReportTemplateByUuid(reportId);
        String statTime = reportTemplate.getStatisticsTime();
        String endTime = reportTemplate.getEndTime();
        Integer timeSetType = reportTemplate.getTimeSetType();
        Integer reportTimeType = reportTemplate.getReportTimeType();
        //周期报表
        if(reportTimeType==1){
            JobInfo job = new JobInfo();
            job.setJobClassName( ReportJob.class.getName() );
            job.setJobGroupName( "report" );
            job.setJobName( reportId );
            job.setTriggerType( "2" );

            String type = "" ;
            String week = "" ;
            String day = "" ;
            //日报
            if(timeSetType == 1){
                day = "*" ;
                week = "?" ;
                type = "日报" ;
            }else if (timeSetType == 2){//周报
                day = "?" ;
                Integer time = Integer.valueOf(endTime) % 7+2;
                //1:周日  2：周一  3：周二  4:周三  5：周四  6：周五 7：周六
                week = String.valueOf(time) ;
                type = "周报" ;
            }else if (timeSetType == 3){//月报
                day = String.valueOf(Integer.valueOf(endTime) % 31 +1) ;
                week = "?" ;
                type = "月报" ;
            }
            job.setTimes( "-1" );
            job.setSecond("0");
            job.setMinutes("0");
            job.setHour(statTime);
            job.setDay(day);
            job.setMonth("*");
            job.setWeek(week);
            Map<String, String> argMap = new HashMap<String, String>();
            argMap.put( "reportUuid", reportId );
            argMap.put( "reportType", "report" );
            job.setArgs( argMap );
            ScheduleUtil.addJob(job);
            log.error("添加报表任务【"+reportId+"】-"+type);
        }
}

启动


package com.wutongyu.util.schedule;
import org.quartz.SchedulerFactory;
import org.quartz.impl.StdSchedulerFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class SchedulerFactorySuninfo {
    private static Logger log = LoggerFactory.getLogger( SchedulerFactorySuninfo.class );
    private static SchedulerFactory schedulerFactory;
    /**
      * 【描述】：  获取schedulerFactory
     */
    public static synchronized SchedulerFactory getInstance() {
        if( schedulerFactory == null ) {
            schedulerFactory = new StdSchedulerFactory();
        }
        return schedulerFactory;
    }

}
public class ReportTaskMain {
    private static final Logger log = LoggerFactory.getLogger( ReportTaskMain.class );
    public static ReportJobService reportJobService;
    public static ReportTemplateService reportTemplateService;
    public static BackupSettingService backupSettingService;
    public static SysConfigService sysConfigService;

    public static void initScheduler() {
        SchedulerFactory schedulerFactory = SchedulerFactorySuninfo.getInstance();
        Scheduler scheduler = null;
        try {
            scheduler = schedulerFactory.getScheduler();
            scheduler.start();// 启动定时任务
            scheduler.resumeAll();
        } catch( Exception e ) {
            log.error( "定时任务启动失败", e );
        }
    }

    public static void main(String[] args) {
        //初始化es
        ElasticsearchUtil.init();
        //初始化job需要的service
        JobContext.init();
        reportJobService=JobContext.reportJobService;
        reportTemplateService=JobContext.reportTemplateService;
        backupSettingService=JobContext.backupSettingService;
        sysConfigService=JobContext.sysConfigService;

        initAllTask();//初始化报表默认任务
        initScheduler();//初始化quart
        BirtReport.createReportEngine();//创建报表引擎
        log.error("报表节点已经启动");
    }
  private static void initAllTask(){
        Criteria criteria=new Criteria();
        criteria.getCondition().put("reportTimeType",1);
        //初始化报表任务
        List<ReportTemplate> reportTemplateList=reportTemplateService.getReportTemplateByList(criteria);
        if(!CollectionUtils.isEmpty(reportTemplateList)){
            for (ReportTemplate reportTemplate : reportTemplateList) {
                Integer isOpen = reportTemplate.getIsOpen();
                //开启定时报表
                if(isOpen == 1){
                    reportJobService.removeReportJob(reportTemplate.getUuid());
                    reportJobService.addReportJob(reportTemplate.getUuid());
                }
            }
        }
        //初始化磁盘预警任务
        ScheduleUtil.deleteJob( "cleanDisk."+UUIDUtil.cleanDiskUuid );
        sysConfigService.addDiskAlertTask();//每天8点执行
        //初始化数据备份
        List<BackupSetting> backupSettingList = backupSettingService.getAll();
        for(BackupSetting backupSetting : backupSettingList){
            ScheduleUtil.deleteJob( "backup."+backupSetting.getUuid() );
            if(1==backupSetting.getIsOpen()){
                //添加任务
                backupSettingService.addBackupJob( backupSetting );
            }
        }
        //初始化定时清除任务
        ScheduleUtil.deleteJob("cleanHistoryLog."+ UUIDUtil.cleanHisLogUuid);
        sysConfigService.addCleanDiskTimingJob();
        //reportJobService.executeJob("c4c24ceca308412abc0975e229752398","html");
    }
}
public class JobContext {
    public static ReportJobService reportJobService;
    public static ReportTemplateService reportTemplateService;
    public static BackupSettingService backupSettingService;
    public static SysConfigService sysConfigService;
    public static void init() {
        ApplicationContext context = new ClassPathXmlApplicationContext( "classpath:spring-report.xml" );
        reportJobService = (ReportJobService) context.getBean("reportJobService");
        reportTemplateService=(ReportTemplateService) context.getBean("reportTemplateService");
        backupSettingService = (BackupSettingService) context.getBean("backupSettingService");
        sysConfigService = (SysConfigService) context.getBean("sysConfigService");
    }
}

ScheduleUtil 类简单列举


package com.wutongyu.util.schedule;
import org.apache.commons.collections.MapUtils;
import org.quartz.*;
import org.quartz.impl.matchers.GroupMatcher;
import org.quartz.impl.matchers.StringMatcher.StringOperatorName;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.File;
import java.io.IOException;
import java.util.*;
import static org.quartz.CronScheduleBuilder.cronSchedule;
import static org.quartz.JobBuilder.newJob;
import static org.quartz.SimpleScheduleBuilder.simpleSchedule;
import static org.quartz.TriggerBuilder.newTrigger;
public class ScheduleUtil {
    private static Logger log = LoggerFactory.getLogger( ScheduleUtil.class );
    public static void main( String[] args ) {
    }
    /**
     * 
     * addJob(增加任务)
     * 
     * @date 2015-12-16 下午12:37:48
     * @param @param jobGroup 任务组名称
     * @param @param jobName 任务名称
     * @param @param jobClassName 执行任务的job类
     * @param @param argsNames 变量名称
     * @param @param argsValues 变量值
     * @param @param triggerType 触发类型
     * @return void 返回类型
     * @throws
     */
    public static Map<String, String> addJob( JobInfo scheduleSuninfo ) {
        Map<String, String> returnMsgMap = new HashMap<String, String>();
        String group = scheduleSuninfo.getJobGroupName();
        String jobName = scheduleSuninfo.getJobName();
        String jobClassName = scheduleSuninfo.getJobClassName();
        String triggerType = scheduleSuninfo.getTriggerType();
        // 重名的任务
        try {
            Scheduler scheduler = SchedulerFactorySuninfo.getInstance().getScheduler();
            boolean flag = scheduler.checkExists( JobKey.jobKey( scheduleSuninfo.getJobName(), scheduleSuninfo.getJobGroupName() ) );
            if( flag ) {
                returnMsgMap.put( "message", "任务重名，已经存在标识为：\"" + scheduleSuninfo.getJobGroupName() + "." + scheduleSuninfo.getJobName() + "\" 的任务!" );
                return returnMsgMap;
            }
        } catch( SchedulerException e ) {
            log.error( "任务重名校验失败" );
            e.printStackTrace();
        }
        Trigger trigger = null;
        if( "1".equals( triggerType ) ) {
            String rate = scheduleSuninfo.getRate();
            String times = scheduleSuninfo.getTimes();
            Integer rateInt = new Integer( rate );
            Integer timesInt = new Integer( times );
            trigger = newTrigger().withIdentity( jobName, group ).withSchedule( simpleSchedule().withIntervalInSeconds( rateInt ).withRepeatCount( timesInt ).withMisfireHandlingInstructionFireNow() ).build();
            trigger.getStartTime();
        }
        if( "2".equals( triggerType ) ) {
            String second = scheduleSuninfo.getSecond();
            String minute = scheduleSuninfo.getMinutes();
            String hour = scheduleSuninfo.getHour();
            String day = scheduleSuninfo.getDay();
            String month = scheduleSuninfo.getMonth();
            String week = scheduleSuninfo.getWeek();
            String cronExpression = String.format( "%s %s %s %s %s %s", second, minute, hour, day, month, week );
            boolean isValid = CronExpression.isValidExpression( cronExpression );
            if( !isValid ) {
                returnMsgMap.put( "message", "cron表达式填写错误,您的表达式是：" + cronExpression );
                return returnMsgMap;
            }
            try {
                trigger = newTrigger().withIdentity( jobName, group ).withSchedule( cronSchedule( cronExpression ).withMisfireHandlingInstructionFireAndProceed() ).build();
            } catch( Exception e ) {
                e.printStackTrace();
            }
        }

        Class jobClass = null;
        try {
            jobClass = Class.forName( jobClassName );
        } catch( ClassNotFoundException e1 ) {
            log.error( jobClassName + "反射异常" );
            e1.printStackTrace();
        }
        if( jobClass == null ) {
            returnMsgMap.put( "message", "类不存在,您的类是：" + jobClassName );

            return returnMsgMap;
        }
        JobDetail job = newJob( jobClass ).withIdentity( jobName, group ).withDescription( scheduleSuninfo.getDesc() ).build();
        JobDataMap map = job.getJobDataMap();
        Map<String, String> argMap = scheduleSuninfo.getArgs();
        if( MapUtils.isNotEmpty( argMap ) ) {
            map.putAll( argMap );
        }
        try {
            Scheduler scheduler = SchedulerFactorySuninfo.getInstance().getScheduler();
            scheduler.scheduleJob( job, trigger );
        } catch( SchedulerException e ) {
            log.error( "添加任务失败" );
            e.printStackTrace();
        }
        returnMsgMap.put( "message", "success" );
        return returnMsgMap;
    }
}

2 复杂调度【间隔指定时间执行job任务】


INSERT INTO qrtz_job_details VALUES ('MonitorScheduler','ping','ping',NULL,'com.suninfo.job.PingJob','0','0','0','0','#\r\n#Thu Jul 21 09:27:33 CST 2016\r\n');

INSERT INTO qrtz_triggers VALUES ('MonitorScheduler','ping','ping','ping','ping',NULL,'1469064445449','-1','5','WAITING','SIMPLE','1469064445449','0',NULL,'1','');
-- 指定每隔6分钟执行一次
INSERT INTO qrtz_simple_triggers VALUES('MonitorScheduler','ping','ping','-1','360000','0');

spring结合quartz实现定时调度

猜你喜欢