动态改变squartz的定时时间

最新推荐文章于 2023-09-28 09:16:17 发布

小胡哥1992

最新推荐文章于 2023-09-28 09:16:17 发布

阅读量898

点赞数

本文链接：https://blog.csdn.net/weixin_37632678/article/details/80416046

版权

注意：根据本人经验 spring跟squartz整合出现了版本问题，如果spring是3.1以下的就要用squartz1.x版本，如果spring是3.1以上的就要用squartz2.x版本，我的spring是4.x的所有整合是

<dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
          
           <version>1.8.4</version>

</dependency>

一：在springmvc中配置

这个自己写的定时器请求类

     <bean id="fixedTaskQuartz" class="com.guojizhineng.controller.FixedTaskQuartz">
       <property name="scheduler" ref="schedulerFactory" />
     </bean>

bean id="schedulerJobDetail" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
         <property name="targetObject" ref="fixedTaskQuartz"/>//fixedTaskQuartz"是请求类的注解
         <property name="targetMethod" value="reScheduleJob"/>//reScheduleJob是请求类方法
         <property name="concurrent" value="false"/>

</bean>

</bean>

二：请求类代码如下

package com.guojizhineng.controller;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;

import org.apache.shiro.SecurityUtils;
import org.quartz.CronTrigger;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.impl.StdSchedulerFactory;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.quartz.CronTriggerBean;
import org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import com.guojizhineng.commons.base.BaseController;
import com.guojizhineng.commons.shiro.ShiroUser;
import com.guojizhineng.model.vo.TaskCondition;
import com.guojizhineng.service.ITaskFixedService;
@Controller
@RequestMapping("/fixedTaskQuartz")
public class FixedTaskQuartz extends BaseController implements BeanFactoryAware{

   private static ITaskFixedService fixedTaskService;

   private static Scheduler scheduler;
   private static BeanFactory beanFactory;
   @Autowired
   private void setTaskFixedInfo(ITaskFixedService fixedTaskService){
       this.fixedTaskService=fixedTaskService;
   }


   public void reScheduleJob() throws Exception{

       try {
           List<TaskCondition> condition=fixedTaskService.findAllFixedTask();
           if(condition!=null){
               for(int i=0;i<condition.size();i++){
                   TaskCondition task=condition.get(i);
                      if(task.getIsWorking().equalsIgnoreCase("0")){
                       //移除任务列表
                       removeTaskFromList(task);
                      }else{
                          //配置任务列表
                          changeCronExpression(task);//在原有的基础自己现在触发器

                      }
               }
           }
       } catch (Exception e) {
           e.printStackTrace();
       }
   }

   private void removeTaskFromList(TaskCondition task) {
       try {
            CronTriggerBean trigger = (CronTriggerBean) scheduler.getTrigger(task.getFixedTaskName(), Scheduler.DEFAULT_GROUP);
            if(trigger!=null){
                scheduler.pauseTrigger(trigger.getName(), trigger.getGroup());// 停止触发器
                scheduler.unscheduleJob(trigger.getName(), trigger.getGroup());// 移除触发器
                scheduler.deleteJob(trigger.getJobName(), trigger.getJobGroup());// 删除任务
            }
        } catch (SchedulerException e) {
            e.printStackTrace();
        }

   }

   private void changeCronExpression(TaskCondition task) throws Exception {
          try {
              //1判断该任务在执行列表中执行列表中，没有就添加有就判断数据库时间表达式有没有被改
                CronTriggerBean trigger = (CronTriggerBean) scheduler.getTrigger(task.getFixedTaskName(), Scheduler.DEFAULT_GROUP);
                if(trigger!=null){//说明schedule中不存在该定时任务
                   // updateTriggerTask(task,trigger);
                   if(task.getIsWorking().equalsIgnoreCase("1")){
                        // 判断从DB中取得的任务时间和现在的quartz线程中的任务时间是否相等如果相等，则表示用户并没有重新设定数据库中的任务时间，这种情况不需要重新rescheduleJob
                            if(trigger.getCronExpression()!=null&&!trigger.getCronExpression().equalsIgnoreCase(task.getCronExpress())) {
                                trigger.setCronExpression(task.getCronExpress());
                                scheduler.rescheduleJob(task.getFixedTaskName(),Scheduler.DEFAULT_GROUP, trigger);
                            }
                         /*   if(trigger.getCronExpression().equalsIgnoreCase(task.getCronExpress())){
                               //2执行真正的时间段数据
                               task.setIsNotAddThreed("1");
                               Object[] arg=new Object[2];
                                arg[0]=task;
                                executeJobDetail(arg);
                               System.err.println("zhixingled===========================================");
                            }*/
                       }else{
                           this.removeTaskFromList(task);
                       }
                }else{
                   createTriggerTask(task);
                }

            } catch (SchedulerException e) {
                e.printStackTrace();
            }

   }

