spring4整合quartz2.x集群配置，并实现任务计数功能

最新推荐文章于 2022-03-10 11:05:30 发布
最新推荐文章于 2022-03-10 11:05:30 发布
阅读量1.8k 收藏 3
点赞数
分类专栏： quartz 文章标签： quartz集群
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhaoyachao123/article/details/78306643
版权

spring4整合quartz2.x请看 spring4和quartz2.x整合,对任务做动态操作(增删改查)

本篇文章在此基础上实现集群配置

quartz存储job方式就分三种，我们最常用的也是quartz默认的是RAMJobStore，RAMJobStore顾名思义就是把job的相关信息存储在内存里，如果用spring配置quartz的job信息的话，所有信息是配置在xml里，当spirng context启动的时候就把xml里的job信息装入内存。这一性质就决定了一旦JVM挂掉或者容器挂掉，内存中的job信息就随之消失，无法持久化。另外两种方式是JobStoreTX和JobStoreCMT，暂时不讨论这两者的区别，使用这两种JobStore，quartz就会通过jdbc直连或者应用服务器jndi连接数据库，读取配置在数据库里的job初始化信息，并且把job通过java序列化到数据库里，这样就使得每个job信息得到了持久化，即使在jvm或者容器挂掉的情况下，也能通过数据库感知到其他job的状态和信息。

spring4,quartz2.x实现集群 是将quartz和数据库结合起来实现，既然和数据库有关当然少不了了要创建一些表，我们在本文的末尾会将表的sql脚本上传

项目结构如下：


集群比非集群时多的jar如下：

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-jdbc</artifactId>
			<version>4.1.2.RELEASE</version>
		</dependency>

		<!-- 阿里巴巴数据库连接池 -->
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>druid</artifactId>
			<version>1.1.4</version>
		</dependency>

		<!--mysql-connector-java -->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>5.1.40</version>
		</dependency>

spring-quartz.xml配置如下：比在不集群时增加了dataSource数据源配置，数据源的一些配置这里不在多说

<?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:aop="http://www.springframework.org/schema/aop"
	xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:util="http://www.springframework.org/schema/util" xmlns:task="http://www.springframework.org/schema/task"  
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop 
	http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/context 
	http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/tx 
	http://www.springframework.org/schema/tx/spring-tx.xsd http://www.springframework.org/schema/util
	http://www.springframework.org/schema/util/spring-util.xsd http://www.springframework.org/schema/task  
    http://www.springframework.org/schema/task/spring-task-3.1.xsd">
	
	<context:component-scan base-package="com.quartz"></context:component-scan>
	<!-- <task:annotation-driven/> -->
	<bean id="propertyConfigurer"
		class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
		<property name="locations">
			<list>
				<value>classpath:dbconfig.properties</value>
			</list>
		</property>
	</bean>
	
		<!-- 阿里 druid数据库连接池 -->
	<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
		destroy-method="close">
		<!-- 数据库基本信息配置 -->
		<property name="url" value="${url}" />
		<property name="username" value="${username}" />
		<property name="password" value="${password}" />
		<property name="driverClassName" value="${driverClassName}" />
		<property name="filters" value="${filters}" />
		<!-- 最大并发连接数 -->
		<property name="maxActive" value="${maxActive}" />
		<!-- 初始化连接数量 -->
		<property name="initialSize" value="${initialSize}" />
		<!-- 配置获取连接等待超时的时间 -->
		<property name="maxWait" value="${maxWait}" />
		<!-- 最小空闲连接数 -->
		<property name="minIdle" value="${minIdle}" />
		<!-- 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 -->
		<property name="timeBetweenEvictionRunsMillis" value="${timeBetweenEvictionRunsMillis}" />
		<!-- 配置一个连接在池中最小生存的时间，单位是毫秒 -->
		<property name="minEvictableIdleTimeMillis" value="${minEvictableIdleTimeMillis}" />
		<property name="validationQuery" value="${validationQuery}" />
		<property name="testWhileIdle" value="${testWhileIdle}" />
		<property name="testOnBorrow" value="${testOnBorrow}" />
		<property name="testOnReturn" value="${testOnReturn}" />
		<property name="maxOpenPreparedStatements" value="${maxOpenPreparedStatements}" />
		<!-- 打开removeAbandoned功能 -->
		<property name="removeAbandoned" value="${removeAbandoned}" />
		<!-- 1800秒，也就是30分钟 -->
		<property name="removeAbandonedTimeout" value="${removeAbandonedTimeout}" />
		<!-- 关闭abanded连接时输出错误日志 -->
		<property name="logAbandoned" value="${logAbandoned}" />
	</bean>
	
	<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">  
        <property name = "dataSource" ref="dataSource"/>  
    </bean>  
	
	<!-- ======================== 调度工厂 ======================== -->
	<bean id="schedulerFactoryBean" lazy-init="false" autowire="no"  class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
	<property name="dataSource" ref="dataSource"></property>
	<property name="configLocation" value="classpath:quartz.properties" />
	<property name="applicationContextSchedulerContextKey" value="applicationContext" />
	</bean>
