quartz动态定时任务

Quartz是 OpenSymphony开源组织在Job scheduling领域又一个开源项目，它可以与J2SE应用程序结合也可以单独使用。Quartz可以用来创建简单或为运行十个，百个，甚至是好几万个Jobs这样复杂的程序。Jobs可以做成标准的java组建或EJBs。目前Quartz的最新版本为Quartz 2.2.1。

其它话就不说了，直接上代码。

1.spring中引入注册bean

<bean id="schedulerFactoryBean"

class="org.springframework.scheduling.quartz.SchedulerFactoryBean">

</bean>

2.创建保存计划任务信息的实体类

public class ScheduleJob {
    public static final String STATUS_RUNNING = "1";
    public static final String STATUS_NOT_RUNNING = "0";
    public static final String CONCURRENT_IS = "1";
    public static final String CONCURRENT_NOT = "0";
    private Integer jobId;

    private Date createTime;

    private Date updateTime;
    /**
     * 任务名称
     */
    private String jobName;
    /**
     * 任务分组
     */
    private String jobGroup;
    /**
     * 任务状态 是否启动任务
     */
    private String jobStatus;
    /**
     * cron表达式
     */
    private String cronExpression;
    /**
     * 描述
     */
    private String description;
    /**
     * 任务执行时调用哪个类的方法 包名+类名
     */
    private String beanClass;
    /**
     * 任务是否有状态
     */
    private String isConcurrent;
    /**
     * spring bean
     */
    private String springId;
    /**
     * 任务调用的方法名
     */
    private String methodName;

    private Integer attemperPro;//执行类型：0:不执行，1：每隔多少分钟执行，2：每隔多少小时执行,3:每天几点执行，4：每星期几执行

    private String intervalTime;//执行时间或者间隔时间

    public String getMethodName() {
        return methodName;
    }

    public void setMethodName(String methodName) {
        this.methodName = methodName;
    }

    public static String getStatusRunning() {
        return STATUS_RUNNING;
    }

    public static String getStatusNotRunning() {
        return STATUS_NOT_RUNNING;
    }

    public static String getConcurrentIs() {
        return CONCURRENT_IS;
    }

    public static String getConcurrentNot() {
        return CONCURRENT_NOT;
    }

    public Integer getJobId() {
        return jobId;
    }

    public void setJobId(Integer jobId) {
        this.jobId = jobId;
    }

