`
m635674608
  • 浏览: 5029162 次
  • 性别: Icon_minigender_1
  • 来自: 南京
社区版块
存档分类
最新评论

Spring定时任务的实现

 
阅读更多

一．分类

  • 从实现的技术上来分类，目前主要有三种技术（或者说有三种产品）：

  1. Java自带的java.util.Timer类，这个类允许你调度一个java.util.TimerTask任务。使用这种方式可以让你的程序按照某一个频度执行，但不能在指定时间运行。一般用的较少，这篇文章将不做详细介绍。
  2. 使用Quartz，这是一个功能比较强大的的调度器，可以让你的程序在指定时间执行，也可以按照某一个频度执行，配置起来稍显复杂，稍后会详细介绍。
  3. Spring3.0以后自带的task，可以将它看成一个轻量级的Quartz，而且使用起来比Quartz简单许多，稍后会介绍。

  • 从作业类的继承方式来讲，可以分为两类：

  1. 作业类需要继承自特定的作业类基类，如Quartz中需要继承自org.springframework.scheduling.quartz.QuartzJobBean；java.util.Timer中需要继承自java.util.TimerTask。
  2. 作业类即普通的java类，不需要继承自任何基类。

注:个人推荐使用第二种方式，因为这样所以的类都是普通类，不需要事先区别对待。

 

  • 从任务调度的触发时机来分，这里主要是针对作业使用的触发器，主要有以下两种：
  1. 每隔指定时间则触发一次，在Quartz中对应的触发器为：org.springframework.scheduling.quartz.SimpleTriggerBean
  2. 每到指定时间则触发一次，在Quartz中对应的调度器为：org.springframework.scheduling.quartz.CronTriggerBean

注：并非每种任务都可以使用这两种触发器，如java.util.TimerTask任务就只能使用第一种。Quartz和spring task都可以支持这两种触发条件。

 

 

二．用法说明

详细介绍每种任务调度工具的使用方式，包括Quartz和spring task两种。

Quartz

第一种，作业类继承自特定的基类：org.springframework.scheduling.quartz.QuartzJobBean。

第一步：定义作业类

 

Java代码 复制代码 收藏代码
  1. import org.quartz.JobExecutionContext;
  2. import org.quartz.JobExecutionException;
  3. import org.springframework.scheduling.quartz.QuartzJobBean;
  4. publicclass Job1 extends QuartzJobBean {
  6. privateint timeout;
  7. privatestaticint i = 0;
  8. //调度工厂实例化后，经过timeout时间开始执行调度
  9. publicvoid setTimeout(int timeout) {
  10. this.timeout = timeout;
  11. }
  13. /**
  14. * 要调度的具体任务
  15. */
  16. @Override
  17. protectedvoid executeInternal(JobExecutionContext context)
  18. throws JobExecutionException {
  19. System.out.println("定时任务执行中…");
  20. }
  21. } 
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.scheduling.quartz.QuartzJobBean;
public class Job1 extends QuartzJobBean {

private int timeout;
private static int i = 0;
//调度工厂实例化后，经过timeout时间开始执行调度
public void setTimeout(int timeout) {
this.timeout = timeout;
}

/**
* 要调度的具体任务
*/
@Override
protected void executeInternal(JobExecutionContext context)
throws JobExecutionException {
  System.out.println("定时任务执行中…");
}
}

第二步：spring配置文件中配置作业类JobDetailBean

Xml代码 复制代码 收藏代码
  1. <beanname="job1"class="org.springframework.scheduling.quartz.JobDetailBean">
  2. <propertyname="jobClass"value="com.gy.Job1"/>
  3. <propertyname="jobDataAsMap">
  4. <map>
  5. <entrykey="timeout"value="0"/>
  6. </map>
  7. </property>
  8. </bean>
<bean name="job1" class="org.springframework.scheduling.quartz.JobDetailBean">
<property name="jobClass" value="com.gy.Job1" />
<property name="jobDataAsMap">
<map>
<entry key="timeout" value="0" />
</map>
</property>
</bean>

说明：org.springframework.scheduling.quartz.JobDetailBean有两个属性，jobClass属性即我们在java代码中定义的任务类，jobDataAsMap属性即该任务类中需要注入的属性值。

第三步：配置作业调度的触发方式（触发器）

Quartz的作业触发器有两种，分别是

org.springframework.scheduling.quartz.SimpleTriggerBean

org.springframework.scheduling.quartz.CronTriggerBean

第一种SimpleTriggerBean，只支持按照一定频度调用任务，如每隔30分钟运行一次。

配置方式如下：

 

Xml代码 复制代码 收藏代码
  1. <beanid="simpleTrigger"class="org.springframework.scheduling.quartz.SimpleTriggerBean">
  2. <propertyname="jobDetail"ref="job1"/>
  3. <propertyname="startDelay"value="0"/><!-- 调度工厂实例化后，经过0秒开始执行调度 -->
  4. <propertyname="repeatInterval"value="2000"/><!-- 每2秒调度一次 -->
  5. </bean>
<bean id="simpleTrigger" class="org.springframework.scheduling.quartz.SimpleTriggerBean">
<property name="jobDetail" ref="job1" />
<property name="startDelay" value="0" /><!-- 调度工厂实例化后，经过0秒开始执行调度 -->
<property name="repeatInterval" value="2000" /><!-- 每2秒调度一次 -->
</bean>

第二种CronTriggerBean，支持到指定时间运行一次，如每天12:00运行一次等。

配置方式如下：

Xml代码 复制代码 收藏代码
  1. <beanid="cronTrigger"class="org.springframework.scheduling.quartz.CronTriggerBean">
  2. <propertyname="jobDetail"ref="job1"/>
  3. <!—每天12:00运行一次 -->
  4. <propertyname="cronExpression"value="0 0 12 * * ?"/>
  5. </bean>
<bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean">
<property name="jobDetail" ref="job1" />
<!—每天12:00运行一次 -->
<property name="cronExpression" value="0 0 12 * * ?" />
</bean>

关于cronExpression表达式的语法参见附录。

第四步：配置调度工厂

Xml代码 复制代码 收藏代码
  1. <beanclass="org.springframework.scheduling.quartz.SchedulerFactoryBean">
  2. <propertyname="triggers">
  3. <list>
  4. <refbean="cronTrigger"/>
  5. </list>
  6. </property>
  7. </bean>
<bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
<property name="triggers">
<list>
<ref bean="cronTrigger" />
</list>
</property>
</bean>

说明：该参数指定的就是之前配置的触发器的名字。

第五步：启动你的应用即可，即将工程部署至tomcat或其他容器。

 

 

第二种，作业类不继承特定基类。

Spring能够支持这种方式，归功于两个类：

org.springframework.scheduling.timer.MethodInvokingTimerTaskFactoryBean

org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean

这两个类分别对应spring支持的两种实现任务调度的方式，即前文提到到java自带的timer task方式和Quartz方式。这里我只写MethodInvokingJobDetailFactoryBean的用法，使用该类的好处是,我们的任务类不再需要继承自任何类，而是普通的pojo。

第一步：编写任务类

Java代码 复制代码 收藏代码
  1. publicclass Job2 {
  2. publicvoid doJob2() {
  3. System.out.println("不继承QuartzJobBean方式-调度进行中...");
  4. }
  5. } 
public class Job2 {
public void doJob2() {
System.out.println("不继承QuartzJobBean方式-调度进行中...");
}
}

可以看出，这就是一个普通的类，并且有一个方法。

第二步：配置作业类

Xml代码 复制代码 收藏代码
  1. <beanid="job2"
  2. class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
  3. <propertyname="targetObject">
  4. <beanclass="com.gy.Job2"/>
  5. </property>
  6. <propertyname="targetMethod"value="doJob2"/>
  7. <propertyname="concurrent"value="false"/><!-- 作业不并发调度 -->
  8. </bean>
<bean id="job2"
class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
<property name="targetObject">
<bean class="com.gy.Job2" />
</property>
<property name="targetMethod" value="doJob2" />
<property name="concurrent" value="false" /><!-- 作业不并发调度 -->
</bean>

说明：这一步是关键步骤，声明一个MethodInvokingJobDetailFactoryBean，有两个关键属性：targetObject指定任务类，targetMethod指定运行的方法。往下的步骤就与方法一相同了，为了完整，同样贴出。

第三步：配置作业调度的触发方式（触发器）

Quartz的作业触发器有两种，分别是

org.springframework.scheduling.quartz.SimpleTriggerBean

org.springframework.scheduling.quartz.CronTriggerBean

第一种SimpleTriggerBean，只支持按照一定频度调用任务，如每隔30分钟运行一次。

配置方式如下：

Xml代码 复制代码 收藏代码
  1. <beanid="simpleTrigger"class="org.springframework.scheduling.quartz.SimpleTriggerBean">
  2. <propertyname="jobDetail"ref="job2"/>
  3. <propertyname="startDelay"value="0"/><!-- 调度工厂实例化后，经过0秒开始执行调度 -->
  4. <propertyname="repeatInterval"value="2000"/><!-- 每2秒调度一次 -->
  5. </bean>
<bean id="simpleTrigger" class="org.springframework.scheduling.quartz.SimpleTriggerBean">
<property name="jobDetail" ref="job2" />
<property name="startDelay" value="0" /><!-- 调度工厂实例化后，经过0秒开始执行调度 -->
<property name="repeatInterval" value="2000" /><!-- 每2秒调度一次 -->
</bean>

第二种CronTriggerBean，支持到指定时间运行一次，如每天12:00运行一次等。

配置方式如下：

Xml代码 复制代码 收藏代码
  1. <beanid="cronTrigger"class="org.springframework.scheduling.quartz.CronTriggerBean">
  2. <propertyname="jobDetail"ref="job2"/>
  3. <!—每天12:00运行一次 -->
  4. <propertyname="cronExpression"value="0 0 12 * * ?"/>
  5. </bean>
<bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean">
<property name="jobDetail" ref="job2" />
<!—每天12:00运行一次 -->
<property name="cronExpression" value="0 0 12 * * ?" />
</bean>

以上两种调度方式根据实际情况，任选一种即可。

第四步：配置调度工厂

Xml代码 复制代码 收藏代码
  1. <beanclass="org.springframework.scheduling.quartz.SchedulerFactoryBean">
  2. <propertyname="triggers">
  3. <list>
  4. <refbean="cronTrigger"/>
  5. </list>
  6. </property>
  7. </bean>
<bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
<property name="triggers">
<list>
<ref bean="cronTrigger" />
</list>
</property>
</bean>

说明：该参数指定的就是之前配置的触发器的名字。

第五步：启动你的应用即可，即将工程部署至tomcat或其他容器。

 

到此，spring中Quartz的基本配置就介绍完了，当然了，使用之前，要导入相应的spring的包与Quartz的包，这些就不消多说了。

其实可以看出Quartz的配置看上去还是挺复杂的，没有办法，因为Quartz其实是个重量级的工具，如果我们只是想简单的执行几个简单的定时任务，有没有更简单的工具，有！

请看我第下文Spring task的介绍。

 

Spring-Task

上节介绍了在Spring 中使用Quartz，本文介绍Spring3.0以后自主开发的定时任务工具，spring task，可以将它比作一个轻量级的Quartz，而且使用起来很简单，除spring相关的包外不需要额外的包，而且支持注解和配置文件两种

形式，下面将分别介绍这两种方式。

第一种：配置文件方式

第一步：编写作业类

即普通的pojo，如下：

Java代码 复制代码 收藏代码
  1. import org.springframework.stereotype.Service;
  2. @Service
  3. publicclass TaskJob {
  5. publicvoid job1() {
  6. System.out.println(“任务进行中。。。”);
  7. }
  8. } 
import org.springframework.stereotype.Service;
@Service
public class TaskJob {
    
    public void job1() {
        System.out.println(“任务进行中。。。”);
    }
}

第二步：在spring配置文件头中添加命名空间及描述

Xml代码 复制代码 收藏代码
  1. <beansxmlns="http://www.springframework.org/schema/beans"
  2. xmlns:task="http://www.springframework.org/schema/task"
  3. 。。。。。。
  4. xsi:schemaLocation="http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-3.0.xsd">
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:task="http://www.springframework.org/schema/task" 
    。。。。。。
    xsi:schemaLocation="http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-3.0.xsd">

第三步：spring配置文件中设置具体的任务

Xml代码 复制代码 收藏代码
  1. <task:scheduled-tasks>
  2. <task:scheduledref="taskJob"method="job1"cron="0 * * * * ?"/>
  3. </task:scheduled-tasks>
  5. <context:component-scanbase-package=" com.gy.mytask "/>
 <task:scheduled-tasks> 
        <task:scheduled ref="taskJob" method="job1" cron="0 * * * * ?"/> 
</task:scheduled-tasks>

<context:component-scan base-package=" com.gy.mytask " />

说明：ref参数指定的即任务类，method指定的即需要运行的方法，cron及cronExpression表达式，具体写法这里不介绍了，详情见上篇文章附录。

<context:component-scan base-package="com.gy.mytask" />这个配置不消多说了，spring扫描注解用的。

到这里配置就完成了，是不是很简单。

第二种：使用注解形式

也许我们不想每写一个任务类还要在xml文件中配置下，我们可以使用注解@Scheduled，我们看看源文件中该注解的定义：

Java代码 复制代码 收藏代码
  1. @Target({java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.ANNOTATION_TYPE})
  2. @Retention(RetentionPolicy.RUNTIME)
  3. @Documented
  4. public@interface Scheduled
  5. {
  6. publicabstract String cron();
  8. publicabstractlong fixedDelay();
  10. publicabstractlong fixedRate();
  11. } 
@Target({java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Scheduled
{
  public abstract String cron();

  public abstract long fixedDelay();

  public abstract long fixedRate();
}

可以看出该注解有三个方法或者叫参数，分别表示的意思是：

cron：指定cron表达式

fixedDelay：官方文档解释：An interval-based trigger where the interval is measured from the completion time of the previous task. The time unit value is measured in milliseconds.即表示从上一个任务完成开始到下一个任务开始的间隔，单位是毫秒。

fixedRate：官方文档解释：An interval-based trigger where the interval is measured from the start time of the previous task. The time unit value is measured in milliseconds.即从上一个任务开始到下一个任务开始的间隔，单位是毫秒。

 

下面我来配置一下。

第一步：编写pojo

Java代码 复制代码 收藏代码
  1. import org.springframework.scheduling.annotation.Scheduled;
  2. import org.springframework.stereotype.Component;
  4. @Component(“taskJob”)
  5. publicclass TaskJob {
  6. @Scheduled(cron = "0 0 3 * * ?")
  7. publicvoid job1() {
  8. System.out.println(“任务进行中。。。”);
  9. }
  10. } 
import org.springframework.scheduling.annotation.Scheduled;  
import org.springframework.stereotype.Component;

@Component(“taskJob”)
public class TaskJob {
    @Scheduled(cron = "0 0 3 * * ?")
    public void job1() {
        System.out.println(“任务进行中。。。”);
    }
}

第二步：添加task相关的配置：

Xml代码 复制代码 收藏代码
  1. <?xmlversion="1.0"encoding="UTF-8"?>
  2. <beansxmlns="http://www.springframework.org/schema/beans"
  3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:aop="http://www.springframework.org/schema/aop"
  4. xmlns:context="http://www.springframework.org/schema/context"
  5. xmlns:tx="http://www.springframework.org/schema/tx"
  6. xmlns:task="http://www.springframework.org/schema/task"
  7. xsi:schemaLocation="
  8. http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
  9. http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
  10. http://www.springframework.org/schema/context
  11. http://www.springframework.org/schema/jdbc/spring-jdbc-3.0.xsd
  12. http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
  13. http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-3.0.xsd"
  14. default-lazy-init="false">
  17. <context:annotation-config/>
  18. <!—spring扫描注解的配置 -->
  19. <context:component-scanbase-package="com.gy.mytask"/>
  21. <!—开启这个配置，spring才能识别@Scheduled注解 -->
  22. <task:annotation-drivenscheduler="qbScheduler"mode="proxy"/>
  23. <task:schedulerid="qbScheduler"pool-size="10"/>
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:task="http://www.springframework.org/schema/task"
	xsi:schemaLocation="
		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
		http://www.springframework.org/schema/context 
http://www.springframework.org/schema/jdbc/spring-jdbc-3.0.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
		http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-3.0.xsd"
	default-lazy-init="false">


	<context:annotation-config />
	<!—spring扫描注解的配置   -->
	<context:component-scan base-package="com.gy.mytask" />
	
<!—开启这个配置，spring才能识别@Scheduled注解   -->
	<task:annotation-driven scheduler="qbScheduler" mode="proxy"/>
	<task:scheduler id="qbScheduler" pool-size="10"/>

说明：理论上只需要加上<task:annotation-driven />这句配置就可以了，这些参数都不是必须的。

 

Ok配置完毕，当然spring task还有很多参数，我就不一一解释了，具体参考xsd文档http://www.springframework.org/schema/task/spring-task-3.0.xsd。

附录：

cronExpression的配置说明，具体使用以及参数请百度google

字段 允许值 允许的特殊字符

秒 0-59 , - * /

分 0-59 , - * /

小时 0-23 , - * /

日期 1-31 , - * ? / L W C

月份 1-12 或者 JAN-DEC , - * /

星期 1-7 或者 SUN-SAT , - * ? / L C #

年（可选） 留空, 1970-2099 , - * /

- 区间

* 通配符

? 你不想设置那个字段

下面只例出几个式子

 

CRON表达式 含义

"0 0 12 * * ?" 每天中午十二点触发

"0 15 10 ? * *" 每天早上10：15触发

"0 15 10 * * ?" 每天早上10：15触发

"0 15 10 * * ? *" 每天早上10：15触发

"0 15 10 * * ? 2005" 2005年的每天早上10：15触发

"0 * 14 * * ?" 每天从下午2点开始到2点59分每分钟一次触发

"0 0/5 14 * * ?" 每天从下午2点开始到2：55分结束每5分钟一次触发

"0 0/5 14,18 * * ?" 每天的下午2点至2：55和6点至6点55分两个时间段内每5分钟一次触发

"0 0-5 14 * * ?" 每天14:00至14:05每分钟一次触发

"0 10,44 14 ? 3 WED" 三月的每周三的14：10和14：44触发

"0 15 10 ? * MON-FRI" 每个周一、周二、周三、周四、周五的10：15触发

 

转载 http://gong1208.iteye.com/blog/1773177

 

分享到：
| weblogic集群集群说明
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    spring定时任务实现

    Spring框架提供了多种方式来实现定时任务，这使得开发者可以在不同场景下选择最适合的方案。本文主要探讨了Spring中实现定时任务的三种主要方法：Java的`java.util.Timer`、Quartz库以及Spring自身的Task调度器。 ...

    Spring定时任务实现（非Web项目）

    在非Web项目中实现Spring定时任务，主要步骤如下： 1. **配置Spring Task**：在Spring的配置文件（如`applicationContext.xml`或使用Java配置类）中，我们需要启用任务调度功能并配置相应的执行器或调度器。例如，...

    Spring定时任务管理

    Spring定时任务的几种实现，欢迎交流！

    spring定时任务关键jar包（齐全）

    本文将详细探讨Spring定时任务的关键知识点，并与提供的jar包列表关联。 首先，Spring定时任务主要依赖于`spring-context-support`模块，这个模块包含了处理定时任务所需的类和接口。在压缩包`lib`中，应该包含了这...

    Spring定时任务实现与配置（一）

    Spring定时任务实现与配置（一） 本文主要介绍了Spring定时任务的实现与配置，涵盖了基本概念、依赖管理、配置文件设置、Quartz配置、Job配置等方面的知识点。 Spring定时任务的基本概念 在Spring中，定时任务是...

    Spring 定时任务源码（spring 三种定时任务的实现方式）

    通过阅读和理解这些源码，你可以更好地了解Spring如何管理和调度定时任务，以及如何根据项目需求选择合适的定时任务实现方式。在chapter13目录下的文件可能包含了这些源码示例，你可以逐一研究，加深对Spring定时...

    Spring提供的三种定时任务机制及其比较

    在Spring框架中，有三种主要的定时任务机制可供开发者选择，分别是基于Quartz的定时机制、Spring自己的`@Scheduled`注解以及...在实际开发中，可以根据项目规模、性能需求和团队熟悉度来决定最适合的定时任务实现方式。

    spring定时任务必须要的10个jar包.zip

    以上每个jar包都是Spring定时任务实现中的关键组件，确保它们在类路径中正确配置，能帮助开发者轻松地创建、管理和调度任务。在实际项目中，除了这些核心库，还可能需要根据具体需求添加其他依赖，如数据库驱动、...

    spring定时任务依赖的jar包

    2. **依赖的jar包**：实现Spring定时任务，通常需要以下10个关键的jar包： - `spring-context`: 包含了Spring的核心功能，如依赖注入(DI)，AOP，事件处理等，是实现定时任务的基础。 - `spring-context-support`: ...

    Spring定时任务的简单例子

    Spring定时任务支持更多的功能，比如任务执行的并发控制、任务执行的监听器、以及使用Quartz等第三方调度库进行更复杂的任务调度。 总结，Spring定时任务为开发者提供了方便的API和注解，使我们可以轻松地在Java...

    Spring定时任务

    Spring定时任务基于`@Scheduled`注解和`TaskScheduler`接口实现。`@Scheduled`用于标注需要定时执行的方法，而`TaskScheduler`则提供了更灵活的定时任务调度方式。 2. **启用定时任务** 要使用Spring定时任务，...

    Spring定时任务（Web项目）

    一、Spring定时任务简介 Spring框架的定时任务功能主要依赖于`Spring Task`模块，也称为Spring的后台任务处理。它提供了基于`@Scheduled`注解和`TaskScheduler`接口的两种定时任务实现方式。`@Scheduled`适用于简单...

    Spring定时任务实现与配置（二）

    Spring定时任务实现与配置（二） 在本文中，我们将详细介绍Spring定时任务的实现与配置的第二篇，主要讨论如何在Spring项目中实现简单的定时任务。 首先，我们需要在Maven项目的pom文件中添加两个依赖项：spring-...

    spring之定时任务实现（spring-task和quartz等不同方式）

    Spring框架提供了一系列工具来支持定时任务的实现，其中包括Spring自带的`spring-task`模块和第三方的Quartz库。下面我们将详细探讨这两种方式以及如何通过注解和非注解的方式进行配置。 首先，`spring-task`是...

    Spring 的定时任务

    #### 二、Spring定时任务实现方式 Spring支持多种定时任务实现方式，包括但不限于： 1. **基于Spring的`@Scheduled`注解** 2. **基于Quartz** 3. **基于Java定时器（Timer）** 本文主要介绍的是基于Quartz的定时...

    Spring中定时任务

    结合Eclipse和Maven，创建Spring定时任务项目时，你需要： 1. 创建一个新的Maven项目，并添加Spring的相关依赖，如`spring-context`, `spring-context-support`(对于Spring Task)，以及`quartz`和`spring-quartz`...

    spring定时任务

    总结来说，选择Spring定时任务实现方式时，可以考虑以下几点： 1. 如果任务需求简单，且不需复杂的调度逻辑，可以优先考虑Spring Task，因为它更加轻便，易于集成。 2. 当任务需要复杂的调度策略，或者需要跨应用...

    spring定时任务所需jar

    下面我们将深入探讨Spring定时任务所需的相关jar包以及它们的功能。 首先，Spring框架的核心jar包`spring-context.jar`是必不可少的。这个jar包包含了Spring的核心功能，如依赖注入（Dependency Injection，DI）、...

    spring xml 定时任务

    在Spring框架中，XML配置是传统且广泛使用的方式来设置应用的组件和行为，包括实现定时任务。定时任务在软件开发中扮演着重要角色，它允许应用程序在预设的时间执行特定的任务，例如数据清理、日志归档或者发送通知...

    spring定时任务实例

    在Spring框架中，定时任务是一项重要的功能，它允许开发者在特定的时间间隔内执行特定的任务，无需手动触发。这个实例是关于如何在Spring中配置和使用定时任务，同时结合MyBatis来向数据库插入数据。接下来，我们将...

Magicbox
Global site tag (gtag.js) - Google Analytics