</beans>
quartz.properties配置文件如下 

    #==============================================================    
    #Configure Main Scheduler Properties    
    #==============================================================     
    #org.quartz.scheduler.instanceName = mapScheduler  
    org.quartz.scheduler.instanceId = AUTO
      
    #==============================================================    
    #Configure JobStore    
    #==============================================================   
    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.isClustered = true
    org.quartz.jobStore.clusterCheckinInterval = 20000
    org.quartz.jobStore.dataSource = myDS
    org.quartz.jobStore.maxMisfiresToHandleAtATime = 1
    org.quartz.jobStore.misfireThreshold = 5000
    org.quartz.jobStore.txIsolationLevelSerializable = true
       
    #==============================================================    
    #Configure DataSource    
    #==============================================================   
    org.quartz.dataSource.myDS.driver = com.mysql.jdbc.Driver
    org.quartz.dataSource.myDS.URL = jdbc\:mysql\://127.0.0.1\:3306/quartzdb?useUnicode\=true&characterEncoding\=UTF-8 
    org.quartz.dataSource.myDS.user = root
    org.quartz.dataSource.myDS.password = 123456
    org.quartz.dataSource.myDS.maxConnections = 30
    org.quartz.jobStore.selectWithLockSQL = SELECT * FROM {0}LOCKS WHERE LOCK_NAME = ? FOR UPDATE
      
    #==============================================================    
    #Configure ThreadPool    
    #==============================================================   
    org.quartz.threadPool.class = org.quartz.simpl.SimpleThreadPool  
    org.quartz.threadPool.threadCount = 10
    org.quartz.threadPool.threadPriority = 5
    org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread = true  
      
    #==============================================================  
    #Skip Check Update  
    #update:true  
    #not update:false  
    #==============================================================  
    org.quartz.scheduler.skipUpdateCheck = true
      
    #============================================================================     
    # Configure Plugins      
    #============================================================================        
    org.quartz.plugin.triggHistory.class = org.quartz.plugins.history.LoggingJobHistoryPlugin
    org.quartz.plugin.shutdownhook.class = org.quartz.plugins.management.ShutdownHookPlugin
    org.quartz.plugin.shutdownhook.cleanShutdown =true
dbconfig.properties配置文件如下： 

url=jdbc\:mysql\://127.0.0.1\:3306/quartzdb?useUnicode\=true&characterEncoding\=UTF-8&zeroDateTimeBehavior\=convertToNull
driverClassName=com.mysql.jdbc.Driver
username=root
password=123456
       
filters=stat
   
maxActive=20
initialSize=1
maxWait=60000
minIdle=10
maxIdle=15
   
timeBetweenEvictionRunsMillis=60000
minEvictableIdleTimeMillis=300000
   
validationQuery=SELECT 'x'
testWhileIdle=true
testOnBorrow=false
testOnReturn=false

maxOpenPreparedStatements=20
removeAbandoned=true
removeAbandonedTimeout=1800
logAbandoned=true
由于spring4，quartz2.x集群时会出现序列化错误 如下

Caused by: java.io.NotSerializableException: Unable to serialize JobDataMap for insertion into database because the value of property '你的属性名' is not serializable

所以我们在之前的基础上把放入的jobdatamap 中的属性都给替换成字符串，在job里面重新解析

TaskServiceImpl重写如下：关于任务中断重启时的运行策略任务重启执行策略

package com.quartz.service.impl;

import java.lang.reflect.Method;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;

import javax.annotation.Resource;

import org.quartz.CronScheduleBuilder;
import org.quartz.CronTrigger;
import org.quartz.JobBuilder;
import org.quartz.JobDataMap;
import org.quartz.JobDetail;
import org.quartz.JobKey;
import org.quartz.Matcher;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SimpleScheduleBuilder;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.TriggerKey;
import org.quartz.impl.matchers.GroupMatcher;
import org.quartz.impl.matchers.KeyMatcher;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.ResultSetExtractor;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.scheduling.quartz.JobDetailFactoryBean;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
import org.springframework.stereotype.Service;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.quartz.ScheduleTask;
import com.quartz.job.MyJob2;
import com.quartz.job.MyJob4;
import com.quartz.listeners.MyTriggerListeners;
import com.quartz.service.TaskService;

@Service("taskService")
public class TaskServiceImpl implements TaskService {

	

	@Resource(name="&schedulerFactoryBean")
	private SchedulerFactoryBean schedulerFactoryBean;
	@Autowired
	private MyJob4 myJob4;
	@Autowired
	private JdbcTemplate jdbcTemplate;
	@Autowired
	MyTriggerListeners myTriggerListeners;

	public List<ScheduleTask> getAllTask() {
		 List<ScheduleTask> list=jdbcTemplate.query("select * from scheduler_task_info", new RowMapper<ScheduleTask>(){

			@Override
			public ScheduleTask mapRow(ResultSet arg0, int arg1) throws SQLException {
				ScheduleTask scheduleTask=new ScheduleTask();
				scheduleTask.setId(arg0.getString("id"));
				scheduleTask.setName(arg0.getString("job_name"));
				scheduleTask.setGroup(arg0.getString("job_group"));
				scheduleTask.setTrigger(arg0.getString("job_trigger"));
				scheduleTask.setTriggerId(arg0.getString("job_trigger_id"));
				scheduleTask.setExpression(arg0.getString("job_expression"));
				scheduleTask.setParam(arg0.getString("job_param").split(","));
				return scheduleTask;
			}});
		
		return list;
	}