    public Date getCreateTime() {
        return createTime;
    }

    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }

    public Date getUpdateTime() {
        return updateTime;
    }

    public void setUpdateTime(Date updateTime) {
        this.updateTime = updateTime;
    }

    public String getJobName() {
        return jobName;
    }

    public void setJobName(String jobName) {
        this.jobName = jobName;
    }

    public String getJobGroup() {
        return jobGroup;
    }

    public void setJobGroup(String jobGroup) {
        this.jobGroup = jobGroup;
    }

    public String getJobStatus() {
        return jobStatus;
    }

    public void setJobStatus(String jobStatus) {
        this.jobStatus = jobStatus;
    }

    public String getCronExpression() {
        return cronExpression;
    }

    public void setCronExpression(String cronExpression) {
        this.cronExpression = cronExpression;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    public String getBeanClass() {
        return beanClass;
    }

    public void setBeanClass(String beanClass) {
        this.beanClass = beanClass;
    }

    public String getIsConcurrent() {
        return isConcurrent;
    }

    public void setIsConcurrent(String isConcurrent) {
        this.isConcurrent = isConcurrent;
    }

    public String getSpringId() {
        return springId;
    }

    public void setSpringId(String springId) {
        this.springId = springId;
    }

    public Integer getAttemperPro() {
        return attemperPro;
    }

    public void setAttemperPro(Integer attemperPro) {
        this.attemperPro = attemperPro;
    }

    public String getIntervalTime() {
        return intervalTime;
    }

    public void setIntervalTime(String intervalTime) {
        this.intervalTime = intervalTime;
    }

该实体类与数据库中的表对应，在数据库中存储多个计划任务。

注意：jobName 跟 groupName的组合应该是唯一的,beanClass springId至少有一个

3.项目启动时启动

public class ApplicationContextListener implements ServletContextListener {


    private ServletContext context = null;
    /**
     * Initialize the root web application context.
     *
     * @param event
     */
    @Override
    public void contextInitialized(ServletContextEvent event) {

        QuartzContext.getInstance().setContext(event.getServletContext());

    }
}

public class QuartzContext {
    private final static QuartzContext instance = new QuartzContext();
    private static ServletContext context;


    private QuartzContext() {
    }

    public static QuartzContext getInstance() {
        return instance;
    }

    public void setContext(ServletContext context) {
        this.context = context;
    }

    public ServletContext getContext() {
        return context;
    }
}

<listener>
        <description>项目启动时启动</description>
        <listener-class>cn.com.web.listener.ApplicationContextListener</listener-class>
    </listener>

public class JobTaskService {

    private  final  static Logger log = Logger.getLogger(JobTaskService.class);



    @Autowired
    private SchedulerFactoryBean schedulerFactoryBean;



    /**
     * 从数据库中查询job
     */
    public ScheduleJob getTaskById(Integer jobId) {
        return mapper.selectByPrimaryKey(jobId);
    }

    /**
     * 更改任务状态
     *
     * @throws org.quartz.SchedulerException
     */
    public void changeStatus(Integer jobId, String cmd) {
        try {
            ScheduleJob job = getTaskById(jobId);
            if (job == null) {
                return;
            }

            if ("stop".equals(cmd)) {

                    deleteJob(job);

                job.setJobStatus(ScheduleJob.STATUS_NOT_RUNNING);
            } else if ("start".equals(cmd)) {
                job.setJobStatus(ScheduleJob.STATUS_RUNNING);

                    addJob(job);

            }
            mapper.updateByPrimaryKeySelective(job);
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }

    /**
     * 更改任务 cron表达式
     *
     * @throws SchedulerException
     */
    public void updateCron(Integer jobId, String cron)  {
        try{

            ScheduleJob job = getTaskById(jobId);
            if (job == null) {
                return;
            }
            job.setCronExpression(cron);
            if (ScheduleJob.STATUS_RUNNING.equals(job.getJobStatus())) {
                updateJobCron(job);
            }
            mapper.updateByPrimaryKeySelective(job);
        }catch (SchedulerException e){

        }
    }

    /**
     * 添加任务
     *
     * @param job
     * @throws SchedulerException
     */
    public void addJob(ScheduleJob job) throws SchedulerException {
        if (job == null || !ScheduleJob.STATUS_RUNNING.equals(job.getJobStatus())) {
            return;
        }

        Scheduler scheduler = schedulerFactoryBean.getScheduler();
        log.debug(scheduler + ".......................................................................................add");
        TriggerKey triggerKey = TriggerKey.triggerKey(job.getJobName(), job.getJobGroup());

        CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);

        // 不存在，创建一个
        if (null == trigger) {
            //Class clazz = ScheduleJob.CONCURRENT_IS.equals(job.getIsConcurrent()) ? QuartzJobFactory.class : QuartzJobFactoryDisallowConcurrentExecution.class;
            Class clazz = QuartzJobFactoryDisallowConcurrentExecution.class;
            JobDetail jobDetail = JobBuilder.newJob(clazz).withIdentity(job.getJobName(), job.getJobGroup()).build();

            jobDetail.getJobDataMap().put("scheduleJob", job);

            CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(job.getCronExpression());

            trigger = TriggerBuilder.newTrigger().withIdentity(job.getJobName(), 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);
        }
    }

    @PostConstruct
    public void init() throws Exception {

        Scheduler scheduler = schedulerFactoryBean.getScheduler();

        // 这里获取任务信息数据
        List<ScheduleJob> jobList = mapper.getAll();

        for (ScheduleJob job : jobList) {
            addJob(job);
        }
    }

    /**
     * 获取所有计划中的任务列表
     *
     * @return
     * @throws SchedulerException
     */
    public List<ScheduleJob> getAllJob() throws SchedulerException {
        Scheduler scheduler = schedulerFactoryBean.getScheduler();
        GroupMatcher<JobKey> matcher = GroupMatcher.anyJobGroup();
        Set<JobKey> jobKeys = scheduler.getJobKeys(matcher);
        List<ScheduleJob> jobList = new ArrayList<ScheduleJob>();
        for (JobKey jobKey : jobKeys) {
            List<? extends Trigger> triggers = scheduler.getTriggersOfJob(jobKey);
            for (Trigger trigger : triggers) {
                ScheduleJob job = new ScheduleJob();
                job.setJobName(jobKey.getName());
                job.setJobGroup(jobKey.getGroup());
                job.setDescription("触发器:" + trigger.getKey());
                Trigger.TriggerState triggerState = scheduler.getTriggerState(trigger.getKey());
                job.setJobStatus(triggerState.name());
                if (trigger instanceof CronTrigger) {
                    CronTrigger cronTrigger = (CronTrigger) trigger;
                    String cronExpression = cronTrigger.getCronExpression();
                    job.setCronExpression(cronExpression);
                }
                jobList.add(job);
            }
        }
        return jobList;
    }

    /**
     * 所有正在运行的job
     *
     * @return
     * @throws SchedulerException
     */
    public List<ScheduleJob> getRunningJob() throws SchedulerException {
        Scheduler scheduler = schedulerFactoryBean.getScheduler();
        List<JobExecutionContext> executingJobs = scheduler.getCurrentlyExecutingJobs();
        List<ScheduleJob> jobList = new ArrayList<ScheduleJob>(executingJobs.size());
        for (JobExecutionContext executingJob : executingJobs) {
            ScheduleJob job = new ScheduleJob();
            JobDetail jobDetail = executingJob.getJobDetail();
            JobKey jobKey = jobDetail.getKey();
            Trigger trigger = executingJob.getTrigger();
            job.setJobName(jobKey.getName());
            job.setJobGroup(jobKey.getGroup());
            job.setDescription("触发器:" + trigger.getKey());
            Trigger.TriggerState triggerState = scheduler.getTriggerState(trigger.getKey());
            job.setJobStatus(triggerState.name());
            if (trigger instanceof CronTrigger) {
                CronTrigger cronTrigger = (CronTrigger) trigger;
                String cronExpression = cronTrigger.getCronExpression();
                job.setCronExpression(cronExpression);
            }
            jobList.add(job);
        }
        return jobList;
    }

    /**
     * 暂停一个job
     *
     * @param scheduleJob
     * @throws SchedulerException
     */
    public void pauseJob(ScheduleJob scheduleJob) throws SchedulerException {
        Scheduler scheduler = schedulerFactoryBean.getScheduler();
        JobKey jobKey = JobKey.jobKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());
        scheduler.pauseJob(jobKey);
    }

    /**
     * 恢复一个job
     *
     * @param scheduleJob
     * @throws SchedulerException
     */
    public void resumeJob(ScheduleJob scheduleJob) throws SchedulerException {
        Scheduler scheduler = schedulerFactoryBean.getScheduler();
        JobKey jobKey = JobKey.jobKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());
        scheduler.resumeJob(jobKey);
    }

    /**
     * 删除一个job
     *
     * @param scheduleJob
     * @throws SchedulerException
     */
    public void deleteJob(ScheduleJob scheduleJob) throws SchedulerException {
        Scheduler scheduler = schedulerFactoryBean.getScheduler();
        JobKey jobKey = JobKey.jobKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());
        scheduler.deleteJob(jobKey);

    }

    /**
     * 立即执行job
     *
     * @param scheduleJob
     * @throws SchedulerException
     */
    public void runAJobNow(ScheduleJob scheduleJob) throws SchedulerException {
        Scheduler scheduler = schedulerFactoryBean.getScheduler();
        JobKey jobKey = JobKey.jobKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());
        scheduler.triggerJob(jobKey);
    }

    /**
     * 更新job时间表达式
     *
     * @param scheduleJob
     * @throws SchedulerException
     */
    public void updateJobCron(ScheduleJob scheduleJob) throws SchedulerException {
        Scheduler scheduler = schedulerFactoryBean.getScheduler();

        TriggerKey triggerKey = TriggerKey.triggerKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());

        CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);

        CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(scheduleJob.getCronExpression());

        trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();

        scheduler.rescheduleJob(triggerKey, trigger);
    }
}

