spring+quartz定时任务入门使用篇-简单的不能再简单了。

最新推荐文章于 2025-04-09 09:48:07 发布
最新推荐文章于 2025-04-09 09:48:07 发布
阅读量551 收藏
点赞数
分类专栏： java quartz 文章标签： java spring quartz
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/siqiangming/article/details/105734814
版权

之前使用定时任务都是使用jar包。电脑的定时任务。本次使用java的定时任务。在spring-task和quartz之间选用了quartz，至于Timer之流的不是主流。

首先是选用原因。

quartz：

  1.     默认多线程异步执行。
  2.     能被集群实例化，支持分布式部署。
  3.     使用JobStoreCMT（JDBCJobStore的子类），Quartz 能参与JTA事务；Quartz 能管理JTA事务(开始和提交)在执行任务之间，这样，任务做的事就可以发生在JTA事务里。
  4.     多个任务时，任务之间没有直接影响，多任务执行的快慢取决于CPU的性能。
  5.     需要手动在xml中设置jobs（先配置job，之后为job设置特定trigger，最后将trigger在调度器中注册即可）。
  6.     需要引入quartz的jar包。
  7.     对异常的处理：Quartz的某次执行任务过程中抛出异常，不影响下一次任务的执行，当下一次执行时间到来时，定时器会再次执行任务。
  8.     任务类的对象：Quartz每次执行都创建一个新的任务类对象。

task

  1.     默认单线程同步执行。
  2.     支持注解（个人建议：不要把表达式通过注解的方式实现：不利于维护）。
  3.     多个任务时，一个任务执行完毕以后才能执行下一个任务（如果当前任务执行时间过长，那么下一个任务可能无法及时运行，即会有阻塞现象发生），如果希望并发运行，需要配置线程池。
  4.     对异常的处理：SpringTask不同，一旦某个任务在执行过程中抛出异常，则整个定时器生命周期就结束，以后永远不会再执行定时器任务。
  5.     任务类的对象：SpringTask则每次使用同一个任务类对象。

这东西网上一大推，我也是借用，整理的。主要因为标红的地方。所以选取了quartz。

下面进入正题

首先是maven依赖。如果不使用maven自己下载对应的jar包。

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>org.neris</groupId>
	<artifactId>CDExchange</artifactId>
	<packaging>war</packaging>
	<version>0.0.1-SNAPSHOT</version>
	<name>CDExchange Maven Webapp</name>
	<url>http://maven.apache.org</url>
	<properties>
		<!-- jar包版本配置 -->
		<spring.version>4.1.9.RELEASE</spring.version>
		<jstl.version>1.2</jstl.version>
		<servlet-api.version>2.5</servlet-api.version>
		<jsp-api.version>2.1</jsp-api.version>
		<mybatis.version>3.2.8</mybatis.version>
		<mybatis-spring.version>1.2.3</mybatis-spring.version>
		<druid.version>1.0.18</druid.version>
		<mysql.driver.version>5.1.30</mysql.driver.version>
		<fastjson.version>1.1.40</fastjson.version>
		<!-- 日志工具 -->
		<!-- 1.slf4j -->
		<slf4j.version>1.7.7</slf4j.version>
		<!-- 2.log4j -->
		<log4j.version>2.1</log4j.version>
		<httpclient.version>4.5.3</httpclient.version>
		<httpcore.version>4.4.6</httpcore.version>
		<quartz.version>2.2.2</quartz.version>
	</properties>

	<dependencies>
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>3.8.1</version>
			<scope>test</scope>
		</dependency>

		<!-- SPRING begin -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<version>${spring.version}</version>
			<exclusions>
				<exclusion>
					<groupId>commons-logging</groupId>
					<artifactId>commons-logging</artifactId>
				</exclusion>
			</exclusions>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-beans</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context-support</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-aop</artifactId>
			<version>${spring.version}</version>
			<exclusions>
				<exclusion>
					<groupId>commons-logging</groupId>
					<artifactId>commons-logging</artifactId>
				</exclusion>
			</exclusions>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-tx</artifactId>
			<version>${spring.version}</version>
		</dependency>

		<!-- spring orm -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-orm</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-jdbc</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<!-- SPRING end -->

		<!-- WEB begin -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-web</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-webmvc</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-oxm</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>jstl</artifactId>
			<version>${jstl.version}</version>
			<type>jar</type>
		</dependency>
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>servlet-api</artifactId>
			<version>${servlet-api.version}</version>
			<scope>provided</scope>
		</dependency>
		<dependency>
			<groupId>javax.servlet.jsp</groupId>
			<artifactId>jsp-api</artifactId>
			<version>${jsp-api.version}</version>
			<scope>provided</scope>
		</dependency>
		<!-- WEB end -->

		<!-- 日志工具引入 start 根据中央监管信息平台日志技术规范v1.0要求 -->
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-api</artifactId>
			<version>${slf4j.version}</version>
		</dependency>
		<dependency>
			<groupId>org.apache.logging.log4j</groupId>
			<artifactId>log4j-slf4j-impl</artifactId>
			<version>${log4j.version}</version>
		</dependency>
		<dependency>
			<groupId>org.apache.logging.log4j</groupId>
			<artifactId>log4j-core</artifactId>
			<version>${log4j.version}</version>
		</dependency>
		<dependency>
			<groupId>org.apache.logging.log4j</groupId>
			<artifactId>log4j-web</artifactId>
			<version>${log4j.version}</version>
		</dependency>
		<!-- 日志工具引入 end 根据中央监管信息平台日志技术规范v1.0要求 -->

		<!-- MyBatis -->
		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis</artifactId>
			<version>${mybatis.version}</version>
		</dependency>
		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis-spring</artifactId>
			<version>${mybatis-spring.version}</version>
		</dependency>

		<!-- connection pool -->
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>druid</artifactId>
			<version>${druid.version}</version>
		</dependency>

		<!-- jdbc driver -->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>${mysql.driver.version}</version>
			<scope>runtime</scope>
		</dependency>

		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>fastjson</artifactId>
			<version>${fastjson.version}</version>
		</dependency>

		<!-- httpclient start -->
		<dependency>
			<groupId>org.apache.httpcomponents</groupId>
			<artifactId>httpclient</artifactId>
			<version>${httpclient.version}</version>
		</dependency>
		<dependency>
			<groupId>org.apache.httpcomponents</groupId>
			<artifactId>httpcore</artifactId>
			<version>${httpcore.version}</version>
		</dependency>
		<!-- httpclient end -->
		
		<!-- quartz -->
		<dependency>  
	            <groupId>org.quartz-scheduler</groupId>  
	            <artifactId>quartz</artifactId>  
	        <version>${quartz.version}</version>  
	    </dependency> 
	</dependencies>
	<build>
		<finalName>CDExchange</finalName>
	</build>