	public CronTrigger getTrigger(String triggerId, String group) {
		Scheduler scheduler = schedulerFactoryBean.getScheduler();
		CronTrigger cronTrigger = null;
		try {
			cronTrigger = (CronTrigger) scheduler.getTrigger(new TriggerKey(
					triggerId, group));
		} catch (SchedulerException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return cronTrigger;
	}

	public ScheduleTask addTask(ScheduleTask task) {
		try {
			Scheduler scheduler = schedulerFactoryBean.getScheduler();
			JobDetail jobDetail = JobBuilder.newJob(myJob4.getClass())
					.withIdentity(task.getName(), task.getGroup()).withDescription(task.getDesc()).build();
			//withMisfireHandlingInstructionDoNothing()用来设置当一台机子挂掉时，集群中另外的机器接管任务后以何种方式重新运行
			CronTrigger trigger = TriggerBuilder
					.newTrigger()
					.withIdentity(task.getTriggerId(), task.getGroup())
					.startNow()
					.withSchedule(
							CronScheduleBuilder.cronSchedule(task
									.getExpression()).withMisfireHandlingInstructionDoNothing()).build();
			Matcher<TriggerKey> triggerMatcher = KeyMatcher.keyEquals(trigger.getKey()); //添加trigger监听器
			scheduler.getListenerManager().addTriggerListener(myTriggerListeners,triggerMatcher);
			System.out.println(trigger.getKey());
			String c="";
			Object[] param=new Object[task.getParam().length];
			for (int i = 0; i < task.getParam().length; i++) {
				c += task.getParam()[i].getClass().getSimpleName()+",";
				param[i]=task.getParam()[i];
			}
			String pm=JSONArray.toJSONString(param);
			JobDataMap jobDataMap = trigger.getJobDataMap();
			jobDataMap.put(MyJob4.JOB_NAME, task.getName());
			jobDataMap.put(MyJob4.JOB_GROUP, task.getGroup());
			jobDataMap.put(MyJob4.JOB_TRIGGER, task.getTrigger());
			jobDataMap.put(MyJob4.JOB_TRIGGER_PARAM, c);
			jobDataMap.put(MyJob4.JOB_TRIGGER_PARAM_OBJ, pm);
			jobDataMap.put("id", task.getId());
			jobDataMap.put("count", 0);
			scheduler.scheduleJob(jobDetail, trigger);
			if (scheduler.isStarted()) {
				scheduler.start();
			}
			jdbcTemplate.update("insert into scheduler_task_info(id,job_name,job_group,job_trigger,job_trigger_id,job_expression,job_param) values(?,?,?,?,?,?,?)", new Object[]{
					task.getId(),task.getName(),task.getGroup(),task.getTrigger(),task.getTriggerId(),task.getExpression(),Arrays.toString(task.getParam())	
			});
			
		} catch (SchedulerException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (SecurityException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return task;
	}

	public ScheduleTask reStartTask(ScheduleTask task) {
		try {
			CronTrigger cronTrigger = getTrigger(task.getTriggerId(),
					task.getGroup());
			Scheduler scheduler = schedulerFactoryBean.getScheduler();
			cronTrigger = cronTrigger
					.getTriggerBuilder()
					.withIdentity(
							new TriggerKey(task.getTriggerId(), task.getGroup()))
					.withSchedule(
							CronScheduleBuilder.cronSchedule(task
									.getExpression())).build();

			// 按新的trigger重新设置job执行

			scheduler.rescheduleJob(
					new TriggerKey(task.getTriggerId(), task.getGroup()),
					cronTrigger);
		} catch (SchedulerException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

		// 下方可以做一些更新数据库中任务的操作

		return task;
	}

	public ScheduleTask deleteTask(ScheduleTask task) {
		try {
			Scheduler scheduler = schedulerFactoryBean.getScheduler();
			JobKey jobKey = new JobKey(task.getName(), task.getGroup());
			scheduler.deleteJob(jobKey);
			jdbcTemplate.update("delete from scheduler_task_info where id=?", task.getId());
		} catch (SchedulerException e) {

			e.printStackTrace();
		}
		return task;
	}

	public ScheduleTask pauseTask(ScheduleTask task) {
		try {
			Scheduler scheduler = schedulerFactoryBean.getScheduler();
			JobKey jobKey = new JobKey(task.getName(), task.getGroup());
			scheduler.pauseJob(jobKey);
		} catch (SchedulerException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return task;
	}

	public ScheduleTask resumeTask(ScheduleTask task) {
		try {
			Scheduler scheduler = schedulerFactoryBean.getScheduler();
			JobKey jobKey = new JobKey(task.getName(), task.getGroup());
			scheduler.resumeJob(jobKey);
		} catch (SchedulerException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return task;
	}

	public void deleteTasks(List<ScheduleTask> scheduleTasks) {
		try {
			Scheduler scheduler = schedulerFactoryBean.getScheduler();
			List<JobKey> jobKeys = new ArrayList<JobKey>();
			JobKey jobKey;
			for (ScheduleTask scheduleTask : scheduleTasks) {
				jobKey = new JobKey(scheduleTask.getName(),
						scheduleTask.getGroup());
				jobKeys.add(jobKey);
			}
			scheduler.deleteJobs(jobKeys);
		} catch (SchedulerException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}

	public void pauseAllTask() {
		try {
			Scheduler scheduler = schedulerFactoryBean.getScheduler();
			scheduler.pauseAll();
		} catch (SchedulerException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

}
MyJob4.java 如下：在原有的基础上实现了任务计数功能 

package com.quartz.job;

import java.io.Serializable;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.text.SimpleDateFormat;
import java.util.Date;

import org.hamcrest.core.IsInstanceOf;
import org.quartz.Job;
import org.quartz.JobDataMap;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.TriggerListener;
import org.quartz.impl.matchers.KeyMatcher;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.scheduling.quartz.QuartzJobBean;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
import org.springframework.stereotype.Service;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.quartz.listeners.MyTriggerListeners;
import com.quartz.util.SpringApplication;
@Service
public class MyJob4 extends QuartzJobBean implements Serializable{

	private ApplicationContext applicationContext;
	/**
	 * 
	 */
	private static final long serialVersionUID = -8509585011462529939L;
	public static final String JOB_NAME="job_name";
	public static final String JOB_GROUP="job_group";
	public static final String JOB_TRIGGER="job_trigger";
	public static final String JOB_TRIGGER_PARAM="job_trigger_param";
	public static final String JOB_TRIGGER_PARAM_OBJ="job_trigger_param_obj";
	@Override
	protected void executeInternal(JobExecutionContext context)
			throws JobExecutionException {
		
		
		SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		System.out.println("调度任务执行的时间=="+sdf.format(context.getFireTime()));//调度任务执行的时间
		//context.getNextFireTime();
		Date d=context.getPreviousFireTime();
		if(d!=null){
			System.out.println("context.getPreviousFireTime()=="+sdf.format(d));
		}
		try {                                                                                           
			SchedulerFactoryBean schedulerFactoryBean=(SchedulerFactoryBean) SpringApplication.getBean("&schedulerFactoryBean");
			Scheduler scheduler = schedulerFactoryBean.getScheduler();
			TriggerListener triggerListener = scheduler.getListenerManager().getTriggerListener("MyTriggerListeners");
			if(triggerListener==null){
				MyTriggerListeners myTriggerListeners=(MyTriggerListeners) SpringApplication.getBean("myTriggerListeners");
				scheduler.getListenerManager().addTriggerListener(myTriggerListeners, KeyMatcher.keyEquals(context.getTrigger().getKey()));
			}
	        JobDataMap jobDataMap = context.getTrigger().getJobDataMap();
	        int count=(int) jobDataMap.get("count");
	        count++;
	        jobDataMap.put("count", count);
	        System.out.println(jobDataMap.get("id")+"----执行------"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
	     	Class<?> classzz = Class.forName(jobDataMap.get(MyJob4.JOB_GROUP).toString());
	     	Object obj=classzz.newInstance();
	     	String param=jobDataMap.get(MyJob4.JOB_TRIGGER_PARAM).toString();
	     	String[] c=param.split(",");
	     	Class<?>[] cc=new Class<?>[c.length];
	     	for(int i=0;i<c.length;i++){
	     		String key=c[i].trim();
	     		switch (key) {
				case "String":
					cc[i]=String.class;
					break;
				case "Integer":
					cc[i]=Integer.class;
					break;
				default:
					cc[i]=Object.class;
					break;
				}
	     	}
	     	JSONArray parseArray = JSONArray.parseArray(jobDataMap.get(MyJob4.JOB_TRIGGER_PARAM_OBJ).toString());
	     	Method method=classzz.getMethod(jobDataMap.get(MyJob4.JOB_TRIGGER).toString(), cc);
	     	Object[] args=new Object[parseArray.size()];
	     	for(int i=0;i<parseArray.size();i++){
	     		args[i]=parseArray.get(i);
	     	}
	     	method.invoke(obj, args);
			} catch (IllegalAccessException e) {
				e.printStackTrace();
			} catch (IllegalArgumentException e) {
				e.printStackTrace();
			} catch (InvocationTargetException e) {
				e.printStackTrace();
			} catch (InstantiationException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (SecurityException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (ClassNotFoundException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (NoSuchMethodException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (SchedulerException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		
	}
	
	 private ApplicationContext getApplicationContext(final JobExecutionContext jobexecutioncontext) {  
	        try {  
	        	applicationContext=(ApplicationContext) jobexecutioncontext.getScheduler().getContext().get("applicationContextKey");
	            return applicationContext;
	        } catch (SchedulerException e) {  
	           
	            throw new RuntimeException(e);  
	        }  
	    }  

}
MyTriggerListeners.java 如下 

package com.quartz.listeners;

import java.util.concurrent.ConcurrentHashMap;

import org.quartz.JobExecutionContext;
import org.quartz.Trigger;
import org.quartz.Trigger.CompletedExecutionInstruction;
import org.quartz.TriggerListener;
import org.springframework.stereotype.Service;

@Service("myTriggerListeners")
public class MyTriggerListeners implements TriggerListener{

        //这里本该换成数据库或者缓存存储的，咱们这里为了方便先用一个线程安全的hashmap 代替
	private static ConcurrentHashMap<String,Long> countHashMap=new ConcurrentHashMap<String,Long>();
	@Override
	public String getName() {
		return "MyTriggerListeners";
	}

	@Override
	public void triggerFired(Trigger trigger, JobExecutionContext context) {
		// TODO Auto-generated method stub
		
	}
	@Override
	public boolean vetoJobExecution(Trigger trigger, JobExecutionContext context) {
		// TODO Auto-generated method stub
		return false;
	}

	@Override
	public void triggerMisfired(Trigger trigger) {
		// TODO Auto-generated method stub
		
	}
	@Override
	public void triggerComplete(Trigger trigger, JobExecutionContext context,
			CompletedExecutionInstruction triggerInstructionCode) {
		System.out.println("Trigger :"+trigger.getKey().getGroup()+"."+trigger.getKey().getName()+" completed with code:"+triggerInstructionCode);
        String key=trigger.getKey().getName();
        if(countHashMap.containsKey(key)){
        	Long count=countHashMap.get(key)+1;
        	countHashMap.put(key, count);
        	System.out.println("任务执行次数=="+count);
        }else{
        	countHashMap.put(key, (long) 1);
        	System.out.println("任务执行次数=="+1);
        }
		
	}
}
SpringApplication.java如下:应为咱们的job虽然声明在了spring容器中，但是咱们使用时使用的是直接new 出来的job,所以咱们自己声明一个spring容器管理类用来查找javabean 

package com.quartz.util;

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;
@Component
public class SpringApplication implements ApplicationContextAware {

	private static ApplicationContext applicationContext;
	@Override
	public void setApplicationContext(ApplicationContext applicationContext)
			throws BeansException {
		this.applicationContext=applicationContext;
		
	}

	public static Object getBean(String bean){
		return applicationContext.getBean(bean);
	}
	
}
MySql建表如下：mysql 表和oracle 表的区别在与字段类型的区别 blob和clob 

DROP TABLE IF EXISTS QRTZ_FIRED_TRIGGERS;  
DROP TABLE IF EXISTS QRTZ_PAUSED_TRIGGER_GRPS;  
DROP TABLE IF EXISTS QRTZ_SCHEDULER_STATE;  
DROP TABLE IF EXISTS QRTZ_LOCKS;  
DROP TABLE IF EXISTS QRTZ_SIMPLE_TRIGGERS;  
DROP TABLE IF EXISTS QRTZ_SIMPROP_TRIGGERS;  
DROP TABLE IF EXISTS QRTZ_CRON_TRIGGERS;  
DROP TABLE IF EXISTS QRTZ_BLOB_TRIGGERS;  
DROP TABLE IF EXISTS QRTZ_TRIGGERS;  
DROP TABLE IF EXISTS QRTZ_JOB_DETAILS;  
DROP TABLE IF EXISTS QRTZ_CALENDARS;  
  
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) 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 NULL,  
PRIMARY KEY (SCHED_NAME,JOB_NAME,JOB_GROUP))  
ENGINE=InnoDB;  
  
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) NULL,  
NEXT_FIRE_TIME BIGINT(13) NULL,  
PREV_FIRE_TIME BIGINT(13) NULL,  
PRIORITY INTEGER NULL,  
TRIGGER_STATE VARCHAR(16) NOT NULL,  
TRIGGER_TYPE VARCHAR(8) NOT NULL,  
START_TIME BIGINT(13) NOT NULL,  
END_TIME BIGINT(13) NULL,  
CALENDAR_NAME VARCHAR(200) NULL,  
MISFIRE_INSTR SMALLINT(2) NULL,  
JOB_DATA BLOB NULL,  
PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),  
FOREIGN KEY (SCHED_NAME,JOB_NAME,JOB_GROUP)  
REFERENCES QRTZ_JOB_DETAILS(SCHED_NAME,JOB_NAME,JOB_GROUP))  
ENGINE=InnoDB;  
  
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),  
FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)  
REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))  
ENGINE=InnoDB;  
  
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),  
PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),  
FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)  
REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))  
ENGINE=InnoDB;  
  
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) NULL,  
    STR_PROP_2 VARCHAR(512) NULL,  
    STR_PROP_3 VARCHAR(512) NULL,  
    INT_PROP_1 INT NULL,  
    INT_PROP_2 INT NULL,  
    LONG_PROP_1 BIGINT NULL,  
    LONG_PROP_2 BIGINT NULL,  
    DEC_PROP_1 NUMERIC(13,4) NULL,  
    DEC_PROP_2 NUMERIC(13,4) NULL,  
    BOOL_PROP_1 VARCHAR(1) NULL,  
    BOOL_PROP_2 VARCHAR(1) NULL,  
    PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),  
    FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)   
    REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))  