@Component
@DisallowConcurrentExecution
public class QuartzJobFactoryDisallowConcurrentExecution implements Job,Serializable {
    public final Logger log = Logger.getLogger(this.getClass());



    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        ScheduleJob scheduleJob = (ScheduleJob) context.getMergedJobDataMap().get("scheduleJob");
      //  TaskUtils.invokeMethod(scheduleJob);
        ServletContext scontext = QuartzContext.getInstance().getContext();
        ApplicationContext ctx = WebApplicationContextUtils.getWebApplicationContext(scontext);
        if(null != scheduleJob){
            Integer jobId = scheduleJob.getJobId();//获取任务id ，然后执行对应的出来方法

            if(1 == jobId){ // 这些自己写
                RealTimeDownTask realTimeDownTask = (RealTimeDownTask) ctx.getBean("realTimeDownTask");
                realTimeDownTask.downTask();
            }
            if(2 == jobId){ // 这些处理方法自己
                RefreshClockTask refreshClockTask = (RefreshClockTask) ctx.getBean("refreshClockTask");
                refreshClockTask.setDeviceTime();
            }
           

}

@Component("realTimeDownTask")

public class RealTimeDownTask {
    private static final Logger LOG = LoggerFactory.getLogger(RealTimeDownTask.class);

   
    public void downTask(){
       //具体处理方法
    }

}

@Component("refreshClockTask")
public class RefreshClockTask {

