quratz动态定时器配置

springmvc配置：

<!-- quartz的定时任务的factorybean,配置其他config -->

<!--获取spring注入实体类-->
<bean id="jobFactory" class="com.mxkjshop.utils.quartz.JobFactory"></bean>
<bean name="quartzScheduler"
    class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
    <property name="dataSource" ref="DataSource1" />
    <property name="jobFactory" ref="jobFactory"></property>
    <property name="applicationContextSchedulerContextKey" value="applicationContextKey" />
    <property name="configLocation" value="classpath:quartz.properties" />
</bean>

<!-- quartz 配置结束 -->

JobFactory 代码：

/**
 *一般情况下，quartz的job中使用autowired注解注入的对象为空，这时候我们就要使用spring-quartz提供的AdaptableJobFactory类。
 */
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;  
        }
}

controller 方法：

@Controller
@RequestMapping("quartz")
public class QuartzController extends BaseController{

    @Reference
    private QuartzService quartzService;
    @Reference
    Ibasecommon bllbase;
    // 主页面
        @RequestMapping(value = "/list", method = RequestMethod.GET)
        public String list(HttpServletRequest request, HttpServletResponse response, String menuid) {
            // 控制编辑权限 16-11-23
            infosession = getsession(request);
            if (infosession != null)
                request.setAttribute("showbutton", outputbtn(infosession.getRoleid().toString(), menuid, bllbase));
            else
                request.setAttribute("showbutton", "");
            // 控制编辑权限 16-11-23
            return "quartz/list";
        }
    /**
     * 定时列表页
     *
     * @return
     * @throws SchedulerException
     */
    @RequestMapping(value="/getlistJob")
    public void listJob(HttpServletRequest request,HttpServletResponse response) throws SchedulerException {
        List<JobEntity> jobInfos = quartzService.getSchedulerJobInfo();
        this.writeJson(response, jobInfos);
    }
    
    /**
     * 跳转到新增
     *
     * @return
     * @throws SchedulerException
     * @throws ClassNotFoundException
     */
    @Token(save=true)
    @RequestMapping(value="/toAdd")
    public String toAdd(HttpServletRequest request,HttpServletResponse response) throws SchedulerException {
        return "quartz/add";
    }
    
    
    /**
     * 新增job
     *
     * @return
     * @throws SchedulerException
     * @throws ClassNotFoundException
     */
    @Token(remove=true)
    @RequestMapping(value="/add",method=RequestMethod.POST)
    public void add(HttpServletRequest request,HttpServletResponse response) throws SchedulerException, ClassNotFoundException {
        String jobName = request.getParameter("jobName");
        String jobGroupName = request.getParameter("jobGroupName");
        String triggerName = request.getParameter("triggerName");
        String triggerGroupName = request.getParameter("triggerGroupName");
        String clazz = request.getParameter("clazz");
        Class cls = Class.forName(clazz);
        String cron = request.getParameter("cron");
        try {
            quartzService.addJob(jobName, jobGroupName, triggerName, triggerGroupName, cls, cron);
            this.writeJson(response, new JsonWrite(true, "新增定时器成功！"));
        } catch (Exception e) {
            // TODO Auto-generated catch block
            rollBackSession(request, request.getParameter("token"));
            e.printStackTrace();
            this.writeJson(response, new JsonWrite(false, "新增定时器失败！"));
        }
    }

    /**
     * 跳转到编辑
     *
     * @return
     * @throws SchedulerException
     * @throws ClassNotFoundException
     */
    @RequestMapping(value="/toEdit")
    public String toEdit(HttpServletRequest request,HttpServletResponse response) throws SchedulerException {
        
        String jobName = request.getParameter("jobName");
        String jobGroup = request.getParameter("jobGroup");
        
//        JobKey jobKey = JobKey.jobKey(jobName, jobGroup);
//        JobDetail jd = quartzService.getJobDetail(jobKey);
//        @SuppressWarnings("unchecked")
//        List<CronTrigger> triggers = (List<CronTrigger>) quartzService.getTriggersOfJob(jobKey);
//        CronTrigger trigger = triggers.get(0);
//        TriggerKey triggerKey = trigger.getKey();
//        String cron = trigger.getCronExpression();
//        Map<String, String> pd = new HashMap<String, String>();
//        pd.put("jobName", jobKey.getName());
//        pd.put("jobGroup", jobKey.getGroup());
//        pd.put("triggerName", triggerKey.getName());
//        pd.put("triggerGroupName", triggerKey.getGroup());
//        pd.put("cron", cron);
//        pd.put("clazz", jd.getJobClass().getCanonicalName());
//        request.setAttribute("pd", pd);
        
        Map<String, String> pd=quartzService.getJobData(jobName, jobGroup);
        request.setAttribute("pd", pd);
        return "quartz/edit";
    }
    
    
    /**
     * 编辑job
     *
     * @return
     * @throws SchedulerException
     * @throws ClassNotFoundException
     */
    @RequestMapping(value="/edit",method=RequestMethod.POST)
    public void edit(HttpServletRequest request,HttpServletResponse response) throws SchedulerException, ClassNotFoundException {
        String jobName = request.getParameter("jobName");
        String jobGroupName = request.getParameter("jobGroupName");
        String triggerName = request.getParameter("triggerName");
        String triggerGroupName = request.getParameter("triggerGroupName");
        String clazz = request.getParameter("clazz");
        Class cls = Class.forName(clazz);
        String cron = request.getParameter("cron");
        
        String oldjobName = request.getParameter("oldjobName");
        String oldjobGroup = request.getParameter("oldjobGroup");
        String oldtriggerName = request.getParameter("oldtriggerName");
        String oldtriggerGroup = request.getParameter("oldtriggerGroup");
        
        boolean result = quartzService.modifyJobTime(oldjobName, oldjobGroup, oldtriggerName, oldtriggerGroup,
                jobName, jobGroupName, triggerName, triggerGroupName, cron);
        this.writeJson(response, new JsonWrite(result, result?"修改定时器成功":"修改定时器失败"));
    }

