spring使用quartz定时调用

建sql语句，用来建表的

1
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`),
  KEY `SCHED_NAME` (`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 ROW_FORMAT=DYNAMIC COMMENT='quartz_blob触发器表'

2

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 ROW_FORMAT=DYNAMIC COMMENT='quartz_日历表'

3

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(120) NOT NULL,
  `TIME_ZONE_ID` varchar(80) DEFAULT NULL,
  PRIMARY KEY (`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 ROW_FORMAT=DYNAMIC COMMENT='quartz_cron触发器表'

4

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`),
  KEY `IDX_QRTZ_FT_TRIG_INST_NAME` (`SCHED_NAME`,`INSTANCE_NAME`),
  KEY `IDX_QRTZ_FT_INST_JOB_REQ_RCVRY` (`SCHED_NAME`,`INSTANCE_NAME`,`REQUESTS_RECOVERY`),
  KEY `IDX_QRTZ_FT_J_G` (`SCHED_NAME`,`JOB_NAME`,`JOB_GROUP`),
  KEY `IDX_QRTZ_FT_JG` (`SCHED_NAME`,`JOB_GROUP`),
  KEY `IDX_QRTZ_FT_T_G` (`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`),
  KEY `IDX_QRTZ_FT_TG` (`SCHED_NAME`,`TRIGGER_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 ROW_FORMAT=DYNAMIC COMMENT='quartz_已触发的触发器表'

5

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`),
  KEY `IDX_QRTZ_J_REQ_RECOVERY` (`SCHED_NAME`,`REQUESTS_RECOVERY`),
  KEY `IDX_QRTZ_J_GRP` (`SCHED_NAME`,`JOB_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 ROW_FORMAT=DYNAMIC COMMENT='quartz_任务详情表'

6

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 ROW_FORMAT=DYNAMIC COMMENT='quartz_悲观锁表'

7

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 ROW_FORMAT=DYNAMIC COMMENT='quartz_已暂停的触发器表'

8

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 ROW_FORMAT=DYNAMIC COMMENT='quartz_集群调度器状态表'

9

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`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 ROW_FORMAT=DYNAMIC COMMENT='quartz_简易触发器表'

10

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`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 ROW_FORMAT=DYNAMIC COMMENT='quartz_简易触发器属性表'

11

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 `IDX_QRTZ_T_J` (`SCHED_NAME`,`JOB_NAME`,`JOB_GROUP`),
  KEY `IDX_QRTZ_T_JG` (`SCHED_NAME`,`JOB_GROUP`),
  KEY `IDX_QRTZ_T_C` (`SCHED_NAME`,`CALENDAR_NAME`),
  KEY `IDX_QRTZ_T_G` (`SCHED_NAME`,`TRIGGER_GROUP`),
  KEY `IDX_QRTZ_T_STATE` (`SCHED_NAME`,`TRIGGER_STATE`),
  KEY `IDX_QRTZ_T_N_STATE` (`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`,`TRIGGER_STATE`),
  KEY `IDX_QRTZ_T_N_G_STATE` (`SCHED_NAME`,`TRIGGER_GROUP`,`TRIGGER_STATE`),
  KEY `IDX_QRTZ_T_NEXT_FIRE_TIME` (`SCHED_NAME`,`NEXT_FIRE_TIME`),
  KEY `IDX_QRTZ_T_NFT_ST` (`SCHED_NAME`,`TRIGGER_STATE`,`NEXT_FIRE_TIME`),
  KEY `IDX_QRTZ_T_NFT_MISFIRE` (`SCHED_NAME`,`MISFIRE_INSTR`,`NEXT_FIRE_TIME`),
  KEY `IDX_QRTZ_T_NFT_ST_MISFIRE` (`SCHED_NAME`,`MISFIRE_INSTR`,`NEXT_FIRE_TIME`,`TRIGGER_STATE`),
  KEY `IDX_QRTZ_T_NFT_ST_MISFIRE_GRP` (`SCHED_NAME`,`MISFIRE_INSTR`,`NEXT_FIRE_TIME`,`TRIGGER_GROUP`,`TRIGGER_STATE`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 ROW_FORMAT=DYNAMIC COMMENT='quartz_触发器表'

2.引入jar包，当然还有spring的jar包和mybatis连接数据库的jar包

<!-- quartz 的jar -->
    <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>

　3.quartz.properties  quartz的一些配置

#集群配置
org.quartz.scheduler.instanceName: openerpQuartzScheduler
org.quartz.scheduler.instanceId = AUTO
org.quartz.scheduler.rmi.export: false
org.quartz.scheduler.rmi.proxy: false
org.quartz.scheduler.wrapJobExecutionInUserTransaction: false
#线程池配置
org.quartz.threadPool.class: org.quartz.simpl.SimpleThreadPool
org.quartz.threadPool.threadCount: 3
org.quartz.threadPool.threadPriority: 5
org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread: true
#任务存储持久化配置
org.quartz.jobStore.class:org.quartz.impl.jdbcjobstore.JobStoreTX
org.quartz.jobStore.driverDelegateClass:org.quartz.impl.jdbcjobstore.StdJDBCDelegate
org.quartz.jobStore.tablePrefix:QRTZ_
#org.quartz.jobStore.dataSource:qzDS
#参与集群调度，检入间隔600秒
org.quartz.jobStore.isClustered = true
org.quartz.jobStore.clusterCheckinInterval = 600000
#JDBC驱动
#org.quartz.dataSource.qzDS.driver:com.mysql.jdbc.Driver
#org.quartz.dataSource.qzDS.URL:jdbc:mysql://openerpdb.banksteel.local:3306/openerp?useUnicode=true&characterEncoding=utf8&autoReconnect=true
#org.quartz.dataSource.qzDS.user:openerp_saas
#org.quartz.dataSource.qzDS.password:PC=5jzwjlf@o
#org.quartz.dataSource.qzDS.maxConnections:10
#org.quartz.dataSource.qzDS.validationQuery=select 1

　　4，datasource.properties  因为表建在自己的数据库里面的，所有要有连接数据库的jdbc

dataSource.driverClassName = com.mysql.jdbc.Driver
dataSource.url = jdbc:mysql://openerpdb.banksteel.local:3306/openerp_saas?useUnicode=true&characterEncoding=utf8&autoReconnect=true
dataSource.username =openerp_saas
dataSource.password =PC=5jzwjlf@o
dataSource.initialSize = 10
dataSource.maxActive = 100
dataSource.maxIdle = 10
dataSource.minIdle = 2
dataSource.testOnBorrow= false
dataSource.testWhileIdle= true
dataSource.validationQuery= select 1
dataSource.filters = stat

　　5. applicationContext.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" xmlns:mvc="http://www.springframework.org/schema/mvc"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:tx="http://www.springframework.org/schema/tx"  
	xsi:schemaLocation="
		http://www.springframework.org/schema/beans 
		http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
		http://www.springframework.org/schema/tx   
        http://www.springframework.org/schema/tx/spring-tx-3.0.xsd 
		http://www.springframework.org/schema/context 
		http://www.springframework.org/schema/context/spring-context-3.0.xsd
		http://www.springframework.org/schema/mvc 
		http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd">
	
	
  	
  	<!-- 配置数据源 -->
	<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
		<property name="driverClassName" value="${dataSource.driverClassName}" />
		<property name="url" value="${dataSource.url}" />
		<property name="username" value="${dataSource.username}" />
		<property name="password" value="${dataSource.password}" />
		<property name="initialSize" value="${dataSource.initialSize}" />
		<property name="maxActive" value="${dataSource.maxActive}" />
		<property name="minIdle" value="${dataSource.minIdle}" />
		<property name="testOnBorrow" value="${dataSource.testOnBorrow}" />
		<property name="testWhileIdle" value="${dataSource.testWhileIdle}" />
		<property name="validationQuery" value="${dataSource.validationQuery}" />
		<property name="filters" value="${dataSource.filters}" />
	</bean>
	
    <!-- (事务管理)transaction manager, use JtaTransactionManager for global tx -->  
    <bean id="transactionManager"  
        class="org.springframework.jdbc.datasource.DataSourceTransactionManager">  
        <property name="dataSource" ref="dataSource" />  
    </bean>  

	
    <!-- 创建SqlSessionFactory，同时指定数据源 -->  
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">  
        <property name="dataSource" ref="dataSource" />  
        <!--<property name="mapperLocations" value="classpath*:com/banksteel/openerp/system/provider/DAOImpl/*Mapper.xml" />-->
        <property name="mapperLocations" value="classpath*:mybatis/mapper/*Mapper.xml" />
        <!-- MyBatis拦截器，拦截SQL语句处理companyId -->
		<property name="plugins">
			<array>
				<bean
					class="com.banksteel.openerp.commons.interceptor.RebuildSqlInterceptor" />
			</array>
		</property>
    </bean>  
      
    <!-- 可通过注解控制事务 -->  
    <tx:annotation-driven/>
   
    <bean id="sessionTemplate" class="org.mybatis.spring.SqlSessionTemplate" destroy-method="close" scope="prototype">
		<constructor-arg index="0" ref="sqlSessionFactory" />
	</bean>

	<!-- 自定义Job工厂Bean -->
	<bean id="jobFactory"
		class="com.banksteel.openerp.quartz.provider.utils.QuartzJobFactory"></bean>
		
	<!-- quartz调度工厂Bean -->
	<bean id="openerpQuartzScheduler" lazy-init="false"
		class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
		<property name="configLocation" value="classpath:quartz.properties" />
		<property name="autoStartup" value="true" />
		<property name="jobFactory" ref="jobFactory"></property>
		<property name="dataSource" ref="dataSource" />  
		<property name="schedulerName" value="openerpQuartzScheduler" />
	</bean>

</beans>  

　　6.QuartzJobFactory.java

package com.banksteel.openerp.quartz.provider.utils;

import org.quartz.spi.TriggerFiredBundle;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.scheduling.quartz.SpringBeanJobFactory;

/**
 * Job工厂类，重写获取Job实例的方式，使得Job可以使用spring注入的bean
 * 
 * @author 
 *
 */
public class QuartzJobFactory extends SpringBeanJobFactory implements ApplicationContextAware {

	private ApplicationContext applicationContext;

	public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
		this.applicationContext = applicationContext;
	}

	@Override
	protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
		Object jobInstance = super.createJobInstance(bundle);
		// 把Job交给Spring来管理，这样Job就能使用由Spring产生的Bean了
		applicationContext.getAutowireCapableBeanFactory().autowireBean(jobInstance);
		return jobInstance;
	}

}

　　7.QuartzServiceImpl.java

package com.banksteel.openerp.quartz.provider.service.impl;

import static org.quartz.CronScheduleBuilder.cronSchedule;
import static org.quartz.JobBuilder.newJob;
import static org.quartz.TriggerBuilder.newTrigger;

import java.util.Map;

import org.quartz.Job;
import org.quartz.JobDetail;
import org.quartz.JobExecutionException;
import org.quartz.JobKey;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.Trigger;
import org.quartz.Trigger.TriggerState;
import org.quartz.TriggerKey;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

import com.banksteel.openerp.quartz.api.job.PricingLockReleaseJob;
import com.banksteel.openerp.quartz.api.service.QuartzService;

@Repository(value = "quartzService")
public class QuartzServiceImpl implements QuartzService {

	@Autowired(required = true)
	private PricingLockReleaseJob pricingLockReleaseJob;


	@Autowired
	private Scheduler openerpQuartzScheduler;

	private static Logger log = (Logger) LoggerFactory.getLogger(QuartzServiceImpl.class);

	@Override
	public Scheduler getScheduler() {
		return openerpQuartzScheduler;
	}
	
	@Override
	public boolean start() {
		try {
			if (!openerpQuartzScheduler.isStarted()) {
				openerpQuartzScheduler.start();
				log.info("启动调度器 ");
			} else {
				log.info("调度器已启动，不再重复启动 ");
			}
			return true;
		} catch (SchedulerException e) {
			e.printStackTrace();
			log.error("启动调度器=> [失败]");
			return false;
		}
	}

	@Override
	public boolean shutdown() {
		try {
			if (openerpQuartzScheduler.isStarted()) {
				openerpQuartzScheduler.shutdown();
				log.info("停止调度器 ");
			} else {
				log.info("调度器已停止，不再重复停止 ");
			}
			return true;
		} catch (SchedulerException e) {
			e.printStackTrace();
			log.error("停止调度器=> [失败]");
			return false;
		}
	}

	@Override
	public boolean addJob(String name, String group, Class<? extends Job> clazz, String cronExpression,
			Map<String, Object> jobDataMap) {

		try {
			// 构造任务
			JobDetail job = newJob(clazz).withIdentity(name, group).build();
			// 添加任务参数
			if (jobDataMap != null && !jobDataMap.isEmpty()) {
				for (Map.Entry<String, Object> entry : jobDataMap.entrySet()) {
					job.getJobDataMap().put(entry.getKey(), entry.getValue());
				}
			}
			// 构造任务触发器
			Trigger trg = newTrigger().withIdentity(name, group).withSchedule(cronSchedule(cronExpression)).build();
			// 将任务添加到调度器
			openerpQuartzScheduler.scheduleJob(job, trg);
			log.info("创建任务=> [任务名称：" + name + " 任务组：" + group + "] ");
			return true;
		} catch (SchedulerException e) {
			e.printStackTrace();
			log.error("创建任务=> [任务名称：" + name + " 任务组：" + group + "]=> [失败]");
			return false;
		}

	}

	@Override
	public boolean removeJob(String name, String group) {
		try {
			TriggerKey tk = TriggerKey.triggerKey(name, group);
			openerpQuartzScheduler.pauseTrigger(tk);// 停止触发器
			openerpQuartzScheduler.unscheduleJob(tk);// 移除触发器
			JobKey jobKey = JobKey.jobKey(name, group);
			openerpQuartzScheduler.deleteJob(jobKey);// 删除任务
			log.info("删除任务=> [任务名称：" + name + " 任务组：" + group + "] ");
			return true;
		} catch (SchedulerException e) {
			e.printStackTrace();
			log.error("删除任务=> [任务名称：" + name + " 任务组：" + group + "]=> [失败]");
			return false;
		}
	}

	@Override
	public boolean pauseJob(String name, String group) {
		try {
			JobKey jobKey = JobKey.jobKey(name, group);
			openerpQuartzScheduler.pauseJob(jobKey);
			log.info("暂停任务=> [任务名称：" + name + " 任务组：" + group + "] ");
			return true;
		} catch (SchedulerException e) {
			e.printStackTrace();
			log.error("暂停任务=> [任务名称：" + name + " 任务组：" + group + "]=> [失败]");
			return false;
		}
	}

	@Override
	public boolean resumeJob(String name, String group) {
		try {
			JobKey jobKey = JobKey.jobKey(name, group);
			openerpQuartzScheduler.resumeJob(jobKey);
			log.info("恢复任务=> [任务名称：" + name + " 任务组：" + group + "] ");
			return true;
		} catch (SchedulerException e) {
			e.printStackTrace();
			log.error("恢复任务=> [任务名称：" + name + " 任务组：" + group + "]=> [失败]");
			return false;
		}
	}

	@Override
	public boolean modifyJobCronExpression(String name, String group, String cronExpression) {
		try {
			TriggerKey tk = TriggerKey.triggerKey(name, group);
			// 构造任务触发器
			Trigger trg = newTrigger().withIdentity(name, group).withSchedule(cronSchedule(cronExpression)).build();
			TriggerState state = openerpQuartzScheduler.getTriggerState(tk);
			openerpQuartzScheduler.rescheduleJob(tk, trg);//修改时间时，会重新启动，导致暂停状态恢复成等待！
			if ("PAUSED".equals(state.toString()))
			{
				pauseJob(name,group);//判断如果编辑时数据为暂停，则重新调用暂停的方法，来保证修改后与修改前的状态一致
			}
			log.info("修改任务触发时间=> [任务名称：" + name + " 任务组：" + group + "] ");
			return true;
		} catch (SchedulerException e) {
			e.printStackTrace();
			log.error("修改任务触发时间=> [任务名称：" + name + " 任务组：" + group + "]=> [失败]");
			return false;
		}
	}

	@Override
	public boolean pauseAll() {
		try {
			openerpQuartzScheduler.pauseAll();
			log.info("暂停全部任务=> 成功");
			return true;
		} catch (SchedulerException e) {
			e.printStackTrace();
			log.info("暂停全部任务=> 失败");
			return false;
		}
	}

	@Override
	public boolean resumeAll() {
		try {
			openerpQuartzScheduler.resumeAll();
			log.info("恢复全部任务=> 成功");
			return true;
		} catch (SchedulerException e) {
			e.printStackTrace();
			log.info("恢复全部任务=> 失败");
			return false;
		}
	}

	@Override
	public void executePricingLockReleaseJob() throws JobExecutionException {
		pricingLockReleaseJob.execute(null);
	}

}

　　

8.QuartzService.java

package com.banksteel.openerp.quartz.api.service;

import java.util.Map;

import org.quartz.Job;
import org.quartz.JobExecutionException;
import org.quartz.Scheduler;

/**
 * 定时任务服务接口
 * 
 * @author KangJian
 *
 */
public interface QuartzService {

	/**
	 * 获取调度器对象
	 * 
	 * @return
	 * @author:
	 * @createTime:2016年12月22日 下午3:07:24
	 */
	public Scheduler getScheduler();

	/**
	 * 启动调度器
	 * 
	 * @return
	 * @author
	 * @date 2016年9月7日 上午11:32:05
	 */
	public boolean start();

	/**
	 * 关闭调度器
	 * 
	 * @return
	 * @author
	 * @date 2016年9月7日 上午11:32:09
	 */
	public boolean shutdown();

	/**
	 * 添加定时任务
	 * 
	 * @param name
	 *            任务名称
	 * @param group
	 *            任务组
	 * @param clazz
	 *            任务字节码文件
	 * @param cronExpression
	 *            cron表达式
	 * @param jobDataMap
	 *            任务参数
	 * @author
	 * @date 2016年9月7日 上午11:25:26
	 */
	public boolean addJob(String name, String group, Class<? extends Job> clazz, String cronExpression,
			Map<String, Object> jobDataMap);

	/**
	 * 删除定时任务
	 * 
	 * @param name
	 *            任务名称
	 * @param group
	 *            任务组
	 * @return
	 * @author
	 * @date 2016年9月7日 上午11:27:49
	 */
	public boolean removeJob(String name, String group);

	/**
	 * 暂停定时任务
	 * 
	 * @param name
	 *            任务名称
	 * @param group
	 *            任务组
	 * @return
	 * @author
	 * @date 2016年9月7日 上午11:29:16
	 */
	public boolean pauseJob(String name, String group);

	/**
	 * 继续定时任务
	 * 
	 * @param name
	 *            任务名称
	 * @param group
	 *            任务组
	 * @return
	 * @author 
	 * @date 2016年9月7日 上午11:29:16
	 */
	public boolean resumeJob(String name, String group);

	/**
	 * 变更定时任务执行时间
	 * 
	 * @param name
	 *            任务名称
	 * @param group
	 *            任务组
	 * @param cronExpression
	 *            cron表达式
	 * @author 
	 * @date 2016年9月7日 上午11:30:49
	 */
	public boolean modifyJobCronExpression(String name, String group, String cronExpression);

	/**
	 * 暂停全部任务
	 * 
	 * @return
	 * @author 
	 * @date 2016年9月7日 下午2:31:58
	 */
	public boolean pauseAll();

	/**
	 * 恢复全部任务
	 * 
	 * @return
	 * @author
	 * @date 2016年9月7日 下午2:32:20
	 */
	public boolean resumeAll();

	/**
	 * 立即执行释放定价锁任务
	 * 
	 * @author 
	 * @throws JobExecutionException
	 * @date 2016年10月10日 下午10:30:49
	 */
	public void executePricingLockReleaseJob() throws JobExecutionException;

}

　　9.PricingLockReleaseJob.java

package com.banksteel.openerp.quartz.api.job;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;


/**
 * 清除所有定价锁定时任务,需要实现Job接口
 * 
 */
@Repository("pricingLockReleaseJob")
public class PricingLockReleaseJob implements Job {

	

	/**
	 * 执行任务的方法
	 */
	public void execute(JobExecutionContext context) throws JobExecutionException {
		// 自己的方法
	}

}

　　参考  https://blog.csdn.net/u010648555/article/details/54891264

转载于:https://www.cnblogs.com/guilf/p/9360454.html