ENGINE=InnoDB;  
  
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 NULL,  
PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),  
INDEX (SCHED_NAME,TRIGGER_NAME, TRIGGER_GROUP),  
FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)  
REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))  
ENGINE=InnoDB;  
  
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;  
  
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;  
  
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 INTEGER NOT NULL,  
STATE VARCHAR(16) NOT NULL,  
JOB_NAME VARCHAR(200) NULL,  
JOB_GROUP VARCHAR(200) NULL,  
IS_NONCONCURRENT VARCHAR(1) NULL,  
REQUESTS_RECOVERY VARCHAR(1) NULL,  
PRIMARY KEY (SCHED_NAME,ENTRY_ID))  
ENGINE=InnoDB;  
  
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;  
  
CREATE TABLE QRTZ_LOCKS (  
SCHED_NAME VARCHAR(120) NOT NULL,  
LOCK_NAME VARCHAR(40) NOT NULL,  
PRIMARY KEY (SCHED_NAME,LOCK_NAME))  
ENGINE=InnoDB;  
  
CREATE INDEX IDX_QRTZ_J_REQ_RECOVERY ON QRTZ_JOB_DETAILS(SCHED_NAME,REQUESTS_RECOVERY);  
CREATE INDEX IDX_QRTZ_J_GRP ON QRTZ_JOB_DETAILS(SCHED_NAME,JOB_GROUP);  
  
