基于Spring4的定时任务管理

在项目中，有时会遇到定时任务的处理，下面介绍一下我的做法。

此做法基于Spring4，Spring框架搭建成功，另需引入quartz.jar,pom.xml文件中加入

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

　　创建基类，继承Job类

import org.quartz.Job;
import org.quartz.JobExecutionContext;

public interface BaseJob extends Job{

    @Override
    public void execute(JobExecutionContext paramJobExecutionContext);
}

import org.quartz.JobExecutionContext;

public class BaseJobImpl implements BaseJob{

    @Override
    public void execute(JobExecutionContext paramJobExecutionContext){

    }

}

创建两个要执行的定时任务类，继承BaseJobImpl 类

import org.quartz.JobExecutionContext;
import org.springframework.stereotype.Component;

@Component
public class Job1 extends BaseJobImpl{

    @Override
    public void execute(JobExecutionContext paramJobExecutionContext){
        System.out.println("定时任务1");
    }

}

import org.quartz.JobExecutionContext;
import org.springframework.stereotype.Component;

@Component
public class Job2 extends BaseJobImpl{

    @Override
    public void execute(JobExecutionContext paramJobExecutionContext){
        System.out.println("定时任务2"); 
    } 
}

创建定时任务管理类

import org.apache.log4j.LogManager;
import org.apache.log4j.Logger;
import org.quartz.JobDataMap;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.impl.JobDetailImpl;
import org.quartz.impl.StdSchedulerFactory;
import org.quartz.impl.triggers.CronTriggerImpl;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@Component
public class JobFactory {
        private final Logger log = LogManager.getLogger(JobFactory.class);
        private final static StdSchedulerFactory schedulerFactory = new StdSchedulerFactory ();
        @Scheduled(cron = "*/10 * * * * ?")
        public void run()  throws SchedulerException{
             //Job为一个Bean，对应数据库一张表，此处简单的做了两条假数据，真实项目应查询数据库表获得List
             List<Job> list=new ArrayList<Job>();
             Job job1=new Job();
             job1.setFunctionName("execute");
             job1.setGroupname("group1");
             //此处Job1为定义的定时任务类，注意这里是类的路径，并不单纯是类名
             job1.setJobClassName("Job1");
             job1.setJobId("00000000000");
             job1.setJobName("测试");
             job1.setManagername("manager");
             //此处为控制定时任务的执行，常见规则示例：

/**

每隔5秒执行一次：*/5 * * * * ?
                  每隔1分钟执行一次：0 */1 * * * ?
                  每天23点执行一次：0 0 23 * * ?
                  每天凌晨1点执行一次：0 0 1 * * ?
                  每月1号凌晨1点执行一次：0 0 1 1 * ?
                  每月最后一天23点执行一次：0 0 23 L * ?
                  每周星期天凌晨1点实行一次：0 0 1 ? * L
                  在26分、29分、33分执行一次：0 26,29,33 * * * ?
                  每天的0点、13点、18点、21点都执行一次：0 0 0,13,18,21 * * ?

*/

job1.setRule("0/2 * * * * ?")           

               list.add(job1);

             Job job2=new Job();
             job2.setFunctionName("execute");
             job2.setGroupname("group1");
             job2.setJobClassName("Job2");
             job2.setJobId("00000000001");
             job2.setJobName("测试");
             job2.setManagername("manager");
             job2.setRule("0/2 * * * * ?");

             list.add(job2);
             Scheduler scheduler = schedulerFactory.getScheduler();
             scheduler.clear();
            for(int i=0;i<list.size();i++){
             Job job=list.get(i);
             System.out.println("任务管理"+i);

             try {

                 String jobid=job.getJobId();
                 String functionName=job.getFunctionName();
                 String managerName=job.getManagername();
                 String classPath=job.getJobClassName();
                 if(jobid==null||jobid.equals("")||functionName==null||functionName.equals("")||managerName==null||managerName.equals("")||
                    classPath==null||classPath.equals("")){
                     log.info("==>Task Info ERROR.Can Not Create Task!");
                     return;
                 }
                 //启动任务
                 Object object=Class.forName(job.getJobClassName()).newInstance();
                 JobDetailImpl jobDetail = new JobDetailImpl(job.getJobId(), job.getGroupname(), 
                 (Class<? extends BaseJobImpl>) object.getClass());
                 JobDataMap jobMap=new JobDataMap();
                 jobMap.put("managerName", managerName);
                 jobMap.put("functionName", functionName);
                 jobMap.put("taskid", jobid);
                 jobDetail.setJobDataMap(jobMap);
                 // 触发器
                 CronTriggerImpl trigger = new CronTriggerImpl(job.getJobId(), job.getGroupname());// 触发器名,触发器组
                 trigger.setCronExpression(job.getRule());
                 scheduler.scheduleJob(jobDetail, trigger);
                 // 启动
                 if (!scheduler.isShutdown()){
                     scheduler.start();
                 }else{
                     log.info("==>"+job.getJobName()+"["+job.getJobId()+"] is Shutdown");
                 }
             } catch (Exception e) {
                 log.error("==>"+job.getJobName()+"["+job.getJobId()+"] Start ERROR");
                 log.error(job.getJobName()+"Start ERROR", e);
             }
        }

        }

}

项目启动时上面的run方法要想启动，需要在spring配置文件中添加如下配置：

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"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.1.xsd
                        http://www.springframework.org/schema/context
                        http://www.springframework.org/schema/context/spring-context-3.1.xsd
                        http://www.springframework.org/schema/mvc
                        http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd
                        http://www.springframework.org/schema/aop
                        http://www.springframework.org/schema/aop/spring-aop-3.1.xsd
                        http://www.springframework.org/schema/tx
                        http://www.springframework.org/schema/tx/spring-tx-3.1.xsd
                        http://www.springframework.org/schema/task
                        http://www.springframework.org/schema/task/spring-task-4.1.xsd "> 

<task:annotation-driven executor="taskExecutor" scheduler="taskScheduler"/>
     <task:executor id="taskExecutor" pool-size="5"/>
     <task:scheduler id="taskScheduler" pool-size="10" />

</beans>  

这样，由于run方法配置了@Scheduled(cron = "*/10 * * * * ?")注解，所以run方法会每隔十秒执行一次。

启动项目，结果如下：

这样就实现了定时任务的管理，如果你想写一个定时任务，只需要继承BaseJobImpl类，覆盖execute方法，并在数据库配置一条信息即可。