最近公司要做个接口定时任务，本来考虑使用java API中的Timer + TimerTask，其实这个类还是蛮强大的，对于执行时间和执行间隔，调控起来也比较容易。
timer.schedule(new MyTask(),calendar.getTime(), 24*60*60*1000)
也就准备用着个了，写个listener监听器，启动服务器一直报null错误。因为服务器启动的时候会去执行监听器，而监听器会执行到这个schedule方法，也就是
说会去执行new MyTask()，此时不知道是Spring未加载的原因还是什么？MyTask()中声明的service方法一直为空，弄了好长时间也没解决，放弃。
第二方案准备使用spring自带的监听器
<bean id="interfaceInvokeAutoTestTask" class="*.InterfaceInvokeAutoTestTask" > </bean> <bean id="scheduledTask" class="org.springframework.scheduling.timer.ScheduledTimerTask"> <property name="timerTask"> <ref bean="interfaceInvokeAutoTestTask"/> </property> <!-- 任务执行周期 关于一些任务的参数请参考JDK doc文档和Spring相关文档--> <property name="period"> <value>10000000</value> </property> <!-- 延时10s 执行任务 --> <property name="delay"> <value>5000000</value> </property> </bean> <!-- 启动定时器 --> <bean id="timerBean" class="org.springframework.scheduling.timer.TimerFactoryBean"> <property name="scheduledTimerTasks"> <list> <ref bean="scheduledTask" /> </list> </property> </bean>
问题1：执行时间控制起来会麻烦点；
问题2：多次执行后执行时间会有延迟，这方面参考其他文档，
ScheduledTimerTask //执行任务单线程
问题3：spring本身已经抛弃
于是考虑使用quarts，下载，导jar就不说了。
直接开始说例子1吧
public class HelloJob implements Job {
private static Logger _log = LoggerFactory.getLogger(HelloJob.class);
/**
* <p>
* Empty constructor for job initilization
* </p>
* <p>
* Quartz requires a public empty constructor so that the
* scheduler can instantiate the class whenever it needs.
* </p>
*/
public HelloJob() {
}
/**
* <p>
* Called by the <code>{@link org.quartz.Scheduler}</code> when a
* <code>{@link org.quartz.Trigger}</code> fires that is associated with
* the <code>Job</code>.
* </p>
*
* @throws JobExecutionException
* if there is an exception while executing the job.
*/
public void execute(JobExecutionContext context)
throws JobExecutionException {
// Say Hello to the World and display the date/time
_log.info("Hello World! - " + new Date());
}
}
public class SimpleExample {
public void run() throws Exception {
Logger log = LoggerFactory.getLogger(SimpleExample.class);
log.info("------- Initializing ----------------------");
// First we must get a reference to a scheduler
SchedulerFactory sf = new StdSchedulerFactory();
Scheduler sched = sf.getScheduler(); // 创建一任务
log.info("------- Initialization Complete -----------");
// computer a time that is on the next round minute
Date runTime = evenMinuteDate(new Date()); //java api Calendar 方法延迟一分钟
log.info("------- Scheduling Job -------------------");
// define the job and tie it to our HelloJob class
JobDetail job = newJob(HelloJob.class)
.withIdentity("job1", "group1") //withIdentity(String name, String group) ,将job关联到组中
.build();
// Trigger the job to run on the next round minute
Trigger trigger = newTrigger()
.withIdentity("trigger1", "group1")
.startAt(runTime)
.build();
/* 生成job
public JobDetail build()
{
JobDetailImpl job = new JobDetailImpl();
job.setJobClass(jobClass);
job.setDescription(description);
if(key == null)
key = new JobKey(Key.createUniqueName(null), null);
job.setKey(key);
job.setDurability(durability);
job.setRequestsRecovery(shouldRecover);
if(!jobDataMap.isEmpty())
job.setJobDataMap(jobDataMap);
return job;
}
*/
// Tell quartz to schedule the job using our trigger
sched.scheduleJob(job, trigger); //触发器执行任务组
log.info(job.getKey() + " will run at: " + runTime);
// Start up the scheduler (nothing can actually run until the
// scheduler has been started)
sched.start();
log.info("------- Started Scheduler -----------------");
// wait long enough so that the scheduler as an opportunity to
// run the job!
log.info("------- Waiting 65 seconds... -------------");
try {
// wait 65 seconds to show job
Thread.sleep(65L * 1000L);
// executing...
} catch (Exception e) {
}
// shut down the scheduler
log.info("------- Shutting Down ---------------------");
sched.shutdown(true);
log.info("------- Shutdown Complete -----------------");
}
public static void main(String[] args) throws Exception {
SimpleExample example = new SimpleExample();
example.run();
}
}
关于简单的定时任务上面的例一已经说明
下面看例2，从任务开始时间，执行次数，执行间隔来控制任务
JobDetail job = newJob(SimpleJob.class)
.withIdentity("job1", "group1")
.build();
SimpleTrigger trigger = (SimpleTrigger) newTrigger()
.withIdentity("trigger1", "group1")
.startAt(startTime)
.build(); //默认执行一次，也就无间隔
Date ft = sched.scheduleJob(job, trigger);
log.info(job.getKey() +
" will run at: " + ft +
" and repeat: " + trigger.getRepeatCount() +
" times, every " + trigger.getRepeatInterval() / 1000 + " seconds");
//group1.job1 will run at: Mon Dec 17 10:05:30 CST 2012 and repeat: 0 times, every 0 seconds
// job3 will run 11 times (run once and repeat 10 more times)
// job3 will repeat every 10 seconds
job = newJob(SimpleJob.class)
.withIdentity("job3", "group1")
.build();
trigger = newTrigger()
.withIdentity("trigger3", "group1")
.startAt(startTime)
.withSchedule(simpleSchedule()
.withIntervalInSeconds(10)
.withRepeatCount(10))
.build();
//group1.job3 will run at: Mon Dec 17 10:05:30 CST 2012 and repeat: 10 times, every 10 seconds
// the same job (job3) will be scheduled by a another trigger
// this time will only repeat twice at a 70 second interval
trigger = newTrigger()
.withIdentity("trigger3", "group2")
.startAt(startTime)
.withSchedule(simpleSchedule()
.withIntervalInSeconds(10)
.withRepeatCount(2))
.forJob(job)
.build();
//group1.job3 will [also] run at: Mon Dec 17 10:24:30 CST 2012 and repeat: 2 times, every 10 seconds
// job4 will run 6 times (run once and repeat 5 more times)
// job4 will repeat every 10 seconds
job = newJob(SimpleJob.class)
.withIdentity("job4", "group1")
.build();
trigger = newTrigger()
.withIdentity("trigger4", "group1")
.startAt(startTime)
.withSchedule(simpleSchedule()
.withIntervalInSeconds(10)
.withRepeatCount(5))
.build();
//group1.job4 will run at: Mon Dec 17 10:24:30 CST 2012 and repeat: 5 times, every 10 seconds
// job5 will run once, five minutes in the future
job = newJob(SimpleJob.class)
.withIdentity("job5", "group1")
.build();
trigger = (SimpleTrigger) newTrigger()
.withIdentity("trigger5", "group1")
.startAt(futureDate(5, IntervalUnit.MINUTE))
.build();
//group1.job5 will run at: Mon Dec 17 10:29:18 CST 2012 and repeat: 0 times, every 0 seconds
// job6 will run indefinitely, every 40 seconds
job = newJob(SimpleJob.class)
.withIdentity("job6", "group1")
.build();
trigger = newTrigger()
.withIdentity("trigger6", "group1")
.startAt(startTime)
.withSchedule(simpleSchedule()
.withIntervalInSeconds(40)
.repeatForever())
.build();
//group1.job6 will run at: Mon Dec 17 10:24:30 CST 2012 and repeat: -1 times, every 40 seconds
// jobs can also be scheduled after start() has been called...
// job7 will repeat 20 times, repeat every five minutes
job = newJob(SimpleJob.class)
.withIdentity("job7", "group1")
.build();
trigger = newTrigger()
.withIdentity("trigger7", "group1")
.startAt(startTime)
.withSchedule(simpleSchedule()
.withIntervalInMinutes(5) //5* 60000
.withRepeatCount(20))
.build();
//group1.job7 will run at: Mon Dec 17 10:24:30 CST 2012 and repeat: 20 times, every 300 seconds
// jobs can be fired directly... (rather than waiting for a trigger)
job = newJob(SimpleJob.class)
.withIdentity("job8", "group1")
.storeDurably()
.build();
sched.addJob(job, true);
log.info("'Manually' triggering job8...");
sched.triggerJob(jobKey("job8", "group1"));
//手动触发一个任务
重新触发
// jobs can be re-scheduled...
// job 7 will run immediately and repeat 10 times for every second
log.info("------- Rescheduling... --------------------");
trigger = newTrigger()
.withIdentity("trigger7", "group1")
.startAt(startTime)
.withSchedule(simpleSchedule()
.withIntervalInMinutes(5)
.withRepeatCount(20))
.build();
显示执行信息
// display some stats about the schedule that just ran
SchedulerMetaData metaData = sched.getMetaData();
log.info("Executed " + metaData.getNumberOfJobsExecuted() + " jobs.");
//Executed 35 jobs.
接下来看例子3，执行条件表达式
// job 1 will run every 20 seconds
JobDetail job = newJob(SimpleJob.class)
.withIdentity("job1", "group1")
.build();
CronTrigger trigger = newTrigger()
.withIdentity("trigger1", "group1")
.withSchedule(cronSchedule("0/20 * * * * ?")) // 20秒执行一次 0,20,40,0---
.build();
Date ft = sched.scheduleJob(job, trigger);
log.info(job.getKey() + " has been scheduled to run at: " + ft
+ " and repeat based on expression: "
+ trigger.getCronExpression());
//group1.job1 has been scheduled to run at: Mon Dec 17 13:11:40 CST 2012 and repeat based on expression: 0/20 * * * * ?
// job 2 will run every other minute (at 15 seconds past the minute)
job = newJob(SimpleJob.class)
.withIdentity("job2", "group1")
.build();
trigger = newTrigger()
.withIdentity("trigger2", "group1")
.withSchedule(cronSchedule("15 0/2 * * * ?")) //没隔一分钟，15秒时执行一次
.build();
下面不贴代码了，将例子中所写的表达式做个说明
// job 3 will run every other minute but only between 8am and 5pm "0 0/2 8-17 * * ?" // job 4 will run every three minutes but only between 5pm and 11pm 0 0/3 17-23 * * ? // job 5 will run at 10am on the 1st and 15th days of the month 0 0 10am 1,15 * ? // job 6 will run every 30 seconds but only on Weekdays (Monday through Friday) 0,30 * * ? * MON-FRI // job 7 will run every 30 seconds but only on Weekends (Saturday and Sunday) 0,30 * * ? * SAT,SUN
- /* 引用别人的
- --------------------------------------
- 0 0 12 * * ? 每天12点触发
- 0 15 10 ? * * 每天10点15分触发
- 0 15 10 * * ? 每天10点15分触发
- 0 15 10 * * ? * 每天10点15分触发
- 0 15 10 * * ? 2005 2005年每天10点15分触发
- 0 * 14 * * ? 每天下午的 2点到2点59分每分触发
- 0 0/5 14 * * ? 每天下午的 2点到2点59分(整点开始，每隔5分触发)
- 0 0/5 14,18 * * ? 每天下午的 2点到2点59分(整点开始，每隔5分触发) 每天下午的 18点到18点59分(整点开始，每隔5分触发)
- 0 0-5 14 * * ? 每天下午的 2点到2点05分每分触发
- 0 10,44 14 ? 3 WED 3月分每周三下午的 2点10分和2点44分触发
- 0 15 10 ? * MON-FRI 从周一到周五每天上午的10点15分触发
- 0 15 10 15 * ? 每月15号上午10点15分触发
- 0 15 10 L * ? 每月最后一天的10点15分触发
- 0 15 10 ? * 6L 每月最后一周的星期五的10点15分触发
- 0 15 10 ? * 6L 2002-2005 从2002年到2005年每月最后一周的星期五的10点15分触发
- 0 15 10 ? * 6#3 每月的第三周的星期五开始触发
- 0 0 12 1/5 * ? 每月的第一个中午开始每隔5天触发一次
- 0 11 11 11 11 ? 每年的11月11号 11点11分触发(光棍节)
- --------------------------------------
- */
| Quartz Cron 表达式支持到七个域 | |||
| 名称 | 是否必须 | 允许值 | 特殊字符 |
| 秒 | 是 | 0-59 | , - * / |
| 分 | 是 | 0-59 | , - * / |
| 时 | 是 | 0-23 | , - * / |
| 日 | 是 | 1-31 | , - * ? / L W |
| 月 | 是 | 1-12 或 JAN-DEC | , - * / |
| 周 | 是 | 1-7 或 SUN-SAT | , - * ? / L # |
| 年 | 否 | 空 或 1970-2099 | , - * / |
可以看到基本结构是 秒_分_小时_日_月_[周]_[年] 后面的周和年是可选的
其次，通配符，主要的有星号(*)；问号(?)；减号(-)；逗号(,)；斜杠(/)；L字母；W字母；井号(#).
- 星号：表示任意时刻
- 问号：只能在日或周字段上使用，http://blog.csdn.net/chh_jiang/article/details/4603529 这里有比较清晰的解释，简单的理解就是日期和星期是有冲突的，指定其中一个的话，另外一个是没办法指定的，比如每个月12号和每个星期二，这两个是"互斥"的，不能用日期和周来指定所有“每个是星期二的12号”这个时间。
- 减号：范围，如 1-5秒
- 逗号：列表，如 1,5,10 秒
- 斜杠：等步长序列，如3/13秒 表示 3,16,29,42,55,3,16...
- L：仅在日和周上支持，表示允许的最后一个值，注意不要让范围和列表与L连用
- W：工作日
- 井号：为给定月份指定具体的工作日实例。把“MON#2”放在周内日期字段中，表示把任务安排在当月的第二个星期一。(引用)
例4主要讲解下job中的JobDataMap
// pass initialization parameters into the job
job1.getJobDataMap().put(ColorJob.FAVORITE_COLOR, "Green");
job1.getJobDataMap().put(ColorJob.EXECUTION_COUNT, 1);
public void execute(JobExecutionContext context)
throws JobExecutionException {
// This job simply prints out its job name and the
// date and time that it is running
JobKey jobKey = context.getJobDetail().getKey();
// Grab and print passed parameters
JobDataMap data = context.getJobDetail().getJobDataMap();
String favoriteColor = data.getString(FAVORITE_COLOR);
int count = data.getInt(EXECUTION_COUNT);
}
后面的例子看了看，就不介绍了。前面这些基本就够了
工作中的过程
1。页面部分，主要是一些任务的定制
页面代码
略
任务代码
/**
* 开启定时任务
* @param id
*/
private void startTaskById(String id){
//获得定时任务信息
SysInterfaceTimerTask newTask = sysInterfaceTimerTaskService.selectByTemplateID(id);
String taskId = newTask.getId(); //主键
Date startTime = newTask.getStartTime();
Date stopTime = newTask.getStopTime();
String conditionK = newTask.getConditionK();
String conditionV = newTask.getConditionV();
String tempId = newTask.getFId(); //模板ID
try {
// 获得一个计划任务
Scheduler sched = sf.getScheduler();
MyJobListener myJobListener = new MyJobListener();
sched.getListenerManager().addJobListener(myJobListener);
if(conditionK.equals("1")){
JobDetail job = JobBuilder.newJob(InterfaceInvokeAutoTestTask.class)
.withIdentity(tempId, tempId)
.build(); //定义一个job
// 将初始化参数设置近 Job 中
job.getJobDataMap().put(InterfaceInvokeAutoTestTask.TEMPLATEID, tempId); //将当前的ID赋值给Job
SimpleTrigger simpleTrigger = (SimpleTrigger) TriggerBuilder.newTrigger()
.withIdentity(tempId,tempId)
.startAt(startTime)
.build(); //定义触发器
sched.scheduleJob(job, simpleTrigger); //绑定任务
}else if(conditionK.equals("2")){
String hour = conditionV.substring(0, conditionV.indexOf(":"));
if(stopTime == null){ //每间隔 1s 执行 1次
String minute = conditionV.substring(conditionV.indexOf(":") + 1, conditionV.indexOf(";"));
String times = conditionV.substring(conditionV.indexOf(";") + 1);
JobDetail job = JobBuilder.newJob(InterfaceInvokeAutoTestTask.class)
.withIdentity(tempId, tempId)
.usingJobData(InterfaceInvokeAutoTestTask.TEMPLATEID, tempId)
.build();
SimpleTrigger simpleTrigger = (SimpleTrigger) TriggerBuilder.newTrigger()
.withIdentity(tempId, tempId)
.startAt(startTime)
.withSchedule(SimpleScheduleBuilder.simpleSchedule()
.withIntervalInHours(Integer.valueOf(hour))
.withIntervalInMinutes(Integer.valueOf(minute))
.withRepeatCount(Integer.valueOf(times) - 1) //重复次数 = 执行次数 - 1
).build();
sched.scheduleJob(job, simpleTrigger);
}else{ //在一定时间范围内，每隔指定时间执行一次
String minute = conditionV.substring(conditionV.indexOf(":") + 1);
JobDetail job = JobBuilder.newJob(InterfaceInvokeAutoTestTask.class)
.withIdentity(tempId, tempId)
.usingJobData(InterfaceInvokeAutoTestTask.TEMPLATEID, tempId)
.build();
SimpleTrigger simpleTrigger = (SimpleTrigger) TriggerBuilder.newTrigger()
.withIdentity(tempId, tempId)
.startAt(startTime)
.withSchedule(SimpleScheduleBuilder.simpleSchedule()
.withIntervalInHours(Integer.valueOf(hour))
.withIntervalInMinutes(Integer.valueOf(minute))
.repeatForever()
)
.endAt(stopTime)
.build();
sched.scheduleJob(job, simpleTrigger);
}
}else if(conditionK.equals("3")){
JobDetail job = JobBuilder.newJob(InterfaceInvokeAutoTestTask.class)
.withIdentity(tempId, tempId)
.usingJobData(InterfaceInvokeAutoTestTask.TEMPLATEID, tempId)
.build();
SimpleTrigger simpleTrigger = (SimpleTrigger) TriggerBuilder.newTrigger()
.withIdentity(taskId, taskId)
.startAt(startTime)
.withSchedule(SimpleScheduleBuilder.simpleSchedule()
.withIntervalInHours(24 * Integer.valueOf(conditionV))
.repeatForever()
)
.endAt(stopTime)
.build();
sched.scheduleJob(job, simpleTrigger);
}else if(conditionK.equals("4")){
StringBuffer sb = new StringBuffer();
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("HH:mm:ss"); //截取时分秒
String formatDate = simpleDateFormat.format(startTime);
String s = formatDate.substring(formatDate.lastIndexOf(":")+1);
String m = formatDate.substring(formatDate.indexOf(":")+1,formatDate.lastIndexOf(":"));
String h = formatDate.substring(0, formatDate.indexOf(":"));
sb.append(s).append(" ").append(m).append(" ").append(h).append(" ")
.append("? * ");
/*周一 Mon
周二 Tue
周三 Wed
周四 Thu
周五 Fri
周六 Sat
周日 Sun*/
String replaceWeek = conditionV.replace("AA", "Mon")
.replace("BB", "Tue")
.replace("CC", "Wed")
.replace("DD", "Thu")
.replace("EE", "Fri")
.replace("FF", "Sat")
.replace("GG", "Sun")
.replace(" ", "");
replaceWeek = replaceWeek.substring(replaceWeek.indexOf("[")+1, replaceWeek.indexOf("]"));
sb.append(replaceWeek);
JobDetail job = JobBuilder.newJob(InterfaceInvokeAutoTestTask.class)
.withIdentity(tempId, tempId)
.usingJobData(InterfaceInvokeAutoTestTask.TEMPLATEID, taskId)
.build();
CronTrigger trigger = TriggerBuilder.newTrigger()
.withIdentity(taskId, taskId)
.startAt(startTime)
.withSchedule(CronScheduleBuilder.cronSchedule(sb.toString()))
.endAt(stopTime)
.build();
sched.scheduleJob(job, trigger);
}
sched.start(); //开启定时任务
newTask.setIsRun("1");
sysInterfaceTimerTaskService.update(newTask); //任务启用后，将任务标志inRun设置为1
} catch (SchedulerException e) {
e.printStackTrace();
}
}
/**
* 停止 单个 任务
* @return
*/
public String stopTask(){
Scheduler sched = null;
try {
sched = sf.getScheduler();
SysInterfaceTimerTask delTask = sysInterfaceTimerTaskService.selectByTemplateID(sysInterfaceTemplate.getId());
sched.deleteJob(new JobKey(delTask.getFId(),delTask.getFId())); //停止任务
delTask.setIsRun("0");
sysInterfaceTimerTaskService.update(delTask); //任务停止后，将任务标志inRun设置为0
} catch (SchedulerException e) {
e.printStackTrace();
}
return "templist_redo";
}
执行任务
package com.besttone.mobile.mcipm.util.interfaceTask;
import *
/**
* 定时任务
* @author Administrator
*
*/
public class InterfaceInvokeAutoTestTask implements Job{
private SysInterfaceTemplateService sysInterfaceTemplateService = (SysInterfaceTemplateService) SpringContextUtil.getBean("sysInterfaceTemplateService");
private SysInterfaceParamsMapper sysInterfaceParamsMapper = (SysInterfaceParamsMapper) SpringContextUtil.getBean("sysInterfaceParamsMapper");
private SysInterfaceTimerInvokeMapper sysInterfaceTimerInvokeMapper = (SysInterfaceTimerInvokeMapper) SpringContextUtil.getBean("sysInterfaceTimerInvokeMapper");
private Date date; //任务开始时间
private long beginTimeInMillis; //任务开始时间
private long endTimeInMillis; //任务结束时间
//模板ID通过job.getJobDataMap() 设置
public static final String TEMPLATEID = "templateId";
/**
* 执行任务
*/
@Override
public void execute(JobExecutionContext context) throws JobExecutionException {
synchronized (InterfaceInvokeAutoTestTask.class) {
System.out.println("======================================================");
date = new Date();
beginTimeInMillis = Calendar.getInstance().getTimeInMillis(); //记录任务的开始时间
// Grab and print passed parameters
JobDataMap data = context.getJobDetail().getJobDataMap();
String templateId = data.getString(TEMPLATEID);
SysInterfaceTemplate selectByPrimaryKey = sysInterfaceTemplateService
.selectByPrimaryKey(templateId);
generateURL(selectByPrimaryKey); //返回结果信息
}
}
/**
*
* @param sysInterfaceTemplate
* @return 请求URL
*/
private void generateURL(SysInterfaceTemplate sysInterfaceTemplate){
String id = sysInterfaceTemplate.getId();
String templatename = sysInterfaceTemplate.getTemplatename();
String url = sysInterfaceTemplate.getUrl();
int paramnum = sysInterfaceTemplate.getParamnum().intValue();
String method = sysInterfaceTemplate.getMethod();
List<SysInterfaceParams> selectByTemplateId = sysInterfaceParamsMapper.selectByTemplateId(id);
List<NameValuePair> nameValueLists = new ArrayList<NameValuePair>();
StringBuffer sb = new StringBuffer(); //请求地址 类似method:*&req={k1:v1}
String keyIsInReq = "";
for(int i=0;i<paramnum;i++){
String keyString = selectByTemplateId.get(i).getParamkey();
String valueString = selectByTemplateId.get(i).getParamvalue();
String isleaf = selectByTemplateId.get(i).getIsleaf();
int sortcount = selectByTemplateId.get(i).getSortcount().intValue();
if(keyString.equals("method")){
sb.append(keyString).append("=").append(valueString);
nameValueLists.add(new NameValuePair(keyString, valueString));
}else if(isleaf.equals("1")){ //如果是非叶子节点，拼接字符串
if (valueString.indexOf("$") != -1) { //req的value 一般类似 3$4$5
String parseJSON = parseJSON(valueString, selectByTemplateId);
sb.append("&").append(keyString).append("=").append(parseJSON);
keyIsInReq = valueString;
nameValueLists.add(new NameValuePair(keyString, parseJSON));
}
}else{
if (!keyIsInReq.contains(String.valueOf(sortcount))) {
sb.append("&").append(keyString).append("=").append(valueString);
nameValueLists.add(new NameValuePair(keyString, valueString));
}
}
/*if (keyString.equalsIgnoreCase("method")) {
sb.append(keyString).append("=").append(valueString);
nameValueLists.add(new NameValuePair(keyString, valueString));
}else if(keyString.equalsIgnoreCase("req")){
sb.append("&").append(keyString).append("=");
String parseJSON = null;
if (valueString.indexOf("$") != -1) { //req的value 一般类似 3$4$5
parseJSON = parseJSON(valueString, selectByTemplateId);
// int lastIndexOf = parseJSON.lastIndexOf("}");
// if(parseJSON.substring(lastIndexOf - 2, lastIndexOf - 1).equals(",") ){
// }
sb.append(parseJSON);
}else{
sb.append(valueString);
}
nameValueLists.add(new NameValuePair(keyString, parseJSON));
}else{
//如果req中包含了当前key，则跳过，否则拼接到字符串中
if(!valueString.contains(String.valueOf((i+1)))){
sb.append("&").append(keyString).append("=").append(valueString);
nameValueLists.add(new NameValuePair(keyString, valueString));
}
}*/
}
try {
String sendRequest = sendRequest(nameValueLists, method, url, sb.toString());
SysInterfaceTimerInvoke sysInterfaceTimerInvoke = new SysInterfaceTimerInvoke();
sysInterfaceTimerInvoke.setTemplateName(templatename);
sysInterfaceTimerInvoke.setUrl(url);
sysInterfaceTimerInvoke.setMethod(method);
sysInterfaceTimerInvoke.setParamNum(paramnum);
sysInterfaceTimerInvoke.setParam(sb.toString());
sysInterfaceTimerInvoke.setStartTime(date);
if (sendRequest.substring(0, 9).equals("Exception")) {
sysInterfaceTimerInvoke.setResult("失败");
}else{
if(sendRequest.indexOf("\"result\":\"00\"") > -1){
sysInterfaceTimerInvoke.setResult("成功");
}else {
sysInterfaceTimerInvoke.setResult("失败");
}
}
sysInterfaceTimerInvoke.setMessage(sendRequest);
endTimeInMillis = Calendar.getInstance().getTimeInMillis(); //记录任务的结束时间
long invokeTime = endTimeInMillis - beginTimeInMillis;
sysInterfaceTimerInvoke.setInvokeTime(invokeTime+" ms");
sysInterfaceTimerInvokeMapper.insert(sysInterfaceTimerInvoke);
} catch (HttpException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
private String parseJSON(String valueString , List<SysInterfaceParams> selectByTemplateId){
// JSON表达式,类似于 3&4&5
String[] json = valueString.split("\\$");
StringBuffer stringBuffer = new StringBuffer();
stringBuffer.append("{");
for (String n : json) {
String paramkey = selectByTemplateId.get(Integer.parseInt(n)-1).getParamkey();
String paramvalue = selectByTemplateId.get(Integer.parseInt(n)-1).getParamvalue();
// if(paramvalue.indexOf("\\$") > 0 ){
// parseJSON(paramvalue,selectByTemplateId);
// } //用不到啦
stringBuffer.append("\""
+ paramkey
+ "\"" + ":" + "\""
+ paramvalue
+ "\"");
stringBuffer.append(",");
}
stringBuffer.deleteCharAt(stringBuffer.length() - 1);
stringBuffer.append("}");
return stringBuffer.toString();
}
/**
* 发送请求
* @return
* @throws IOException
* @throws HttpException
*/
public String sendRequest(List<NameValuePair> lists, String type, String url, String params) throws HttpException, IOException{
String responseBodyAsString ;
GetMethod getMethod = null;
PostMethod postMethod = null;
try {
if(type.equalsIgnoreCase("get")){
if (params.trim().equals("")) {
getMethod = new GetMethod(url);
} else {
getMethod = new GetMethod(url + "?" + params);
}
HttpClient httpClient = new HttpClient();
httpClient.executeMethod(getMethod);
responseBodyAsString = getMethod.getResponseBodyAsString();
getMethod.releaseConnection();
}else{
postMethod = new GBKPostMethod(url);
NameValuePair[] data = new NameValuePair[lists.size()];
for (int i = 0; i < lists.size(); i++) {
data[i] = lists.get(i);
}
postMethod.setRequestBody(data);
HttpClient httpClient = new HttpClient();
httpClient.executeMethod(postMethod);
responseBodyAsString = postMethod.getResponseBodyAsString();
postMethod.releaseConnection();
}
} catch (Exception e) {
e.printStackTrace();
responseBodyAsString = "Exception :"+e.getMessage();
return responseBodyAsString;
} finally{
if (getMethod != null) {
getMethod.releaseConnection();
}
if(postMethod != null){
postMethod.releaseConnection();
}
}
return responseBodyAsString;
}
}
任务监听接口
package com.besttone.mobile.mcipm.util.interfaceTask;
import java.util.Collection;
import java.util.Date;
import java.util.Map;
import org.quartz.JobDataMap;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.quartz.JobListener;
import org.quartz.SchedulerException;
import org.quartz.TriggerKey;
import com.besttone.mobile.mcipm.dao.SysInterfaceTimerTaskMapper;
import com.besttone.mobile.mcipm.model.SysInterfaceTimerTask;
import com.besttone.mobile.mcipm.util.SpringContextUtil;
public class MyJobListener implements JobListener {
private SysInterfaceTimerTaskMapper sysInterfaceTimerTaskMapper = (SysInterfaceTimerTaskMapper) SpringContextUtil.getBean("sysInterfaceTimerTaskMapper");
@Override
public String getName() {
return "myJobListenerName";
}
@Override
public void jobExecutionVetoed(JobExecutionContext arg0) {
}
@Override
public void jobToBeExecuted(JobExecutionContext context) {
System.out.println("任务开始进行了");
}
@Override
public void jobWasExecuted(JobExecutionContext context,
JobExecutionException arg1) {
JobDataMap jobDataMap = context.getJobDetail().getJobDataMap();
Map<String, Object> wrappedMap = jobDataMap.getWrappedMap();
Collection<Object> values = wrappedMap.values();
String templateId = null;
for (Object object : values) {
templateId = (String)object; //获得当前任务的ID号
}
try {
/* 设置为 一个触发器触发一个任务
* 获得当前触发器的下一次执行时间，如果为null的话
* 则表示当前的任务已经执行完
*/
Date nextFireTime = context.getScheduler().getTrigger(new TriggerKey(templateId,templateId)).getNextFireTime();
//当任务的下一次执行时间为null的时候，表示任务已经结束了，此时将任务的运行状态设置为停止 (0)
if(nextFireTime == null){
SysInterfaceTimerTask selectByTemplateID = sysInterfaceTimerTaskMapper.selectByTemplateID(templateId);
selectByTemplateID.setIsRun("0");
sysInterfaceTimerTaskMapper.updateByTempId(selectByTemplateID);
}
} catch (SchedulerException e) {
e.printStackTrace();
}
System.out.println("任务执行完成了");
}
}
至此，计划任务基本完成。
相关推荐
Spring 2 和 Quartz 是两个在 Java Web 开发中非常重要的框架。Spring 是一个全面的开源应用框架，提供了依赖注入（DI）、面向切面编程（AOP）以及丰富的数据访问和事务管理功能。Quartz，则是一个功能强大的作业...
这个部分可能是介绍集成Quartz的基本步骤，包括引入依赖库，创建Job类以及Trigger，然后在Web应用的启动过程中配置Scheduler。Job类是执行任务的实体，Trigger则是触发Job执行的时间规则。 2. **quartz02** ...
通过上述内容，我们可以构建一个基于Quartz的Web应用定时任务系统，实现任务的自动执行。对于"Quartz_demo"这个压缩包文件，可能包含了示例代码、配置文件和说明文档，可以进一步帮助学习和实践Quartz在Web环境中的...
它可以被应用在任何 Java 应用中作为一个独立的类库或作为一个为 Web 应用提供服务的后端任务执行者。Quartz 允许开发人员定义触发器（Trigger），这些触发器用来告诉调度器何时运行作业。Quartz 提供了丰富的调度...
Quartz是一个开源的作业调度框架，它允许程序在预定的时间执行特定任务，广泛应用于Java企业级应用中。这个实例主要探讨如何使用Quartz实现自动化的任务调度，包括自动生成表达式、动态更新XML配置文件以及在Tomcat...
在Web应用中，Quartz的配置通常在`web.xml`中进行。我们需要配置`SchedulerFactoryBean`，指定配置文件路径（如`quartz.properties`），并设置启动时自动初始化调度器： ```xml ...
下面是一个简单的 Quartz 应用程序示例，演示如何创建一个 `Job`、`JobDetail`、`Trigger` 和 `Scheduler`，以及如何调度和执行一个作业： ```java import org.quartz.*; import org.quartz.impl....
总结，这个示例项目提供了一个在Jboss上运行的Web应用，使用Quartz进行后台作业调度的实例。学习这个项目，你可以了解到如何配置Quartz、创建和调度作业，以及在Web环境中集成Quartz的关键步骤。这对于需要定期执行...
例如，通过阅读Web服务器的配置文件，可以了解如何部署和管理Java Web应用；查看消息中间件的示例，可以学习如何实现异步通信和消息队列；分析数据库连接池的代码，可以理解如何优化数据库操作。 此外，对于计算机...
Quartz支持CRON表达式、触发器、作业和集群等多种功能，使得在Java应用中实现复杂的定时任务变得非常方便。 在SSM框架中集成Quartz，通常的做法是： 1. **配置Spring**：在Spring的配置文件中添加Quartz的配置，...
6. **工具化应用**：作为一款强大的工具，Quartz可以集成到各种Java应用程序中，例如Web应用、后台服务等。文章可能涵盖了如何在Spring框架中集成Quartz，利用Spring的声明式特性简化任务调度的配置。 7. **实际...
1. **Web初始化**：可能有一个名为`QuartzInitializerListener`的监听器，它在Web应用启动时被调用，负责设置Scheduler，并将Job和Trigger绑定到Web环境。 2. **Servlet或Filter**：可能包含一个Servlet或Filter，...
本文将详细解析“spring quartz定时任务demo”这个项目，它提供了实现Java定时任务的实例，便于快速理解和应用。 首先，Quartz是一个开源的作业调度框架，支持复杂的调度策略，可以创建、调度和执行重复或一次性...
在实际项目中，SpringMVC 和 Quartz 的结合可以帮助开发者构建出高效、灵活的应用程序，尤其是对于那些需要定期执行后台任务的系统，如数据分析、监控报警等。同时，由于 Spring 提供了对 Quartz 的良好支持，使得...
Quartz 可以被应用在任何 Java 应用中，但大多数情况下，它被用于构建服务端应用。 #### 2. Tomcat 启动时调用 Quartz 执行一次 根据题目中的描述，目标是在 Tomcat 启动时调用 Quartz 执行一次任务。下面将详细...
Servlet整合Quartz2是一项在Java Web应用中实现定时任务的重要技术。Quartz2是一个功能强大的开源作业调度框架，它允许开发者在应用程序中安排任务执行，而无需关心具体执行时间的管理。下面将详细介绍如何整合...
SpringBoot是Spring框架的一种简化和快速开发方式，它集成了大量常用的第三方库配置，如 JDBC、MongoDB、JPA、RabbitMQ、Quartz 等，使得开发者能够快速上手构建自己的应用。在这个"springboot的java配置实例"中，...
Quartz 是一个开源的工作调度框架，常用于Java应用程序中实现定时任务的管理。Spring框架与Quartz的整合，使得在Spring应用中配置和管理定时任务变得更加便捷。在"quartz demo"这个项目中，我们将探讨如何在Spring...