</project>

不知道为什么放在这里，格式不太正常。我也懒得整理了。贴了这么多其实，就最后一个依赖，当然和spring整合。肯定有spring支持quartz的jar。这些都不是重点。

配置文件

<?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:context="http://www.springframework.org/schema/context"   
	xmlns:tx="http://www.springframework.org/schema/tx" xmlns:mvc="http://www.springframework.org/schema/mvc"
    xsi:schemaLocation="
		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.1.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.1.xsd
		http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.1.xsd"
	default-lazy-init="true">
	
	<description>Quartz Configuration</description>
	
	<context:property-placeholder location="classpath:quartz.properties"/>
	<!-- 任务 -->
    <bean id="exchangeJob" class="org.neris.CDExchange.quartz.job.FyCaseExchangeJob"/>
    
    <!-- 任务详情工厂 -->
    <bean id="exchangeJobDetail" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
    	<!-- 调用任务对象 -->
    	<property name="targetObject" ref="exchangeJob"/>
    	<!-- 调用任务对象中的方法 -->
    	<property name="targetMethod" value="execute"/>
    </bean>
    
    <!-- 触发器 -->
    <bean id="exchangeTrigger" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
    	<property name="jobDetail" ref="exchangeJobDetail"/>
    	<!-- 任务计划 -->
    	<property name="cronExpression" value="${exchange_cronExpression}"/>
    </bean>
    
    <!-- 调度工厂 -->
    <bean id="scheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
    	<property name="triggers">
    		<list>
    			<ref bean="exchangeTrigger"/>
    		</list>
    	</property>
    </bean>
</beans>

其中基本上都加上注释了，方便以后查看。

首先说明其中的任务类，很简单就是说，你的定时任务做什么。我这里就是一个输出而已。

package org.neris.CDExchange.quartz.job;

import java.util.Date;
import java.util.List;

import javax.annotation.Resource;

import org.neris.CDExchange.entity.po.FyCase;
import org.neris.CDExchange.service.FyCaseService;

/**
 * 复议案件任务
 * @author SiQiangMing 2020年4月24日 上午10:38:21
 */
public class FyCaseExchangeJob {
	
