javaweb使用quartz简单整合，控制定时任务。

小灰灰 2022-01-12 02:25 182阅读 0赞

首先，可以查看这篇：[https://blog.csdn.net/qq\_36411874/article/details/93165715][https_blog.csdn.net_qq_36411874_article_details_93165715]

Javaweb也可以引入她的jar包，使用框架控制。

# （1）导入的jar包 #

包括quartz-2.3.1.jar、quartz-jobs-2.3.1.jar。，下载地址：[https://download.csdn.net/download/qq\_36411874/11251807][https_download.csdn.net_download_qq_36411874_11251807]

![20190621112750698.png][]

# （2）开始开撸写代码了 #

## （1）结构说明 ##

主要用到 SuNingGetInvoiceStartQuartzJobListener（监听任务）——SuNingInvoiceQuartzManager（管理我们的任务）——SuNingGetInvoiceJob和SuNingGetSalesReturnInvoiceJob （执行我们的任务详情），而SuNingInvoiceStart是Application如何类Start注入MyJobFactory和Scheduler。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NDExODc0_size_16_color_FFFFFF_t_70][]

（2）先处理两个任务类，也就是自己执行的逻辑。

创建job1的SuNingGetInvoiceJob：

import org.apache.commons.logging.Log;
    import org.apache.commons.logging.LogFactory;
    import org.quartz.Job;
    import org.quartz.JobExecutionContext;
    import org.quartz.JobExecutionException;
    import org.quartz.SchedulerException;
    import org.springframework.beans.factory.annotation.Autowired;
    
    import com.css.eshop.thirdparty.services.ISuNingService;
    
    
    public class SuNingGetInvoiceJob implements Job{
    	@Autowired
        private ISuNingService suNingService;
    	protected Log logger = LogFactory.getLog(this.getClass().getName());
    	
        public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {//重新execute方法
        	logger.info("--------------SuNingGetInvoiceJob的提取发票任务开始执行--------------");
            try {
                executeTask();
            } catch (SchedulerException e) {
                e.printStackTrace();
            }
            logger.info("任务执行结束了");
        }
     
        private void executeTask() throws SchedulerException {//重新executeTask方法，放入需要执行的任务。
        	logger.info("--------------suNingService.insertSuNingVoice();//执行提取开票任务--------------");
        	//suNingService.insertSuNingVoice();//执行任务，这里写自己的任务。需要执行的东西
        }
    }

创建job2的SuNingGetSalesReturnInvoiceJob：

import org.apache.commons.logging.Log;
    import org.apache.commons.logging.LogFactory;
    import org.quartz.Job;
    import org.quartz.JobExecutionContext;
    import org.quartz.JobExecutionException;
    import org.quartz.SchedulerException;
    import org.springframework.beans.factory.annotation.Autowired;
    
    import com.css.eshop.thirdparty.services.ISuNingService;
    
    
    public class SuNingGetSalesReturnInvoiceJob implements Job{
    	@Autowired
        private ISuNingService suNingService;
    	protected Log logger = LogFactory.getLog(this.getClass().getName());
    	
        public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {//重新execute方法
        	logger.info("--------------SuNingGetSalesReturnInvoiceJob的提取退货开票任务开始执行--------------");
            try {
                executeTask();
            } catch (SchedulerException e) {
                e.printStackTrace();
            }
            logger.info("SuNingGetSalesReturnInvoiceJob任务执行结束了");
        }
     
        private void executeTask() throws SchedulerException {//重新executeTask方法，放入需要执行的任务。
        	logger.info("--------------suNingService.insertSuNingVoiceReturnOfGoods();执行提取退货开票任务--------------");
        	//suNingService.insertSuNingVoiceReturnOfGoods();//执行任务，你自己的逻辑。
        }
    }

（3）创建管理Job的类，SuNingInvoiceQuartzManager：

package com.css.eshop.suning.invoice.manager;
    /* 
     * L54280_1 	huang.hui	2019/06/14      苏宁获取开票成功后台任务
    */
    import java.util.Date;
    
    import org.quartz.CronScheduleBuilder;
    import org.quartz.CronTrigger;
    import org.quartz.JobBuilder;
    import org.quartz.JobDetail;
    import org.quartz.JobKey;
    import org.quartz.Scheduler;
    import org.quartz.SchedulerException;
    import org.quartz.TriggerBuilder;
    import org.quartz.TriggerKey;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.context.annotation.Configuration;
    
    import com.css.eshop.suning.invoice.job.SuNingGetInvoiceJob;
    import com.css.eshop.suning.invoice.job.SuNingGetSalesReturnInvoiceJob;
    
    @Configuration
    public class SuNingInvoiceQuartzManager {//定义SuNingInvoiceQuartzManager管理我们的定时任务方法
    
        public static final String JOB1="job1";
        public static final String GROUP1="group1";
        /**默认每个星期凌晨一点执行*/
        //public static final String DEFAULT_CRON="0 0 1 ? * L";
        /**默认5秒执行一次*/
        public static final String DEFAULT_CRON="*/5 * * * * ?";
     
        
        //第二个任务job
        public static final String JOB2="job2";
        public static final String GROUP2="group2";
        /**
         * 任务调度
         */
        @Autowired
        private Scheduler scheduler;
     
        /**
         * 开始执行定时任务
         */
        public void startJob() throws SchedulerException {
            startJobTask(scheduler);
            scheduler.start();
        }
     
        /**
         * 启动定时任务
         * @param scheduler
         */
        private void startJobTask(Scheduler scheduler) throws SchedulerException {
            JobDetail jobDetail= JobBuilder.newJob(SuNingGetInvoiceJob.class).withIdentity(JOB1,GROUP1).build();//执行任务
            CronScheduleBuilder cronScheduleBuilder=CronScheduleBuilder.cronSchedule(DEFAULT_CRON);
            CronTrigger cronTrigger=TriggerBuilder.newTrigger().withIdentity(JOB1,GROUP1).withSchedule(cronScheduleBuilder).build();
            scheduler.scheduleJob(jobDetail,cronTrigger);
            
            JobDetail jobDetail2= JobBuilder.newJob(SuNingGetSalesReturnInvoiceJob.class).withIdentity(JOB2,GROUP2).build();//执行任务
            CronScheduleBuilder cronScheduleBuilder2 = CronScheduleBuilder.cronSchedule(DEFAULT_CRON);
            CronTrigger cronTrigger2=TriggerBuilder.newTrigger().withIdentity(JOB2,GROUP2).withSchedule(cronScheduleBuilder2).build();
            scheduler.scheduleJob(jobDetail2,cronTrigger2);
        }
        /**
         * 获取Job信息
         * @param name
         * @param group
         */
        public String getjobInfo(String name,String group) throws SchedulerException {
            TriggerKey triggerKey=new TriggerKey(name,group);
            CronTrigger cronTrigger= (CronTrigger) scheduler.getTrigger(triggerKey);
            return String.format("time:%s,state:%s",cronTrigger.getCronExpression(),
                    scheduler.getTriggerState(triggerKey).name());
        }
     
        /**
         * 修改任务的执行时间
         * @param name
         * @param group
         * @param cron cron表达式
         * @return
         * @throws SchedulerException
         */
        public boolean modifyJob(String name,String group,String cron) throws SchedulerException{
            Date date=null;
            TriggerKey triggerKey=new TriggerKey(name, group);
            CronTrigger cronTrigger= (CronTrigger) scheduler.getTrigger(triggerKey);
            String oldTime=cronTrigger.getCronExpression();
            if (!oldTime.equalsIgnoreCase(cron)){
                CronScheduleBuilder cronScheduleBuilder=CronScheduleBuilder.cronSchedule(cron);
                CronTrigger trigger=TriggerBuilder.newTrigger().withIdentity(name,group)
                        .withSchedule(cronScheduleBuilder).build();
                date=scheduler.rescheduleJob(triggerKey,trigger);
            }
            return date !=null;
        }
     
        /**
         * 暂停所有任务
         * @throws SchedulerException
         */
        public void pauseAllJob()throws SchedulerException{
            scheduler.pauseAll();
        }
     
        /**
         * 暂停某个任务
         * @param name
         * @param group
         * @throws SchedulerException
         */
        public void pauseJob(String name,String group)throws SchedulerException{
            JobKey jobKey=new JobKey(name,group);
            JobDetail jobDetail=scheduler.getJobDetail(jobKey);
            if (jobDetail==null)
                return;
            scheduler.pauseJob(jobKey);
        }
     
        /**
         * 恢复所有任务
         * @throws SchedulerException
         */
        public void resumeAllJob()throws SchedulerException{
            scheduler.resumeAll();
        }
        /**
         * 恢复某个任务
         */
        public void resumeJob(String name,String group)throws SchedulerException{
            JobKey jobKey=new JobKey(name,group);
            JobDetail jobDetail=scheduler.getJobDetail(jobKey);
            if (jobDetail==null)
                return;
            scheduler.resumeJob(jobKey);
        }
     
        /**
         * 删除某个任务
         * @param name
         * @param group
         * @throws SchedulerException
         */
        public void deleteJob(String name,String group)throws SchedulerException{
            JobKey jobKey=new JobKey(name, group);
            JobDetail jobDetail=scheduler.getJobDetail(jobKey);
            if (jobDetail==null)
                return;
            scheduler.deleteJob(jobKey);
        }
        public static void main(String[] args) {//测试功能
    		//SpringApplication.run(SuNingInvoiceStart.class, args);//springboot启动项目
        	SuNingInvoiceQuartzManager SuNingInvoiceQuartzManager = new SuNingInvoiceQuartzManager();
        	try {
    			SuNingInvoiceQuartzManager.startJob();
    		} catch (SchedulerException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    	}
    }

（4）创建SuNingGetInvoiceJobFactory

import org.quartz.spi.TriggerFiredBundle;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
    import org.springframework.scheduling.quartz.AdaptableJobFactory;
    import org.springframework.stereotype.Component;
    
    @Component
    public class SuNingGetInvoiceJobFactory  extends AdaptableJobFactory{
    	  @Autowired
    	  private AutowireCapableBeanFactory capableBeanFactory;
    
    	  @Override
    	  protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
    	     // 调用父类的方法
    	     Object jobInstance = super.createJobInstance(bundle);
    	      // 进行注入
    	     capableBeanFactory.autowireBean(jobInstance);
    	     return jobInstance;
    	 }
    }

（5）SuNingInvoiceStart，注入JobFactory和Scheduler

import org.quartz.Scheduler;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.annotation.AnnotationConfigApplicationContext;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    import org.springframework.context.support.FileSystemXmlApplicationContext;
    import org.springframework.scheduling.quartz.SchedulerFactoryBean;
    
    import com.css.eshop.suning.invoice.factory.SuNingGetInvoiceJobFactory;
    
    @Configuration
    public class SuNingInvoiceStart {
    	public static void main(String[] args) {//测试功能
    		//SpringApplication.run(SuNingInvoiceStart.class, args);//springboot启动项目
    		//ApplicationContext context = new FileSystemXmlApplicationContext("d://spring-config.xml");
    	}
     
    	@Autowired
    	private SuNingGetInvoiceJobFactory suNingGetInvoiceJobFactory;//
     
    	@Bean
    	public SchedulerFactoryBean schedulerFactoryBean() {
    		SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean();
    		schedulerFactoryBean.setJobFactory(suNingGetInvoiceJobFactory);
    		System.out.println("myJobFactory:"+suNingGetInvoiceJobFactory);
    		return schedulerFactoryBean;
    	}
    	@Bean
    	public Scheduler scheduler() {
    		return schedulerFactoryBean().getScheduler();
    	}
    
    }

（6）创建监听类SuNingGetInvoiceStartQuartzJobListener，监听任务

import org.apache.commons.logging.Log;
    import org.apache.commons.logging.LogFactory;
    import org.quartz.Scheduler;
    import org.quartz.SchedulerException;
    import org.quartz.SchedulerFactory;
    import org.quartz.impl.StdSchedulerFactory;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.context.ApplicationListener;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.context.event.ContextRefreshedEvent;
    
    import com.css.eshop.suning.invoice.manager.SuNingInvoiceQuartzManager;
    
    @Configuration  //关闭监听器
    public class SuNingGetInvoiceStartQuartzJobListener  implements ApplicationListener<ContextRefreshedEvent>{//使用quartz动态实现定时任务！
    	 @Autowired
    	 private SuNingInvoiceQuartzManager suNingInvoiceQuartzManager;//苏宁发票管理类
    	 protected Log logger = LogFactory.getLog(this.getClass().getName());//打印日志
    	 
    	 @Override
    	 public void onApplicationEvent(ContextRefreshedEvent contextRefreshedEvent) {
    		 try {
    			 suNingInvoiceQuartzManager.startJob();//启动任务
    			 logger.info("任务已经启动......");
    	     } catch (SchedulerException e) {
    	            e.printStackTrace();
    	        }
    	    }
    	    /**
    	     * 初始注入scheduler
    	     */
    	    @Bean
    	    public Scheduler scheduler() throws SchedulerException{
    	      SchedulerFactory schedulerFactoryBean = new StdSchedulerFactory();
    	      return schedulerFactoryBean.getScheduler();
    	  }
    }

（7）启动任务，自动注入开启方法了，在前端页面给个页面的组件按钮，控制是否开启、停止、或者开启指定的任务。管理使用SuNingInvoiceQuartzManager去控制即可。（如果没有启动起来，请检查你的类是否写好了@Component等注释）

例，在controller中这样，某个组件触发的方法：

/**
    		 * 重置查询条件
    		 * */
    		public void resetAction(){
    	
    			try {
    		
    				SuNingInvoiceQuartzManager quartzManager = SpringContextUtil.getBean(SuNingInvoiceQuartzManager.class); 
    				 String cron="*/10 * * * * ?";
    				 //quartzManager.pauseJob(quartzManager.JOB1,quartzManager.GROUP1);
    				 /*  quartzManager.modifyJob(quartzManager.JOB1,quartzManager.GROUP1,cron);	*/
    			     quartzManager.pauseAllJob();//停止所有后台任务，在tomcat启动时候就会自动监听启动任务，可以手动操作控制。
    			} catch (Exception e) {
    				e.printStackTrace();
    			}
    		}

前端页面：，必须要在form里才会提交触发，否则不提交触发方法。

<h:form>	
    <a4j:commandLink action="#{InvoiceManager.resetAction}" reRender="sn,list,action">
    					<h:outputText value="#{msg.snOrder_reset}"></h:outputText>
    				</a4j:commandLink>
    				<h:outputText value=""></h:outputText>
    
    </h:form>

（8）启动任务，即可在前端处理任务。

如果想根据名字控制后台任务，

将job名称和name+group封装到一个map里面去。停止的时候直接map.get(key) 得到name+group，在去找jobdetail然后停止。

如果你是两个job的话，相当于于构造出两个jobDetail这块，然后再scheduler.scheduler两个job，启动一个sheduler就可以了。nice。收工了。![20190621115037640.png][]

[https_blog.csdn.net_qq_36411874_article_details_93165715]: https://blog.csdn.net/qq_36411874/article/details/93165715
[https_download.csdn.net_download_qq_36411874_11251807]: https://download.csdn.net/download/qq_36411874/11251807
[20190621112750698.png]: /images/20220109/561d38db0fcd48dea44767ef2e27743b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NDExODc0_size_16_color_FFFFFF_t_70]: /images/20220109/af11234b4e0a490d92c9fadea5e4463e.png
[20190621115037640.png]: /images/20220109/14c9680eca414e08a82c345bc93be72f.png