    private static final Logger logger = LoggerFactory.getLogger(RefreshClockTask.class);

 

    public void setDeviceTime() {
    //具体处理方法
    }
}

-- ----------------------------
-- Table structure for pb_task_schedule_job
-- ----------------------------
DROP TABLE IF EXISTS `pb_task_schedule_job`;
CREATE TABLE `pb_task_schedule_job` (
  `job_id` bigint(20) NOT NULL auto_increment,
  `create_time` timestamp NULL default NULL,
  `update_time` timestamp NULL default CURRENT_TIMESTAMP on update CURRENT_TIMESTAMP,
  `job_name` varchar(255) default NULL,
  `job_group` varchar(255) default NULL,
  `job_status` varchar(255) default NULL,
  `cron_expression` varchar(255) NOT NULL,
  `description` varchar(255) default NULL,
  `bean_class` varchar(255) default NULL,
  `is_concurrent` varchar(255) default NULL COMMENT '1',
  `spring_id` varchar(255) default NULL,
  `method_name` varchar(255) NOT NULL,
  `attemper_pro` int(11) default NULL,
  `interval_time` varchar(20) default NULL,
  PRIMARY KEY  (`job_id`),
  UNIQUE KEY `name_group` USING BTREE (`job_name`,`job_group`)
) ENGINE=InnoDB AUTO_INCREMENT=8 DEFAULT CHARSET=utf8;

有些数据库字段不一定用的上

，有需要demo的后期可以补上，今天就到这里

quartz动态定时任务

猜你喜欢