	@Resource
	private FyCaseService fyCaseService;
	
	public void execute(){
		List<FyCase> list = fyCaseService.list("0");
		for (FyCase fyCase : list) {
			System.out.println(new Date() + "task: " + fyCase.getCaseId());
		}
	}
}

接着是用任务详情工厂管理你使用哪个定时任务的的对象。以及对象中的那个方法。

  <!-- 任务详情工厂 -->
    <bean id="exchangeJobDetail" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
        <!-- 调用任务对象 -->
        <property name="targetObject" ref="exchangeJob"/>
        <!-- 调用任务对象中的方法 -->
        <property name="targetMethod" value="execute"/>
    </bean>

之后再定义一个触发器。意思就是什么时候触发定时任务，当然最基本的功能是指定Job的执行时间，执行间隔，运行次数等。

<!-- 触发器 -->
    <bean id="exchangeTrigger" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
        <property name="jobDetail" ref="exchangeJobDetail"/>
        <!-- 任务计划 -->
        <property name="cronExpression" value="${exchange_cronExpression}"/>
    </bean>

再后面是调度工厂，其中可以调度多个触发器

<!-- 调度工厂 -->
    <bean id="scheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
        <property name="triggers">
            <list>
                <ref bean="exchangeTrigger"/>
            </list>
        </property>
    </bean>

个人理解调度的作用就是将触发器启用。

