java定时器每天凌晨

⑴ java怎么让程序每天晚上12点做定时任务，因为程序是不定时开的，所以要实时监听系统时间。

java定时任务，每天定时执行任务(JDK TimerTask)
标签： taskTasktimerTimer
2013-01-14 13:28 8747人阅读 评论(0) 收藏 举报
01 public class TimerManager {
02
03 //时间间隔
04 private static final long PERIOD_DAY = 24 * 60 * 60 * 1000;
05
06 public TimerManager() {
07 Calendar calendar = Calendar.getInstance();
08
09 /*** 定制每日2:00执行方法 ***/
10
11 calendar.set(Calendar.HOUR_OF_DAY, 2);
12 calendar.set(Calendar.MINUTE, 0);
13 calendar.set(Calendar.SECOND, 0);
14
15 Date date=calendar.getTime(); //第一次执行定时任务的时间
16
17 //如果第一次执行定时任务的时间 小于 当前的时间
18 //此时要在 第一次执行定时任务的时间 加一天，以便此任务在下个时间点执行。如果不加一天，任务会立即执行。
19 if (date.before(new Date())) {
20 date = this.addDay(date, 1);
21 }
22
23 Timer timer = new Timer();
24
25 NFDFlightDataTimerTask task = new NFDFlightDataTimerTask();
26 //安排指定的任务在指定的时间开始进行重复的固定延迟执行。
27 timer.schele(task,date,PERIOD_DAY);
28 }
29
30 // 增加或减少天数
31 public Date addDay(Date date, int num) {
32 Calendar startDT = Calendar.getInstance();
33 startDT.setTime(date);
34 startDT.add(Calendar.DAY_OF_MONTH, num);
35 return startDT.getTime();
36 }
37
38 }

在 TimerManager 这个类里面，大家一定要注意 时间点的问题。如果你设定在凌晨2点执行任务。但你是在2点以后
发布的程序或是重启过服务，那这样的情况下，任务会立即执行，而不是等到第二天的凌晨2点执行。为了，避免这种情况
发生，只能判断一下，如果发布或重启服务的时间晚于定时执行任务的时间，就在此基础上加一天。

01 public class NFDFlightDataTimerTask extends TimerTask {
02
03 private static Logger log = Logger.getLogger(NFDFlightDataTimerTask.class);
04
05 @Override
06 public void run() {
07 try {
08 //在这里写你要执行的内容
09
10 } catch (Exception e) {
11 log.info("-------------解析信息发生异常--------------");
12 }
13 }
14 }
15
16 public class NFDFlightDataTaskListener implements ServletContextListener {
17
18 public void contextInitialized(ServletContextEvent event) {
19 new TimerManager();
20 }
21
22 public void contextDestroyed(ServletContextEvent event) {
23 }
24
25 }

然后要在web.xml里面配置监听器
1 <listener>
2 <listener-class>
3 com.listener.NFDFlightDataTaskListener
4 </listener-class>
5 </listener>

⑵ 如何配置Spring定时器准确运行时间，例如我想它在每天半夜12点运行一次

Spring中有自带任务调度框架Quartz ，直接在xml配置文件中配置就好。
一般我们使用spring定时器的时候都是配置的固定时间在spring配置文件中，如果我们有一个时间设置页面，通过这个页面设置定时器的执行时间，就可以达到动态执行的效果。

上代码：
package com.test.action;
import java.text.ParseException;

import javax.annotation.Resource;

import org.quartz.Scheler;

import org.quartz.SchelerException;

import org.springframework.scheling.quartz.CronTriggerBean;

import org.springframework.web.context.WebApplicationContext;

import org.springframework.web.context.support.WebApplicationContextUtils;

import com.opensymphony.xwork2.ActionSupport;