    @RequestMapping(value="/pauseJob",method=RequestMethod.POST)
    @ResponseBody
 public void pauseJob(HttpServletResponse response,@RequestParam("jobName") String jobName,@RequestParam("jobGroupName") String jobGroupName){
        if(StringUtils.isEmpty(jobName) || StringUtils.isEmpty(jobGroupName)){
            this.writeJson(response, new JsonWrite(false, "暂停失败！"));
        }else{
            quartzService.pauseJob(jobName, jobGroupName);
            this.writeJson(response, new JsonWrite(true, "暂停成功！"));
        }
    }
    
    @RequestMapping(value="/resumeJob",method=RequestMethod.POST)
    @ResponseBody
 public void resumeJob(HttpServletResponse response,@RequestParam("jobName") String jobName,@RequestParam("jobGroupName") String jobGroupName){
        if(StringUtils.isEmpty(jobName) || StringUtils.isEmpty(jobGroupName)){
            this.writeJson(response, new JsonWrite(false, "恢复失败！"));
        }else{
            quartzService.resumeJob(jobName, jobGroupName);
            this.writeJson(response, new JsonWrite(true, "恢复成功！"));
        }
    }
    
    @RequestMapping(value="/deleteJob",method=RequestMethod.POST)
    @ResponseBody
 public void deleteJob(HttpServletResponse response,@RequestParam("jobName") String jobName,@RequestParam("jobGroupName") String jobGroupName,
            @RequestParam("triggerName") String triggerName,@RequestParam("triggerGroupName") String triggerGroupName ){
        if(StringUtils.isEmpty(jobName) || StringUtils.isEmpty(jobGroupName) ||
                StringUtils.isEmpty(triggerName) || StringUtils.isEmpty(triggerGroupName) ){
            this.writeJson(response, new JsonWrite(false, "删除失败！"));
        }else{
             quartzService.removeJob(jobName, jobGroupName, triggerName, triggerGroupName);
             this.writeJson(response, new JsonWrite(true, "删除成功！"));
        }
    }

 

接口：

public interface QuartzService {

    /**
     * addJob(方法描述：添加一个定时任务) <br />
     * (方法适用条件描述： – 可选)
     *
     * @param jobName
     *            作业名称
     * @param jobGroupName
     *            作业组名称
     * @param triggerName
     *            触发器名称
     * @param triggerGroupName
     *            触发器组名称
     * @param cls
     *            定时任务的class
     * @param cron
     *            时间表达式 void
     * @exception
     * @since 1.0.0
     */
    public void addJob(String jobName, String jobGroupName,String triggerName, String triggerGroupName, Class cls, String cron);

    /**
     *
     * @param oldjobName 原job name
     * @param oldjobGroup 原job group
     * @param oldtriggerName 原 trigger name
     * @param oldtriggerGroup 原 trigger group
     * @param jobName
     * @param jobGroup
     * @param triggerName
     * @param triggerGroup
     * @param cron
     */
    public boolean modifyJobTime(String oldjobName,String oldjobGroup, String oldtriggerName, String oldtriggerGroup, String jobName, String jobGroup,String triggerName, String triggerGroup, String cron);

    /**
     * 修改触发器调度时间
     * @param triggerName  触发器名称
     * @param triggerGroupName  触发器组名称
     * @param cron cron表达式
     */
    public void modifyJobTime(String triggerName,
            String triggerGroupName, String cron);

    
    /**
     * 暂停指定的任务
     * @param jobName 任务名称
     * @param jobGroupName 任务组名称
     * @return
     */
    public void pauseJob(String jobName,String jobGroupName);
    
