一、序言

上篇文章Java下Spring实现Quartz集群分布式（一）的spring管理配置的xml文件的解析之一，为何需要配置红色字体的属性呢？

<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 name="quartzScheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">

<property name="jobFactory">
<bean class="wade.core.interceptors.SpringBeanJobFactory"/>
</property>
<property name="dataSource">
<ref bean="dataSource"/>
</property>
<property name="configLocation" value="classpath:/conf/quartz.properties"/>
</bean>

</beans>

二、正文

1、假设我们要实现以下代码，即spring注入。

public class Task implements Job {
    @Autowired
    private AppServcie appServcie ;

    @Override
    public void execute(JobExecutionContext ctx) throws JobExecutionException {
        ...
}

2、但是Job对象的实例化过程是在Quartz中进行的，AppServcie是在Spring容器当中的，那么如何将他们关联到一起呢。好在Quartz提供了JobFactory接口，让我们可以自定义实现创建Job的逻辑。

public interface JobFactory {

    Job newJob(TriggerFiredBundle bundle, Scheduler scheduler) throws SchedulerException;

}

3、那么我们通过实现JobFactory 接口，在实例化Job以后，在通过ApplicationContext 将Job所需要的属性注入即可。在Spring与Quartz集成时用到的是org.springframework.scheduling.quartz.SchedulerFactoryBean这个类。源码如下，我们只看最关键的地方。

try {
this.scheduler = createScheduler(schedulerFactory, this.schedulerName);
populateSchedulerContext();

if (!this.jobFactorySet && !(this.scheduler instanceof RemoteScheduler)) {
// Use AdaptableJobFactory as default for a local Scheduler, unless when
// explicitly given a null value through the "jobFactory" bean property.
this.jobFactory = new AdaptableJobFactory();
}
if (this.jobFactory != null) {
if (this.jobFactory instanceof SchedulerContextAware) {
((SchedulerContextAware) this.jobFactory).setSchedulerContext(this.scheduler.getContext());
}
this.scheduler.setJobFactory(this.jobFactory);
}
}

4、其中红色标记的是重点，如果我们不指定jobFactory，那么Spring就使用AdaptableJobFactory。我们在来看一下这个类的实现。

package org.springframework.scheduling.quartz;

import java.lang.reflect.Method;

import org.quartz.Job;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.spi.JobFactory;
import org.quartz.spi.TriggerFiredBundle;

import org.springframework.util.ReflectionUtils;

public class AdaptableJobFactory implements JobFactory {

public Job newJob(TriggerFiredBundle bundle, Scheduler scheduler) throws SchedulerException {
return newJob(bundle);
}

public Job newJob(TriggerFiredBundle bundle) throws SchedulerException {
try {
Object jobObject = createJobInstance(bundle);
return adaptJob(jobObject);
}
catch (Exception ex) {
throw new SchedulerException("Job instantiation failed", ex);
}
}

protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
// Reflectively adapting to differences between Quartz 1.x and Quartz 2.0...
Method getJobDetail = bundle.getClass().getMethod("getJobDetail");
Object jobDetail = ReflectionUtils.invokeMethod(getJobDetail, bundle);
Method getJobClass = jobDetail.getClass().getMethod("getJobClass");
Class jobClass = (Class) ReflectionUtils.invokeMethod(getJobClass, jobDetail);
return jobClass.newInstance();
}

protected Job adaptJob(Object jobObject) throws Exception {
if (jobObject instanceof Job) {
return (Job) jobObject;
}
else if (jobObject instanceof Runnable) {
return new DelegatingJob((Runnable) jobObject);
}
else {
throw new IllegalArgumentException("Unable to execute job class [" + jobObject.getClass().getName() +
"]: only [org.quartz.Job] and [java.lang.Runnable] supported.");
}
}

}

5、其他的我们都不管，我们就看红色的地方，这里是创建了一个Job,那我们就在这里去给Job的属性进行注入就可以了，让我们写一个类继承它，然后复写这个方法进行对Job的注入。

package wade.core.interceptors;

import org.quartz.spi.TriggerFiredBundle;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.scheduling.quartz.AdaptableJobFactory;

/**
 * <P><B>描述:</B> 自定义SpringBeanJobFactory，用于对Job注入ApplicationContext等。 </P>
 *
 * 
 */
public class SpringBeanJobFactory extends AdaptableJobFactory {
    /**
     * The Application context.
     *
     * @see ApplicationContext
     */
    private ApplicationContext applicationContext;
    /**
     * The Capable bean factory.
     */
    @Autowired
    private AutowireCapableBeanFactory capableBeanFactory;
    /**
     * 日志记录.
     */
    private static final org.slf4j.Logger LOGGER = LoggerFactory.getLogger(SpringBeanJobFactory.class);

    @Override
    protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
        LOGGER.info("创建作业实体类");
        //调用父类的方法
        Object jobInstance = super.createJobInstance(bundle);
        //进行注入（这属于Spring的技术,不清楚的可以查看Spring的API）
        capableBeanFactory.autowireBean(jobInstance);
        return jobInstance;
    }
}

6、接着就是最开始的配置到spring里。

<property name="jobFactory">
<bean class="wade.core.interceptors.SpringBeanJobFactory"/>
</property>

Java下Spring实现Quartz集群分布式（二）

一、序言

二、正文

猜你喜欢