public class TestAction extends ActionSupport{ @Resourcepublic CronTriggerBean triggerBean;
//系统 public CronTriggerBean triggerTempBean;

@Resource private Scheler scheler;

private String configTime;

public String configTime(){ try { /*得到系统设置的定时器执行时间
*/System.out.println(triggerBean.getCronExpression());

/*得到指定定时器, testDoTrigger为applicationContext.xml中CronTriggerBean*/
triggerTempBean = (CronTriggerBean) scheler.getTrigger("testDoTrigger", Scheler.DEFAULT_GROUP);

/*指定定时器的执行时间*/

System.out.println(triggerTempBean.getCronExpression());

/*将指定定时器的执行时间设置为从前台传递过来的时间*/
triggerTempBean.setCronExpression(configTime);

/*让设置生效*/
scheler.rescheleJob("testDoTrigger", Scheler.DEFAULT_GROUP,triggerTempBean);
} catch(ParseException e) {

// TODO Auto-generated catch block
e.printStackTrace();

} catch(SchelerException e) {
// TODO Auto-generated catch block
e.printStackTrace();

}
return SUCCESS;
}

public String getConfigTime(){
return configTime;
}

public void setConfigTime(String configTime){
this.configTime = configTime;}

⑶ spring怎么设置定时任务为每天凌晨2点执行和每小时执行一次

每天凌晨2点 0 0 2 * * ?和每天隔一小时 0 * */1 * * ?

⑷ java定时器 每天12点 固定执行一个方法

Calendar cal = Calendar.getInstance();
//每天定点执行
cal.set(Calendar.HOUR_OF_DAY,12);
cal.set(Calendar.MINUTE,0);
cal.set(Calendar.SECOND,0);
Timer timer = new Timer();
timer.schele(new TimerTask() {
public void run() {
//执行的内内容容
}
},cal.getTime(), 24*60*60*1000);

⑸ java定时器 每天凌晨 固定执行一个方法

可以通过以下方式实现，

public class TimerManager {
//时间间隔
private static final long PERIOD_DAY = 24 * 60 * 60 * 1000;
public TimerManager() {
Calendar calendar = Calendar.getInstance();
/*** 定制每日:00执行方法 ***/
calendar.set(Calendar.HOUR_OF_DAY, 2);
calendar.set(Calendar.MINUTE, 0);
calendar.set(Calendar.SECOND, 0);

Date date=calendar.getTime(); //第一次执行定时任务的时间

//如果第一次执行定时任务的时间 小于 当前的时间
//此时要在 第一次执行定时任务的时间 加一天，以便此任务在下个时间点执行。如果不加一天，任务会立即执行。
if (date.before(new Date())) {
date = this.addDay(date, 1);
}

Timer timer = new Timer();

NFDFlightDataTimerTask task = new NFDFlightDataTimerTask();
//安排指定的任务在指定的时间开始进行重复的固定延迟执行。
timer.schele(task,date,PERIOD_DAY);
}

// 增加或减少天数
public Date addDay(Date date, int num) {
Calendar startDT = Calendar.getInstance();
startDT.setTime(date);
startDT.add(Calendar.DAY_OF_MONTH, num);
return startDT.getTime();
}

}

public class NFDFlightDataTimerTask extends TimerTask {

private static Logger log = Logger.getLogger(NFDFlightDataTimerTask.class);

@Override
public void run() {
try {
//在这里写你要执行的内容

} catch (Exception e) {
log.info("-------------解析信息发生异常--------------");
}
}
}

public class NFDFlightDataTaskListener implements ServletContextListener {
public void contextInitialized(ServletContextEvent event) {
new TimerManager();
}
public void contextDestroyed(ServletContextEvent event) {
}

}

然后要在web.xml里面配置监听器
<listener>
<listener-class>
com.listener.NFDFlightDataTaskListener
</listener-class>
</listener>

⑹ JAVA单机版程序，如何指定在每天凌晨0：00：00执行

import java.util.Calendar;
import java.util.Date;
import java.util.Timer;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;

public class HandleTimerTask implements ServletContextListener {

private Timer timer = null; //定时器
private static int DOWNlOAD_HOUR = 0; //执行任务开始时间（时）
private static int DOWNlOAD_MINUTE = 0; //执行任务开始时间（分）
private static int DOWNlOAD_SECOND = 0; //执行任务开始时间（秒）
private long delay; //延时时间值（当前系统时间到下载时间之间的时间差毫秒数）

public void contextInitialized(ServletContextEvent event) {
init();//初始化参数
timer = new Timer(true);//创建Timer对象
//定时执行程序
timer.schele(new Handle(event.getServletContext()),delay,24*60*60*1000);//调用Handle()类（即每天要执行的任务），delay表示延迟毫秒数，0,24*60*60*1000表示每隔一天执行一次任务，60*60*1000表示一个小时；
}

public void contextDestroyed(ServletContextEvent event) {
timer.cancel();
}

/**
* 初始化参数
* @return
*/
public void init(){
//声明一个Calendar对象
Calendar cal = Calendar.getInstance();
//设置时间
cal.set(Calendar.HOUR_OF_DAY, DOWNlOAD_HOUR);
cal.set(Calendar.MINUTE, DOWNlOAD_MINUTE);
cal.set(Calendar.SECOND, DOWNlOAD_SECOND);
Date date = new Date();
//获取设定的时间
date = cal.getTime();
//声明当前时间
Date now = new Date();
//获取设定的时间和当前的时间差（毫秒数）
long interval = date.getTime() - now.getTime();
//如果当前时间大于下载时间，则将下载时间设置为下一个下载时间
if (interval < 0) {
cal.add(Calendar.DAY_OF_MONTH, 1);//将天数加1
date = cal.getTime();
//获取设定的时间和当前的时间差（毫秒数）
interval = date.getTime() - now.getTime();
}
this.startTime = date;//初始化开始下载时间
this.delay = interval;//初始化当前时间到下载时间之间的时间差
}
}

public class Handle extends TimerTask {

private ServletContext context = null;
Timer timer = null; //查询任务定时器

public Handle(ServletContext context)
{
this.context = context;
}

/**
* 开始执行
*/
public void run() {
//开始执行
context.log("开始执行！");
}
}

用延迟时间可以实现，添加了一个init()方法用来计算延时数，不管什么时候启动服务，都可以根据当前系统时间和执行任务的开始时间计算出延时时间毫秒数。

虽然没有分，还是希望能帮助你。 ^_^

⑺ java如何在每一天的凌晨00:00:00自动运行程序

LZ指的是定时任务吧
在java里面做定时任务通常是线程的
下面有个简单的定时任务(没验证是否好使 但基本是这个样子的)
在web.xml里面增加一个监听
<listener>
<listener-class>CountListen</listener-class>
</listener>
具体代码如下
import javax.servlet.ServletContextListener;
import javax.servlet.ServletContextEvent;
import java.util.*;

public class CountListen
implements ServletContextListener {
private java.util.Timer timer = null;
public void contextInitialized(ServletContextEvent event) {
timer = new java.util.Timer(true);
event.getServletContext().log("定时器已启动");
System.out.println("定时器已启动");
Date date = new Date(1900,1,1,23,59);
timer.schele(new SampleTask(event.getServletContext()),0,
24 * 60 * 60 * 1000);
event.getServletContext().log("已经添加任务调度表");
System.out.println("已经添加任务调度表");
}

public void contextDestroyed(ServletContextEvent event) {
timer.cancel();
event.getServletContext().log("定时器销毁");
}
}

import java.util.*;
import javax.servlet.ServletContext;
import com.founder.gongan.util.ConfigPropertie;
import com.founder.gongan.manage.CountManager;
import com.founder.botong.entity.EnumFolder;

class SampleTask
extends TimerTask {
private static boolean isRunning = true;
private ServletContext context = null;
public SampleTask(ServletContext context) {
this.context = context;
}

public void run() {
if (isRunning) {
isRunning = false;
context.log("开始执行指定任务");
System.out.println("开始执行指定任务");
//指定的任务......
isRunning = true;
context.log("指定任务执行结束");
System.out.println("指定任务执行结束");
}else {
context.log("上一次任务执行还未结束");
}
}

}

⑻ java定时器每天晚上23：00开始刷新数据怎么写

publicstaticvoidtimer4(){
Calendarcalendar=Calendar.getInstance();
calendar.set(Calendar.HOUR_OF_DAY,23);//控制时
calendar.set(Calendar.MINUTE,0);//控制分
calendar.set(Calendar.SECOND,0);//控制秒

Datetime=calendar.getTime();//得出执行任务的时间,此处为今天的23：00：00

Timertimer=newTimer();
timer.scheleAtFixedRate(newTimerTask(){
publicvoidrun(){
System.out.println("-------设定要指定任务--------");
}
},time,1000*60*60*24);//这里设定将延时每天固定执行
}

⑼ java定时任务的定时表达式，每天早晨6：30执行任务，还有一个是每个月的1号和15号执行任务

public class TestTimerTask extends TimerTask{
public void run() {
Calendar cal = Calendar.getInstance();
//每月5号执行

if(cal.get(Calendar.DATE) == 5){
try {
//需要执行的代码
} catch (Exception e) {
//logger.error(e);
e.printStackTrace();
}
System.gc();
//......
}
//周日执行

if(cal.get(Calendar.DAY_OF_WEEK) == 1){
try {
//需要执行的代码

} catch (Exception e) {
// logger.error(e);
e.printStackTrace();
}
System.gc();
}
}
}
public class Test{
public static void main (String[] ages){
Timer timer = new Timer();//定时器
TestTimerTask ts = newTestTimerTask();//定时任务目标
Date firstTime = new Date();//第一次执行时间
long period = 1000 * 60 * 60 * 24;//执行间隔1天
timer.scheleAtFixedRate(ts, firstTime, period);//设置执行参数并且开始定时任务
}

}

⑽ java如何在每个月最后一天的凌晨00:00:00自动运行程序

可以写个定时器。设置定时一天的时间，再通过代码时间判断是不是月末，如果是执行程序。