文档章节

定时任务-quartz的使用,实现可页面化管理

chaun
 chaun
发布于 2015/07/30 17:37
字数 2440
阅读 1347
收藏 26
定时任务-quartz的使用,实现可页面化管理
使用spring+quartz实现定时任务的页面化管理。主要特点:
1.时间表达式等信息配置在数据库中,从而实现页面化管理。
2.可以手动执行或者停止单个任务,也可以使一个任务加入或者移出自动运行列表。

下面开始介绍用法,在这之前先说明框架的版本。spring3.2.4+quartz1.6.0
一.配置文件
只需要在spring的配置文件中加入:
<bean id="scheduler"  class="org.springframework.scheduling.quartz.SchedulerFactoryBean">  
	</bean>
	<bean id="jobManager"  class="com.temobi.quartz.JobManager">  
	</bean>

说明:scheduler对象是spring管理定时任务的对象。
jobManager是我们自定义加载定时任务列表的对象,此对象加载所有任务列表后,将他们加入到自动运行列表。
二.jobManager代码:
public class JobManager implements InitializingBean  {
	private static final Log log = LogFactory.getLog(JobManager.class);
	@Autowired
	TaskJobService taskJobService;
	@Autowired
	QuartzManager quartzManager;
	@Override
	public void afterPropertiesSet() throws Exception {
		loadAllJob();
	}
	private void loadAllJob(){
		List<TaskJob> list =taskJobService.getTaskList();
		quartzManager.enableCronSchedule(list);
	}
	
}


说明:
1.实现spring中InitializingBean接口,并覆盖afterPropertiesSet方法,则该方法会在应用启动的时候而且其他servlet执行完成之后执行,此处用来加载所有定时任务,并加入定时任务自动运行列表。
2.quartzManager是我们自定义的定时任务管理类,用来实现我们文章开头说的功能。
三.QuartzManager代码
@Controller
public class QuartzManager {
	@Autowired
	Scheduler scheduler;
	
