springmvc+quartz 实现定时任务

springmvc+quartz实现定时任务；

1.pom.xml中添加依赖

    1）springmvc依赖省略。。

     2）quartz依赖

   

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

 

2. 代码实现

  1）systemJob实体类

  

  省略 geter and seter

   2.) service 类

 

  3.）任务调度类

   

package com.meta.wx.quartz;

import com.meta.wx.beans.SystemJob;
import com.meta.wx.utils.DateUtil;
import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
import org.springframework.stereotype.Service;

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

/**
 * 定时任务
 * @author Administrator
 * CronTrigger的作业 （Trigger的另一个分支）比较强大
 *  基于日历的作业调度器 （如在每月的1号执行或每周一调用等）
 *  而不像SimpleTrigger那样精确指定间隔时间，比SimpleTrigger更常用。
 *  Cront 表达式来设置调度的频率
 *  秒 分 时 日 月 周 年     顺序设置
 *
 *  Scheduler 的主要函数
 *  Date scheduleJob(JobDetail jobDetail,Trigger trigger) 绑定JobDetail和Trigger 返回最近一次要执行的时间
 *  void start() 启动
 *  void standby()挂起执行（可用start()开启）
 *  void  shutdown()关闭
 */
@Service
public class JobTask {
    private Logger log= LoggerFactory.getLogger(JobTask.class);
    @Autowired
    private SchedulerFactoryBean schedulerFactoryBean;


    /**
     * 启动任务
     * @throws SchedulerException
     */
  public boolean startJob(SystemJob sjob) throws SchedulerException{
      //创建Scheduler实例
      Scheduler scheduler=schedulerFactoryBean.getScheduler();
    //创建一个JobDetail实例，绑定所建的作业
      Class clazz= null;
      try {
          clazz = Class.forName(sjob.getClasspath());
      } catch (ClassNotFoundException e) {
          e.printStackTrace();
      }

      JobDetail jobDetail=JobBuilder.newJob(clazz).build();
      // 创建一个Trigger;
      TriggerKey triggerKey=TriggerKey.triggerKey(sjob.getId(),Scheduler.DEFAULT_GROUP);
      CronTrigger trigger =(CronTrigger)TriggerBuilder.newTrigger()
              .withIdentity(triggerKey)
              .withSchedule(
                      //1.2018年内每天10点15分出发一次
                      //可通过cront表达式在线生成 http://cron.qqe2.com/
                      CronScheduleBuilder.cronSchedule(sjob.getCron())//参数为cront表达式(秒 分 时 日 月 周 年)
              )
              .build();
          scheduler.scheduleJob(jobDetail,trigger);//绑定与触发器

      //启动任务
      if(!scheduler.isShutdown()){
          scheduler.start();
          log.info("---任务["+triggerKey.getName()+"] 启动成功。。。");
          return true;
      }else{
          log.info("---任务["+triggerKey.getName()+"] 已启动，无需再次启动。。。");
      }
    return false;
  }

