为了能够实现对定时任务的动态控制，我将定时任务做了一个实体类，并将相关信息映射到了数据库中
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还有一些需要改进的地方，如果高手有例子的话，还望赐教啊！！！互相交流，互相进步！！，谢谢
相关推荐
SSH+quartz实现的可动态配置时间规则的定时任务是一个在IT行业中常见的需求，尤其是在企业级应用和服务中，为了实现自动化运维、数据处理或者业务触发等目的。SSH指的是Spring、Struts和Hibernate这三个Java开发框架...
本文将深入探讨如何在Spring中配置多个Quartz定时任务，并结合`quartz.properties`文件进行详细讲解。 首先，我们需要理解Quartz的基本概念。Quartz是开源的作业调度框架，允许应用程序在特定时间执行任务。它支持...
在本实例中，我们将探讨如何在Java Web环境中设置和执行定时任务，以及涉及到的相关技术和工具。 首先，Java Web定时任务通常通过Java的定时框架如Quartz或Spring的TaskScheduler来实现。Quartz是一个开源的作业...
在Java中，有多种实现定时任务调度的方式，包括但不限于Java内置的`java.util.Timer`类、Spring框架的`@Scheduled`注解以及Quartz库。 1. **Java内置的`java.util.Timer`和`TimerTask`**： - `Timer`类用于创建一...
例如，可以开启或关闭定时任务，调整线程池大小等： ```properties # application.properties spring.task.scheduling.pool.size=5 # 设置定时任务线程池大小为5 ``` 除了`@Scheduled`注解，Spring Boot还支持使用...
总的来说，Spring 与 Quartz 的整合提供了强大的定时任务管理能力，无论是旧版的 1.8 还是新版的 2.2，都可以帮助开发者灵活地定义和控制任务执行。理解并掌握这两个版本的整合方法，将有助于在实际开发中构建出稳定...
Quartz是一款开源的作业调度框架，它允许开发者创建、组织和执行定时任务。在Quartz 2.2.1版本中，对存储和持久化进行了优化，以支持更高效、可靠的作业调度。在这个基于Spring的配置中，我们将深入探讨如何在Spring...
Spring与Quartz的结合使用，为开发者提供了在应用程序中实现定时任务的强大工具。 首先，Spring 3.2之后对Quartz的配置有所改变。在早期版本中，配置通常涉及XML配置文件，而在新版本中，Spring推荐使用Java配置或...
3. **配置调度器**：使用Quartz.NET的`IScheduler`和`StandardSchedulerFactory`来创建和配置调度器，设定作业触发的时间规则。 4. **启动调度器**：启动调度器，使其按照预定规则执行作业。 具体代码示例中，`...
在Spring配置文件中，我们需要开启定时任务支持并配置调度器。以下是一个XML配置示例： ```xml ``` 这样，Spring会自动扫描并执行所有标记了`@Scheduled`的方法。 3. **使用TimerTask与Spring集成** ...
此外，JFinal提供了丰富的内置插件，如：I18n、Shiro安全控制、Quartz定时任务等，满足了各种应用场景的需求。 二、JFinal的项目结构与配置 在JFinal项目中，通常会包含以下几个主要部分： 1. src/main/java：...