protected Object getBean(String beanName) {
	return new ClassPathXmlApplicationContext("spring.xml", "spring-mybatis.xml").getBean(beanName);
}

// testService必须在bean中扫描有
TestService testService = this.getBean("testService");	

import org.quartz.spi.TriggerFiredBundle;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.scheduling.quartz.SpringBeanJobFactory;

/**
 * 解决Spring quartz Job不能依赖注入 <br/>
 * Create Date: 3/20/18 10:09 PM <br/>
 * 
 * @author Peter Guo
 * @version 0.1
 **/
public class CustomJobFactory extends SpringBeanJobFactory {

    /**
     * slf4j日志记录
     */
    protected final Logger logger = LoggerFactory.getLogger(this.getClass());

    @Autowired
    private AutowireCapableBeanFactory capableBeanFactory;

    /**
     * 覆盖super的createJobInstance方法，对其创建出来的类再进行autowire。
     * @param bundle
     * @return
     * @throws Exception
     */
    @Override
    protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
        //调用父类的方法
        Object jobInstance = super.createJobInstance(bundle);
        logger.debug("SpringBeanJobFactory 开始注入==============================================");
        //进行注入
        capableBeanFactory.autowireBean(jobInstance);
        return jobInstance;
    }
}

<bean id="scheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean" lazy-init="false" autowire="no">
    <property name="jobFactory">
        <!-- 在job定时任务中调用service注解无效解决方案 -->
        <bean class="com.refill.base.job.CustomJobFactory"/>
    </property>
</bean>

<!-- 定时任务配置 start -->
<bean id="scheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean" lazy-init="false" autowire="no">
    <!-- 获取quartz配置文件 -->
    <property name="configLocation" value="classpath:spring-quartz.properties" />
    <property name="jobFactory">
        <!-- 在job定时任务中调用service注解无效解决方案 -->
        <bean class="com.refill.base.job.CustomJobFactory"/>
    </property>
    <!-- scheduler的名称 -->
    <property name="schedulerName" value="scheduler"/>
    <!--使用配置的数据源-->
    <property name="dataSource" ref="dataSource"/>
    <!--使用spring的事务管理-->
    <property name="transactionManager" ref="txManager"/>
    <!--可选，QuartzScheduler 启动时更新己存在的Job，这样就不用每次修改targetObject后删除qrtz_job_details表对应记录了-->
    <property name="overwriteExistingJobs" value="true" />
    <!-- 必须的，QuartzScheduler 延时启动，应用启动完后 QuartzScheduler 再启动  -->
    <property name="startupDelay" value="5" />
    <!-- 设置自动启动  -->
    <property name="autoStartup" value="true" />
    <!-- 把spring上下 文以key/value的方式存放在了quartz的上下文中了 -->
    <property name="applicationContextSchedulerContextKey" value="applicationContextKey" />
</bean>

@Autowired
private Scheduler scheduler;

<!-- 配置scheduler -->
<bean class="com.refill.basic.bean.JobBeanUtil">
    <property name="scheduler" ref="scheduler"/>
</bean>

public class JobBeanUtil {

//    @Autowired
//    private Scheduler scheduler;

    //静态
    private static Scheduler scheduler;
    public void setScheduler(Scheduler scheduler) {
        JobBeanUtil.scheduler = scheduler;
    }
}

/**
 * 获取所有任务
 *
 * @return list
 * @throws SchedulerException
 */
public static List<JobBean> getAllJobs() throws SchedulerException {
    GroupMatcher<JobKey> matcher = GroupMatcher.anyJobGroup();
    Set<JobKey> jobKeys = scheduler.getJobKeys(matcher);
    List<JobBean> jobList = new ArrayList<>();
    //一个任务可以有多个触发器
    for (JobKey jobKey : jobKeys) {
        List<? extends Trigger> triggers = scheduler.getTriggersOfJob(jobKey);
        for (Trigger trigger : triggers) {
            jobList.add(getJobBean( jobKey, trigger.getKey()));
        }
    }
    return jobList;
}

/**
* xml中spring的事务管理器
*/
@Resource(name = "txManager")
private DataSourceTransactionManager transactionManager;

/**
 * 添加单个工作
 *
 * @param jobEntity 调度实体
 * @param paramMap 在execute中获取到的参数
 * @return ResultJsonBean
 */
@Override
public ResultJsonBean saveEntity(JobEntity jobEntity, Map<String, Object> paramMap){
    if (jobDao.getEntityByJobName(jobEntity.getJobName()) != null) {
        return new ResultJsonBean(null, false, "任务名称已经存在,不要重复添加!!!!");
    }
    if (jobDao.getEntityByTriggerName(jobEntity.getJobTriggerName()) != null) {
        return new ResultJsonBean(null, false, "触发器名称已经存在,不要重复添加!!!!");
    }
    DefaultTransactionDefinition def = new DefaultTransactionDefinition();
    def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW); // 事物隔离级别，开启新事务，这样会比较安全些。
    TransactionStatus status = transactionManager.getTransaction(def); // 获得事务状态
    try {
        jobEntity.setJobTriggerStatus(JobTriggerStatusEnum.OPEN.toInt());
        QuartzUtil.addJob(scheduler, jobEntity, paramMap);
        jobDao.saveEntity(jobEntity);
        transactionManager.commit(status);
        return new ResultJsonBean(null, jobEntity, true);
    } catch (Exception e) {
        QuartzUtil.shutdownJobs(scheduler);
        transactionManager.rollback(status);
        QuartzUtil.startJobs(scheduler);
        return new ResultJsonBean(null, false, "添加计划任务失败,程序异常,请连续管理员!!!");
    }
}

/**
 * 添加单个工作
 *
 * @param jobEntity 调度实体
 * @param paramMap 在execute中获取到的参数
 * @return ResultJsonBean
 */
@Override
@Transactional(value = "txManager",propagation =Propagation.REQUIRES_NEW)
public ResultJsonBean saveEntity(JobEntity jobEntity, Map<String, Object> paramMap){
    if (jobDao.getEntityByJobName(jobEntity.getJobName()) != null) {
        return new ResultJsonBean(null, false, "任务名称已经存在,不要重复添加!!!!");
    }

    if (jobDao.getEntityByTriggerName(jobEntity.getJobTriggerName()) != null) {
        return new ResultJsonBean(null, false, "触发器名称已经存在,不要重复添加!!!!");
    }
    QuartzUtil.addJob(scheduler, jobEntity, paramMap);
    jobEntity.setJobTriggerStatus(JobTriggerStatusEnum.OPEN.toInt());
    jobDao.saveEntity(jobEntity);
    return new ResultJsonBean(null, jobEntity, true);
}