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

二、如果是需要Tomcat启动就能执行，不需要main方法的定时器的话：

web.xml里面需要这么配置：

com.InitListener

我爱编程网

第一个类：InitListener

package com.listener;

import java.util.Calendar;

import java.util.Date;

import java.util.Timer;

import javax.servlet.ServletContextEvent;

import javax.servlet.ServletContextListener;

/**

* 系统启动时的监听类 初始化系统数据

*

* @author jhoneder

*

*/

public class InitListener implements ServletContextListener {

public void contextDestroyed(ServletContextEvent arg0) {

// TODO Auto-generated method stub

// context销毁时，销毁初始化数据

}

public void contextInitialized(ServletContextEvent event) {

// TODO Auto-generated method stub

try {

goTimmer();

} catch (Exception e) {

System.out.println("失败:" + e.getMessage());

}

}

private void goTimer() {

Timer timmerTask = new Timer();

Calendar calEnviron = Calendar.getInstance();

// 每天的02:00.am开始执行

calEnviron.set(Calendar.HOUR_OF_DAY, 2);

calEnviron.set(Calendar.MINUTE, 00);

// date为制定时间

Date dateSetter = new Date();

dateSetter = calEnviron.getTime();

// nowDate为当前时间

Date nowDateSetter = new Date();

// 所得时间差为，距现在待触发时间的间隔

long intervalEnviron = dateSetter.getTime() - nowDateSetter.getTime();

if (intervalEnviron < 0) {

calEnviron.add(Calendar.DAY_OF_MONTH, 1);

dateSetter = calEnviron.getTime();

intervalEnviron = dateSetter.getTime() - nowDateSetter.getTime();

}

// 每24小时执行一次

timmerTask.schedule(new UseTimer(timmerTask), intervalEnviron, 1 * 1000 * 60 * 60 * 24);

}

}

第二个类：

package com.listener;

import java.util.Timer;

import java.util.TimerTask;

/**

* 被调用执行类

*

* @author Administrator

*

*/

public class UseTimer extends TimerTask {

Timer timer = new Timer();

public UseTimer(Timer timer) {

this.timer = timer;

}

/*

* 被调用具体的方法

*/

public void run() {

System.out.println("开始具体执行!");

}

}

不懂得话可以追问!

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.schedule(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()方法用来计算延时数，不管什么时候启动服务，都可以根据当前系统时间和执行任务的开始时间计算出延时时间毫秒数。

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

JDK 自带的定时器实现

// schedule(TimerTask task, long delay) 延迟 delay 毫秒 执行

// schedule(TimerTask task, Date time) 特定时间执行

public static void main(String[] args) {

for (int i = 0; i < 10; ++i) {

new Timer("timer - " + i).schedule(new TimerTask() {

@Override

public void run() {

println(Thread.currentThread().getName() + " run ");

}

}, 1000);

}

}

2. Quartz 定时器实现

//首先我们需要定义一个任务类，比如为MyJob02 ，

//该类需要继承Job类，然后添加execute(JobExecutionContext context)方法，在

//这个方法中就是我们具体的任务执行的地方。

//由希望由调度程序执行的组件实现的接口

public class MyJob02 implements Job {

@Override

public void execute(JobExecutionContext context) throws JobExecutionException {

// TODO Auto-generated method stub

// 执行响应的任务.

System.out.println("HelloJob.execute,"+new Date());

}

}

public class QuartzTest5 {

public static void main(String[] args) throws Exception {

//SchedulerFactory 是一个接口，用于Scheduler的创建和管理

SchedulerFactory factory = new StdSchedulerFactory();

//从工厂里面拿到一个scheduler实例

//计划表(可能翻译的不太贴切)，现在我们有了要做的内容，

//与调度程序交互的主要API

/*

* Scheduler的生命期，从SchedulerFactory创建它时开始，

到Scheduler调用shutdown()方法时结束;Scheduler被创建后，

可以增加、删除和列举Job和Trigger，以及执行其它与调度相关的操作

(如暂停Trigger)。但是，Scheduler只有在调用start()方法后，

才会真正地触发trigger(即执行job)

*/

Scheduler scheduler = factory.getScheduler();

//具体任务.

//用于定义作业的实例

//JobBuilder - 用于定义/构建JobDetail实例，用于定义作业的实例。

JobDetail job = JobBuilder.newJob(MyJob.class).withIdentity("job1", "group1").build();

//Trigger(即触发器) - 定义执行给定作业的计划的组件

//TriggerBuilder - 用于定义/构建触发器实例

CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity("trigger1", "group1")

.withSchedule(CronScheduleBuilder.cronSchedule("0/1  * * * * ?")).build();

scheduler.scheduleJob(job, trigger);

scheduler.start();

}

3. Spring  boot 任务调度(这个非常容易实现)

/*

*  开启对定时任务的支持

*  在相应的方法上添加@Scheduled声明需要执行的定时任务。

*/

@EnableScheduling

//@EnableScheduling注解来开启对计划任务的支持

public class Application {

public static void main(String[] args) {

SpringApplication.run(Application.class, args);

}

}

@Component

public class ScheduledTasks {

private Logger logger = LoggerFactory.getLogger(ScheduledTasks.class);

private    int     i=0;

//0 0 0 2 * ?

@Scheduled(cron="*  *  *  2  *  ?")

//@Scheduled 注解用于标注这个方法是一个定时任务的方法

public void testFixDelay() {

logger.info("执行方法"+i++);

}