CREATE INDEX IDX_QRTZ_T_J ON QRTZ_TRIGGERS(SCHED_NAME,JOB_NAME,JOB_GROUP);  
CREATE INDEX IDX_QRTZ_T_JG ON QRTZ_TRIGGERS(SCHED_NAME,JOB_GROUP);  
CREATE INDEX IDX_QRTZ_T_C ON QRTZ_TRIGGERS(SCHED_NAME,CALENDAR_NAME);  
CREATE INDEX IDX_QRTZ_T_G ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_GROUP);  
CREATE INDEX IDX_QRTZ_T_STATE ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_STATE);  
CREATE INDEX IDX_QRTZ_T_N_STATE ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP,TRIGGER_STATE);  
CREATE INDEX IDX_QRTZ_T_N_G_STATE ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_GROUP,TRIGGER_STATE);  
CREATE INDEX IDX_QRTZ_T_NEXT_FIRE_TIME ON QRTZ_TRIGGERS(SCHED_NAME,NEXT_FIRE_TIME);  
CREATE INDEX IDX_QRTZ_T_NFT_ST ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_STATE,NEXT_FIRE_TIME);  
CREATE INDEX IDX_QRTZ_T_NFT_MISFIRE ON QRTZ_TRIGGERS(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME);  
CREATE INDEX IDX_QRTZ_T_NFT_ST_MISFIRE ON QRTZ_TRIGGERS(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME,TRIGGER_STATE);  
CREATE INDEX IDX_QRTZ_T_NFT_ST_MISFIRE_GRP ON QRTZ_TRIGGERS(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME,TRIGGER_GROUP,TRIGGER_STATE);  
  
CREATE INDEX IDX_QRTZ_FT_TRIG_INST_NAME ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,INSTANCE_NAME);  
CREATE INDEX IDX_QRTZ_FT_INST_JOB_REQ_RCVRY ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,INSTANCE_NAME,REQUESTS_RECOVERY);  
CREATE INDEX IDX_QRTZ_FT_J_G ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,JOB_NAME,JOB_GROUP);  
CREATE INDEX IDX_QRTZ_FT_JG ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,JOB_GROUP);  
CREATE INDEX IDX_QRTZ_FT_T_G ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP);  
CREATE INDEX IDX_QRTZ_FT_TG ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,TRIGGER_GROUP);  
  
commit;

Oracle 如下： 

delete from qrtz_fired_triggers;  
delete from qrtz_simple_triggers;  
delete from qrtz_simprop_triggers;  
delete from qrtz_cron_triggers;  
delete from qrtz_blob_triggers;  
delete from qrtz_triggers;  
delete from qrtz_job_details;  
delete from qrtz_calendars;  
delete from qrtz_paused_trigger_grps;  
delete from qrtz_locks;  
delete from qrtz_scheduler_state;  
  
drop table qrtz_calendars;  
drop table qrtz_fired_triggers;  
drop table qrtz_blob_triggers;  
drop table qrtz_cron_triggers;  
drop table qrtz_simple_triggers;  
drop table qrtz_simprop_triggers;  
drop table qrtz_triggers;  
drop table qrtz_job_details;  
drop table qrtz_paused_trigger_grps;  
drop table qrtz_locks;  
drop table qrtz_scheduler_state;  
  
