Springboot+Quratz实现定时任务

这里是我自己项目用到的业务逻辑，需要用的只要稍微修改下就可以直接使用

 

 

jar包：处理springboot自身jar包之外添加

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

配置启动执行定时任务

package com.epsoft.gas.web.config;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

import com.epsoft.gas.major.bpo.job.ClockTaskJobBPO;
import com.epsoft.gas.major.model.job.ClockTaskJob;
import com.epsoft.gas.major.quartz.QuartzManager;

@Component
public class GasJobConfig implements CommandLineRunner{
    
    @Autowired
    private ClockTaskJobBPO clockTaskBPO;
    
    @Value("${system.quartz}")
    private boolean quartz;

    @Override
    public void run(String... arg0) throws Exception {
        if(quartz) {
            List<ClockTaskJob> jobs = clockTaskBPO.selectTaskList("1");
            if(null != jobs) {
                QuartzManager.startAll(jobs);
            }
        }
    }
}
 

QuartzManager类：

package com.epsoft.gas.major.quartz;

import java.util.List;

import org.quartz.CronTrigger;
import org.quartz.JobDataMap;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.impl.StdSchedulerFactory;
import org.springframework.transaction.annotation.Transactional;

import com.epsoft.gas.major.bpo.job.TransGroupJob;
import com.epsoft.gas.major.model.job.ClockTaskJob;

/**
 * 定时任务管理
 *
 */
public class QuartzManager {

    // 默认的任务组名
    private static String JOB_GROUP_NAME = "EXTJWEB_JOBGROUP_NAME";
    // 触发器组名
    private static String TRIGGER_GROUP_NAME = "EXTJWEB_TRIGGERGROUP_NAME";

    /**
     * @Description: 系统启动时，调用该方法，启动数据库中存贮的所有定时任务
     */
    public static void startAll(List<ClockTaskJob> clockTaskJobs) {
        System.out.println("定时任务启动成功.....");
        try {
            SchedulerFactory gSchedulerFactory = new StdSchedulerFactory();
            Scheduler sched = gSchedulerFactory.getScheduler();
            JobDataMap dataMap=new JobDataMap();
            
            for (ClockTaskJob clockTaskJob : clockTaskJobs) {
                JobDetail jobDetail = new JobDetail(clockTaskJob.getJobName(), JOB_GROUP_NAME,
                        TransGroupJob.class);// 任务名，任务组，任务执行类
                dataMap.put("transId",clockTaskJob.getTransId());
                dataMap.put("jobName", clockTaskJob.getJobName());
                dataMap.put("id", clockTaskJob.getId());
                jobDetail.setJobDataMap(dataMap);
                // 触发器
                CronTrigger trigger = new CronTrigger(clockTaskJob.getJobName(), TRIGGER_GROUP_NAME);// 触发器名,触发器组
                trigger.setCronExpression(clockTaskJob.getCron());// 触发器时间设定
                sched.scheduleJob(jobDetail, trigger);
            }
            //判断是否启动，如果没有启动则，直接启动，否则 如果启动了，先停止，再启动
            if (!sched.isShutdown()) {
                sched.start();
            }else {
                sched.shutdown();
                sched.start();
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * @Description: 添加定时任务
     */
    public static void addJob(Scheduler sched, String jobName, String time) {
        try {
            JobDetail jobDetail = new JobDetail(jobName, JOB_GROUP_NAME, TransGroupJob.class);// 任务名，任务组，任务执行类
            // 触发器
            CronTrigger trigger = new CronTrigger(jobName, TRIGGER_GROUP_NAME);// 触发器名,触发器组
            trigger.setCronExpression(time);// 触发器时间设定
            sched.scheduleJob(jobDetail, trigger);
            //判断是否启动，如果没有启动则，直接启动，否则 如果启动了，先停止，再启动
            if (!sched.isShutdown()) {
                sched.start();
            }else {
                sched.shutdown();
                sched.start();
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * @throws SchedulerException 
     * @Description: 修改一个任务的触发时间(使用默认的任务组名，触发器名，触发器组名)
     */
    @Transactional
    public static void modifyJobTime(Scheduler sched, String jobName, String time) throws SchedulerException {
            CronTrigger trigger = (CronTrigger) sched.getTrigger(jobName, TRIGGER_GROUP_NAME);
            if (trigger == null) {
                return ;
            }
            removeJob(sched, jobName);
            addJob(sched, jobName, time);
    }

    /**
     * @Description: 移除一个任务(使用默认的任务组名，触发器名，触发器组名)
     */
    public static void removeJob(Scheduler sched, String jobName) {
        try {
            sched.pauseTrigger(jobName, TRIGGER_GROUP_NAME);// 停止触发器
            sched.unscheduleJob(jobName, TRIGGER_GROUP_NAME);// 移除触发器
            sched.deleteJob(jobName, JOB_GROUP_NAME);// 删除任务
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * @Description:关闭所有定时任务
     */
    public static void shutdownJobs(Scheduler sched) {
        try {
            if (!sched.isShutdown()) {
                sched.shutdown();
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}
 

 

执行任务：

package com.epsoft.gas.major.bpo.job;

import java.util.Date;
import java.util.concurrent.Future;
import org.quartz.Job;
import org.quartz.JobDataMap;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

import com.epsoft.gas.core.exception.BaseException;
import com.epsoft.gas.major.bpo.trans.TransManageBPO;
import com.epsoft.gas.major.model.job.ClockTaskJob;
import com.epsoft.gas.major.util.ApplicationContextUtil;

/**
 * 转换抽取定时任务
 * 
 *
 */
public class TransGroupJob implements Job {

    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        JobDataMap dataMap = context.getJobDetail().getJobDataMap();
        if(dataMap.get("jobName")==null) {
            throw new BaseException("存在定时任务名为空,定时任务执行失败...");
        }
        String jobName=dataMap.get("jobName").toString();
        if(dataMap.get("transId")==null) {
            throw new BaseException(jobName+"的获取转换id为空,定时任务执行失败...");
        }
        if(dataMap.get("id")==null) {
            throw new BaseException(jobName+"的获取任务id为空,定时任务执行失败...");
        }
        String transId=dataMap.get("transId").toString();
        System.out.println(jobName+"任务开始执行....");
        TransManageBPO transManageBPO=ApplicationContextUtil.getBean(TransManageBPO.class);
        //查询所有库中保存的定时任务
        Future<Integer> f= null;
        Date startDate = new Date();
        try {
            f=transManageBPO.asyncTransExtract(transId);
            while(true){
                 if(f.isDone()) {
                     break;
                 }
        }
        Date endDate = new Date();
        long num = (endDate.getTime()) - (startDate.getTime());
        //该定时任务记录此次任务的执行时间
        ClockTaskJob clockTaskJob = new ClockTaskJob();
        clockTaskJob.setId(dataMap.get("id").toString());
        clockTaskJob.setJoblastTime(new Date());
        System.out.println(jobName+"任务结束,总抽取耗时："+num);
        } catch (Exception e) {
            e.printStackTrace();
        }
        
    }

}
 

 

注入bean类（关键）

package com.epsoft.gas.major.util;

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

@Component
public class ApplicationContextUtil implements ApplicationContextAware {

    private static ApplicationContext appContext;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        // TODO Auto-generated method stub
        appContext = applicationContext;
    }

    public static ApplicationContext getAppContext() {
        return appContext;
    }

    public static <T> T getBean(Class<T> clazz) {
        return getAppContext().getBean(clazz);
    }

}