   //创建任务列表
   private void createTriggerTask(TaskCondition task) {
                try{
                   if(task.getIsWorking().equalsIgnoreCase("1")){
                           //System.out.println("=创建：="+bo.getTaskName());
                           MethodInvokingJobDetailFactoryBean mjdfb = new MethodInvokingJobDetailFactoryBean();
                           mjdfb.setBeanName(task.getFixedTaskName());
                            Object obj = beanFactory.getBean("fixedTaskQuartz");
                            mjdfb.setTargetObject(obj);
                            mjdfb.setTargetMethod("executeJobDetail");
                            Object[] arg=new Object[2];
                            arg[0]=task;
                            mjdfb.setArguments(arg);
                            mjdfb.setConcurrent(false);//不并发
                            mjdfb.afterPropertiesSet(); //将管理Job类提交到计划管理类
                            JobDetail jobDetail = new JobDetail();
                            jobDetail = mjdfb.getObject();
                            jobDetail.setName(task.getFixedTaskName());
                            scheduler.addJob(jobDetail, true); // 将Job添加到管理类
                            // 新一个基于Spring的时间类
                            CronTriggerBean c = new CronTriggerBean();
                            String cron=task.getCronExpress();
                            c.setCronExpression(cron);// 设置时间表达式
                            c.setName(task.getFixedTaskName());// 设置名称
                            c.setJobDetail(jobDetail);// 注入Job
                            c.setJobName(task.getFixedTaskName());// 设置Job名称
                            scheduler.scheduleJob(c);// 注入到管理类
                            scheduler.rescheduleJob(task.getFixedTaskName(), Scheduler.DEFAULT_GROUP,c);// 刷新管理类
                   }else{
                       this.removeTaskFromList(task);
                   }
                }catch(Exception e){
                    e.printStackTrace();
                }

   }

    /**
     * 更新任务列表
     * @param bo
     */
    private void updateTriggerTask(TaskCondition task,CronTriggerBean trigger) {
            try{
               if(task.getIsWorking().equalsIgnoreCase("1")){
                // 判断从DB中取得的任务时间和现在的quartz线程中的任务时间是否相等
                // 如果相等，则表示用户并没有重新设定数据库中的任务时间，这种情况不需要重新rescheduleJob
                    if(trigger.getCronExpression()!=null&&!trigger.getCronExpression().equalsIgnoreCase(task.getCronExpress())) {
                        trigger.setCronExpression(task.getCronExpress());
                        scheduler.rescheduleJob(task.getFixedTaskName(),Scheduler.DEFAULT_GROUP, trigger);
                    }
               }else{
                   this.removeTaskFromList(task);
               }
            }catch(Exception e){
                e.printStackTrace();
            }
    }

   private void executeJobDetail( Object[] arg) {
       try {
           TaskCondition task=(TaskCondition) arg[0];
           ShiroUser user=(ShiroUser) SecurityUtils.getSubject().getPrincipal();
           CronTriggerBean trigger = (CronTriggerBean) scheduler.getTrigger(task.getFixedTaskName(), Scheduler.DEFAULT_GROUP);

SimpleDateFormat df = new SimpleDateFormat("mm");

int startTimeForTomcat=Integer.valueOf(df.format(new Date())).intValue()-Integer.valueOf(df.format(trigger.getStartTime())).intValue();//加这一行是为了防止服务器多次启动查询出来的任务数据加入到定时列表中

           if(startTimeForTomcat!=0){
              // ShiroUser user=getShiroUser();
               System.err.println("ddddd");
               fixedTaskService.excuteFixedTask(task,user);
           }
           //scheduler.rescheduleJob(task.getFixedTaskName(), Scheduler.DEFAULT_GROUP,trigger);// 刷新管理类

       } catch (Exception e) {
           e.printStackTrace();
       }
   }

   public Scheduler getScheduler() {
       return scheduler;
   }
   public static BeanFactory getBeanFactory() {
       return beanFactory;
   }
   public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
       FixedTaskQuartz.beanFactory = beanFactory;
   }

   public void setScheduler(Scheduler scheduler) {
       this.scheduler = scheduler;
   }



}