为了能够实现对定时任务的动态控制，我将定时任务做了一个实体类，并将相关信息映射到了数据库中
package com.acca.entity;
/**
*
* 任务实体
*
*
* @author zhouhua, 2013-1-16
*/
public class SchedulingJob {
public static final int JS_ENABLED = 0; // 任务启用状态
public static final int JS_DISABLED = 1; // 任务禁用状态
public static final int JS_DELETE = 2; // 任务已删除状态
private String jobId; // 任务的Id，一般为所定义Bean的ID
private String jobName; // 任务的描述
private String jobGroup; // 任务所属组的名称
private int jobStatus; // 任务的状态，0：启用；1：禁用；2：已删除
private String cronExpression; // 定时任务运行时间表达式
private String memos; // 任务描述
/**
* @return the jobId
*/
public String getJobId() {
return jobId;
}
/**
* @param jobId the jobId to set
*/
public void setJobId(String jobId) {
this.jobId = jobId;
}
/**
* @return the jobName
*/
public String getJobName() {
return jobName;
}
/**
* @param jobName the jobName to set
*/
public void setJobName(String jobName) {
this.jobName = jobName;
}
/**
* @return the jobGroup
*/
public String getJobGroup() {
return jobGroup;
}
/**
* @param jobGroup the jobGroup to set
*/
public void setJobGroup(String jobGroup) {
this.jobGroup = jobGroup;
}
/**
* @return the jobStatus
*/
public int getJobStatus() {
return jobStatus;
}
/**
* @param jobStatus the jobStatus to set
*/
public void setJobStatus(int jobStatus) {
this.jobStatus = jobStatus;
}
/**
* @return the cronExpression
*/
public String getCronExpression() {
return cronExpression;
}
/**
* @param cronExpression the cronExpression to set
*/
public void setCronExpression(String cronExpression) {
this.cronExpression = cronExpression;
}
/**
* @return the memos
*/
public String getMemos() {
return memos;
}
/**
* @param memos the memos to set
*/
public void setMemos(String memos) {
this.memos = memos;
}
public String getTriggerName() {
return this.getJobId() + "Trigger";
}
}
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping >
<class name="com.acca.entity.SchedulingJob" table="t_job">
<id name="jobId">
<generator class="uuid"/>
</id>
<property name="jobName"/>
<property name="jobGroup"/>
<property name="jobStatus"/>
<property name="cronExpression"/>
<property name="memos"/>
</class>
</hibernate-mapping>
/**
* 启动定时任务
*
* @param context
* @param schedulingJob
*/
protected void enabled(SchedulingJob schedulingJob) {
try {
CronTrigger trigger = (CronTrigger) this.scheduler.getTrigger(
schedulingJob.getTriggerName(), schedulingJob.getJobGroup());
if (null == trigger) {
// Trigger不存在，那么创建一个
JobDetail jobDetail = new JobDetail(schedulingJob.getJobId(),
schedulingJob.getJobGroup(), QuartzJobBean.class);
jobDetail.getJobDataMap().put("targetObjectId", schedulingJob.getJobId());
trigger = new CronTrigger(schedulingJob.getTriggerName(),
schedulingJob.getJobGroup(), schedulingJob.getCronExpression());
this.scheduler.scheduleJob(jobDetail, trigger);
} else {
// Trigger已存在，那么更新相应的定时设置
trigger.setCronExpression(schedulingJob.getCronExpression());
this.scheduler.rescheduleJob(trigger.getName(), trigger.getGroup(), trigger);
}
} catch (Exception e) {
e.printStackTrace();
// TODO
}
}
这个类我放到了service层
/**
* 禁用指定的定时任务
*
* @param context
* @param schedulingJob
*/
protected void disabled(SchedulingJob schedulingJob) {
try {
Trigger trigger = this.scheduler.getTrigger(schedulingJob.getTriggerName(),
schedulingJob.getJobGroup());
if (null != trigger) {
this.scheduler.deleteJob(schedulingJob.getJobId(), schedulingJob.getJobGroup());
}
} catch (SchedulerException e) {
e.printStackTrace();
// TODO
}
}
/**
*
*
* @version sas-web v1.0
* @author zhouhua, 2013-1-16
*/
public interface MyJob {
public void execute();
}
public class QuartzJobBean implements Job {
/**
* @param arg0
* @throws JobExecutionException
* @see org.quartz.Job#execute(org.quartz.JobExecutionContext)
*/
@Override
public void execute(JobExecutionContext context) throws JobExecutionException {
String targetBeanId = (String) context.getMergedJobDataMap().get("targetObjectId");
if (SpringUtils.isNullString(targetBeanId))
return;
Object targetBean = SpringUtils.getBean(targetBeanId);
if (null == targetBean)
return;
// 判断是否是实现了MyJob接口
if (!(targetBean instanceof MyJob))
return;
// 执行相应的任务
((MyJob) targetBean).execute();
}
}
package com.acca.util;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
/**
*
*
*
* @author zhouhua, 2013-1-16
*/
public class SpringUtils implements ApplicationContextAware {
private static ApplicationContext applicationContext;
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
this.applicationContext = applicationContext;
}
public static Object getBean(String name) throws BeansException {
return applicationContext.getBean(name);
}
/**
* 判断字符串是否为空
* @param str
* @return
*/
public static boolean isNullString(String str){
if("".equals(str)&&str==null){
return true;
}else{
return false;
}
}
}
public class QuartzJob implements MyJob {
public void work() {
System.out.println("Quartz的任务调度！！！"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
}
/**
*
* @see com.acca.task.MyJob#execute()
*/
@Override
public void execute() {
work();
}
}
public class QuartzJob01 implements MyJob {
public void work() {
System.out.println("Quartz01的任务调度！！！"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
}
/**
*
* @see com.acca.task.MyJob#execute()
*/
@Override
public void execute() {
work();
}
}
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">
<bean id="scheduler"
class="org.springframework.scheduling.quartz.SchedulerFactoryBean" />
<bean id="springUtils" class="com.acca.util.SpringUtils"></bean>
<bean id="quartzJob" class="com.acca.task.QuartzJob"></bean>
<bean id="quartzJob01" class="com.acca.task.QuartzJob01"></bean>
</beans>
这里需要注意的是：定时任务的bean id必须和数据中的id一致否则无法获取定时任务
public class SystemIni implements ServletContextListener {
private JobTaskService jobTaskService;
/**
* @param arg0
* @see javax.servlet.ServletContextListener#contextDestroyed(javax.servlet.ServletContextEvent)
*/
@Override
public void contextDestroyed(ServletContextEvent arg0) {
// TODO Auto-generated method stub
}
/**
* 项目启动时加载所有已启动的定时任务
*
* @param arg0
* @see javax.servlet.ServletContextListener#contextInitialized(javax.servlet.ServletContextEvent)
*/
@Override
public void contextInitialized(ServletContextEvent servletContextEvent) {
System.out.println("load....");
ServletContext context=servletContextEvent.getServletContext();
ApplicationContext applicationContext=WebApplicationContextUtils.getWebApplicationContext(context);
jobTaskService=(JobTaskService) applicationContext.getBean("jobTaskService");
jobTaskService.IniLoadClass();
}
}
我自己写了一个demo，如果有需要的朋友可以给我邮箱，我会及时给你发过去，高手勿喷，这个demo还有一些需要改进的地方，如果高手有例子的话，还望赐教啊！！！互相交流，互相进步！！，谢谢
求代码一份，fhm727@163.com,多谢
相关推荐
quartz 动态定时任务 根据数据库数据配置动态定时任务
可以通过quartz和spring的简单配置即可完成，但如果要改变任务的执行时间、频率，废弃任务等就需要改变配置甚至代码需要重启服务器，这里介绍一下如何通过quartz与spring的组合实现动态的改变定时任务的状态的一个...
定时任务quartz实现分组串行并行动态配置
SpringBoot2 与 Quartz 整合的Demo。 后台可添加、修改、移除 定时任务。 也可查看当前任务的状态 灵活的定时任务
spring+springMVC+mybatis+quartz动态定时任务
附件中实现了对quartz的动态添加、修改和删除定时任务，方便通过页面动态控制执行定时任务。
springboot+quartz 动态化配置，可在页面操作，查看、添加、修改、删除，暂停等操作
这三个核心组件共同组成了Quartz的任务调度机制，使得开发人员可以通过配置简单的定时任务来实现复杂的调度策略。 Scheduler 是Quartz的核心组件，它负责调度和执行任务。Scheduler有一个任务管理器，负责维护任务...
Springboot整合Quartz实现定时任务数据库动态配置，新增任务、修改cron表达式、暂停任务、恢复任务、删除任务等操作
主要实现quartz的时间规则的动态配置以及动态开启和关闭
上一次传错了资源了，这个是正确的，包含quartz动态定时任务的
springboot整合Quartz实现动态配置定时任务源码
springboot jpa quartz 动态定时任务,任务增加，任务删除，任务修改demo,非常简单
SpringBoot整合Quartz实现动态定时任务,在页面动态展示,添加,暂停,删除定时任务. 并整合了MyBatis-plus, 感兴趣的小伙伴 可以试试
Spring+Quartz 从数据库中获取定时任务和定时时间，动态实现对定时任务的增删改查，部署到tomcat即可看到定时任务执行效果。本人亲测，可用！
基于Spring的Quartz动态定时任务增删改查，代码简洁。后端采用SpringMvc+Spring+Mybatis+Quartz，前端采用Bootstrap框架，数据库采用MySQL；完成定时任务动态任务初始化，增删改查
Quartz.net作业调度自定义定时执行任务多任务执行c#，定时执行任务，如超时取消订单，自动确认收货等等
基于SSM+quartz的定时任务管理demo
Spring + quartz 定时任务修改定时时间不重启服务
Spring Quartz 动态暂停、恢复、修改定时任务的一个demo，使用maven构建，框架采用spring springmvc jpa，数据库mysql，含数据库脚本，运行可用，页面访问地址http://localhost:8080/quartz_demo/quartz/list