A. spring中的定时器和jdk自带的定时器有什么区别
今天我介绍一下spring的定时器功能，它不仅实现起来方便，功能强大，而且在web开发时正好配合spring框架使用。
spring支持jdk内置的Timer类和Quartz Scheler
?
介绍spring的定时器，当然要先介绍配置文件applicationContext.xml了。
?
<bean name="job" class="org.springframework.scheling.quartz.JobDetailBean">
<property name="jobClass">
<value>jaoso.news.web.action.JobAction</value>
</property>
<property name="jobDataAsMap">
<map>
<entry key="timeout">
<value>10</value>
</entry>
</map>
</property>
</bean>
?
说明：org.springframework.scheling.quartz.JobDetailBean是spring对你的类进行调度的代理，在jobClass中要指定你的任务类（com.yangsq.web.action.JobAction），在jobDataAsMap中向你的任务类中注入一些信息，当然也可以reference一个，不要忘记在你的任务里加入这些属性及set方法（有些罗嗦）。
timeout属性设定了当服务器启动后过10秒钟首次调用你的JobAction。
?
<bean id="cronTrigger" class="org.springframework.scheling.quartz.CronTriggerBean">
<property name="jobDetail">
<ref bean="job"/>
</property>
<property name="cronExpression">
<value>0 0/2 * * * ?</value>
</property>
</bean>
?
说明：org.springframework.scheling.quartz.CronTriggerBean是spring提供的触发器，在这个触发器中设定了要触发的job（jobDetail属性设定了先前定义的bean），同时设定了触发时间（cronExpression）---每隔两分钟（0 0/2 * * * ?），这个的设定方式最后会说明。
?
<bean class="org.springframework.scheling.quartz.SchelerFactoryBean">
<property name="triggers">
<list>
<ref local="cronTrigger"/>
</list>
</property>
</bean>
?
说明：org.springframework.scheling.quartz.SchelerFactoryBean这是一个spring的工厂bean，在他的triggers属性列表中加入刚才定义的触发器，这里可以定义多个触发器（list嘛）。
?
好了，配置文件就介绍完了，该介绍com.yangsq.web.action.JobAction类了，
?
引入包：
说明：QuartzJobBean是spring自带的，把spring的jar包加入就行了，但是前两个包要去下了，呵呵，google吧。
?
?
当然要继承QuartzJobBean了，但是光extends不行，必须要重载他的executeInternal方法
B. java spring quartz 动态定时器
DELPHI这边的连接并不难。
你可以使用DBExpress进行连接，效率高、直接，使用DELHPI提供的引擎。
其它的方式，你可能要安装相应的驱动(数据客户端程序通常包括驱动)。
要保障，你的服务端提供的服务是可用的。可以使用管理工具查看确认。
C. spring 定时器的方法参数是否能动态修改
很多时候，spring的quartz定时任务并不能完全满足项目的需要，经常会遇到需要任务的执行时间和频率是可控的，而不是写死在 quartz配置xml上面。为此，思考了很多动态修改任务执行的方法，以下方法是通过获取scheler，对trigger的时间表达式进行修改，并重启任务去实现任务的动态变化。
[java] view plain
public class QuartzHandler {
public static final String DEFAULT_GROUP_NAME = "DEFAULT";
private static QuartzHandler instance = new QuartzHandler();
private static Logger logger = Logger.getLogger(QuartzHandler.class);
private QuartzManager quartzManager;
private Scheler scheler;
private ApplicationContext context;
private QuartzHandler() {
}
public static QuartzHandler genInstance() {
return instance;
}
/**
* 开始定时任务
*/
public void start() {
context = new (
"spring/applicationContext.xml");
scheler = (StdScheler) context.getBean("schelerFactory");
quartzManager = (QuartzManager) context.getBean("quartzManager");
}
/**
* 更新定时任务的触发表达式
*
* @param triggerName
* 触发器名字
* @param groupName
* 触发器组名字
* @param cronExpression
* 触发表达式
* @return 成功则返回true，否则返回false
*/
public boolean updateCronExpression(String triggerName, String groupName,
String cronExpression) {
try {
CronTrigger trigger = (CronTrigger) getTrigger(triggerName,
groupName);
if (trigger == null) {
return false;
}
if (StringUtils.equals(trigger.getCronExpression(), cronExpression)) {
logger.info("cronExpression is same with the running Schele , no need to update.");
return true;
}
trigger.setCronExpression(cronExpression);
scheler.rescheleJob(trigger.getName(), trigger.getGroup(),
trigger);
logger.info("Update the cronExpression successfully!!");
return true;
} catch (ParseException e) {
logger.error("The new cronExpression - " + cronExpression
+ " not conform to the standard. " + e);
return false;
} catch (SchelerException e) {
logger.error("Fail to reschele. " + e);
return false;
}
}
/**
* 获取触发器
*
* @param triggerName
* 触发器名字
* @param groupName
* 触发器组名字
* @return 对应Trigger
*/
public Trigger getTrigger(String triggerName, String groupName) {
Trigger trigger = null;
if (StringUtils.isBlank(groupName)) {
logger.warn("Schele Job Group is empty!");
return null;
}
if (StringUtils.isBlank(triggerName)) {
logger.warn("Schele trigger Name is empty!");
return null;
}
try {
trigger = scheler.getTrigger(triggerName, groupName);
} catch (SchelerException e) {
logger.warn("Fail to get the trigger (triggerName: " + triggerName
+ ", groupName : " + groupName + ")");
return null;
}
if (trigger == null) {
logger.warn("Can not found the trigger of triggerName: "
+ triggerName + ", groupName : " + groupName);
}
return trigger;
}
}
D. java定时任务 spring配置了定时器 在执行run（）时调用service 但是却得不到hiberbate的连接
= =我也遇到这个问题，而且都不抛出异常。。。。！！！！！！！！！！！！！！我发现问题了，我用try catch打印异常发现是无法获取session。我是因为aop切面出现问题，也就是事务有问题，因为我这个定时器没有定义和实现接口，然后我配置的切面是在service包里面，所以无法得到session。然后我增加了接口，放在service包里面立马没问题了。果然还是事务配置有问题。虽然隔了很久了但是我还是要回复一下！！！！！！！！我现在心情很激动！！！我果然机智！！！！话说回来，spring我还是没怎么学好啊。
E. Spring 定时器 设置30秒 运行一次方法怎么设置
//
import javax.swing.Timer;
import java.awt.*;
class A {
Timer timer;
//
public void A(){
ActionListener al=new ActionListener(){
public void actionPerformed(ActionEvent e){
hello();
}
};
timer =new Timer(30000,al);
timer.start();
}
public void hello(){
System.out.println("hello everyone");
}
}
F. spring定时器如何配置
有两种流行Spring定时器配置：Java的Timer类和OpenSymphony的Quartz。
1.Java Timer定时
首先继承java.util.TimerTask类实现run方法
import java.util.TimerTask;
public class EmailReportTask extends TimerTask{
@Override
public void run() {
...
}
}
在Spring定义
...
配置Spring定时器
<bean id="scheleReportTask" class="org.springframework.scheling.timer.ScheledTimerTask">
<property name="timerTask" ref="reportTimerTask" />
<property name="period">
<value>86400000value>
property>
bean>
timerTask属性告诉ScheledTimerTask运行哪个。86400000代表24个小时
启动Spring定时器
Spring的TimerFactoryBean负责启动定时任务
<bean class="org.springframework.scheling.timer.TimerFactoryBean">
<property name="scheledTimerTasks">
<list><ref bean="scheleReportTask"/>list>
property>
bean>
scheledTimerTasks里显示一个需要启动的定时器任务的列表。
可以通过设置delay属性延迟启动
<bean id="scheleReportTask" class="org.springframework.scheling.timer.ScheledTimerTask">
<property name="timerTask" ref="reportTimerTask" />
<property name="period">
<value>86400000value>
property>
<property name="delay">
<value>3600000value>
property>
bean>
这个任务我们只能规定每隔24小时运行一次，无法精确到某时启动
2.Quartz定时器
首先继承QuartzJobBean类实现executeInternal方法
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.scheling.quartz.QuartzJobBean;
public class EmailReportJob extends QuartzJobBean{
protected void executeInternal(JobExecutionContext arg0)
throws JobExecutionException {
...
}
}
在Spring中定义
<bean id="reportJob" class="org.springframework.scheling.quartz.JobDetailBean">
<property name="jobClass">
<value>EmailReportJobvalue>
property>
<property name="jobDataAsMap">
<map>
<entry key="courseService">
<ref bean="courseService"/>
entry>
map>
property>
bean>
在这里我们并没有直接声明一个EmailReportJob Bean，而是声明了一个JobDetailBean。这个是Quartz的特点。JobDetailBean是Quartz的org.quartz.JobDetail的子类，它要求通过jobClass属性来设置一个Job对象。
使用Quartz的JobDetail中的另一个特别之处是EmailReportJob的courseService属性是间接设置的。JobDetail的jobDataAsMap属性接受一个Map，包括设置给jobClass的各种属性，当。JobDetailBean实例化时，它会将courseService Bean注入到EmailReportJob 的courseService 属性中。
启动定时器
Quartz的org.quartz.Trigger类描述了何时及以怎样的频度运行一个Quartz工作。Spring提供了两个触发器SimpleTriggerBean和CronTriggerBean。
SimpleTriggerBean与scheledTimerTasks类似。指定工作的执行频度，模仿scheledTimerTasks配置 .
<bean id="simpleReportTrigger" class="org.springframework.scheling.quartz.SimpleTriggerBean">
<property name="jobDetail" ref="reprotJob" />
<property name="startDelay">
<value>360000value>
property>
<property name="repeatInterval">
<value>86400000value>
property>
bean>
startDelay也是延迟1个小时启动
CronTriggerBean指定工作的准确运行时间
<bean id="cronReportTrigger" class="org.springframework.scheling.quartz.CronTriggerBean">
<property name="jobDetail" ref="reprotJob" />
<property name="cronExpression">
<value>0 0 6 * * ?value>
property>
bean>
属性cronExpression告诉何时触发。最神秘就是cron表达式：
Linux系统的计划任务通常有cron来承担。一个cron表达式有至少6个（也可能7个）有空格分隔的时间元素。从左到右：
1.秒2.分3.小时4.月份中的日期（1-31）5.月份（1-12或JAN-DEC)6.星期中的日期（1-7或SUN-SAT）7.年份（1970-2099）
每个元素都显示的规定一个值（如6），一个区间（9-12），一个列表（9，11，13）或一个通配符（*）。因为4和6这两个元素是互斥的，因此应该通过设置一个问号（？）来表明不想设置的那个字段，“/”如果值组合就表示重复次数（10/6表示每10秒重复6次）。
启动定时器
<bean class="org.springframework.scheling.quartz.SchelerFactoryBean">
<property name="triggers">
<list><ref bean="cronReportTrigger"/>list>
property>
bean>
triggers属性接受一组触发器。
G. 如何配置Spring定时器准确运行时间
Spring中有自带任务调度框架Quartz ，直接在xml配置文件中配置就好。
H. java 定时器 怎么跟spring结合
java定时器的使用（ ）
1、在应用开发中，经常需要一些周期性的操作，比如每5分钟执行某一操作等。
对于这样的操作最方便、高效的实现方式就是使用java.util.Timer工具类。
private java.util.Timer timer;
timer = new Timer(true);
timer.schele(
new java.util.TimerTask() { public void run()
{ //server.checkNewMail(); 要操作的方法} }, 0, 5*60*1000);
第一个参数是要操作的方法，第二个参数是要设定延迟的时间，第三个参
数是周期的设定，每隔多长时间执行该操作。
使用这几行代码之后，Timer本身会每隔5分钟调用一遍
server.checkNewMail()方法，不需要自己启动线程。Timer本身也是多线程同
步的，多个线程可以共用一个Timer，不需要外部的同步代码。
2、
(1)Timer.schele(TimerTask task,Date time)安排在制定的时间执行指定的
任务。
(2)Timer.schele(TimerTask task,Date firstTime ,long period)安排指定
的任务在指定的时间开始进行重复的固定延迟执行．
(3)Timer.schele(TimerTask task,long delay)安排在指定延迟后执行指定的
任务．
(4)Timer.schele(TimerTask task,long delay,long period)安排指定的任务
从指定的延迟后开始进行重复的固定延迟执行．
(5)Timer.scheleAtFixedRate(TimerTask task,Date firstTime,long period)
安排指定的任务在指定的时间开始进行重复的固定速率执行．
(6)Timer.scheleAtFixedRate(TimerTask task,long delay,long period)安
排指定的任务在指定的延迟后开始进行重复的固定速率执行．
用Java Timer API 进行时间调度开发的相关注意点
java.util这个包中可以找到Timer和TimerTask这两个类。Timer直接从Object
继承，它相当于一个计时器，能够用它来指定某个时间来执行一项任务，或者
每隔一定时间间隔反复执行同一个任务。创建一个Timer后，就会生成一个线程
在背后运行，来控制任务的执行。而TimerTask就是用来实现某项任务的类，
它实现了Runnable接口，因此相当于一个线程。
Timer 的构造方法 new Timer(true)如果参数为 true 的话，这个线程就是一个守护线程，导致我在后面调用几个 timer.schele() 方法时，只有第一个被执行，后面几个都被屏蔽了，如果把这个参数设置为 false ，后面的调用才能生效。
如何实现自己的任务调度？
1、继承TimerTask，注意TimerTask是实现Runnable接口的，因此只要重载run()
方法即可。
2、创建Timer对象，调用schele()方法。
相关注意点分析：
1、任务调度要优先考虑实时保证
由于Java的天性，并且在开发JDK的过程中要考虑到不同平台，而不同平台的
线程调度机制是不同的，因此各种平台下JVM 的线程调度机制也是不一致的。
从而Timer不能保证任务在所指定的时间内执行。另外由于TimerTask是实现
Runnable接口的，在TimerTask被放进线程队列睡眠一段时间（wait）之后，
当到了指定的该唤起该TimerTask时，由于执行的确切时机取决于JVM的调度策
略和当前还有多少线程在等待CPU处理。因此就不能保证任务在所指定的时间
内执行。通常在如下两种情况下导致任务延迟执行：
（1）、有大量线程在等待执行
（2）、GC机制的影响导致延迟
这也是为什么在Timer API中存在两组调度方法的原因。即：
（1）、schele()
用固定延迟调度。使用本方法时，在任务执行中的每一个延迟会传播到后续的任
务的执行。
（2）、scheleAsFixedRate()
用固定比率调度。使用本方法时，所有后续执行根据初始执行的时间进行调度，
从而希望减小延迟。
具体使用哪一个方法取决于哪些参数对你的程序或系统更重要。
2、每个Timer对象要在后台启动一个线程。这种性质在一些托管的环境下不推
荐使用，比如在应用服务器中。因为这些线程不在容器的控制范围之内了。
具体Java API 中的Timer 类和TimerTask类的描述如下：
java.util
类Timer
java.lang.Object
java.util.Timer
public class Timer
extends Object
一种线程设施，用于安排以后在后台线程中执行的任务。可安排任务执行一次，
或者定期重复执行。
与每个Timer 对象相对应的是单个后台线程，用于顺序地执行所有计时器任务。
计时器任务应该迅速完成。如果完成某个计时器任务的时间太长，那么它会“独
占”计时器的任务执行线程。因此，这就可能延迟后续任务的执行，而这些任务
就可能“堆在一起”，并且在上述令人讨厌的任务最终完成时才能够被快速连续
地执行。
对Timer 对象最后的引用完成后，并且所有未处理的任务都已执行完成后，计
时器的任务执行线程会正常终止（并且成为垃圾回收的对象）。但是这可能要很
长时间后才发生。默认情况下，任务执行线程并不作为守护线程来运行，所以
它能够阻止应用程序终止。如果调用方想要快速终止计时器的任务执行线程，那
么调用方应该调用计时器的cancel 方法。
如果意外终止了计时器的任务执行线程，例如调用了它的stop 方法，那么所有
以后对该计时器安排任务的尝试都将导致IllegalStateException，就好像调用
了计时器的cancel 方法一样。
此类是线程安全的：多个线程可以共享单个Timer 对象而无需进行外部同步。
此类不提供实时保证：它使用Object.wait(long) 方法来安排任务。
实现注意事项：此类可扩展到大量同时安排的任务（存在数千个都没有问题）。
在内部，它使用二进制堆来表示其任务队列，所以安排任务的开销是O(log n)，
其中n 是同时安排的任务数。
实现注意事项：所有构造方法都启动计时器线程。
从以下版本开始：
1.3
另请参见：
TimerTask, Object.wait(long)
构造方法摘要
Timer()
创建一个新计时器。
Timer(boolean isDaemon)
创建一个新计时器，可以指定其相关的线程作为守护程序运行。
Timer(String name)
创建一个新计时器，其相关的线程具有指定的名称。
Timer(String name, boolean isDaemon)
创建一个新计时器，其相关的线程具有指定的名称，并且可以指定作为守护程序运
行。
方法摘要
void cancel()
终止此计时器，丢弃所有当前已安排的任务。
int purge()
从此计时器的任务队列中移除所有已取消的任务。
void schele(TimerTask task, Date time)
安排在指定的时间执行指定的任务。
void schele(TimerTask task, Date firstTime, long period)
安排指定的任务在指定的时间开始进行重复的固定延迟执行。
void schele(TimerTask task, long delay)
安排在指定延迟后执行指定的任务。
void schele(TimerTask task, long delay, long period)
安排指定的任务从指定的延迟后开始进行重复的固定延迟执行。
void scheleAtFixedRate(TimerTask task, Date firstTime, long period)
安排指定的任务在指定的时间开始进行重复的固定速率执行。
void scheleAtFixedRate(TimerTask task, long delay, long period)
安排指定的任务在指定的延迟后开始进行重复的固定速率执行。
从类java.lang.Object 继承的方法
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
构造方法详细信息
Timer
public Timer()
创建一个新计时器。相关的线程不作为守护程序运行。
另请参见：
Thread, cancel()
Timer
public Timer(boolean isDaemon)
创建一个新计时器，可以指定其相关的线程作为守护程序运行。如果计时器将用于
安排重复的“维护活动”，则调用守护线程，在应用程序运行期间必须调用守护线程，
但是该操作不应延长程序的生命周期。
参数：
isDaemon - 如果应该将相关的线程作为守护程序运行，则为true。
另请参见：
Thread, cancel()
Timer
public Timer(String name)
创建一个新计时器，其相关的线程具有指定的名称。相关的线程不作为守护程序运
行。
参数：
name - 相关线程的名称。
抛出：
NullPointerException - 如果name 为null。
从以下版本开始：
1.5
另请参见：
Thread.getName(), Thread.isDaemon()
Timer
public Timer(String name,
boolean isDaemon)
创建一个新计时器，其相关的线程具有指定的名称，并且可以指定作为守护程序运
行。
参数：
name - 相关线程的名称。
isDaemon - 如果应该将相关的线程作为守护程序运行，则为true。
抛出：
NullPointerException - 如果name 为null。