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

原文地址：https://blog.csdn.net/qq736655183/article/details/79230156

本文主要写一下关于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);  
                //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生成SchedulerFactoryBean的方法改变了，但文章都没告诉在使用时没去spring中拿这个SchedulerFactoryBean类的scheduler。所以很多人看了文章留言还是还是说拿不到service。

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

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