这里是我自己项目用到的业务逻辑,需要用的只要稍微修改下就可以直接使用
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);
}
}