spring整合quartz注入service的及动态任务处理问题

本文主要写一下关于spring+quartz的用法，对于quartz基本或原理不太了解的话最好去相关文章了解一下。

ps:个人觉得，quartz和spring+quartz原本的用法还是有着天差地别，所以了解下原理，也没必要把quartz基础的用法都搞懂，实际中一般不会直接使用quartz的。

使用spring+quartz，一般都是web项目中，大多都是为了引入service完成相关业务逻辑。

但网上相关导入service都存在在各种不完整和各种问题。现在我就来整理两种方式：

方式一：直接定时

使用：定时只能写死，不能更改。用于一些不会变量的任务情况


1.设置一个任务类 StockPushTask,在类中编写自己需要实现的方法test

2.配置文件


 spring配置省略，spirng采用注解扫描方式。需要扫描mvc各层的包及此task任务类所在包


注意：要在此类中用@Component注解类和@Resource注解自己需要用到的service类    目的使此类交由spring管理，并为自己装配上所需要的service。

@Component
public class StockPushTask {

@Resource
private StockService stockService;
@Resource
private UserService userService;
private JPushUtil jPushUtil;

public void test() {
System.out.println("————清理开始执行————");
//清理电子券到期的
userService.updateVoucher();
//清理会员到期的
userService.delUsers();
System.out.println("————清理执行结束————");
}
｝

spring-quartz.xml中的配置

<!-- 任务类 -->
<bean id="MyScheduler" class="com.stock.way.app.controller.StockPushTask"></bean>

<!-- 把任务类绑定给jobDetail对象 -->
<bean id="jobHand" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
<property name="targetObject">
<ref bean="MyScheduler"/><!-- 指定具体拦截哪个定时任务 -->
</property>
<property name="targetMethod">
<value>test</value><!-- 指定要执行的类里面的哪个方法 -->
</property>
</bean>

<!-- 计划触发器，使用 CronTriggerFactoryBean。这种类型更加灵活，允许你针对特定实例选择计划方案以及将来要执行的频率。 -->
<bean id="cronTrigger"  class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
<property name="jobDetail" ref="jobHand" />
<property name="cronExpression" value="20 54 10 * * ?" />
</bean>

<!-- 把任务jobDetail对象和计划触发器绑定一起，程序便会根据计划触发器的时间执行指定任务 -->
<bean id="schedulerFactory" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
<property name="jobDetails">
<list>
<ref bean="jobHand" />
</list>
</property>

<property name="triggers">
<list>
<ref bean="cronTrigger" />
</list>
</property>
</bean>

方式二：动态定时（未结合数据库）
本文主要是关于定时中导入service的讲解，所以动态定时的实现方法并未结合数据库实现，定时只是在内存中，重启tomcat定时会清空。

1.编辑动态处理定时任务的类：

public class QuartzManager {
  private static Scheduler scheduler = (Scheduler) SpringContextUtil.getApplicationContext()
.getBean("schedulerFactory");

/**
* @Description: 添加一个定时任务
*
* @param jobName 任务名
* @param jobGroupName  任务组名
* @param triggerName 触发器名
* @param triggerGroupName 触发器组名
* @param jobClass  任务
* @param cron   时间设置，参考quartz说明文档
* @param id
*/
@SuppressWarnings({ "unchecked", "rawtypes" })
public static void addJob(String jobName, String jobGroupName,
String triggerName, String triggerGroupName, Class jobClass,String content, String cron,String id,String sendTime) {
try {
Scheduler sched = scheduler;
// 任务名，任务组，任务执行类
JobDetail jobDetail= JobBuilder.newJob(jobClass).withIdentity(jobName, jobGroupName)
.usingJobData("content", content).usingJobData("messageId", id)
.usingJobData("sendTime", sendTime).build();

// 触发器
TriggerBuilder<Trigger> triggerBuilder = TriggerBuilder.newTrigger();
// 触发器名,触发器组
triggerBuilder.withIdentity(triggerName, triggerGroupName);
triggerBuilder.startNow();
// 触发器时间设定
triggerBuilder.withSchedule(CronScheduleBuilder.cronSchedule(cron));
// 创建Trigger对象
CronTrigger trigger = (CronTrigger) triggerBuilder.build();

// 调度容器设置JobDetail和Trigger
sched.scheduleJob(jobDetail, trigger);

// 启动
if (!sched.isShutdown()) {
sched.start();
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}

/**
* @Description: 修改一个任务的触发时间
*
* @param jobName
* @param jobGroupName
* @param triggerName 触发器名
* @param triggerGroupName 触发器组名
* @param cron   时间设置，参考quartz说明文档
*/
public static void modifyJobTime(String jobName,
String jobGroupName, String triggerName, String triggerGroupName, String cron) {
try {
Scheduler sched = scheduler;
TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, triggerGroupName);
CronTrigger trigger = (CronTrigger) sched.getTrigger(triggerKey);
if (trigger == null) {
return;
}

String oldTime = trigger.getCronExpression();
if (!oldTime.equalsIgnoreCase(cron)) {
/** 方式一 ：调用 rescheduleJob 开始 */
// 触发器
TriggerBuilder<Trigger> triggerBuilder = TriggerBuilder.newTrigger();
// 触发器名,触发器组
triggerBuilder.withIdentity(triggerName, triggerGroupName);
triggerBuilder.startNow();
// 触发器时间设定
triggerBuilder.withSchedule(CronScheduleBuilder.cronSchedule(cron));
// 创建Trigger对象
trigger = (CronTrigger) triggerBuilder.build();
// 方式一 ：修改一个任务的触发时间
sched.rescheduleJob(triggerKey, trigger);
/** 方式一 ：调用 rescheduleJob 结束 */

/** 方式二：先删除，然后在创建一个新的Job  */
//JobDetail jobDetail = sched.getJobDetail(JobKey.jobKey(jobName, jobGroupName));
//Class<? extends Job> jobClass = jobDetail.getJobClass();
//removeJob(jobName, jobGroupName, triggerName, triggerGroupName);

4000
//addJob(jobName, jobGroupName, triggerName, triggerGroupName, jobClass, cron);
/** 方式二 ：先删除，然后在创建一个新的Job */
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}

/**
* @Description: 移除一个任务
*
* @param jobName
* @param jobGroupName
* @param triggerName
* @param triggerGroupName
*/
public static void removeJob(String jobName, String jobGroupName,
String triggerName, String triggerGroupName) {
try {
Scheduler sched = scheduler;

TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, triggerGroupName);

sched.pauseTrigger(triggerKey);// 停止触发器
sched.unscheduleJob(triggerKey);// 移除触发器
sched.deleteJob(JobKey.jobKey(jobName, jobGroupName));// 删除任务
} catch (Exception e) {
throw new RuntimeException(e);
}
}

/**
* @Description:启动所有定时任务
*/
public static void startJobs() {
try {
Scheduler sched = scheduler;
sched.start();
} catch (Exception e) {
throw new RuntimeException(e);
}
}

/**
* @Description:关闭所有定时任务
*/
public static void shutdownJobs() {
try {
Scheduler sched = scheduler;
if (!sched.isShutdown()) {
sched.shutdown();
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}

2.配置spring-quartz.xml

<bean id="jobFactory" class="com.stock.way.utils.quartz.JobFactory"></bean>

<bean id="schedulerFactory" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
<property name="jobFactory" ref="jobFactory" />
</bean>

3.写JobFactory类。此类是改变spirng生成scheduler对象的方法，改写后可以在生成scheduler时导入我们所需要的service

public class JobFactory extends AdaptableJobFactory {

@Autowired
private AutowireCapableBeanFactory capableBeanFactory;

@Override
protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
//调用父类的方法
Object jobInstance = super.createJobInstance(bundle);
//进行注入
capableBeanFactory.autowireBean(jobInstance);
return jobInstance;
}
}

4.写springContextUtil类，主要用于获取当前的spirng容器。获取applicationContext.

public class SpringContextUtil implements ApplicationContextAware {
// Spring应用上下文环境
private static ApplicationContext applicationContext;
/**
* 实现ApplicationContextAware接口的回调方法，设置上下文环境
*
* @param applicationContext
*/
public void setApplicationContext(ApplicationContext applicationContext) {
SpringContextUtil.applicationContext = applicationContext;
}
/**
* @return ApplicationContext
*/
public static ApplicationContext getApplicationContext() {
if(applicationContext == null) {
applicationContext = ContextLoader.getCurrentWebApplicationContext();
}
if(applicationContext == null) {
applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
}
return applicationContext;
}
/**
* 获取对象
*
* @param name
* @return Object
* @throws BeansException
*/
public static Object getBean(String name) throws BeansException {
return applicationContext.getBean(name);
}
}

注意：把springContextUtil类要放入spring中，且一定要加上lazy-init=“false”，这是bean对象的懒加载，使用到得时候才加载此bean。如果不加上，在初始化spring时，applicationContext还是加载完，所以springContextUtil根本得不到appliactionContext对象。。网上也有篇文章写动态spring+quartz，使用得就是此方式，但怎么都获取不到spring容器就是因为没加lazy-init。

<bean id="springContextUtil" class="com.stock.way.utils.SpringContextUtil" lazy-init="false"></bean>

注：关于spring+quartz注入service，网上也不少文章，但都缺胳膊少腿，所以写此文方便广大码友走出迷雾。大多都是自定义JobFactory改变spring的SchedulerFactoryBean的生成方法。

问题：确实是把spring生成[b]SchedulerFactoryBean的方法改变了，但文章都没告诉在使用时没去spring中拿这个SchedulerFactoryBean类的scheduler。所以很多人看了文章留言还是还是说拿不到service。
[/b]

如在使用时又new 出了quartz的工厂自己生产scheduler，当然不会给你注入service了。

private static Scheduler scheduler = (StdSchedulerFactory) new StdSchedulerFactory().getScheduler();