-- 存储每一个已配置的 Job 的详细信息  
CREATE TABLE qrtz_job_details  
  (  
    SCHED_NAME VARCHAR2(120) NOT NULL,  
    JOB_NAME  VARCHAR2(200) NOT NULL,  
    JOB_GROUP VARCHAR2(200) NOT NULL,  
    DESCRIPTION VARCHAR2(250) NULL,  
    JOB_CLASS_NAME   VARCHAR2(250) NOT NULL,   
    IS_DURABLE VARCHAR2(1) NOT NULL,  
    IS_NONCONCURRENT VARCHAR2(1) NOT NULL,  
    IS_UPDATE_DATA VARCHAR2(1) NOT NULL,  
    REQUESTS_RECOVERY VARCHAR2(1) NOT NULL,  
    JOB_DATA BLOB NULL,  
    CONSTRAINT QRTZ_JOB_DETAILS_PK PRIMARY KEY (SCHED_NAME,JOB_NAME,JOB_GROUP)  
);  
--  存储已配置的 Trigger 的信息  
CREATE TABLE qrtz_triggers  
  (  
    SCHED_NAME VARCHAR2(120) NOT NULL,  
    TRIGGER_NAME VARCHAR2(200) NOT NULL,  
    TRIGGER_GROUP VARCHAR2(200) NOT NULL,  
    JOB_NAME  VARCHAR2(200) NOT NULL,   
    JOB_GROUP VARCHAR2(200) NOT NULL,  
    DESCRIPTION VARCHAR2(250) NULL,  
    NEXT_FIRE_TIME NUMBER(13) NULL,  
    PREV_FIRE_TIME NUMBER(13) NULL,  
    PRIORITY NUMBER(13) NULL,  
    TRIGGER_STATE VARCHAR2(16) NOT NULL,  
    TRIGGER_TYPE VARCHAR2(8) NOT NULL,  
    START_TIME NUMBER(13) NOT NULL,  
    END_TIME NUMBER(13) NULL,  
    CALENDAR_NAME VARCHAR2(200) NULL,  
    MISFIRE_INSTR NUMBER(2) NULL,  
    JOB_DATA BLOB NULL,  
    CONSTRAINT QRTZ_TRIGGERS_PK PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),  
    CONSTRAINT QRTZ_TRIGGER_TO_JOBS_FK FOREIGN KEY (SCHED_NAME,JOB_NAME,JOB_GROUP)   
      REFERENCES QRTZ_JOB_DETAILS(SCHED_NAME,JOB_NAME,JOB_GROUP)   
);  
-- 存储简单的 Trigger，包括重复次数，间隔，以及已触的次数  
CREATE TABLE qrtz_simple_triggers  
  (  
    SCHED_NAME VARCHAR2(120) NOT NULL,  
    TRIGGER_NAME VARCHAR2(200) NOT NULL,  
    TRIGGER_GROUP VARCHAR2(200) NOT NULL,  
    REPEAT_COUNT NUMBER(7) NOT NULL,  
    REPEAT_INTERVAL NUMBER(12) NOT NULL,  
    TIMES_TRIGGERED NUMBER(10) NOT NULL,  
    CONSTRAINT QRTZ_SIMPLE_TRIG_PK PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),  
    CONSTRAINT QRTZ_SIMPLE_TRIG_TO_TRIG_FK FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)   
  REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)  
);  
-- 存储 Cron Trigger，包括 Cron 表达式和时区信息  
CREATE TABLE qrtz_cron_triggers  
  (  
    SCHED_NAME VARCHAR2(120) NOT NULL,  
    TRIGGER_NAME VARCHAR2(200) NOT NULL,  
    TRIGGER_GROUP VARCHAR2(200) NOT NULL,  
    CRON_EXPRESSION VARCHAR2(120) NOT NULL,  
    TIME_ZONE_ID VARCHAR2(80),  
    CONSTRAINT QRTZ_CRON_TRIG_PK PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),  
    CONSTRAINT QRTZ_CRON_TRIG_TO_TRIG_FK FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)   
      REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)  
);  
CREATE TABLE qrtz_simprop_triggers  
  (            
    SCHED_NAME VARCHAR2(120) NOT NULL,  
    TRIGGER_NAME VARCHAR2(200) NOT NULL,  
    TRIGGER_GROUP VARCHAR2(200) NOT NULL,  
    STR_PROP_1 VARCHAR2(512) NULL,  
    STR_PROP_2 VARCHAR2(512) NULL,  
    STR_PROP_3 VARCHAR2(512) NULL,  
    INT_PROP_1 NUMBER(10) NULL,  
    INT_PROP_2 NUMBER(10) NULL,  
    LONG_PROP_1 NUMBER(13) NULL,  
    LONG_PROP_2 NUMBER(13) NULL,  
    DEC_PROP_1 NUMERIC(13,4) NULL,  
    DEC_PROP_2 NUMERIC(13,4) NULL,  
    BOOL_PROP_1 VARCHAR2(1) NULL,  
    BOOL_PROP_2 VARCHAR2(1) NULL,  
    CONSTRAINT QRTZ_SIMPROP_TRIG_PK PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),  
    CONSTRAINT QRTZ_SIMPROP_TRIG_TO_TRIG_FK FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)   
      REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)  
);  
-- Trigger 作为 Blob 类型存储(用于 Quartz 用户用 JDBC 创建他们自己定制的 Trigger 类型，<span style="color:#800080;">JobStore</span> 并不知道如何存储实例的时候)  
CREATE TABLE qrtz_blob_triggers  
  (  
    SCHED_NAME VARCHAR2(120) NOT NULL,  
    TRIGGER_NAME VARCHAR2(200) NOT NULL,  
    TRIGGER_GROUP VARCHAR2(200) NOT NULL,  
    BLOB_DATA BLOB NULL,  
    CONSTRAINT QRTZ_BLOB_TRIG_PK PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),  
    CONSTRAINT QRTZ_BLOB_TRIG_TO_TRIG_FK FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)   
        REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)  
);  
-- 以 Blob 类型存储 Quartz 的 Calendar 信息  
CREATE TABLE qrtz_calendars  
  (  
    SCHED_NAME VARCHAR2(120) NOT NULL,  
    CALENDAR_NAME  VARCHAR2(200) NOT NULL,   
    CALENDAR BLOB NOT NULL,  
    CONSTRAINT QRTZ_CALENDARS_PK PRIMARY KEY (SCHED_NAME,CALENDAR_NAME)  
);  
-- 存储已暂停的 Trigger 组的信息   
CREATE TABLE qrtz_paused_trigger_grps  
  (  
    SCHED_NAME VARCHAR2(120) NOT NULL,  
    TRIGGER_GROUP  VARCHAR2(200) NOT NULL,   
    CONSTRAINT QRTZ_PAUSED_TRIG_GRPS_PK PRIMARY KEY (SCHED_NAME,TRIGGER_GROUP)  
);  
-- 存储与已触发的 Trigger 相关的状态信息，以及相联 Job 的执行信息  
CREATE TABLE qrtz_fired_triggers   
  (  
    SCHED_NAME VARCHAR2(120) NOT NULL,  
    ENTRY_ID VARCHAR2(95) NOT NULL,  
    TRIGGER_NAME VARCHAR2(200) NOT NULL,  
    TRIGGER_GROUP VARCHAR2(200) NOT NULL,  
    INSTANCE_NAME VARCHAR2(200) NOT NULL,  
    FIRED_TIME NUMBER(13) NOT NULL,  
    SCHED_TIME NUMBER(13) NOT NULL,  
    PRIORITY NUMBER(13) NOT NULL,  
    STATE VARCHAR2(16) NOT NULL,  
    JOB_NAME VARCHAR2(200) NULL,  
    JOB_GROUP VARCHAR2(200) NULL,  
    IS_NONCONCURRENT VARCHAR2(1) NULL,  
    REQUESTS_RECOVERY VARCHAR2(1) NULL,  
    CONSTRAINT QRTZ_FIRED_TRIGGER_PK PRIMARY KEY (SCHED_NAME,ENTRY_ID)  
);  
-- 存储少量的有关 Scheduler 的状态信息，和别的 Scheduler 实例(假如是用于一个集群中)  
CREATE TABLE qrtz_scheduler_state   
  (  
    SCHED_NAME VARCHAR2(120) NOT NULL,  
    INSTANCE_NAME VARCHAR2(200) NOT NULL,  
    LAST_CHECKIN_TIME NUMBER(13) NOT NULL,  
    CHECKIN_INTERVAL NUMBER(13) NOT NULL,  
    CONSTRAINT QRTZ_SCHEDULER_STATE_PK PRIMARY KEY (SCHED_NAME,INSTANCE_NAME)  
);  
-- 存储程序的悲观锁的信息(假如使用了悲观锁)  
CREATE TABLE qrtz_locks  
  (  
    SCHED_NAME VARCHAR2(120) NOT NULL,  
    LOCK_NAME  VARCHAR2(40) NOT NULL,   
    CONSTRAINT QRTZ_LOCKS_PK PRIMARY KEY (SCHED_NAME,LOCK_NAME)  
);  
  
