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

时间：2021-12-08 07:52:47
</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@Transactionalpublic 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;@DisallowConcurrentExecutionpublic 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 






 




标签：
相关文章