KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > springframework > scheduling > commonj > ScheduledTimerListener


1 /*
2  * Copyright 2002-2007 the original author or authors.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 package org.springframework.scheduling.commonj;
18
19 import commonj.timers.TimerListener;
20
21 /**
22  * JavaBean that describes a scheduled TimerListener, consisting of
23  * the TimerListener itself (or a Runnable to create a TimerListener for)
24  * and a delay plus period. Period needs to be specified;
25  * there is no point in a default for it.
26  *
27  * <p>The CommonJ TimerManager does not offer more sophisticated scheduling
28  * options such as cron expressions. Consider using Quartz for such
29  * advanced needs.
30  *
31  * <p>Note that the TimerManager uses a TimerListener instance that is
32  * shared between repeated executions, in contrast to Quartz which
33  * instantiates a new Job for each execution.
34  *
35  * @author Juergen Hoeller
36  * @since 2.0
37  * @see commonj.timers.TimerListener
38  * @see commonj.timers.TimerManager#schedule(commonj.timers.TimerListener, long, long)
39  * @see commonj.timers.TimerManager#scheduleAtFixedRate(commonj.timers.TimerListener, long, long)
40  */
41 public class ScheduledTimerListener {
42
43     private TimerListener timerListener;
44
45     private long delay = 0;
46
47     private long period = -1;
48
49     private boolean fixedRate = false;
50
51
52     /**
53      * Create a new ScheduledTimerListener,
54      * to be populated via bean properties.
55      * @see #setTimerListener
56      * @see #setDelay
57      * @see #setPeriod
58      * @see #setFixedRate
59      */
60     public ScheduledTimerListener() {
61     }
62
63     /**
64      * Create a new ScheduledTimerListener, with default
65      * one-time execution without delay.
66      * @param timerListener the TimerListener to schedule
67      */
68     public ScheduledTimerListener(TimerListener timerListener) {
69         this.timerListener = timerListener;
70     }
71
72     /**
73      * Create a new ScheduledTimerListener, with default
74      * one-time execution with the given delay.
75      * @param timerListener the TimerListener to schedule
76      * @param delay the delay before starting the task for the first time (ms)
77      */
78     public ScheduledTimerListener(TimerListener timerListener, long delay) {
79         this.timerListener = timerListener;
80         this.delay = delay;
81     }
82
83     /**
84      * Create a new ScheduledTimerListener.
85      * @param timerListener the TimerListener to schedule
86      * @param delay the delay before starting the task for the first time (ms)
87      * @param period the period between repeated task executions (ms)
88      * @param fixedRate whether to schedule as fixed-rate execution
89      */
90     public ScheduledTimerListener(TimerListener timerListener, long delay, long period, boolean fixedRate) {
91         this.timerListener = timerListener;
92         this.delay = delay;
93         this.period = period;
94         this.fixedRate = fixedRate;
95     }
96
97     /**
98      * Create a new ScheduledTimerListener, with default
99      * one-time execution without delay.
100      * @param timerTask the Runnable to schedule as TimerListener
101      */
102     public ScheduledTimerListener(Runnable JavaDoc timerTask) {
103         setRunnable(timerTask);
104     }
105
106     /**
107      * Create a new ScheduledTimerListener, with default
108      * one-time execution with the given delay.
109      * @param timerTask the Runnable to schedule as TimerListener
110      * @param delay the delay before starting the task for the first time (ms)
111      */
112     public ScheduledTimerListener(Runnable JavaDoc timerTask, long delay) {
113         setRunnable(timerTask);
114         this.delay = delay;
115     }
116
117     /**
118      * Create a new ScheduledTimerListener.
119      * @param timerTask the Runnable to schedule as TimerListener
120      * @param delay the delay before starting the task for the first time (ms)
121      * @param period the period between repeated task executions (ms)
122      * @param fixedRate whether to schedule as fixed-rate execution
123      */
124     public ScheduledTimerListener(Runnable JavaDoc timerTask, long delay, long period, boolean fixedRate) {
125         setRunnable(timerTask);
126         this.delay = delay;
127         this.period = period;
128         this.fixedRate = fixedRate;
129     }
130
131
132     /**
133      * Set the Runnable to schedule as TimerListener.
134      * @see DelegatingTimerListener
135      */
136     public void setRunnable(Runnable JavaDoc timerTask) {
137         this.timerListener = new DelegatingTimerListener(timerTask);
138     }
139
140     /**
141      * Set the TimerListener to schedule.
142      */
143     public void setTimerListener(TimerListener timerListener) {
144         this.timerListener = timerListener;
145     }
146
147     /**
148      * Return the TimerListener to schedule.
149      */
150     public TimerListener getTimerListener() {
151         return this.timerListener;
152     }
153
154     /**
155      * Set the delay before starting the task for the first time,
156      * in milliseconds. Default is 0, immediately starting the
157      * task after successful scheduling.
158      * <p>If the "firstTime" property is specified, this property will be ignored.
159      * Specify one or the other, not both.
160      */
161     public void setDelay(long delay) {
162         this.delay = delay;
163     }
164
165     /**
166      * Return the delay before starting the job for the first time.
167      */
168     public long getDelay() {
169         return this.delay;
170     }
171
172     /**
173      * Set the period between repeated task executions, in milliseconds.
174      * <p>Default is -1, leading to one-time execution. In case of zero or a
175      * positive value, the task will be executed repeatedly, with the given
176      * interval inbetween executions.
177      * <p>Note that the semantics of the period value vary between fixed-rate
178      * and fixed-delay execution.
179      * <p><b>Note:</b> A period of 0 (for example as fixed delay) <i>is</i>
180      * supported, because the CommonJ specification defines this as a legal value.
181      * Hence a value of 0 will result in immediate re-execution after a job has
182      * finished (not in one-time execution like with <code>java.util.Timer</code>).
183      * @see #setFixedRate
184      * @see #isOneTimeTask()
185      * @see commonj.timers.TimerManager#schedule(commonj.timers.TimerListener, long, long)
186      */
187     public void setPeriod(long period) {
188         this.period = period;
189     }
190
191     /**
192      * Return the period between repeated task executions.
193      */
194     public long getPeriod() {
195         return this.period;
196     }
197
198     /**
199      * Is this task only ever going to execute once?
200      * @return <code>true</code> if this task is only ever going to execute once
201      * @see #getPeriod()
202      */
203     public boolean isOneTimeTask() {
204         return (this.period < 0);
205     }
206
207     /**
208      * Set whether to schedule as fixed-rate execution, rather than
209      * fixed-delay execution. Default is "false", i.e. fixed delay.
210      * <p>See TimerManager javadoc for details on those execution modes.
211      * @see commonj.timers.TimerManager#schedule(commonj.timers.TimerListener, long, long)
212      * @see commonj.timers.TimerManager#scheduleAtFixedRate(commonj.timers.TimerListener, long, long)
213      */
214     public void setFixedRate(boolean fixedRate) {
215         this.fixedRate = fixedRate;
216     }
217
218     /**
219      * Return whether to schedule as fixed-rate execution.
220      */
221     public boolean isFixedRate() {
222         return this.fixedRate;
223     }
224
225 }
226
Popular Tags