create index idx_qrtz_j_req_recovery on qrtz_job_details(SCHED_NAME,REQUESTS_RECOVERY);  
create index idx_qrtz_j_grp on qrtz_job_details(SCHED_NAME,JOB_GROUP);  
  
create index idx_qrtz_t_j on qrtz_triggers(SCHED_NAME,JOB_NAME,JOB_GROUP);  
create index idx_qrtz_t_jg on qrtz_triggers(SCHED_NAME,JOB_GROUP);  
create index idx_qrtz_t_c on qrtz_triggers(SCHED_NAME,CALENDAR_NAME);  
create index idx_qrtz_t_g on qrtz_triggers(SCHED_NAME,TRIGGER_GROUP);  
create index idx_qrtz_t_state on qrtz_triggers(SCHED_NAME,TRIGGER_STATE);  
create index idx_qrtz_t_n_state on qrtz_triggers(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP,TRIGGER_STATE);  
create index idx_qrtz_t_n_g_state on qrtz_triggers(SCHED_NAME,TRIGGER_GROUP,TRIGGER_STATE);  
create index idx_qrtz_t_next_fire_time on qrtz_triggers(SCHED_NAME,NEXT_FIRE_TIME);  
create index idx_qrtz_t_nft_st on qrtz_triggers(SCHED_NAME,TRIGGER_STATE,NEXT_FIRE_TIME);  
create index idx_qrtz_t_nft_misfire on qrtz_triggers(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME);  
create index idx_qrtz_t_nft_st_misfire on qrtz_triggers(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME,TRIGGER_STATE);  
create index idx_qrtz_t_nft_st_misfire_grp on qrtz_triggers(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME,TRIGGER_GROUP,TRIGGER_STATE);  
  
create index idx_qrtz_ft_trig_inst_name on qrtz_fired_triggers(SCHED_NAME,INSTANCE_NAME);  
create index idx_qrtz_ft_inst_job_req_rcvry on qrtz_fired_triggers(SCHED_NAME,INSTANCE_NAME,REQUESTS_RECOVERY);  
create index idx_qrtz_ft_j_g on qrtz_fired_triggers(SCHED_NAME,JOB_NAME,JOB_GROUP);  
create index idx_qrtz_ft_jg on qrtz_fired_triggers(SCHED_NAME,JOB_GROUP);  
create index idx_qrtz_ft_t_g on qrtz_fired_triggers(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP);  
create index idx_qrtz_ft_tg on qrtz_fired_triggers(SCHED_NAME,TRIGGER_GROUP);