    /**
     * 恢复指定的任务
     * @param jobName 任务名称
     * @param jobGroupName 任务组名称
     * @return
     */
    public void resumeJob(String jobName,String jobGroupName);
    
    /**
     * 删除指定组任务
     * @param jobName 作业名称
     * @param jobGroupName 作业组名称
     * @param triggerName 触发器名称
     * @param triggerGroupName 触发器组名称
     */
    public void removeJob(String jobName, String jobGroupName,
            String triggerName, String triggerGroupName);

    
    /**
     * 开始所有定时任务。启动调度器
     */
    public void startSchedule();

    /**
     * 关闭调度器
     */
    public void shutdownSchedule();
    
    /**
     * 获取定时器信息
     * @return
     * @throws SchedulerException
     */
    public List<JobEntity> getSchedulerJobInfo() throws SchedulerException;
    
    public JobDetail getJobDetail(JobKey jobKey) throws SchedulerException;
    
    public List<CronTrigger> getTriggersOfJob(JobKey jobKey) throws SchedulerException;

    public Map<String, String> getJobData(String jobName, String jobGroup) throws SchedulerException;

实现类：

@Service
@Transactional
public class QuartzServiceImpl implements QuartzService{
    
    @Resource
    private Scheduler quartzScheduler;
    
    @Override
    public void addJob(String jobName, String jobGroupName, String triggerName,
            String triggerGroupName, Class cls, String cron) {
        try {
            // 获取调度器
            Scheduler sched = quartzScheduler;
            // 创建一项作业
            JobDetail job = JobBuilder.newJob(cls)
                    .withIdentity(jobName, jobGroupName).build();
            // 创建一个触发器  withMisfireHandlingInstructionDoNothing()不立即触发
            CronTrigger trigger = TriggerBuilder.newTrigger()
                    .withIdentity(triggerName, triggerGroupName)
                    .withSchedule(CronScheduleBuilder.cronSchedule(cron).withMisfireHandlingInstructionDoNothing())
                    .build();
            // 告诉调度器使用该触发器来安排作业
            sched.scheduleJob(job, trigger);
            // 启动
            if (!sched.isShutdown()) {
                sched.start();
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    
    /**
     * 修改定时器任务信息
     */
    @Override
    public boolean modifyJobTime(String oldjobName, String oldjobGroup, String oldtriggerName, String oldtriggerGroup, String jobName, String jobGroup,
            String triggerName, String triggerGroup, String cron) {
        try {
            Scheduler sched = quartzScheduler;
            CronTrigger trigger = (CronTrigger) sched.getTrigger(TriggerKey
                    .triggerKey(oldtriggerName, oldtriggerGroup));
            if (trigger == null) {
                return false;
            }

            JobKey jobKey = JobKey.jobKey(oldjobName, oldjobGroup);
            TriggerKey triggerKey = TriggerKey.triggerKey(oldtriggerName,
                    oldtriggerGroup);

            JobDetail job = sched.getJobDetail(jobKey);
            Class jobClass = job.getJobClass();
            // 停止触发器
            sched.pauseTrigger(triggerKey);
            // 移除触发器
            sched.unscheduleJob(triggerKey);
            // 删除任务
            sched.deleteJob(jobKey);
            
            addJob(jobName, jobGroup, triggerName, triggerGroup, jobClass,
                    cron);
            
            return true;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        
    }

    @Override
    public void modifyJobTime(String triggerName, String triggerGroupName,
            String time) {
        try {
            Scheduler sched = quartzScheduler;
            CronTrigger trigger = (CronTrigger) sched.getTrigger(TriggerKey
                    .triggerKey(triggerName, triggerGroupName));
            if (trigger == null) {
                return;
            }
            String oldTime = trigger.getCronExpression();
            if (!oldTime.equalsIgnoreCase(time)) {
                CronTrigger ct = (CronTrigger) trigger;
                // 修改时间
                ct.getTriggerBuilder()
                        .withSchedule(CronScheduleBuilder.cronSchedule(time))
                        .build();
                // 重启触发器
                sched.resumeTrigger(TriggerKey.triggerKey(triggerName,
                        triggerGroupName));
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public void removeJob(String jobName, String jobGroupName,
            String triggerName, String triggerGroupName) {
        try {
            Scheduler sched = quartzScheduler;
            // 停止触发器
            sched.pauseTrigger(TriggerKey.triggerKey(triggerName,
                    triggerGroupName));
            // 移除触发器
            sched.unscheduleJob(TriggerKey.triggerKey(triggerName,
                    triggerGroupName));
            // 删除任务
            sched.deleteJob(JobKey.jobKey(jobName, jobGroupName));
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public void startSchedule() {
        try {
            Scheduler sched = quartzScheduler;
            sched.start();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public void shutdownSchedule() {
        try {
            Scheduler sched = quartzScheduler;
            if (!sched.isShutdown()) {
                sched.shutdown();
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public void pauseJob(String jobName, String jobGroupName) {
        try {
            quartzScheduler.pauseJob( JobKey.jobKey(jobName, jobGroupName));
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    
    }

    @Override
    public void resumeJob(String jobName, String jobGroupName) {
        try {
            quartzScheduler.resumeJob(JobKey.jobKey(jobName, jobGroupName));
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }

    /**
     * 获取定时器信息
     * @return
     * @throws SchedulerException
     */
    public List<JobEntity> getSchedulerJobInfo() throws SchedulerException {
        List<JobEntity> jobInfos = new ArrayList<JobEntity>();
        List<String> triggerGroupNames = quartzScheduler.getTriggerGroupNames();
        for (String triggerGroupName : triggerGroupNames) {
            Set<TriggerKey> triggerKeySet = quartzScheduler
                    .getTriggerKeys(GroupMatcher
                            .triggerGroupEquals(triggerGroupName));
            for (TriggerKey triggerKey : triggerKeySet) {
                Trigger t = quartzScheduler.getTrigger(triggerKey);
                if (t instanceof CronTrigger) {
                    CronTrigger trigger = (CronTrigger) t;
                    JobKey jobKey = trigger.getJobKey();
                    JobDetail jd = quartzScheduler.getJobDetail(jobKey);
                    JobEntity jobInfo = new JobEntity();
                    jobInfo.setJobName(jobKey.getName());
                    jobInfo.setJobGroup(jobKey.getGroup());
                    jobInfo.setTriggerName(triggerKey.getName());
                    jobInfo.setTriggerGroupName(triggerKey.getGroup());
                    jobInfo.setCronExpr(trigger.getCronExpression());
                    jobInfo.setNextFireTime(trigger.getNextFireTime());
                    jobInfo.setPreviousFireTime(trigger.getPreviousFireTime());
                    jobInfo.setStartTime(trigger.getStartTime());
                    jobInfo.setEndTime(trigger.getEndTime());
                    jobInfo.setJobClass(jd.getJobClass().getCanonicalName());
                    // jobInfo.setDuration(Long.parseLong(jd.getDescription()));
                    Trigger.TriggerState triggerState = quartzScheduler
                            .getTriggerState(trigger.getKey());
                    jobInfo.setJobStatus(triggerState.toString());// NONE无,
                                                                    // NORMAL正常,
                                                                    // PAUSED暂停,
                                                                    // COMPLETE完全,
                                                                    // ERROR错误,
                                                                    // BLOCKED阻塞
                    JobDataMap map = quartzScheduler.getJobDetail(jobKey)
                            .getJobDataMap();
                    if (null != map&&map.size() != 0) {
                        jobInfo.setCount(Integer.parseInt((String) map
                                .get("count")));
                        jobInfo.setJobDataMap(map);
                    } else {
                        jobInfo.setJobDataMap(new JobDataMap());
                    }
                    jobInfos.add(jobInfo);
                }
            }
        }
        return jobInfos;
    }

    @Override
    public JobDetail getJobDetail(JobKey jobKey) throws SchedulerException {
        // TODO Auto-generated method stub
        return quartzScheduler.getJobDetail(jobKey);
    }

    @Override
    public List<CronTrigger> getTriggersOfJob(JobKey jobKey) throws SchedulerException {
        // TODO Auto-generated method stub
        return (List<CronTrigger>) quartzScheduler
                .getTriggersOfJob(jobKey);
    }

    @Override
    public Map<String, String> getJobData(String jobName, String jobGroup) throws SchedulerException {
        // TODO Auto-generated method stub
        JobKey jobKey = JobKey.jobKey(jobName, jobGroup);
        JobDetail jd = quartzScheduler.getJobDetail(jobKey);
        @SuppressWarnings("unchecked")
        List<CronTrigger> triggers = (List<CronTrigger>) quartzScheduler.getTriggersOfJob(jobKey);
        CronTrigger trigger = triggers.get(0);
        TriggerKey triggerKey = trigger.getKey();
        String cron = trigger.getCronExpression();
        Map<String, String> pd = new HashMap<String, String>();
        pd.put("jobName", jobKey.getName());
        pd.put("jobGroup", jobKey.getGroup());
        pd.put("triggerName", triggerKey.getName());
        pd.put("triggerGroupName", triggerKey.getGroup());
        pd.put("cron", cron);
        pd.put("clazz", jd.getJobClass().getCanonicalName());
        return pd;
    }
   

添加定时器：