spring mvc-quartz的maven配置管理项目

项目中要用到定时任务，所以自己研究了一下，下面就我们项目中用到的spring-quartz的实现步骤做以下分享。

一：用到的技术（maven构建的spring-mvc项目）

         Spring-mvc

         Mybatis,

         Maven

         Quartz

二：配置

         1）：首先在pom.xml中引入quartz的jar包（项目中的其他的jar包这里就不再概述）

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

    2）：在spring的配置文件applicationg.xml（不同的项目的名称可能不一样）的头部添加如下声明（红色部分为quartz需要添加的声明）。

<?xml
version="1.0"encoding="UTF-8"?>
<beans
xmlns="http://www.springframework.org/schema/beans"
    xmlns:context="http://www.springframework.org/schema/context"xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
    xmlns:aop="http://www.springframework.org/schema/aop"xmlns:task="http://www.springframework.org/schema/task"
    xsi:schemaLocation="http://www.springframework.org/schema/beans

   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
   http://www.springframework.org/schema/context

   http://www.springframework.org/schema/context/spring-context-3.0.xsd
    http://www.springframework.org/schema/tx
   http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
    http://code.alibabatech.com/schema/dubbo   
   http://code.alibabatech.com/schema/dubbo/dubbo.xsd
    http://www.springframework.org/schema/aop    http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
   http://www.springframework.org/schema/task 

    http://www.springframework.org/schema/task/spring-task-3.1.xsd">
再次在该配置文件中将quartz纳入到spring管理中

<!-- 定时器配置开始 -->
     <bean
id="simpleJobFactory"class="org.quartz.simpl.SimpleJobFactory"
/> 
     
     <bean
id="schedulerFactoryBean" 
class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
        <property
name="jobFactory"
ref="simpleJobFactory"
/>
     </bean>
     <!-- 定时器配置结束 -->

3）：我们的spring的quartz配置就完成了

         二：代码实现

         1）：要将定时任务纳入到管理中，我们首先要将定时任务持久化到数据库中（持久化表的脚本就不概述了）下面为持久化类。

        
public
class ScheduleJob{
    private Long
id;//唯一标示
 
    private String
jobId;//定时任务唯一（uuid）
 
    private String
jobName;//定时任务名称
 
    private String
jobGroup; //定时任务所属组
 
    private String
jobStatus; //定时任务状态（0：开启，1：禁用，2：删除）
 
    private String
cronExpression; //定时任务表达式
 
    private String
cronClass; //定时任务执行类
 
    private String
descs; //定时任务描述
 

//setting,getting方法省略

 

}

 

 

         2）：定时任务业务处理层（用的是注解的方式）

@Component
public
class QuartzJobService {
   
   
    @Autowired
    private SchedulerFactoryBean
schedulerFactoryBean;
   
 
    //开启
    public
void startJob(ScheduleJob job) throws Exception{
       stopJob(job);
//     log.info("start Job (start) >jobid:"+job.getId());
       Scheduler scheduler = schedulerFactoryBean.getScheduler();
           TriggerKey triggerKey = TriggerKey.triggerKey(job.getJobId(),job.getJobGroup());
            
           //获取trigger，即在spring配置文件中定义的
bean id="myTrigger"
           CronTrigger trigger = (CronTrigger)scheduler.getTrigger(triggerKey);
            
           //不存在，创建一个
           if (null == trigger) {
              Job jb =  (Job)Class.forName(job.getCronClass()).newInstance();
           JobDetail jobDetail = JobBuilder.newJob(jb.getClass())
           .withIdentity(job.getJobId(), job.getJobGroup()).build();
           jobDetail.getJobDataMap().put(job.getJobId(), job);
            
           //表达式调度构建器
           CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(job
           .getCronExpression());
            
           //按新的cronExpression表达式构建一个新的trigger
           trigger = TriggerBuilder.newTrigger().withIdentity(job.getJobId(),job.getJobGroup()).withSchedule(scheduleBuilder).build();
            
           scheduler.scheduleJob(jobDetail, trigger);
           } else {
           // Trigger已存在，那么更新相应的定时设置
           //表达式调度构建器
           CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(job
           .getCronExpression());
            
           //按新的cronExpression表达式重新构建trigger
           trigger =trigger.getTriggerBuilder().withIdentity(triggerKey)
           .withSchedule(scheduleBuilder).build();
            
           //按新的trigger重新设置job执行
           scheduler.rescheduleJob(triggerKey, trigger);
           }
//         log.info("start Job (end) >jobid:"+job.getId());
    }
    //停止 
    public 
booleanstopJob(ScheduleJob job) {
//     log.info("stop Job (start) >jobid:"+job.getId());
       String jobId =job.getJobId();
       String jobGroupId = job.getJobGroup();
       if (jobId.equals("") || jobGroupId.equals("")) {
           return
false;
       }
       Scheduler scheduler = schedulerFactoryBean.getScheduler();
       TriggerKey triggerKey = TriggerKey.triggerKey(job.getJobId(),job.getJobGroup());
       try {
           CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
           if (null != trigger) {
              scheduler.deleteJob(trigger.getJobKey());
           }
       } catch (SchedulerException e) {
//         log.error(e.getMessage(), e);
           e.printStackTrace();
           return
false;
       }
//     log.info("stop Job (end) >jobid:"+job.getId());
       return
true;
    }
   
 
 
}
这里面的方法我就不再一一做讲解了（这里参考的是网上的分享（原文找不到了…））。

3）：下面就是具体的控制层的了。

@Controller
@RequestMapping("/job")
public
class JobController extends BaseController {
   
