Spring整合Quartz实现动态定时任务-阿里云开发者社区

</pre><p>1.创建动态定时任务实体</p><p><pre name="code" class="java">import java.util.Date;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.SequenceGenerator;
import javax.persistence.Table;

/**
 * 动态定时任务
 * 
 * @author
 * 
 */
@Entity
@Table(name = "SCHEDULE_JOB", schema = "JLW")
public class ScheduleJob implements java.io.Serializable {

	private static final long serialVersionUID = 7058240968903003001L;
	private Integer id;
	private Date createTime;
	private Date updateTime;
	private String jobName;// 任务名称
	private String jobGroup;// 任务分组
	private String jobStatus;// 任务状态 是否启动任务
	private String cronExpression;// cron表达式
	private String description;// 描述
	private String beanClass;// 任务执行时调用哪个类的方法 包名+类名
	private String isConcurrent;// 任务是否有状态（是否并发任务）
	private String springId;// spring bean
	private String methodName;// 任务调用的方法名

	@SequenceGenerator(name = "generator", sequenceName = "SEQ_SCHEDULE_JOB")
	@Id
	@GeneratedValue(strategy = GenerationType.AUTO, generator = "generator")
	@Column(name = "ID", unique = true, nullable = false, precision = 10, scale = 0)
	public Integer getId() {
		return id;
	}

	public void setId(Integer id) {
		this.id = id;
	}

	@Column(name = "CREATETIME")
	public Date getCreateTime() {
		return createTime;
	}

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

	@Column(name = "UPDATETIME")
	public Date getUpdateTime() {
		return updateTime;
	}

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

	@Column(name = "JOBNAME")
	public String getJobName() {
		return jobName;
	}

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

	@Column(name = "JOBGROUP")
	public String getJobGroup() {
		return jobGroup;
	}

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

	@Column(name = "JOBSTATUS")
	public String getJobStatus() {
		return jobStatus;
	}

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

	@Column(name = "CRONEXPRESSION")
	public String getCronExpression() {
		return cronExpression;
	}

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

	@Column(name = "DESCRIPTION")
	public String getDescription() {
		return description;
	}

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

	@Column(name = "BEANCLASS")
	public String getBeanClass() {
		return beanClass;
	}

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

	@Column(name = "ISCONCURRENT")
	public String getIsConcurrent() {
		return isConcurrent;
	}

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

	@Column(name = "SPRINGID")
	public String getSpringId() {
		return springId;
	}

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

	@Column(name = "METHODNAME")
	public String getMethodName() {
		return methodName;
	}

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

2.实现实体的dao层与service层，这里仅给出service接口的代码



public interface ScheduleJobService {

	List<ScheduleJob> findAll();

	void save(ScheduleJob scheduleJob);

	void update(ScheduleJob scheduleJob);

	ScheduleJob findById(Integer id);
}

3.实现系统动态定时任务管理service接口和实现



public interface ScheduleJobManageService {

	/**
	 * 添加任务
	 * 
	 * @param scheduleJob
	 */
	void addScheduleJob(ScheduleJob scheduleJob);

	/**
	 * 暂停任务
	 * 
	 * @param scheduleJob
	 */
	void pauseScheduleJob(ScheduleJob scheduleJob);

	/**
	 * 恢复任务
	 * 
	 * @param scheduleJob
	 */
	void resumeScheduleJob(ScheduleJob scheduleJob);

	/**
	 * 删除任务
	 * 
	 * @param scheduleJob
	 */
	void deleteScheduleJob(ScheduleJob scheduleJob);

	/**
	 * 立即执行任务
	 * 
	 * @param scheduleJob
	 */
	void runScheduleJobNow(ScheduleJob scheduleJob);

	/**
	 * 更新任务
	 * 
	 * @param scheduleJob
	 */
	void updateSchedule(ScheduleJob scheduleJob);

	/**
	 * 所有任务
	 * 
	 * @return
	 */
	List<ScheduleJob> getAllScheduleJob();