	private static final Log log = LogFactory.getLog(QuartzManager.class);
	public void enableCronSchedule(List<TaskJob> list) {
		for(TaskJob task : list){
			SchedulingJob job = new SchedulingJob();
			job.setJobId(task.getId());
			job.setJobName(task.getJobName());
			//job.setMemos(task.getNote());
			job.setCronExpression(task.getJobCronExpression());
			try{
			String  className=	task.getJobClass().trim();
				Class clazz = Class.forName(className);
				job.setStateFulljobExecuteClass(clazz);
			}catch(Exception e){
				e.printStackTrace();
				continue;
			}
			JobDataMap paramsMap = new JobDataMap();
			paramsMap.put("jobName", task.getJobName());

			if(task.getParamsKey1()!=null && task.getParamsValue1()!=null){
				paramsMap.put(task.getParamsKey1(), task.getParamsValue1());
			}
			if(task.getParamsKey2()!=null && task.getParamsValue2()!=null){
				paramsMap.put(task.getParamsKey2(), task.getParamsValue2());
			}
			if(task.getParamsKey3()!=null && task.getParamsValue3()!=null){
				paramsMap.put(task.getParamsKey3(), task.getParamsValue3());
			}
			enableCronSchedule(job, paramsMap, true);
			
			log.info("系统结束初始化任务:"+task.getId()+":"+task.getJobName()+":"+task.getJobId());
		}
	}
	/**
	 * 启动一个自定义的job
	 * 
	 * @param schedulingJob
	 *            自定义的job
	 * @param paramsMap
	 *            传递给job执行的数据
	 * @param isStateFull
	 *            是否是一个同步定时任务,true:同步,false:异步
	 * @return 成功则返回true,否则返回false
	 */
	public boolean enableCronSchedule(SchedulingJob schedulingJob, JobDataMap paramsMap, boolean isStateFull) {
		if (schedulingJob == null) {
			return false;
		}
		try {
			//scheduler = (Scheduler) ApplicationHelper.getBean("scheduler");
			CronTrigger trigger = (CronTrigger) scheduler.getTrigger(schedulingJob.getTriggerName(),
					schedulingJob.getJobGroup());
			if (null == trigger) {// 如果不存在该trigger则创建一个
				JobDetail jobDetail = null;
				if (isStateFull) {
					jobDetail = new JobDetail(schedulingJob.getJobId(), schedulingJob.getJobGroup(),
							schedulingJob.getStateFulljobExecuteClass());
				} else {
					jobDetail = new JobDetail(schedulingJob.getJobId(), schedulingJob.getJobGroup(),
							schedulingJob.getJobExecuteClass());
				}
				jobDetail.setJobDataMap(paramsMap);
				trigger = new CronTrigger(schedulingJob.getTriggerName(), schedulingJob.getJobGroup(),
						schedulingJob.getCronExpression());
				scheduler.scheduleJob(jobDetail, trigger);
			} else {
				// Trigger已存在,那么更新相应的定时设置
				trigger.setCronExpression(schedulingJob.getCronExpression());
				scheduler.rescheduleJob(trigger.getName(), trigger.getGroup(), trigger);
			}
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
		return true;
	}

	/**
	 * 禁用一个job
	 * 
	 * @param jobId
	 *            需要被禁用的job的ID
	 * @param jobGroupId
	 *            需要被警用的jobGroupId
	 * @return 成功则返回true,否则返回false
	 */
	public boolean disableSchedule(String jobId) {
		if (jobId.equals("")) {
			return false;
		}
		try {
			String jobGroupId="DEFAULT";
			Trigger trigger = getJobTrigger(jobId, jobGroupId);
			if (null != trigger) {
				scheduler.deleteJob(jobId, jobGroupId);
			}
		} catch (SchedulerException e) {
			e.printStackTrace();
			return false;
		}
		return true;
	}

	/**
	 * 得到job的详细信息
	 * 
	 * @param jobId
	 *            job的ID
	 * @param jobGroupId
	 *            job的组ID
	 * @return job的详细信息,如果job不存在则返回null
	 */
	public JobDetail getJobDetail(String jobId, String jobGroupId) {
		if (jobId.equals("") || jobGroupId.equals("") || null == jobId || jobGroupId == null) {
			return null;
		}
		try {
			return scheduler.getJobDetail(jobId, jobGroupId);
		} catch (SchedulerException e) {
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 得到job对应的Trigger
	 * 
	 * @param jobId
	 *            job的ID
	 * @param jobGroupId
	 *            job的组ID
	 * @return job的Trigger,如果Trigger不存在则返回null
	 */
	public Trigger getJobTrigger(String jobId, String jobGroupId) {
		if (jobId.equals("") || jobGroupId.equals("") || null == jobId || jobGroupId == null) {
			return null;
		}
		try {
			return scheduler.getTrigger(jobId + "Trigger", jobGroupId);
		} catch (SchedulerException e) {
			e.printStackTrace();
			return null;
		}
	}

}


说明:
1.主要方法有三个,启动一个任务,禁用一个任务,启动多个任务。启动即加入自动运行列表,禁用即移出自动运行列表。
2.TaskJob是一个任务对象,和数据库表结构相对应,后面给出数据库设计。
3.程序中有类似,
paramsMap.put(task.getParamsKey1(), task.getParamsValue1());
这样的代码,意思是假如你:如果你在数据库的ParamsKey1值为"username",ParamsValue1的值为"zhangsang".那么你在具体的job中给定变量名为"username"的变量并给出set/get方法,就可以得到值"zhangsang",此功能适用于给定时任务配置固定参数,并且参数名字随便你定。我们这里给了三个备用的,你也可以扩展,步骤就是数据库加一个字段,在上面的程序中paramsMap放入这个字段,当然你也可以不用参数。你数据库没有配置任何值,表示该定时任务没有固定参数。
4.SchedulingJob是一个定时任务执行参数的bean。即 将Taskjob对象的值经过处理转换成SchedulingJob对象,然后用SchedulingJob对象的值调用定时任务的API。
SchedulingJob对象主要做的事就是,TriggerName和JobGroup分别给出默认值。根据className生成StateFulljobExecuteClass的Class对象。
四。SchedulingJob代码:
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; // 任务描述
    private Class<?> stateFulljobExecuteClass;//同步的执行类,需要从StatefulMethodInvokingJob继承
    private Class<?> jobExecuteClass;//异步的执行类,需要从MethodInvokingJob继承
      /**
       * 得到该job的Trigger名字
       * @return
       */
     public String getTriggerName() {
            return this.getJobId() + "Trigger";
     }
	public String getJobId() {
		return jobId;
	}
	public void setJobId(String jobId) {
		this.jobId = jobId;
	}
	public String getJobName() {
		return jobName;
	}
	public void setJobName(String jobName) {
		this.jobName = jobName;
	}
	public String getJobGroup() {
		if(jobGroup==null){
			jobGroup = Scheduler.DEFAULT_GROUP;
		}
		return jobGroup;
	}
	public void setJobGroup(String jobGroup) {
		this.jobGroup = jobGroup;
	}
	public int getJobStatus() {
		return jobStatus;
	}
	public void setJobStatus(int jobStatus) {
		this.jobStatus = jobStatus;
	}
	public String getCronExpression() {
		return cronExpression;
	}
	public void setCronExpression(String cronExpression) {
		this.cronExpression = cronExpression;
	}
	public String getMemos() {
		return memos;
	}
	public void setMemos(String memos) {
		this.memos = memos;
	}
	public Class<?> getStateFulljobExecuteClass() {
		return stateFulljobExecuteClass;
	}
	public void setStateFulljobExecuteClass(Class<?> stateFulljobExecuteClass) {
		this.stateFulljobExecuteClass = stateFulljobExecuteClass;
	}
	public Class<?> getJobExecuteClass() {
		return jobExecuteClass;
	}
	public void setJobExecuteClass(Class<?> jobExecuteClass) {
		this.jobExecuteClass = jobExecuteClass;
	}
	public static int getJS_ENABLED() {
		return JS_ENABLED;
	}
	public static int getJS_DISABLED() {
		return JS_DISABLED;
	}
	public static int getJS_DELETE() {
		return JS_DELETE;
	}

}

五。具体JOB实现
只要继承QuartzJobBean类,覆盖executeInternal方法即可。在job中可能通过get方法的方式得到jobDetail对象中JobDataMap(详见QuartzManager类)中同名参数值。示例代码。
@Controller
public class ContentJob extends QuartzJobBean{
	@Autowired
	TaskJobService taskJobService;
	private String  beginDate;
	private String  endDate;
	
	/**
	 * 手动执行任务
	 * @param request
	 */
	@RequestMapping("/contentJobManual.do")
	public void manual(HttpServletRequest request) {
		String startDate=request.getParameter("startDate");
		String endDate=request.getParameter("endDate");
		TaskJobService taskJobService = (TaskJobService) ApplicationHelper.getBean("taskJobService");
		Map<String, String> param = new HashMap<String, String>();
		SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
		String today=sdf.format(new Date());
		if(StringUtils.isEmpty(startDate)){
			param.put("beginDate", today); 
		}else{
			param.put("beginDate", startDate); 
		}
		if(StringUtils.isEmpty(endDate)){
			param.put("endDate", today); 
		}else{
			param.put("endDate", endDate); 
		}
		taskJobService.callStatisticContent(param);
	}
	
	@Override
	public void executeInternal(JobExecutionContext context) {
		TaskJobService taskJobService = (TaskJobService) ApplicationHelper.getBean("taskJobService");
		Map<String, String> param = new HashMap<String, String>();
		SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
		String today=sdf.format(new Date());
		if(StringUtils.isEmpty(beginDate)){
			param.put("beginDate", today); 
		}else{
			param.put("beginDate", beginDate); 
		}
		if(StringUtils.isEmpty(endDate)){
			param.put("endDate", today); 
		}else{
			param.put("endDate", endDate); 
		}
		taskJobService.callStatisticContent(param);
	}
	
	public String getBeginDate() {
		return beginDate;
	}

	public void setBeginDate(String beginDate) {
		this.beginDate = beginDate;
	}

	public String getEndDate() {
		return endDate;
	}
	public void setEndDate(String endDate) {
		this.endDate = endDate;
	}

六。手动执行一个任务。可以将该job类声明成一个@Controller。另外写一个方法如上例中的manual方法。
扩展:目前还不能将自动运行的方法和手动执行的方法(即executeInternal方法和manual方法)写成一个。因为自动运行的方法不是一个action类,它不在web环境中,是通过反射实现的。如果把executeInternal这个方法强行配置成具有web功能的方法(即类上面加@Controller ,方法上面加@RequestMapping("/contentJobManual.do"))也是不行的,因为该方法没有HttpServletRequest对象,获取不了参数。除非你的定时任务没有参数。当然你也不能修改该方法的参数类型,因为他是覆盖QuartzJobBean的方法。
七。数据库设计。
ID	VARCHAR2(60)	N				
JOB_CLASS	VARCHAR2(255)	N			
JOB_NAME	VARCHAR2(60)	N			
JOB_CRON_EXPRESSION	VARCHAR2(60)	N		
JOB_SERVICE_BEAN	VARCHAR2(60)	Y			
PARAMS_KEY1	VARCHAR2(60)	Y			
PARAMS_VALUE1	VARCHAR2(60)	Y			
PARAMS_KEY2	VARCHAR2(60)	Y			
PARAMS_VALUE2	VARCHAR2(60)	Y			
PARAMS_KEY3	VARCHAR2(60)	Y			
PARAMS_VALUE3	VARCHAR2(60)	Y			
NOTE	VARCHAR2(255)	Y			
JOB_STATUS	VARCHAR2(1)	Y			
UPDATETIME	DATE	Y			
JOB_AUTORUN	VARCHAR2(1)	Y
JOB_GROUP	VARCHAR2(60)	Y

说明:JOB_STATUS表示是否有效任务,JOB_AUTORUN表示是否自动运行,JOB_SERVICE_BEAN表示手动执行的请求URL,JOB_CLASS表示JOB类的全路径,JOB_GROUP表示任务属于哪个组,方便对任务的分组管理(批量启动,禁止等),区别于quartz的API所要求的同名参数,其实也可以把这个值传给API。其它字段比较好理解。该表对应的bean是taskjob。
八。页面管理。
主要功能是将一个任务加入或者移出自动运行队列(通过quartzManager对象)。和任务的增删查改。示例代码如下:
@Controller
public class TaskJobAction{
	private static final Log log = LogFactory.getLog(TaskJobAction.class);
	@Autowired
	TaskJobService taskJobService;
	@Autowired
	QuartzManager quartzManager;
	
	@RequestMapping("/enableTask.do")
	public void enableTask(HttpServletRequest request, HttpServletResponse response) throws IOException {
		String parameterStr="";
		parameterStr = IOUtils.toString(request.getInputStream(), InputConstant.CHAR_SET);
		parameterStr = StringUtils.trim(parameterStr);
		parameterStr =URLDecoder.decode(parameterStr,"utf-8");
		Map<String, String> p = JsonUtil.getParameterMap(parameterStr);
		String id=p.get("id");
		if(!StringUtils.isEmpty(id)){
			TaskJob task=taskJobService.getTaskById(id);
			List<TaskJob> list=new ArrayList<TaskJob>();
			list.add(task);
			quartzManager.enableCronSchedule(list);
			
			task.setJobEnabled("Y");
			taskJobService.update(task);//将任务设置成自动运行状态
		}
			
	}
	@RequestMapping("/disableTask.do")
	public void disableTask(HttpServletRequest request, HttpServletResponse response) throws IOException {
		String parameterStr="";
		parameterStr = IOUtils.toString(request.getInputStream(), InputConstant.CHAR_SET);
		parameterStr = StringUtils.trim(parameterStr);
		parameterStr =URLDecoder.decode(parameterStr,"utf-8");
		Map<String, String> p = JsonUtil.getParameterMap(parameterStr);
		String id=p.get("id");
		if(!StringUtils.isEmpty(id)){
			TaskJob task=taskJobService.getTaskById(id);
			quartzManager.disableSchedule(task.getJobId());
			
			task.setJobEnabled("N");
			taskJobService.update(task);//将任务设置成非运行状态
		}
			
	}
	@RequestMapping("/add.do")
	public void add(HttpServletRequest request, HttpServletResponse response) throws IOException {
		String parameterStr="";
			parameterStr = IOUtils.toString(request.getInputStream(), InputConstant.CHAR_SET);
			parameterStr = StringUtils.trim(parameterStr);
			Map<String, String> p = JsonUtil.getParameterMap(parameterStr);
			String jobjson=p.get("jobjson");
			jobjson=URLDecoder.decode(jobjson,"utf-8");
			TaskJob task=JsonUtil.toObject(jobjson, TaskJob.class);
			String jobName=URLDecoder.decode(task.getJobName(),"utf-8");
			task.setJobName(jobName);
			if(!StringUtils.isEmpty(jobjson)){
				taskJobService.insert(task);
			}
			
	}
	
	@RequestMapping("/update.do")
	public void update(HttpServletRequest request, HttpServletResponse response) throws IOException {
		String parameterStr="";
			parameterStr = IOUtils.toString(request.getInputStream(), InputConstant.CHAR_SET);
			parameterStr = StringUtils.trim(parameterStr);
			Map<String, String> p = JsonUtil.getParameterMap(parameterStr);
			String jobjson=p.get("jobjson");
			jobjson=URLDecoder.decode(jobjson,"utf-8");
			TaskJob task=JsonUtil.toObject(jobjson, TaskJob.class);
			String jobName=URLDecoder.decode(task.getJobName(),"utf-8");
			task.setJobName(jobName);
			if(!StringUtils.isEmpty(jobjson)){
				taskJobService.update(task);
			}
			
	}
	
	@RequestMapping("/delete.do")
	public void delete(HttpServletRequest request, HttpServletResponse response) throws IOException {
		String parameterStr="";
			parameterStr = IOUtils.toString(request.getInputStream(), InputConstant.CHAR_SET);
			parameterStr = StringUtils.trim(parameterStr);
			parameterStr =URLDecoder.decode(parameterStr,"utf-8");
			Map<String, String> p = JsonUtil.getParameterMap(parameterStr);
			String idStr=p.get("idStr");
			if(!StringUtils.isEmpty(idStr)){
				taskJobService.delete(idStr);
			}
			
	}
	@ResponseBody
	@RequestMapping("/taskList.do")
	public RecordResultBean list(HttpServletRequest request, HttpServletResponse response,@RequestParam("pageSize") int pageSize,
			@RequestParam("startIndex") int startIndex) throws IOException {
		int pageNum=startIndex/pageSize+1;
		String startDate=request.getParameter("startDate");
		String endDate=request.getParameter("endDate");
		String jobName=request.getParameter("jobName");
		if (!StringUtils.isEmpty(jobName)) {
			jobName=URLDecoder.decode(jobName, "UTF-8");
			jobName=URLDecoder.decode(jobName, "UTF-8");
		}
		RecordResultBean resultBean = new RecordResultBean();
		try {
			
			Pager pager = new Pager(pageNum, pageSize);
			Map<String, Object> map = new HashMap<String, Object>();
			map.put("jobName",jobName);
			pager.setKeys(map);
			pager = taskJobService.findPage(pager);
			if (pager == null || pager.getTotalCount() == 0) {
				resultBean.setResult(false);

			} else {
				resultBean.setResult(true);
				resultBean.setBean(pager);
			}
			
		}catch(Exception ex) {
			log.warn(JDKStackTrace.getJDKStrack(ex));
		}
		
		return resultBean;
	}

本文转载自:http://blog.csdn.net/hiyohu/article/details/45478215

chaun
粉丝 92
博文 271
码字总数 91117
作品 0
深圳
高级程序员
私信 提问
Spring Boot Quartz 分布式集群任务调度实现

主要内容 Spring Scheduler 框架 Quartz 框架,功能强大,配置灵活 Quartz 集群 mysql 持久化定时任务脚本(tables_mysql.sql) 介绍 在工程中时常会遇到一些需求,例如定时刷新一下配置、隔一...

编辑之路
06/21
166
0
Quartz 集群定时任务

用quartz管理任务计划很方便,但是当使用数据库作为存储介质的时候,必须要先创建表,不然就会报错。 mysql为例 2.x版本的建表语句为: 配置Job任务注意:加入定时任务有两种方式: ① 继承Q...

james_lz
2016/07/02
130
0
为什么要用分布式集群任务调度?

作为一个开发者,避免不了定时任务的问题,最粗暴和简单直接的解决方案就是crontab。当然在机器少,任务不多,定时任务之间关联少的情况下,crontab效率还是比较高和便捷的。但当机器越多、定...

调皮仔3683
2018/05/04
0
0
为社么要用分布式集群任务调度?

作为一个开发者,避免不了定时任务的问题,最粗暴和简单直接的解决方案就是crontab。当然在机器少,任务不多,定时任务之间关联少的情况下,crontab效率还是比较高和便捷的。但当机器越多、定...

友凡老师
2018/07/15
0
0
实现Spring中的任务调度及异步执行

首先要端正一下本人的态度,开发了很长时间的Java Web项目,寄托于Spring MVC的架构,多数时间都是在处理业务逻辑问题,所以我个人单纯地认为Web开发,多线程的应用场景应该不多,能不用尽量...

chace0120
2014/08/01
1K
1

没有更多内容

加载失败,请刷新页面

加载更多

golang-字符串-地址分析

demo package mainimport "fmt"func main() {str := "map.baidu.com"fmt.Println(&str, str)str = str[0:5]fmt.Println(&str, str)str = "abc"fmt.Println(&s......

李琼涛
55分钟前
4
0
Spring Boot WebFlux 增删改查完整实战 demo

03:WebFlux Web CRUD 实践 前言 上一篇基于功能性端点去创建一个简单服务,实现了 Hello 。这一篇用 Spring Boot WebFlux 的注解控制层技术创建一个 CRUD WebFlux 应用,让开发更方便。这里...

泥瓦匠BYSocket
今天
6
0
从0开始学FreeRTOS-(列表与列表项)-3

FreeRTOS列表&列表项的源码解读 第一次看列表与列表项的时候,感觉很像是链表,虽然我自己的链表也不太会,但是就是感觉很像。 在FreeRTOS中,列表与列表项使用得非常多,是FreeRTOS的一个数...

杰杰1号
今天
4
0
Java反射

Java 反射 反射是框架设计的灵魂(使用的前提条件:必须先得到代表的字节码的 Class,Class 类 用于表示.class 文件(字节码)) 一、反射的概述 定义:JAVA 反射机制是在运行状态中,对于任...

zzz1122334
今天
5
0
聊聊nacos的LocalConfigInfoProcessor

序 本文主要研究一下nacos的LocalConfigInfoProcessor LocalConfigInfoProcessor nacos-1.1.3/client/src/main/java/com/alibaba/nacos/client/config/impl/LocalConfigInfoProcessor.java p......

go4it
昨天
8
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部