鲨鱼也是鱼
关注
专栏目录
【Quartz】任务调度Quartz从入门到入土(史上最详细)
德仔
11-14 946
GitHub:Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目quartz是一个用java实现的开源任务调度框架，可以用来创建简单或者复杂的任务调度，并且可以提供许多企业级的功能，比如JTA以及集群等，是当今比较流行的JAVA任务调度框架。现在也移植到NET,支持.NET。引用官网的一段话jobs大概意思：quartz是一个功能丰富的开源的任务调用系统，它可以创建简单或者复杂的几十、几百、甚至成千上万的job。
开发知识点-分布式微服务技术栈 SpringCloud
最新发布
aming小老弟
10-19 2669
分布式架构的一种把服务进行 拆分springcloud 解决了 服务拆分过程中的 治理问题与单体应用 进行区分（单体架构 把业务所有功能集中开发，打成一个包部署）每个模块独立开发和部署（服务集群）服务之间互相调用出现分布式技术WebserviceESBHessionDubbo异步通信 消息队列（秒杀）敏捷开发思想高内聚低耦合微服务 + 持续集成。
Spring4+Quartz2集群动态创建任务
周江霄
08-29 9487
公司最近需要使用Quartz集群来实现任务的动态创建和删除，之前自己只是用过配置好的单机版的，而且是定时 执行的任务，正好借这个机会深入学习一下Quartz。      在正式开始之前，我们先来了解下，spring3.1以下的版本必须使用quartz1.x系列，3.1以上的版本才支持quartz 2.x，不然会出错。至于原因，则是spring对于quartz的支持实现，org.springfr
Spring 3整合Quartz 2实现定时任务一：常规整合
iteye_19426的博客
02-04 126
http://www.meiriyouke.net/?p=82 最近工作中需要用到定时任务的功能，虽然Spring3也自带了一个轻量级的定时任务实现，但感觉不够灵活，功能也不够强大。在考虑之后，决定整合更为专业的Quartz来实现定时任务功能。 首先，当然是添加依赖的jar文件，我的项目是maven管理的，以下的我项目的依赖： org.spri...
Spring4集成Quartz2.2.3定时任务集群配置
峪幽兰 的博客
09-20 1754
Quartz与Spring集成及集群环境配置 Quartz介绍 Quartz是一个开源项目，专注于任务调度器，它可以与J2EE应用程序相结合也可以单独使用。简单的使用方法创建一个实现org.quartz.Job接口的java类，实现Job接口包含的唯一方法：execute()。将定时任务逻辑添加到execute()方法中。 当在集群环境下，当有配置Quartz多个客户端（节点）时，采用Quar...
Quartz2集群
实践出真知
09-20 1004
使用spring4.0.6 和 quartz 2.2.3 集群示例
Spring 4.0 下Quartz 配置
siluntan的专栏
08-27 992
Caused by: java.lang.IncompatibleClassChangeError: class org.springframework.scheduling.quartz.CronTriggerBean has interface org.quartz.CronTrigger as super class
Java基于SpringBoot的牛客网社区项目实现详解（下）
weixin_48610702的博客
05-07 7144
Java基于SpringBoot的牛客网社区项目实现详解（下） 上传篇幅有限，因此分为上下两部分，完整从零介绍牛客网项目的创建。不涉及到代码层面，仅介绍搭建逻辑过程。 文章目录Java基于SpringBoot的牛客网社区项目实现详解（下）十一、Kafka消息队列1. 阻塞队列2. Kafka入门3. Spring整合Kafka4. 发布系统通知5. 显示系统通知十二、Elasticsearch 分步式搜索引擎1. ES入门2. Spring整合ES3. 开发社区搜索功能十三、权限控制2. 权限控制3. 置
这份2021Java程序员常用技术栈和工具清单，刷爆了朋友圈...
公众号-老炮说Java
02-02 7029
点击上方蓝色字体，选择“标星公众号”优质文章，第一时间送达关注公众号后台回复pay或mall获取实战项目资料+视频作为一枚Java程序员，需要掌握哪些技术和工具才能完成一个JavaWeb...
Java面试题
qq_32362489的博客
03-10 4363
目录 1... JAVA系列... 10 1.1 常用容器... 10 1.2 ArrayList 和 linkedlist 区别。ArrayList 是否会越界... 12 1.3 ArrayList 和 hashset 的区别。hashset 存的数是否有序。... 12 1.4 HashMap与HashTable的区别... 13 1.5...
用quartz做的计数器程序
11-11
用quartz做的计数器程序，规定程序在规定的时间运行，并且可以很方便的修改间隙
Spring整合quartz2.2.3总结，quartz动态定时任务，Quartz定时任务集群配置
04-30
NULL 博文链接：https://fanshuyao.iteye.com/blog/2392350
Spring4 quartz job xml configuration
sunxboy的专栏
11-11 111
   1. 定义job details public class NotifyJobProcessor extends JobProcessor { private static final Log LOG = LogFactory.getLog(NotifyJobProcessor.class); public NotifyJobProcessor() { ...
spring4+quartz2基本配置及应用
guoningyan_nihao的专栏
09-20 494
spring4+quartz2基本配置及应用 1、新建maven工程，添加spring4.0及quartz2.2依赖，pom.xml文件内容如下 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation=
quartz2.2.x集群环境搭建
chy2z的专栏
04-25 369
1 下载最新的quartz，下载地址：http://www.quartz-scheduler.org/2  quartz支持集群与持久化，使用数据库存储的解决方案3  解压安装包，执行数据库语句，建表文件目录        quartz-2.2.3-distribution\quartz-2.2.3\docs\dbTables\tables_mysql_innodb.sql4  数据库mysql
Spring之——quartz集群的问题及解决方案(基于Spring4.0+quartz2.2.1的集群架构)
热门推荐
冰河的专栏
10-15 1万+
特别注意一点，与Spring3.1以下版本整合必须使用Quartz1，最初我拿2.2.1的，怎么搞都报错： Caused by: org.springframework.beans.factory.CannotLoadBeanClassException: Error loading class [org.springframework.scheduling.quartz.CronTrigger
Spring4整合quartz2.2.3，quartz动态任务
蕃薯耀的博客
08-25 220
Spring4+Springmvc+quartz实现多线程动态定时调度 原创 2017年11月07日 14:44:35
chuyiyou7095的博客
11-07 221
scheduler定时调度系统是大多行业项目都需要的，传统的spring-job模式，个人感觉已经out了，因为存在很多的问题，特别是定时调度的追加、修改、删除等，需要修改xml，xml的配置生效无非是热部署灰度发布方案或者直接停止、重启服务器，完全不能做到自动启动、修复方式。 提醒：可以对...
Spring+Quartz集群部署与分布式定时任务实现
在设置Quartz集群之前，你需要在Spring配置文件中指定合适的数据库驱动代理类（如org.quartz.impl.jdbcjobstore.StdJDBCDelegate），同时确保数据库表已根据你的数据库类型和版本创建。这个过程涉及到了数据库迁移和...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值