	/**
	 * 所有正在运行的任务
	 * 
	 * @return
	 */
	List<ScheduleJob> getAllScheduleJobRunning();

	/**
	 * 系统初始化添加计划任务
	 */
	void init();
}

@Service
@Transactional
public class ScheduleJobManageServiceImpl implements ScheduleJobManageService {

	public final Logger logger = Logger.getLogger(getClass());
	@Autowired
	private SchedulerFactoryBean schedulerFactoryBean;
	@Resource
	private ScheduleJobService scheduleJobService;

	@Override
	public void addScheduleJob(ScheduleJob scheduleJob) {
		if (scheduleJob == null || !Constants.SCHEDULEJOB_STATUS_RUNNING.equals(scheduleJob.getJobStatus())) {
			return;
		}
		Scheduler scheduler = schedulerFactoryBean.getScheduler();
		logger.info("开始添加任务，任务:" + scheduleJob.getJobName());
		try {
			TriggerKey triggerKey = TriggerKey.triggerKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());
			CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
			// 不存在，创建一个
			if (trigger == null) {
				Class clazz = Constants.SCHEDULEJOB_CONCURRENT_IS.equals(scheduleJob.getIsConcurrent()) ? ScheduleJobFactory.class : ScheduleJobFactoryNotCurrent.class;
				JobDetail jobDetail = JobBuilder.newJob(clazz).withIdentity(scheduleJob.getJobName(), scheduleJob.getJobGroup()).build();
				jobDetail.getJobDataMap().put("scheduleJob", scheduleJob);
				CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(scheduleJob.getCronExpression());
				trigger = TriggerBuilder.newTrigger().withIdentity(scheduleJob.getJobName(), scheduleJob.getJobGroup()).withSchedule(scheduleBuilder).build();
				scheduler.scheduleJob(jobDetail, trigger);
			} else {
				// Trigger已存在，那么更新相应的定时设置
				CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(scheduleJob.getCronExpression());
				// 按新的cronExpression表达式重新构建trigger
				trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();
				// 按新的trigger重新设置job执行
				scheduler.rescheduleJob(triggerKey, trigger);
			}
		} catch (Exception e) {
			logger.error("添加任务出错，任务:" + scheduleJob.getJobName());
		}
		logger.info("添加任务完成，任务:" + scheduleJob.getJobName());
	}

	@Override
	public void pauseScheduleJob(ScheduleJob scheduleJob) {
		try {
			Scheduler scheduler = schedulerFactoryBean.getScheduler();
			JobKey jobKey = JobKey.jobKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());
			scheduler.pauseJob(jobKey);
		} catch (Exception e) {
			logger.error("暂停任务出错，任务:" + scheduleJob.getJobName());
			throw new MyException("暂停任务出错，任务:" + scheduleJob.getJobName(), e);
		}
	}

	@Override
	public void resumeScheduleJob(ScheduleJob scheduleJob) {
		try {
			Scheduler scheduler = schedulerFactoryBean.getScheduler();
			JobKey jobKey = JobKey.jobKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());
			scheduler.resumeJob(jobKey);
		} catch (Exception e) {
			logger.error("恢复任务出错，任务:" + scheduleJob.getJobName());
			throw new MyException("恢复任务出错，任务:" + scheduleJob.getJobName(), e);
		}
	}

	@Override
	public void deleteScheduleJob(ScheduleJob scheduleJob) {
		try {
			Scheduler scheduler = schedulerFactoryBean.getScheduler();
			JobKey jobKey = JobKey.jobKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());
			scheduler.deleteJob(jobKey);
		} catch (Exception e) {
			logger.error("删除任务出错，任务:" + scheduleJob.getJobName());
			throw new MyException("删除任务出错，任务:" + scheduleJob.getJobName(), e);
		}
	}

	@Override
	public void runScheduleJobNow(ScheduleJob scheduleJob) {
		try {
			Scheduler scheduler = schedulerFactoryBean.getScheduler();
			JobKey jobKey = JobKey.jobKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());
			scheduler.triggerJob(jobKey);
		} catch (Exception e) {
			logger.error("立即启动任务出错，任务:" + scheduleJob.getJobName());
			throw new MyException("立即启动任务出错，任务:" + scheduleJob.getJobName(), e);
		}
	}

	@Override
	public void updateSchedule(ScheduleJob scheduleJob) {
		try {
			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);
		} catch (Exception e) {
			logger.error("更新任务出错，任务:" + scheduleJob.getJobName());
			throw new MyException("更新任务出错，任务:" + scheduleJob.getJobName(), e);
		}
	}

	@Override
	public List<ScheduleJob> getAllScheduleJob() {
		try {
			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;
		} catch (Exception e) {
			logger.error("获取系统所有任务出错！");
			throw new MyException("获取系统所有任务出错！", e);
		}
	}

	@Override
	public List<ScheduleJob> getAllScheduleJobRunning() {
		try {
			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;
		} catch (Exception e) {
			logger.error("获取系统所有正在运行任务出错！");
			throw new MyException("获取系统所有正在运行任务出错！", e);
		}
	}

	@Override
	public void init() {
		// 这里获取任务信息数据
		List<ScheduleJob> jobList = scheduleJobService.findAll();
		for (ScheduleJob scheduleJob : jobList) {
			addScheduleJob(scheduleJob);
		}
	}
}

