- 浏览: 981184 次
文章分类
- 全部博客 (428)
- Hadoop (2)
- HBase (1)
- ELK (1)
- ActiveMQ (13)
- Kafka (5)
- Redis (14)
- Dubbo (1)
- Memcached (5)
- Netty (56)
- Mina (34)
- NIO (51)
- JUC (53)
- Spring (13)
- Mybatis (17)
- MySQL (21)
- JDBC (12)
- C3P0 (5)
- Tomcat (13)
- SLF4J-log4j (9)
- P6Spy (4)
- Quartz (12)
- Zabbix (7)
- JAVA (9)
- Linux (15)
- HTML (9)
- Lucene (0)
- JS (2)
- WebService (1)
- Maven (4)
- Oracle&MSSQL (14)
- iText (11)
- Development Tools (8)
- UTILS (4)
- LIFE (8)
最新评论
-
Donald_Draper:
Donald_Draper 写道刘落落cici 写道能给我发一 ...
DatagramChannelImpl 解析三(多播) -
Donald_Draper:
刘落落cici 写道能给我发一份这个类的源码吗Datagram ...
DatagramChannelImpl 解析三(多播) -
lyfyouyun:
请问楼主,执行消息发送的时候,报错:Transport sch ...
ActiveMQ连接工厂、连接详解 -
ezlhq:
关于 PollArrayWrapper 状态含义猜测:参考 S ...
WindowsSelectorImpl解析一(FdMap,PollArrayWrapper) -
flyfeifei66:
打算使用xmemcache作为memcache的客户端,由于x ...
Memcached分布式客户端(Xmemcached)
在阅读以下文章之前,如果对Quartz任务调度不是很熟悉,请看以下文章
Quartz任务调度分析:http://donald-draper.iteye.com/blog/2323118
Spring与Quartz集成详解:http://donald-draper.iteye.com/blog/2323591
ThreadLocal彻底理解:http://blog.csdn.net/lufeng20/article/details/24314381/
//SchedulerAccessor
//资源加载器
//事务状态
//bean工场
//beanName设置
//应用上下文
//bean初始化
//bean销毁
//生命周期管理
//job工厂
// JobDetailAwareTrigger-Spring
总结:
Spring与Quartz的整合关键在于SchedulerFactoryBean,我们在XML中配SchedulerFactoryBean时候,如要需要任务持久化,我们需要配置datasource,配置Quartz属性(线程池, 调度器名,线程池优先级,持久化类等信息),配置jobDetails,配置触发任务trrigers(TrrigerWapper),延迟加载属性,监听器,重写属性;SchedulerFactoryBean实现了InitializingBean,在SchedulerFactoryBean属性初始化完毕,调用afterPropertiesSet方法,完成数据源,Quartz-schedulerFactory初始化,创建调度器,初始化调度器上下文,注册监听器,注册job,Trrigers。
Quartz任务调度分析:http://donald-draper.iteye.com/blog/2323118
Spring与Quartz集成详解:http://donald-draper.iteye.com/blog/2323591
ThreadLocal彻底理解:http://blog.csdn.net/lufeng20/article/details/24314381/
public class SchedulerFactoryBean extends SchedulerAccessor implements FactoryBean, BeanNameAware, ApplicationContextAware, InitializingBean, DisposableBean, SmartLifecycle { public SchedulerFactoryBean() { //Quartz的标准调度工场类 schedulerFactoryClass = org/quartz/impl/StdSchedulerFactory; jobFactorySet = false; autoStartup = true; startupDelay = 0; phase = 2147483647; exposeSchedulerInRepository = false; waitForJobsToCompleteOnShutdown = false; } //设置调度器工厂类 public void setSchedulerFactoryClass(Class schedulerFactoryClass) { Assert.isAssignable(org/quartz/SchedulerFactory, schedulerFactoryClass); this.schedulerFactoryClass = schedulerFactoryClass; } //设置调度器Name public void setSchedulerName(String schedulerName) { this.schedulerName = schedulerName; } //Quartz属性 public void setQuartzProperties(Properties quartzProperties) { this.quartzProperties = quartzProperties; } //设置任务执行器 public void setTaskExecutor(Executor taskExecutor) { this.taskExecutor = taskExecutor; } //设置beanName public void setBeanName(String name) { if(schedulerName == null) schedulerName = name; } //设置应用上下文 public void setApplicationContext(ApplicationContext applicationContext) { this.applicationContext = applicationContext; } //设置job工厂 public void setJobFactory(JobFactory jobFactory) { this.jobFactory = jobFactory; jobFactorySet = true; } public void setAutoStartup(boolean autoStartup) { this.autoStartup = autoStartup; } public void afterPropertiesSet() throws Exception { SchedulerFactory schedulerFactory; if(dataSource == null && nonTransactionalDataSource != null) dataSource = nonTransactionalDataSource; if(applicationContext != null && resourceLoader == null) resourceLoader = applicationContext; //实例化调度器工厂 schedulerFactory = (SchedulerFactory)BeanUtils.instantiateClass(schedulerFactoryClass); //初始化调度器工厂 initSchedulerFactory(schedulerFactory); if(resourceLoader != null) configTimeResourceLoaderHolder.set(resourceLoader); if(taskExecutor != null) configTimeTaskExecutorHolder.set(taskExecutor); if(dataSource != null) configTimeDataSourceHolder.set(dataSource); if(nonTransactionalDataSource != null) configTimeNonTransactionalDataSourceHolder.set(nonTransactionalDataSource); //创建调度器 scheduler = createScheduler(schedulerFactory, schedulerName); //初始化调度器上下文 populateSchedulerContext(); if(!jobFactorySet && !(scheduler instanceof RemoteScheduler)) jobFactory = new AdaptableJobFactory(); if(jobFactory != null) { if(jobFactory instanceof SchedulerContextAware) ((SchedulerContextAware)jobFactory).setSchedulerContext(scheduler.getContext()); //设置调度器job工厂类 scheduler.setJobFactory(jobFactory); } if(resourceLoader != null) configTimeResourceLoaderHolder.remove(); if(taskExecutor != null) configTimeTaskExecutorHolder.remove(); if(dataSource != null) configTimeDataSourceHolder.remove(); if(nonTransactionalDataSource != null) configTimeNonTransactionalDataSourceHolder.remove(); break MISSING_BLOCK_LABEL_334; if(resourceLoader != null) configTimeResourceLoaderHolder.remove(); if(taskExecutor != null) configTimeTaskExecutorHolder.remove(); if(dataSource != null) configTimeDataSourceHolder.remove(); if(nonTransactionalDataSource != null) configTimeNonTransactionalDataSourceHolder.remove(); //注册监听器 registerListeners(); //注册job&Trriger registerJobsAndTriggers(); return; } //初始化调度工厂类 private void initSchedulerFactory(SchedulerFactory schedulerFactory) throws SchedulerException, IOException { //判断标准调度工厂的属性是否完整 if(!(schedulerFactory instanceof StdSchedulerFactory)) if(configLocation != null || quartzProperties != null || taskExecutor != null || dataSource != null) throw new IllegalArgumentException((new StringBuilder()).append("StdSchedulerFactory required for applying Quartz properties: ").append(schedulerFactory).toString()); Properties mergedProps = new Properties(); if(resourceLoader != null) //设置classLoadHelper类 mergedProps.setProperty("org.quartz.scheduler.classLoadHelper.class", org/springframework/scheduling/quartz/ResourceLoaderClassLoadHelper.getName()); if(taskExecutor != null) { //设置线程池类 mergedProps.setProperty("org.quartz.threadPool.class", org/springframework/scheduling/quartz/LocalTaskExecutorThreadPool.getName()); } else { mergedProps.setProperty("org.quartz.threadPool.class", org/quartz/simpl/SimpleThreadPool.getName()); mergedProps.setProperty("org.quartz.threadPool.threadCount", Integer.toString(10)); } if(configLocation != null) { PropertiesLoaderUtils.fillProperties(mergedProps, configLocation); } //调度器工厂属性合并重组 CollectionUtils.mergePropertiesIntoMap(quartzProperties, mergedProps); if(dataSource != null) mergedProps.put("org.quartz.jobStore.class", org/springframework/scheduling/quartz/LocalDataSourceJobStore.getName()); if(schedulerName != null) mergedProps.put("org.quartz.scheduler.instanceName", schedulerName); //标准调度工厂初始化 ((StdSchedulerFactory)schedulerFactory).initialize(mergedProps); } //创建调度器 protected Scheduler createScheduler(SchedulerFactory schedulerFactory, String schedulerName) throws SchedulerException { Thread currentThread; ClassLoader threadContextClassLoader; boolean overrideClassLoader; currentThread = Thread.currentThread(); threadContextClassLoader = currentThread.getContextClassLoader(); overrideClassLoader = resourceLoader != null && !resourceLoader.getClassLoader().equals(threadContextClassLoader); if(overrideClassLoader) //如果资源加载器不为空,则设置当前线程上下文加载器 currentThread.setContextClassLoader(resourceLoader.getClassLoader()); //获取调度器仓库实例 SchedulerRepository repository = SchedulerRepository.getInstance(); Scheduler scheduler1; synchronized(repository) { //从调度器仓库寻找schedulerName的调度器 Scheduler existingScheduler = schedulerName == null ? null : repository.lookup(schedulerName); //从调度器工厂获取调度器 Scheduler newScheduler = schedulerFactory.getScheduler(); if(newScheduler == existingScheduler) throw new IllegalStateException((new StringBuilder()).append("Active Scheduler of name '").append(schedulerName).append("' already registered ").append("in Quartz SchedulerRepository. Cannot create a new Spring-managed Scheduler of the same name!").toString()); if(!exposeSchedulerInRepository) //从仓库中移除newScheduler SchedulerRepository.getInstance().remove(newScheduler.getSchedulerName()); scheduler1 = newScheduler; } if(overrideClassLoader) currentThread.setContextClassLoader(threadContextClassLoader); return scheduler1; } //初始化调度器上下文,SchedulerContext,实际上是Map private void populateSchedulerContext() throws SchedulerException { //如果schedulerContextMap不为空,则将schedulerContextMap放入调度器上下文中 if(schedulerContextMap != null) scheduler.getContext().putAll(schedulerContextMap); //如果applicationContextSchedulerContextKey不为空, //则将applicationContext放入到调度器上下文中 if(applicationContextSchedulerContextKey != null) { if(applicationContext == null) throw new IllegalStateException("SchedulerFactoryBean needs to be set up in an ApplicationContext to be able to handle an 'applicationContextSchedulerContextKey'"); scheduler.getContext().put(applicationContextSchedulerContextKey, applicationContext); } } //启动调度器 protected void startScheduler(final Scheduler scheduler, final int startupDelay) throws SchedulerException { if(startupDelay <= 0) { logger.info("Starting Quartz Scheduler now"); scheduler.start(); } else { if(logger.isInfoEnabled()) logger.info((new StringBuilder()).append("Will start Quartz Scheduler [").append(scheduler.getSchedulerName()).append("] in ").append(startupDelay).append(" seconds").toString()); Thread schedulerThread = new Thread() { public void run() { try { //如果延迟加载,则休眠startupDelay秒钟 Thread.sleep(startupDelay * 1000); } if(logger.isInfoEnabled()) logger.info((new StringBuilder()).append("Starting Quartz Scheduler now, after delay of ").append(startupDelay).append(" seconds").toString()); try { scheduler.start(); } } final int val$startupDelay; final Scheduler val$scheduler; final SchedulerFactoryBean this$0; { this.this$0 = SchedulerFactoryBean.this; startupDelay = i; scheduler = scheduler1; super(); } }; schedulerThread.setName((new StringBuilder()).append("Quartz Scheduler [").append(scheduler.getSchedulerName()).append("]").toString()); schedulerThread.setDaemon(true); schedulerThread.start(); } } public Scheduler getScheduler() { return scheduler; } //返回bean对象为Scheduler public Scheduler getObject() { return scheduler; } public Class getObjectType() { return scheduler == null ? org/quartz/Scheduler : scheduler.getClass(); } //是否是单例模式,是 public boolean isSingleton() { return true; } //启动 public void start() throws SchedulingException { if(scheduler != null) try { startScheduler(scheduler, startupDelay); } catch(SchedulerException ex) { throw new SchedulingException("Could not start Quartz Scheduler", ex); } } //关闭操作 public void stop() throws SchedulingException { if(scheduler != null) try { scheduler.standby(); } } //关闭操作 public void stop(Runnable callback) throws SchedulingException { stop(); callback.run(); } //获取调度器是否运行信息 public boolean isRunning() throws SchedulingException { if(scheduler == null) break MISSING_BLOCK_LABEL_28; return !scheduler.isInStandbyMode(); return false; } //bean销毁,关闭调度器 public void destroy() throws SchedulerException { logger.info("Shutting down Quartz Scheduler"); scheduler.shutdown(waitForJobsToCompleteOnShutdown); } public volatile Object getObject() throws Exception { return getObject(); } public static final String PROP_THREAD_COUNT = "org.quartz.threadPool.threadCount"; public static final int DEFAULT_THREAD_COUNT = 10; private static final ThreadLocal configTimeResourceLoaderHolder = new ThreadLocal(); private static final ThreadLocal configTimeTaskExecutorHolder = new ThreadLocal(); private static final ThreadLocal configTimeDataSourceHolder = new ThreadLocal(); private static final ThreadLocal configTimeNonTransactionalDataSourceHolder = new ThreadLocal(); private Class schedulerFactoryClass;//调度工厂类 private String schedulerName;//调度器名 private Resource configLocation; private Properties quartzProperties;//quartz属性 private Executor taskExecutor;//任务执行器 private DataSource dataSource;//数据源 private DataSource nonTransactionalDataSource;//无事务数据源 private Map schedulerContextMap;//调度器上下文 private ApplicationContext applicationContext;//应用上下文 private String applicationContextSchedulerContextKey; private JobFactory jobFactory;//job工厂 private boolean jobFactorySet; private boolean autoStartup; private int startupDelay;//延时加载 private int phase; private boolean exposeSchedulerInRepository;//是否将调度器存储在调度器仓库 private boolean waitForJobsToCompleteOnShutdown;//是否等job完成,才关闭调度器 private Scheduler scheduler;//调度器 }
//SchedulerAccessor
public abstract class SchedulerAccessor implements ResourceLoaderAware { public SchedulerAccessor() { overwriteExistingJobs = false; if(jobKeyClass == null && logger.isInfoEnabled()) logger.info("Spring's Quartz 1.x support is deprecated - please upgrade to Quartz 2.0+"); } protected void registerListeners() throws SchedulerException { Object target; boolean quartz2; try { //调度器获取监听管理器方法 Method getListenerManager = org/quartz/Scheduler.getMethod("getListenerManager", new Class[0]); //获取调度器监听管理器 target = ReflectionUtils.invokeMethod(getListenerManager, getScheduler()); quartz2 = true; } catch(NoSuchMethodException ex) { target = getScheduler(); quartz2 = false; } Class targetClass = target.getClass(); try { if(schedulerListeners != null) { Method addSchedulerListener = targetClass.getMethod("addSchedulerListener", new Class[] { org/quartz/SchedulerListener }); SchedulerListener aschedulerlistener[] = schedulerListeners; int k = aschedulerlistener.length; for(int l1 = 0; l1 < k; l1++) { SchedulerListener listener = aschedulerlistener[l1]; //添加调度器监听器 ReflectionUtils.invokeMethod(addSchedulerListener, target, new Object[] { listener }); } } //添加全局job监听器 if(globalJobListeners != null) { Method addJobListener; if(quartz2) //添加job监听器方法 addJobListener = targetClass.getMethod("addJobListener", new Class[] { org/quartz/JobListener, java/util/List }); else //添加全局job监听器方法 addJobListener = targetClass.getMethod("addGlobalJobListener", new Class[] { org/quartz/JobListener }); JobListener ajoblistener1[] = globalJobListeners; int l = ajoblistener1.length; for(int i2 = 0; i2 < l; i2++) { JobListener listener = ajoblistener1[i2]; if(quartz2) { List emptyMatchers = new LinkedList(); //添加job监听器 ReflectionUtils.invokeMethod(addJobListener, target, new Object[] { listener, emptyMatchers }); } else { //添加全局job监听器 ReflectionUtils.invokeMethod(addJobListener, target, new Object[] { listener }); } } } if(jobListeners != null) { JobListener ajoblistener[] = jobListeners; int i = ajoblistener.length; for(int i1 = 0; i1 < i; i1++) { JobListener listener = ajoblistener[i1]; if(quartz2) throw new IllegalStateException("Non-global JobListeners not supported on Quartz 2 - manually register a Matcher against the Quartz ListenerManager instead"); //添加job监听器 getScheduler().addJobListener(listener); } } //添加全局触发器监听器 if(globalTriggerListeners != null) { Method addTriggerListener; if(quartz2) //添加触发器监听器方法 addTriggerListener = targetClass.getMethod("addTriggerListener", new Class[] { org/quartz/TriggerListener, java/util/List }); else //添加全局触发器监听器方法 addTriggerListener = targetClass.getMethod("addGlobalTriggerListener", new Class[] { org/quartz/TriggerListener }); TriggerListener atriggerlistener1[] = globalTriggerListeners; int j1 = atriggerlistener1.length; for(int j2 = 0; j2 < j1; j2++) { TriggerListener listener = atriggerlistener1[j2]; if(quartz2) { List emptyMatchers = new LinkedList(); //添加触发器监听器 ReflectionUtils.invokeMethod(addTriggerListener, target, new Object[] { listener, emptyMatchers }); } else { //添加全局触发器监听器 ReflectionUtils.invokeMethod(addTriggerListener, target, new Object[] { listener }); } } } if(triggerListeners != null) { TriggerListener atriggerlistener[] = triggerListeners; int j = atriggerlistener.length; for(int k1 = 0; k1 < j; k1++) { TriggerListener listener = atriggerlistener[k1]; if(quartz2) throw new IllegalStateException("Non-global TriggerListeners not supported on Quartz 2 - manually register a Matcher against the Quartz ListenerManager instead"); //添加触发器监听器 getScheduler().addTriggerListener(listener); } } } catch(NoSuchMethodException ex) { throw new IllegalStateException((new StringBuilder()).append("Expected Quartz API not present: ").append(ex).toString()); } } //添加job和trriger protected void registerJobsAndTriggers() throws SchedulerException { TransactionStatus transactionStatus = null; if(transactionManager != null) transactionStatus = transactionManager.getTransaction(new DefaultTransactionDefinition()); try { if(jobSchedulingDataLocations != null) { ClassLoadHelper clh = new ResourceLoaderClassLoadHelper(resourceLoader); clh.initialize(); XMLSchedulingDataProcessor dataProcessor = new XMLSchedulingDataProcessor(clh); String as[] = jobSchedulingDataLocations; int i = as.length; for(int j = 0; j < i; j++) { String location = as[j]; dataProcessor.processFileAndScheduleJobs(location, getScheduler()); } } if(jobDetails != null) { JobDetail jobDetail; //如果jobDetails不为空,则添加jobDetails到调度器 for(Iterator iterator = jobDetails.iterator(); iterator.hasNext(); addJobToScheduler(jobDetail)) jobDetail = (JobDetail)iterator.next(); } else { jobDetails = new LinkedList(); } if(calendars != null) { String calendarName; Calendar calendar; for(Iterator iterator1 = calendars.keySet().iterator(); iterator1.hasNext(); getScheduler().addCalendar(calendarName, calendar, true, true)) { calendarName = (String)iterator1.next(); calendar = (Calendar)calendars.get(calendarName); } } if(triggers != null) { //添加TrrigerWapprer触发任务到调度器 Trigger trigger; for(Iterator iterator2 = triggers.iterator(); iterator2.hasNext(); addTriggerToScheduler(trigger)) trigger = (Trigger)iterator2.next(); } } catch(Throwable ex) { if(transactionStatus != null) try { transactionManager.rollback(transactionStatus); } catch(TransactionException tex) { logger.error("Job registration exception overridden by rollback exception", ex); throw tex; } if(ex instanceof SchedulerException) throw (SchedulerException)ex; if(ex instanceof Exception) throw new SchedulerException((new StringBuilder()).append("Registration of jobs and triggers failed: ").append(ex.getMessage()).toString(), ex); else throw new SchedulerException((new StringBuilder()).append("Registration of jobs and triggers failed: ").append(ex.getMessage()).toString()); } if(transactionStatus != null) transactionManager.commit(transactionStatus); } //添加jobDetail到调度器 private boolean addJobToScheduler(JobDetail jobDetail) throws SchedulerException { if(overwriteExistingJobs || !jobDetailExists(jobDetail)) { getScheduler().addJob(jobDetail, true); return true; } else { return false; } } //添加TrrigerWapprer触发任务到调度器 private boolean addTriggerToScheduler(Trigger trigger) throws SchedulerException { boolean triggerExists = triggerExists(trigger); if(!triggerExists || overwriteExistingJobs) { JobDetail jobDetail = findJobDetail(trigger); if(jobDetail != null && !jobDetails.contains(jobDetail) && addJobToScheduler(jobDetail)) jobDetails.add(jobDetail); if(!triggerExists) try { //关键在这里,调度触发任务 getScheduler().scheduleJob(trigger); } catch(ObjectAlreadyExistsException ex) { if(logger.isDebugEnabled()) logger.debug((new StringBuilder()).append("Unexpectedly found existing trigger, assumably due to cluster race condition: ").append(ex.getMessage()).append(" - can safely be ignored").toString()); if(overwriteExistingJobs) //如果允许重写存在的job,则重新调度触发任务 rescheduleJob(trigger); } else rescheduleJob(trigger); return true; } else { return false; } } //根据trigger获取JobDetail private JobDetail findJobDetail(Trigger trigger) { if(trigger instanceof JobDetailAwareTrigger) return ((JobDetailAwareTrigger)trigger).getJobDetail(); Map jobDataMap = (Map)ReflectionUtils.invokeMethod(org/quartz/Trigger.getMethod("getJobDataMap", new Class[0]), trigger); return (JobDetail)jobDataMap.remove("jobDetail"); } //设置JobDetail public transient void setJobDetails(JobDetail jobDetails[]) { this.jobDetails = new ArrayList(Arrays.asList(jobDetails)); } //设置Trigger public transient void setTriggers(Trigger triggers[]) { this.triggers = Arrays.asList(triggers); } //设置SchedulerListener public transient void setSchedulerListeners(SchedulerListener schedulerListeners[]) { this.schedulerListeners = schedulerListeners; } protected abstract Scheduler getScheduler(); private static Class jobKeyClass; private static Class triggerKeyClass; protected final Log logger = LogFactory.getLog(getClass()); private boolean overwriteExistingJobs; private String jobSchedulingDataLocations[]; private List jobDetails; private Map calendars; private List triggers; private SchedulerListener schedulerListeners[]; private JobListener globalJobListeners[]; private JobListener jobListeners[]; private TriggerListener globalTriggerListeners[]; private TriggerListener triggerListeners[]; private PlatformTransactionManager transactionManager; protected ResourceLoader resourceLoader; static { try { jobKeyClass = ClassUtils.forName("org.quartz.JobKey", org/springframework/scheduling/quartz/SchedulerAccessor.getClassLoader()); triggerKeyClass = ClassUtils.forName("org.quartz.TriggerKey", org/springframework/scheduling/quartz/SchedulerAccessor.getClassLoader()); } } }
//资源加载器
public interface ResourceLoaderAware extends Aware { public abstract void setResourceLoader(ResourceLoader resourceloader); }
//事务状态
public interface TransactionStatus extends SavepointManager { public abstract boolean isNewTransaction(); public abstract boolean hasSavepoint(); public abstract void setRollbackOnly(); public abstract boolean isRollbackOnly(); public abstract boolean isCompleted(); }
//bean工场
public interface FactoryBean { public abstract Object getObject() throws Exception; public abstract Class getObjectType(); public abstract boolean isSingleton(); }
//beanName设置
public interface BeanNameAware extends Aware { public abstract void setBeanName(String s); }
//应用上下文
public interface ApplicationContextAware extends Aware { public abstract void setApplicationContext(ApplicationContext applicationcontext) throws BeansException; }
//bean初始化
public interface InitializingBean { public abstract void afterPropertiesSet() throws Exception; }
//bean销毁
public interface DisposableBean { public abstract void destroy() throws Exception; }
//生命周期管理
public interface SmartLifecycle extends Lifecycle, Phased { public abstract boolean isAutoStartup(); public abstract void stop(Runnable runnable); }
//job工厂
public interface JobFactory { //TriggerFiredBundle,触发任务包装类,Scheduler,调度器 public abstract Job newJob(TriggerFiredBundle triggerfiredbundle, Scheduler scheduler) throws SchedulerException; }
// JobDetailAwareTrigger-Spring
public interface JobDetailAwareTrigger { public abstract JobDetail getJobDetail(); public static final String JOB_DETAIL_KEY = "jobDetail"; }
总结:
Spring与Quartz的整合关键在于SchedulerFactoryBean,我们在XML中配SchedulerFactoryBean时候,如要需要任务持久化,我们需要配置datasource,配置Quartz属性(线程池, 调度器名,线程池优先级,持久化类等信息),配置jobDetails,配置触发任务trrigers(TrrigerWapper),延迟加载属性,监听器,重写属性;SchedulerFactoryBean实现了InitializingBean,在SchedulerFactoryBean属性初始化完毕,调用afterPropertiesSet方法,完成数据源,Quartz-schedulerFactory初始化,创建调度器,初始化调度器上下文,注册监听器,注册job,Trrigers。
发表评论
-
TreeSet在Quartz任务调度过程中的作用
2017-08-24 23:43 727红黑树详解:http://www.cnblogs.com/sk ... -
Quartz使用与Spring集成系列教程
2016-10-26 09:48 496Quartz的使用:http://donald-draper. ... -
Spring的RequestMappingHandlerMapping详解
2016-09-23 08:40 4595深刻理解IdentityHashMap:http://dona ... -
Spring-RequestMappingHandlerAdapter初始化及请求处理
2016-09-22 11:50 10573看这篇文章之前,最好先看下面这篇,以便更好的理解handler ... -
Spring+Mybatis多数据源的实现
2016-09-21 18:15 3094浅谈Spring事务隔离级别:http://www.cnblo ... -
Spring的DefaultAnnotationHandlerMapping详解
2016-09-20 08:47 5841前面我们讲解过Dispatcher ... -
Spring-DispatcherServlet请求处理
2016-09-19 15:42 1687Spring-DispatcherServlet初始化详解:h ... -
Spring-DispatcherServlet初始化详解
2016-09-19 15:03 3691Spring-DispatcherServlet请求处理:ht ... -
Spring上下文加载监听器ContextLoaderListener--源码解析
2016-09-18 18:10 4659一般在web应用配置Spring上下文如下,那么Context ... -
JobDetailFactoryBean与MethodInvokingJobDetailFactoryBean源码分析
2016-09-13 16:07 4303Spring与Quartz集成详解:http://donald ... -
Spring与Quartz集成详解
2016-09-09 17:52 2818首先这个所有的依赖包就不需要多讲了,首先下载Quazrt发布包 ... -
Quartz 任务存储JobStoreTX 持久化之RDB-源码分析
2016-09-08 18:24 2322Quartz 任务存储JobStoreTX 持久化之RDB:h ... -
Quartz 任务存储JobStoreTX 持久化之RDB
2016-09-08 11:52 2823Quartz储存方式之JDBC JobStoreTX:http ... -
Quartz任务调度源码分析
2016-09-07 13:12 3570Quartz的使用:http://donald-draper. ... -
Quartz的job调度源码分析
2016-09-06 13:03 8Quartz的使用:http://donald ... -
Quartzs的job,trriger监听器源码分析
2016-09-06 11:15 1483Quartz的使用:http://donald-draper. ... -
Quartz的job、触发器的暂停与恢复源码分析
2016-09-06 09:01 5266Quartz的使用:http://donald-draper. ... -
Quartz的Scheduler初始化源码分析
2016-09-05 16:14 3592Quartz的使用:http://donald ... -
Quartzs的job存储,触发器、job删除源码分析
2016-09-05 15:39 4550前言:unscheduleJob针对TriggerKey,而d ... -
Quartz的使用
2016-09-05 11:39 1787Quartz使用总结:http://www.cnblogs.c ...
相关推荐
在将 Spring 2 与 Quartz 整合到 Web 应用中时,主要涉及以下几个关键知识点: 1. **Spring 2 的核心概念**:Spring 2 提供了 IoC(Inversion of Control,控制反转)和 AOP(Aspect-Oriented Programming,面向切...
源码分析的过程中,我们需要注意Spring如何通过依赖注入(Dependency Injection,DI)和面向切面编程(Aspect-Oriented Programming,AOP)来实现这些功能。例如,通过`@Autowired`注解可以自动装配所需的bean,而`@...
- Spring 3.2.x 支持与各种框架的集成,如 MyBatis、Quartz、Struts 等,源码中可以看到这些集成的实现细节。 通过对 Spring Framework 3.2.x 源码的深入研究,我们可以更好地理解这个框架的工作原理,提高我们的...
**Spring与Quartz集成** Spring通过`org.springframework.scheduling.quartz`模块提供了与Quartz的集成。集成主要涉及以下几个核心组件: 1. **SchedulerFactoryBean**:这是Spring提供的一个工厂bean,用于配置和...
这个场景的应用是使用Quartz来安排任务,而Spring则提供了集成环境和邮件服务支持。 首先,Quartz是一个开源的作业调度框架,它允许开发者定义、调度和执行任务。在Java应用程序中,Quartz可以用来在特定时间执行...
2. **Spring与Quartz集成**:介绍如何在Spring应用中配置Quartz,包括使用`@EnableScheduling`注解开启调度,以及如何定义`@Scheduled`注解的任务。 3. **Cron表达式**:详细讲解Cron表达式的组成部分和语法,以及...
2. **Spring与Quartz的集成**: Spring通过`org.springframework.scheduling.quartz`包提供了对Quartz的全面支持。通过Spring的bean定义,我们可以声明式地配置Job和Trigger,避免了直接操作Quartz的API。 3. **...
本文将深入探讨Spring提供的两种定时器——`Quartz`和`Spring Task`,并进行对比分析。 首先,让我们了解`Quartz`。Quartz是一个开源的作业调度框架,它允许应用程序在指定的时间执行任务。Quartz提供了丰富的API,...
这个压缩包包含的是SSM框架与Quartz 2.2版本的集成,用于实现定时任务管理。接下来,我们将深入探讨SSM框架的各个组件以及Quartz的相关知识点。 **Spring框架** 是一个全面的、开源的应用程序框架,主要负责依赖...
Quartz是一款开源的作业调度框架,它允许程序在特定时间执行特定任务,广泛应用于各种需要自动化定时任务的场景。而Spring是Java领域中一个流行的...这是一个很好的学习资源,对于理解Quartz和Spring的集成有极大帮助。
Quartz 2.2.1 和 Spring 3.1.1 是两个在企业级Java应用开发中常用的开源框架。Quartz 是一个强大的、...通过源码分析,开发者可以更好地理解这两个框架的内部机制,从而更有效地利用它们的功能来满足特定的业务需求。
这篇博客可能探讨了如何在Spring框架中集成Quartz,以实现灵活、可扩展的任务调度。 Quartz是一个开源的作业调度框架,支持 cron 表达式和其他定时规则来安排任务。它具有强大的功能,例如并发性控制、持久化作业...
6. **源码分析**: Spring源码是学习框架设计思想和Java高级技术的好资料。通过阅读源码,可以深入了解依赖注入、AOP、事件驱动等方面的实现。 7. **文档**: 完整的文档包括用户指南、参考手册和API文档,有助于...
《Spring Boot实战派》源码提供了丰富的学习材料,旨在帮助开发者深入理解并...通过分析《Spring Boot实战派》源码,读者不仅可以了解上述技术点,还能学习到如何在实际项目中应用这些技术,提升开发效率和代码质量。
- 它也可以与其他框架集成,如Spring,提供更方便的使用方式。 7. **注意事项** - 调度任务时,应合理设计触发策略,避免过多的任务导致系统负载过高。 - 对于长时间运行的任务,要考虑任务之间的隔离,防止阻塞...
标题 "Spring Quartz" 提到的是将 Spring 框架与 Quartz 定时任务调度库集成的应用。Quartz 是一个开源的作业调度框架,允许开发者安排任务在特定时间执行,而 Spring 框架则提供了方便的依赖注入和管理组件的能力。...
7. **Spring与其它框架的整合**:如Spring与Struts、Hibernate、Quartz等的协同工作。源码中可以看到如何配置和使用这些框架,实现各组件间的无缝集成。 8. **国际化(I18N)**:Spring提供支持多语言环境的功能,...
本资源"基于Spring的Quartz动态定时任务增删改查源码.rar"提供了一套完整的示例,帮助开发者了解如何在Spring环境中集成Quartz来实现动态管理定时任务。 首先,Quartz的核心概念包括Job(任务)、Trigger(触发器)...
- 异步处理和定时任务,如使用Spring Task或Quartz。 - 错误处理和日志记录机制。 通过深入学习这个生鲜交易系统的源码,可以了解一个完整的电商应用是如何运作的,对Spring Boot框架有更深入的理解,并掌握如何...
2. **Spring与Quartz集成** - 首先,我们需要在项目中引入Quartz的相关依赖,通常通过Maven或Gradle进行管理。 - 创建`quartz.properties`配置文件,定义Quartz的运行参数,如数据库连接、job存储方式等。 - 在...