    @Autowired
    private QuartzJobService
quartzJobService;
    @Autowired
    private ScheduleJobService
scheduleJobService;
//  private final Logger log = Logger.getLogger(JobController.class);
   
    /**
     * 开启定时任务
     * @param id
     * @return
     * @author
zhangzq-a
     */
    @RequestMapping(value="/start", produces =
"text/plain;charset=UTF-8")
    @ResponseBody
    public String startTask(Long[] id){
       if(id==null||id.length<1){
           return
"redirect:/job/list";
       }
       for(Long jId :id){
           ScheduleJob job = scheduleJobService.get(jId);
           if(job!=null){
//            log.info("开启定时任务start》定时任务ID:"+jId);
              if("1".equals(job.getJobStatus())){
                  ScheduleJob j = new ScheduleJob();
                  j.setId(job.getId());
                  j.setJobStatus("0");
                  scheduleJobService.update(j);
              }
              try {
                  quartzJobService.startJob(job);
//                log.info("开启定时任务end》定时任务ID:"+jId);
                  return
"true";
              } catch (Exception e) {
//                log.error(e.getMessage(), e);
              }
           }
       }
      
       return 
"定时任务启动失败，请联系管理员";
      
    }
   
    /**
     * 禁用任务
     * @param id
     * @return
     * @author
zhangzq-a
     */
    @RequestMapping(value="/stop", produces =
"text/plain;charset=UTF-8")
    @ResponseBody
    public String stopTask(Long[] id){
       if(id==null||id.length<1){
           return
"redirect:/job/list";
       }
       for(Long jId :id){
           ScheduleJob job = scheduleJobService.get(jId);
           if(job!=null){
//            log.info("禁用定时任务start》定时任务ID:"+jId);
              if("0".equals(job.getJobStatus())){
                  ScheduleJob j = new ScheduleJob();
                  j.setId(job.getId());
                  j.setJobStatus("1");
                  scheduleJobService.update(j);
              }
              try {
                  quartzJobService.stopJob(job);
//                log.info("禁用定时任务end》定时任务ID:"+jId);
                  return
"true";
              } catch (Exception e) {
//                log.error(e.getMessage(), e);
              }
           }
       }
      
       return 
"定时任务启动失败，请联系管理员";
    }
    /**
     * 删除定时任务
     * @param id
     * @return
     * @author
zhangzq-a
     */
    @RequestMapping("/delete")
    @ResponseBody
    public String deleteTask(Long[] id){
       if(id==null||id.length<1){
           return
"redirect:/job/list";
       }
       for(Long jId :id){
           ScheduleJob job = scheduleJobService.get(jId);
           if(job!=null){
//            log.info("删除定时任务start》定时任务ID:"+jId);
//            if("1".equals(job.getJobStatus())){
                  ScheduleJob j = new ScheduleJob();
                  j.setId(job.getId());
                  j.setJobStatus("2");
                  scheduleJobService.update(j);
//            }
              try {
                  quartzJobService.stopJob(job);
//                log.info("删除定时任务end》定时任务ID:"+jId);
                  return
"true";
              } catch (Exception e) {
//                log.error(e.getMessage(), e);
              }
           }
       }
      
       return 
"定时任务删除失败，请联系管理员";
    }
 
    /**
     * 获取定时任务
     * @param id
     * @return
     * @author
zhangzq-a
     */
    @RequestMapping(value="/get")
    @ResponseBody
    public ScheduleJob getTask(Long id){
       if(id==null){
           return
new ScheduleJob();
       }
       return
scheduleJobService.get(id);
    }
   
    /**
     * 新增或修改定时任务
     * @param id
     * @return
     * @author
zhangzq-a
     */
    @RequestMapping(value="/edit", produces =
"text/plain;charset=UTF-8")
    @ResponseBody
    public String editTask(ScheduleJob job){
       if(job.getId()!=null){//修改
           ScheduleJob job2 = scheduleJobService.get(job.getId());
           if(job2==null){
              return
"定时任务不存在";
           }else
if("2".equals((job2.getJobStatus()))){
              return
"定时任务已被删除";
           }else {
              boolean boo =
scheduleJobService.checkUnion(job);
              if(!boo){
                  return
"定时任务已经存在";
              }
               boo = quartzJobService.stopJob(job2);
              if(!boo){
                  return
"定时任务禁用失败";
              }
//            log.info("修改定时任务start》定时任务ID:"+job.getId());
              scheduleJobService.update(job);
              if("0".equals((job.getJobStatus()))){
                  String msg = startTask(new Long[]{job.getId()});
                  if(!"true".equalsIgnoreCase(msg)){
                     return
"定时开启失败";
                  }
              }
//            log.info("修改定时任务end》定时任务ID:"+job.getId());
           }
       }else{//保存
           boolean boo =
scheduleJobService.checkUnion(job);
           if(!boo){
              return
"定时任务已经存在";
           }
//         log.info("新增定时任务start》定时任务ID:"+job.getId());
           scheduleJobService.insert(job);
           if("0".equalsIgnoreCase(job.getJobStatus())){
              String msg = startTask(new Long[]{job.getId()});
              if(!"true".equalsIgnoreCase(msg)){
                  return
"定时开启失败";
              }
           }
//         log.info("修改定时任务end》定时任务ID:"+job.getId());
       }
       return
"true";
    }
   
 
}
4）：下面就是具体的前端的控制实现了，这里 我也就不做相应的分享了...

 

上面的定时任务只能够满足部分要求，对于负载和容错都不满足，对于分布式是不能满足要求的，分布式的实现方式目前正在研究中…