service实现需要调用的类



public class ScheduleJobFactory implements Job {

	@Override
	public void execute(JobExecutionContext context) throws JobExecutionException {
		ScheduleJob scheduleJob = (ScheduleJob) context.getMergedJobDataMap().get("scheduleJob");
		ScheduleJobUtil.invokMethod(scheduleJob);
	}
}

import org.quartz.DisallowConcurrentExecution;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import com.tongdow.jianle.entity.ScheduleJob;

@DisallowConcurrentExecution
public class ScheduleJobFactoryNotCurrent implements Job {

	@Override
	public void execute(JobExecutionContext context) throws JobExecutionException {
		ScheduleJob scheduleJob = (ScheduleJob) context.getMergedJobDataMap().get("scheduleJob");
		ScheduleJobUtil.invokMethod(scheduleJob);
	}
}



public class ScheduleJobUtil {

	public final static Logger logger = Logger.getLogger(ScheduleJobUtil.class);

	/**
	 * 通过反射调用scheduleJob中定义的方法
	 * 
	 * @param scheduleJob
	 */
	public static void invokMethod(ScheduleJob scheduleJob) {
		Object object = null;
		Class clazz = null;
		try {
			if (!Common.isNullOrEmpty(scheduleJob.getSpringId()) && SpringUtils.containsBean(scheduleJob.getSpringId())) {
				object = SpringUtils.getBean(scheduleJob.getSpringId());
			} else if (!Common.isNullOrEmpty(scheduleJob.getBeanClass())) {
				clazz = Class.forName(scheduleJob.getBeanClass());
				object = clazz.newInstance();
			}
			if (object == null) {
				logger.error("任务：" + scheduleJob.getJobName() + "，结果:启动失败！");
				return;
			}
			clazz = object.getClass();
			Method method = null;
			method = clazz.getDeclaredMethod(scheduleJob.getMethodName());
			if (method != null) {
				method.invoke(object);
			} else {
				logger.error("任务：" + scheduleJob.getJobName() + "，结果:启动失败！");
				return;
			}
			logger.info("任务：" + scheduleJob.getJobName() + "，结果:启动成功！");
		} catch (Exception e) {
			logger.error("任务：" + scheduleJob.getJobName() + "，结果:启动失败！，原因:" + e.getMessage());
			throw new MyException("计划任务启动出错", e);
		}
	}
}

4.动态定时任务的执行方法



@Component
public class JobTask {

