1、總控制臺
2、計劃任務的設置界面。
3、控制臺輸出結果。
二、程序開發環境：
使用Java(JDK 1.4)開發，圖形界面使用Eclipse （2.1.3版）的SWT方式開發。運行主機：P4 2.6+1G內存 windowsXP操作系統
三、預備。
開發此類程序，最好不要直接使用JAVA的線程來編程，這樣會增加不必要的復雜度和難度，吃力不討好。在JAVA中有壹個包 java.util.Timer 這個包封裝了對線程的操作，我們可以把它稱做定時器類。我們先來看壹個簡單例子：
import java.util.Timer;
import java.util.TimerTask;
public class Reminder {
Timer timer;
public Reminder(int seconds) {
timer = new Timer();
timer.schedule(new RemindTask(),seconds*1000); //參數要求轉化成毫秒
}
public static void main(String args[]) {
new Reminder(5); //5秒後運行
}
/**壹個內部類，封裝了所要運行的任務*/
class RemindTask extends TimerTask {
public void run() {
System.out.println("任務運行。。。。");
timer.cancel(); //結束timer中的所有任務
}
}
}
這裏涉及於兩個JAVA類Timer和TimerTask。我們繼承TimerTask類後，將所要運行的任務封裝其run方法中；Timer可以管理幾千個任務（TimerTask），註意，同壹個任務對象不能兩次加入到Timer中執行。
對（雖然執行的任務都壹樣，但是兩個任務對象）：
timer.schedule(new RemindTask(), seconds * 1000);
timer.schedule(new RemindTask(), seconds * 1000);
錯
RemindTask task= new RemindTask();
timer.schedule(task, seconds * 1000);
timer.schedule(task, seconds * 2000);
四、設計方案。
主要的類圖
說明：
任務類的設計。我們先創建壹個抽象類AbstractTimerTask，這個類直接繼承至TimerTask類，提供對TimerTask封裝。然後所有具體的任務類（如：TimerTask_1）繼承自AbstractTimerTask。
import java.util.TimerTask;
public abstract class AbstractTimerTask extends TimerTask {
TaskEntry taskEntry; //任務記錄
public AbstractTimerTask(TaskEntry taskEntry) {
this.taskEntry = taskEntry;
}
/*
* 生成壹個新的實例相當於克隆自身;原因在於：同壹任務對象不能兩次加入到Timer
* 在TaskEntry類將看到它的使用方法
*/
abstract AbstractTimerTask getCloneObject();
}
下面是它的壹個實現類的源代碼我們可以將要運行任務的代碼寫在這個類中。
import java.util.Calendar;
public class TimerTask_1 extends AbstractTimerTask {
public TimerTask_1(TaskEntry taskEntry) { //構造方法
super(taskEntry);
}
public AbstractTimerTask getCloneObject() {
return new TimerTask_1(taskEntry);
}
public void run() {
/*在這裏寫妳要執行的程序。。。。。*/
System.out.println("?時："+taskEntry.getName()+"運行了壹次");
this.taskEntry.taskStart(); //運行下壹個時間點任務
}
}
在AbstractTimerTask類有壹個TaskEntry字段，這是本設計的壹個核心類,它代表壹條封裝完整的任務記錄,每個任務類和它的運行計劃都封裝在這條類中,源代碼如下。Timer和AbstractTimerTask前面都已說過,那麽TimePlan是做什麽用的呢？
import java.util.Calendar;
import java.util.Date;
import java.util.Timer;
import mytimer.util.Util;
/**任務記錄類*/
public class TaskEntry {
public static final int TASK_START = 0; //定義兩個表示任務記錄狀態常量
public static final int TASK_STOP = 1;
private Long oid; //任務ID號，唯壹
private String name; //任務名稱
private int state = TASK_STOP; //任務狀態（啟動/停止）
private Timer timer; //JAVA計時器
private TimePlan timePlan; //時間計劃的類型
private AbstractTimerTask timerTask; //任務類的種子對象,由這個對象來不斷克隆
private AbstractTimerTask runTimerTask; //運行計劃的當前任務
/**
* ITaskEntry.taskStart()-->TimerTask.run()-->ITaskEntry.taskStart()
* 形成壹個循環回路。本方法負責起動本類代表的任務
*/
public void taskStart() {
if (timePlan.haveNext()) {
Date date = timePlan.nextDate();//得到任務計劃時間
runTimerTask = timerTask.getCloneObject();//得到任務(復制)
timer.schedule(runTimerTask, date); //加入計劃隊列
//打印將要運行的計劃任務的信息
Calendar c = Calendar.getInstance();
c.setTimeInMillis(runTimerTask.scheduledExecutionTime());
System.out.println(Util.dateToLongStr(c.getTime())+"將運行"+name);
} else {
state = TASK_STOP;
System.out.println(name + "結束");
}
}
/**停止任務*/
public void taskStop() {
if (runTimerTask != null) {
//打印信息
Calendar c = Calendar.getInstance();
c.setTimeInMillis(runTimerTask.scheduledExecutionTime());
System.out.println("計劃於:"+Util.dateToLongStr(c.getTime())+"運行的" + name + "被終止");
//終止本任務, 調用Timer.cancel()是終止Timer的所有任務。
runTimerTask.cancel();
} else {
System.out.println(name + "未進入執行計劃");
}
}
……… 壹些屬性的get/set方法（省略）
/** 監聽類（內部類） */
public static class DateBeforeTodayException extends NullPointerException {
private Date date;
public DateBeforeTodayException(Date date) {this.date = date;}
public String toString() {
return "計劃時間(" + Util.dateToLongStr(date) + ")早於當前時間";
}
}
}
1、TimePlan是壹個接口(interface)，它是表示“運行計劃的方案”，這個程序中提供了三種運行計劃方案（見前圖：計劃任務的設置界面）：
壹次性運行。
每隔壹個時間段運行。
壹周中選擇那幾天運行。
將它設計成壹個接口是為了方便今後擴展，如果要新增新的時間方案只需要繼承這個接口寫壹個新的實現即可。三種時間方案的類圖如下：
說明：
a) TimePlan封裝了五個方法，其它haveNext()和nextDate()最重要，這個兩個方法模仿了Java中集合類（Collection）的叠代器(Iterator)的設計形式，代碼如下：
import java.util.Date;
//時間計劃方案的接口
public interface TimePlan {
boolean haveNext();//判斷還有沒有下壹個計劃時間
Date nextDate();//得到下壹個計劃時間
Date getCurrentDate();//得到開始時間
void setCurrentDate(Date date); //設計開始時間
String getTimePlanString();//顯示運行計劃方案的文字說明
}
b) AbstractTimePlan是這個抽象類，主要目的是將壹些各子類的公***方法寫在這裏。代碼如下：
import java.util.Date;
public abstract class AbstractTimePlan implements TimePlan {
//記錄計劃的第壹時間點，除設置新的起始時間，否則不再改變
protected Date currentDate;
/*
當前計劃的時間點，每次計劃替換時被更新，
似乎這個才應叫cureentDate，sorry不想再改了
*/
protected Date planDate;
public boolean haveNext() {
return (planDate != null);
}
public Date getCurrentDate() {
return currentDate;
}
public void setCurrentDate(Date date) {
currentDate = date;
planDate = date; //在賦給currentDate值時，同時也賦給planDate
}
}
c) 然後我們看看三種計劃方案的實現類的源代碼：
//“壹次性運行”的計劃方案類
import java.util.Date;
public class TimePlanOnce extends AbstractTimePlan {
public Date nextDate() {
//把要當前的計劃時間保存在中間變量中
Date returnDate = this.planDate;
//算出下壹個計劃時間。沒有下壹個就設為null
this.planDate = null;
//判斷壹下計劃時間合不合條件
if (returnDate == null)
throw new NullPointerException("沒有下壹個計劃日期");
return returnDate;
}
public String getTimePlanString() {
return "壹次性運行,運行時間: （打印this.currentDate） ";
}
}
//“周期性間隔”的時間計劃方案類
import java.util.Date;
public class TimePlanPeriod extends AbstractTimePlan {
public static final int HOUR = 0;
public static final int DAY = 1;
private int spaceTime; //間隔時間,單位毫秒
private int timeType;
public Date nextDate() {
//把要當前的計劃時間保存在中間變量中
Date returnDate = this.planDate;
//算出下壹個計劃時間。沒有下壹個就設為null
int milliSecond = 0;
if (timeType ==HOUR) milliSecond = spaceTime * 1000; //小時*60*60*1000;
if (timeType ==DAY) milliSecond = spaceTime * 24 * 60 * 60 * 1000; //天
planDate = Util.DateAddSpaceMilliSecond(planDate, milliSecond);
//判斷壹下計劃時間合不合條件
if (returnDate == null)
throw new NullPointerException("沒有下壹個計劃日期");
return returnDate;
}
public String getTimePlanString() {
if (timeType == HOUR)
return "第壹次運行於:currentDate.並每隔spaceTime小時運行壹次";
if (timeType == DAY)
return "第壹次運行於:currentDate.並每隔spaceTime天運行壹次";
return "";
}
public int getSpaceTime() { return spaceTime; }
public int getTimeType() { return timeType; }
public void setSpaceTime(int i) { spaceTime = i; }
public void setTimeType(int i) { timeType = i; }
}
/**選擇壹周的某幾天,讓這幾天在同壹時間點運行任務, 壹周內必須選擇壹天*/
import java.util.Calendar;
import java.util.Date;
public class TimePlanSelectWeek extends AbstractTimePlan {
private static Calendar c = Calendar.getInstance(); //取得壹個日歷實例
private static int spaceMilliSecond = 0; //間隔時間,單位毫秒
private boolean[] selectWeek = new boolean[7]; //0為星期日 ,1為星期壹
public Date nextDate() {
Date returnDate = null;
if (!isSelectWeek(planDate)) //如果這壹天不是所選周中的壹天
planDate = getNextDate(planDate);
returnDate = planDate;
planDate = getNextDate(planDate);
//判斷壹下計劃時間合不合條件
if (returnDate == null)
throw new NullPointerException("沒有下壹個計劃日期");
return returnDate;
}
//算出下壹個計劃時間。沒有下壹個就設為null
private Date getNextDate(Date date) {
Date tempDate = date;
Date returnDate = null;
for (int i = 0; i < 7; i++) {
tempDate = Util.DateAddSpaceMilliSecond(tempDate, spaceMilliSecond);
if (isSelectWeek(tempDate)) {
returnDate = tempDate;
break;
}
}
return returnDate;
}
/**設置某星期是否被選, 0為星期日 ,1為星期壹....6為星期六*/
public void setSelectWeek(int i, boolean b) {selectWeek[i] = b;}
/** 判斷某星期是否被選*/
public boolean isSelectWeek(int i) {return selectWeek[i];}
/**判斷某天所屬星期幾是否被選*/
public boolean isSelectWeek(Date date) {
if (date == null) return false;
c.setTime(date);
//Calendar.DAY_OF_WEEK:星期日=1,星期六=7 c.get(Calendar.DAY_OF_WEEK)
return isSelectWeek(c.get(Calendar.DAY_OF_WEEK) - 1);
}
public String getTimePlanString() {
StringBuffer sb = new StringBuffer("");
if (selectWeek[1]) sb.append("周壹,");
if (selectWeek[2]) sb.append("周二,");
if (selectWeek[3]) sb.append("周三,");
if (selectWeek[4]) sb.append("周四,");
if (selectWeek[5]) sb.append("周五,");
if (selectWeek[6]) sb.append("周六,");
if (selectWeek[0]) sb.append("周日,");
return "每周的"+sb.toString()+"運行";
}
}
TimerTask的工廠類。將生成TimerTask的代碼另起壹個類的好處是代碼的層次比較清楚，也比較好管理。由於TimerTask包含有幾個字段，因此產生壹個TimerTask對象還是有壹定的復雜度，建立壹個專門生成TimerTask的工廠類，這樣我們在生成壹個TimerTask對象時就可以少掉很多麻煩的代碼了。當然由於我的工作任務，只需要壹個TimerTask對象就夠了，所以最初之前我是將它直接寫在圖形界面的代碼裏的。
這裏建立壹個TimerTask對象池tasks，它是壹個靜態變量，這樣在getInstance時不必總是要新生成壹個TimerTask。還有Timer也是壹個靜態變量，它是壹個全局單例（是最簡單的單例模式了），因為前面說了Timer可以管理幾千個任務，所以Timer對象壹個就夠了。
import java.util.HashMap;
import java.util.Timer;
public class TaskEntryFactory {
private static final HashMap tasks = new HashMap();
private static final Timer timer = new Timer();
public static TaskEntry getInstance(Long oid, String name) {
if (tasks.containsKey(oid)) {
return (TaskEntry) tasks.get(oid);
} else {
TaskEntry entry = new TaskEntry();
entry.setOid(oid);
entry.setName(name);
entry.setTimer(timer);
entry.setTimerTask(new TimerTask_1(entry));
tasks.put(oid, entry);
return entry;
}
}
}
起動和停止任務,當“任務設置界面（TaskListDialog.java）”點擊OK後處理。界面的編寫就不在本文討論的範圍內了。
//任務設置界面中點擊”確認(OK)”按鈕後的處理
if (dialog.open() == Window.OK) {
if (taskEntry.getState() == TaskEntry.TASK_START) {
taskEntry.taskStop();//將舊的停掉
taskEntry.taskStart();//開始新設置的
}
if (taskEntry.getState() == TaskEntry.TASK_STOP)
taskEntry.taskStop();
tv.refresh(taskEntry);
}