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

系统管理员 2022-01-12 15:47 166阅读 0赞

原文地址：[https://blog.csdn.net/qq736655183/article/details/79230156][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>
    	
    
       <bean id="jobHand" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">  
          <property name="targetObject">  
            <ref bean="MyScheduler"/>  
          </property>  
          <property name="targetMethod">  
            <value>test</value>  
          </property>  
        </bean>  
     
      
        <bean id="cronTrigger"  class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">  
            <property name="jobDetail" ref="jobHand" />  
            <property name="cronExpression" value="20 54 10 * * ?" /> 
        </bean>  
      
    
        <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

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。

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

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

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

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

[https_blog.csdn.net_qq736655183_article_details_79230156]: https://blog.csdn.net/qq736655183/article/details/79230156