	public Logger logger = Logger.getLogger(getClass());
	@Resource
	private GoodsOrdersService goodsOrdersService;

	public void goodsOrder() {
		logger.info("商品订单处理定时任务开始！");
		logger.info("商品订单处理定时任务结束！");
	}

	public void order() {
		logger.info("订单处理定时任务开始！");
		logger.info("订单处理定时任务结束！");
	}
}

5.Spring配置文件需加入的内容

<bean id="springUtils" class="xxx" /><pre name="code" class="html"><!-- xxx为具体的类 -->

<!-- 任务调度器生成器，Spring生成具有指定属性调度器对象 -->
    <bean id="schedulerFactoryBean" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
       <!-- 生成的调度器所管理的所有触发器 -->
       <property name="triggers">
           <list>
              <ref bean="goodsOrder" /><!-- 项目发布定时任务 -->
           </list>
       </property>
       <property name="autoStartup" value="true" />
    </bean>   

    <!-- 触发器生成器类，用被指定的调度器调度生成指定规则的触发器对象 -->
    <bean id="goodsOrder" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
       <!-- 触发后要做的操作，这个操作由spring管理，只需要指定一个MethodInvokingJobDetailFactoryBean -->
       <property name="jobDetail" ref="goodsOrderJobDetail" />
       <!-- 触发规则，这里的触发规则是每隔1分钟后触发一次 -->
       <property name="cronExpression" value="0 */1 * * * ?" /><!--  -->
    </bean>
    
       
    <!--任务生成器，由spring管理，只需要指定其对应的对象和方法即可，任务的执行即是某个对象调用一个方法 -->
    <bean id="goodsOrderJobDetail"
        class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
       <!-- 指定该任务对应的调用对象，这个对象所属的类无需实现任何接口-->
        <property name="targetObject" ref="jobTask" />
       <!-- 指定在targetObject对象中某个的方法 -->
       <property name="targetMethod" value="goodsOrder" />
       <!-- 是否允许任务并发执行。当值为false时，表示必须等到前一个线程处理完毕后才再启一个新的线程 -->
       <property name="concurrent" value="false" />
    </bean>
    
	
    <!-- 一个普通的类-->
    <bean id="jobTask" class="xxx同上"/>

配置文件说明，如果只需要动态定时任务，则只需要

<bean id="schedulerFactoryBean" class="org.springframework.scheduling.quartz.SchedulerFactoryBean"/>

其他的为非动态定时任务

如果配置了这个

<bean id="jobTask" class="xxx同上"/>

则实体类可以springId字段可以指定jobTask，前提是执行任务的方法是写在这个bean里的。

6.用到的常量

/**
 * 常量定义
 * 
 * @author
 * 
 */
public class Constants {

	// 计划任务 状态和是否有状态
	public static final String SCHEDULEJOB_STATUS_RUNNING = "1";// 启动任务
	public static final String SCHEDULEJOB_STATUS_NOT_RUNNING = "0";// 不启动任务
	public static final String SCHEDULEJOB_CONCURRENT_IS = "1";// 有状态
	public static final String SCHEDULEJOB_CONCURRENT_NOT = "0";// 无状态
}

7.系统初始化

<span style="white-space:pre">	</span>logger.info("系统开始初始化");
<span style="white-space:pre">	</span>// 获取容器与相关的Service对象
<span style="white-space:pre">	</span>ApplicationContext ac = WebApplicationContextUtils.getWebApplicationContext(sce.getServletContext());
<span style="white-space:pre">	</span>ScheduleJobManageService scheduleJobManageService = ac.getBean(ScheduleJobManageService.class);
<span style="white-space:pre">	</span>// 初始化系统动态定时任务
	scheduleJobManageService.init();
	logger.info("系统初始化完成");

结束,有问题可以qq135018413

Spring整合Quartz实现动态定时任务

热门文章

最新文章

相关课程

相关电子书

相关实验场景