    /**
     * 修改任务
     * @param sjob
     * @return
     * @throws SchedulerException
     */
    public boolean updateJob(SystemJob sjob) {
        //创建Scheduler实例
        Scheduler scheduler=schedulerFactoryBean.getScheduler();
        String createTime = DateUtil.getCurDate();

        try {
            Class clazz =null;
            try {
                clazz = Class.forName(sjob.getClasspath());
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
            //创建一个JobDetail实例，绑定所建的作业（将该实例与HelloJobClass绑定）
            JobDetail jobDetail=JobBuilder.newJob(clazz).build();
            // 创建一个Trigger;
            TriggerKey triggerKey=TriggerKey.triggerKey(sjob.getId(),Scheduler.DEFAULT_GROUP);

            if (scheduler.checkExists(triggerKey)){
                return false;
            }

            JobKey jobKey=JobKey.jobKey(sjob.getId(),Scheduler.DEFAULT_GROUP);
            CronScheduleBuilder scheduleBuilder=CronScheduleBuilder.cronSchedule(sjob.getCron())
                    .withMisfireHandlingInstructionDoNothing();
            CronTrigger trigger=TriggerBuilder.newTrigger().withIdentity(triggerKey)
                    .withDescription(createTime).withSchedule(scheduleBuilder).build();

                JobDetail jobDetail1=scheduler.getJobDetail(jobKey);

            HashSet<Trigger> triggerSet=new HashSet<>();
            triggerSet.add(trigger);
            scheduler.scheduleJob(jobDetail,triggerSet,true);
            log.info("---任务[{}]更新成功---",triggerKey.getName());
            return true;
        } catch (SchedulerException e) {
            e.printStackTrace();
            throw new RuntimeException(e.getMessage());
        }
    }

    /**
     * 删除
     * @param job
     * @return
     */
    public boolean remove(SystemJob job){
        Scheduler scheduler=schedulerFactoryBean.getScheduler();
        TriggerKey triggerKey=TriggerKey.triggerKey(job.getId(),Scheduler.DEFAULT_GROUP);

        try {
            if (checkJob(job)){
                scheduler.pauseTrigger(triggerKey);
                scheduler.unscheduleJob(triggerKey);
                log.info("---任务[{}]删除成功！",triggerKey.getName());
                return true;
            }
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
        return  false;
    }

    /**
     *     true 存在 false 不存在
     * @param job
     * @return
     */
    public boolean checkJob(SystemJob job){
        Scheduler scheduler=schedulerFactoryBean.getScheduler();
        //触发器
        TriggerKey triggerKey=TriggerKey.triggerKey(job.getId(),Scheduler.DEFAULT_GROUP);

        try {
               if(scheduler.checkExists(triggerKey)){
                   return true;
               }
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
       return false;
    }
}

4.)任务启动线程类

package com.meta.wx.model;

import com.meta.wx.beans.SystemJob;
import com.meta.wx.quartz.JobTask;
import com.meta.wx.service.JobService;
import com.meta.wx.utils.SpringUtil;
import org.quartz.Job;
import org.quartz.SchedulerException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Configuration;

import javax.annotation.Resource;
import java.util.List;

/**
 * Created by Administrator on 2019/3/28.
 * 启动数据库中已经设定为启动状态（status：true）的任务，项目启动时init
 */
@Configuration
public class JobTreadModel extends Thread{
    private Logger log= LoggerFactory.getLogger(JobTreadModel.class);
    @Resource
   private JobService jobService;


    @Override
    public void run() {

           try {
               Thread.sleep(1000);
               log.info("---启动任务线程----");
               JobTask jobTask = SpringUtil.getBean("jobTask");
               List<SystemJob> jobList = jobService.startJob();
               //开启任务
               jobList.forEach(jobs -> {
                   log.info("---任务[{}] 系统 init---开始启动 ", jobs.getId());
                   try {
                       jobTask.startJob(jobs);
                   } catch (SchedulerException e) {
                       e.printStackTrace();
                   }
               });
               if (jobList.size() == 0) {
                   log.info("---数据库暂无启动的任务---------");
               } else {
                   log.info("---任务启动完毕---------");
               }
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
    }
}

5）使用spring的ApplicationListener监听待加载完毕时启动任务

package com.meta.wx.model;

import org.apache.log4j.Logger;
import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.stereotype.Component;

/**
 * Created by Administrator on 2019/3/28.
 * 通过监听，开辟线程，执行定时任务 当然 也可以执行其他
 */
@Component
public class MyApplicationListener implements ApplicationListener<ContextRefreshedEvent> {
   public Logger log=Logger.getLogger(MyApplicationListener.class);


    /**
     * bean加载完之后执行
     * @param event
     */
    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
        System.out.println("-------------bean初始化完毕-------------");
        /**
         * 系统两种容器：root application context 和项目名-servlet context ；
         * 下面代码防止执行两次
         */
        if(event.getApplicationContext().getParent() == null) {

            JobTreadModel myThread = (JobTreadModel) event.getApplicationContext().getBean(
                    "jobTreadModel");
            myThread.start();
        }
    }
}

6）配置spring的Application_mvc.xml

    <!-- quartz 定时任务配置-->
    <bean id="jobFactory" class="com.meta.wx.quartz.MyJobFactory"></bean>

    <bean name="schedulerFactoryBean" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
        <property name="jobFactory" ref="jobFactory"></property>
    </bean>