这样，一个定时任务就配置完成。当然不要忘记加载这个定时任务配置文件spring-quartz.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
	version="2.5">

	<display-name>Archetype Created Web Application</display-name>

	<listener>
        <listener-class>org.springframework.web.context.request.RequestContextListener</listener-class>  
	</listener>
	<filter>
		<filter-name>encodingFilter</filter-name>
		<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
		<init-param>
			<param-name>encoding</param-name>
			<param-value>UTF-8</param-value>
		</init-param>
		<init-param>
			<param-name>forceEncoding</param-name>
			<param-value>true</param-value>
		</init-param>
	</filter>
	<filter-mapping>
		<filter-name>encodingFilter</filter-name>
		<url-pattern>/*</url-pattern>
	</filter-mapping>
  	
  	<!-- MVC Servlet -->
	<servlet>
		<servlet-name>springServlet</servlet-name>
		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
		<init-param>
			<param-name>contextConfigLocation</param-name>
			<param-value>classpath*:/spring-*.xml</param-value>
		</init-param>
		<load-on-startup>1</load-on-startup>
	</servlet>
	<servlet-mapping>
		<servlet-name>springServlet</servlet-name>
		<url-pattern>/</url-pattern>
	</servlet-mapping>
</web-app>

至于springmvc的配置文件可以不用看，都是copy，改改

<?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:context="http://www.springframework.org/schema/context"   
	xmlns:tx="http://www.springframework.org/schema/tx" xmlns:mvc="http://www.springframework.org/schema/mvc"
    xsi:schemaLocation="
		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.1.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.1.xsd
		http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.1.xsd"
	default-lazy-init="true">

	<description>Spring Configuration</description>
	
    <!-- 加载配置属性文件 -->
	<context:property-placeholder ignore-unresolvable="true" location="classpath:jdbc.properties" />
	
	<!-- 使用Annotation自动注册Bean，解决事物失效问题：在主容器中不扫描@Controller注解，在SpringMvc中只扫描@Controller注解。  -->
	<context:component-scan base-package="org.neris.CDExchange"><!-- base-package 如果多个，用“,”分隔 -->
		<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
	</context:component-scan>
	
 	<!-- MyBatis begin -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="typeAliasesPackage" value="org.neris.CDExchange"/>
        <property name="mapperLocations" value="classpath:/mappings/*.xml"/>
		<property name="configLocation" value="classpath:/mybatis-config.xml"></property>
    </bean>
    
    <!-- 扫描basePackage下所有以@Repository注解的Dao接口，注入sqlSessionFactory -->
    <bean id="mapperScannerConfigurer" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" />
        <property name="basePackage" value="org.neris.CDExchange"/>
        <property name="annotationClass" value="org.springframework.stereotype.Repository"/>
    </bean>

    <!-- 定义事务 -->
	<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource" />
	</bean>

	<!-- 配置 Annotation 驱动，扫描@Transactional注解的类定义事务  -->
	<tx:annotation-driven transaction-manager="transactionManager" proxy-target-class="true"/>
    <!-- MyBatis end -->
    
	<!-- 数据源配置, 使用 BoneCP 数据库连接池 -->
	<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close"> 
	    <!-- 数据源驱动类可不写，Druid默认会自动根据URL识别DriverClass -->
	    <property name="driverClassName" value="${jdbc.driver}" />
	    
		<!-- 基本属性 url、user、password -->
		<property name="url" value="${jdbc.url}" />
		<property name="username" value="${jdbc.username}" />
		<property name="password" value="${jdbc.password}" />
		
		<!-- 配置初始化大小、最小、最大 -->
		<property name="initialSize" value="${jdbc.pool.init}" />
		<property name="minIdle" value="${jdbc.pool.minIdle}" /> 
		<property name="maxActive" value="${jdbc.pool.maxActive}" />
		
		<!-- 配置获取连接等待超时的时间 -->
		<property name="maxWait" value="60000" />
		
		<!-- 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 -->
		<property name="timeBetweenEvictionRunsMillis" value="60000" />
		
		<!-- 配置一个连接在池中最小生存的时间，单位是毫秒 -->
		<property name="minEvictableIdleTimeMillis" value="300000" />
		
		<property name="validationQuery" value="${jdbc.testSql}" />
		<property name="testWhileIdle" value="true" />
		<property name="testOnBorrow" value="false" />
		<property name="testOnReturn" value="false" />
		
		<!-- 配置监控统计拦截的filters -->
	    <property name="filters" value="stat" /> 
	</bean>
	
	<!-- 使用Annotation自动注册Bean,只扫描@Controller -->
	<context:component-scan base-package="org.neris.CDExchange" use-default-filters="false"><!-- base-package 如果多个，用“,”分隔 -->
		<context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
	</context:component-scan>
	
	<!-- 定义视图文件解析 -->
	<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<property name="prefix" value="${web.view.prefix}"/>
		<property name="suffix" value="${web.view.suffix}"/>
	</bean>
	<!-- 静态资源映射 -->
    <mvc:resources mapping="/static/**" location="/static/" cache-period="31536000"/>
    
    <mvc:annotation-driven/>
</beans>

花了半天时间，学习了。分享一下。

Quartz定时任务
qq_2831427504的博客
03-08 873
Java实现定时任务的方式 一、线程等待（不建议使用，任务复杂时存在内存泄露风险） Thread myThread = new Thread(new Runnable() { @Override public void run() { while (true) { System.out.println("TestThreadWait is called!"); try { // 使用线程休眠来实现
SpringBoot + Quartz 定时任务从开始到放弃
qq_44460210的博客
11-22 924
目录maven依赖Spring配置JobStore配置RAMJobStoreJDBCJobStore定义定时任务其他Job状态与并发(@DisallowConcurrentExecution与@PersistJobDataAfterExecution注解)Job中断再执行(RequestsRecovery属性)监听器集群参考 maven依赖 <dependency> <grou...
spring中使用quartz
程序员笔记
04-04 774
一、引入相关包 如果需要在web应用中使用quartz ，则将quartz-all-1.6.0.jar得到到WEB-INF/lib目录下，其它依赖的包根据情况引入（本地还需引入 jta-1.1.jar、commons-collections-3.2.1.jar）。 二、quartz简单介绍  1、quartz运行的基本属性 quartz提供了一个名为quartz.properties的配置...
记录一个线上 quartz 阻塞问题
最新发布
Balance
04-09 172
debug 看一下 url，发现有时候是connect连接不上，直接超时；线上的错误是 connect连接上了，但是socket#read超时了，所以应该再加上一个socketTimeout。所以，即使类似调用 socket.read 时，线程会挂起 ，但此时状态还是 runnable。JVM 将I/O阻塞视为“等待资源”，与CPU调度无关，因此，统一归为。注意：此时线程阻塞，但是状态是 runnable。发现: 所有的 quartz 线程都在。简化了线程状态管理，牺牲了状态细粒度。
spring4.1.5 配置quartz2.2.1
登高必自卑，涉远必自迩
11-04 1027
一：需要的jar包如下： 二：spring 配置文件如下： autoRun 0 36 16 ? * *
spring+quartz
上善若水
05-23 708
本文只介绍最简单的spring+quartz 首先先贴需要的依赖（pom.xml） &amp;amp;lt;project xmlns=&amp;quot;http://maven.apache.org/POM/4.0.0&amp;quot; xmlns:xsi=&amp;quot;http://www.w3.org/2001/XMLSchema-instance&amp;quot; xsi:schemaLocation=&amp;quot;htt
Spring Quartz
qq_37933128的博客
08-17 831
Quartz是由Java编写的开源作业调度框架，Quartz可以定时或周期性的执行一些任务。
Java分布式Elastic-Job和Quartz定时任务课程（1.6G）
04-11
1_什么事定时任务.mp4 2_为什么学习定时任务.mp4 3_定时任务技术发展趋势.mp4 4_主流定时任务框架优缺点和什么是分布式定时任务.mp4 5_环境搭建总体流程.mp4 6_前期准备-JDK.mp4 7_前期准备-Maven.mp4 8_前期准备-...
Spring2.5+Quartz在Web工程中的定时任务实践
通过以上分析，可以得出该Web工程是一个典型的基于Spring框架与Quartz定时任务调度器的Web应用项目，适用于学习和理解如何在Java环境中实现和管理定时任务。开发者可以通过导入并运行该工程，来亲身体验Spring与...
SpringBoot系列：Spring Boot集成定时任务Quartz(1)
2401_84049200的博客
05-03 472
《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门，即可获取！ org.springframework.bootspring-boot-starter-quartz首先定义定时具体执行逻辑Job，创建类QuartzJob1，这里集继承QuartzJobBean实现executeInternal即可，该方法即定时执行任务逻辑，这里简单打印了下当前时间。public class QuartzJob1 extends QuartzJobBean {@Overrideprote
Spring集成Quartz实现定时任务入门教程
标题中提到的“quartz入门例子，spring集成配置使用”涉及了两个主要知识点：Quartz 定时任务框架以及与Spring框架的集成。 Quartz是一个功能强大的开源作业调度库，它几乎可以集成到任何Java应用程序中，从最小的...
quartz定时任务
11-14
quartz定时任务（包含动态切换数据源），spring集成。
Spring quartz
zhongyangjian的专栏
07-27 236
本文摘自http://www.blogjava.net/mikechen/archive/2012/07/03/382090.html 由于本人看到这篇文章很多帮助，欣喜之下，转之，希望更多人看到，谢谢作者！   一：quartz简介       OpenSymphony 的Quartz提供了一个比较完美的任务调度解决方案。        Quartz 是个开源的作业调度框架，定时调度...
Spring中Quartz的配置实例
VirgooooS
10-13 157
Quartz是一个强大的企业级任务调度框架，Spring中继承并简化了Quartz，下面就看看在Spring中怎样配置Quartz： 首先我们来写一个被调度的类： [code="java"]package com.kay.quartz; public class QuartzJob { public void work() { System.out.pr...
Spring +Quartz（一）
小武的Blog
04-18 390
1.Quartz大致介绍 1.1介绍 Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目，是完全由java开发的一个开源的任务日程管理系统，“任务进度管理器”就是一个在预先确定（被纳入日程）的时间到达时，负责执行（或者通知）其他软件组件的系统。 Quartz用一个小Java库发布文件（.jar文件），这个库文件包含了所有Quartz核心功...
Spring中如何使用Quartz
我是你妹她哥的博客
07-20 4377
背景： 接着上一篇文章，项目当中有个需求需要定时去检测工单的状态，这时我就想到了使用quartz来做一个任务调度系统。本篇文章就是给大家介绍如何在spring中加入quartz。 spring集成Quartz： 首先第一步肯定是在pom文件中导入相关的包。pom.xml: &lt;dependency&gt; &lt;groupId&gt;org.apache.loggin...
spring+quartz详解
weixin_30568715的博客
01-03 162
1. 首先用一个纯quartz例子讲一下quartz的基本概念 其中有两个基本概念,job(封装业务)与trigger(任务调度)，trigger又分两种，simpleTrigger与cronTrigger,分别模拟了window下的schedule task与linux下的cron table,详见本文最末 　以一个maven project为例，在pom.xml中要引入quart...
Spring任务调度之Quartz
weixin_30776863的博客
07-05 158
一、Quartz作业类的继承方式来讲，可以分为两类： 作业类需要继承自特定的作业类基类，如Quartz中需要继承自org.springframework.scheduling.quartz.QuartzJobBean；java.util.Timer中需要继承自java.util.TimerTask。 作业类即普通的java类，不需要继承自任何基类。 注:推荐使用第二种方式，...
在Spring中使用quartz
漫步
01-08 2660
写了一个自动去moofeel网站签到领金币魔币的程序，想要每天早上九点自动运行，于是考虑在Spring中用quartz实现 用maven创建 web工程，可参考在ECLIPSE中使用maven插件创建webapp类型项目 引入spring 和 quartz包 org.springframework spring-core ${spring.version}
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值