Spring 引入的运用 - hello world! - ITeye技术网站
博客分类：
参考《Spring高级程序设计》
引入是Spring提供的AOP功能的重要组成部分。使用引入可以动态地在现有的对象中添加新的功能。当我们在现有的对象中添加的功能是一个横切关注点而用传统的面向对象方法难以实现时，我们就可以利用引入动态的添加该功能了。
Spring文档中列举了两个典型的引入用法：对象锁定和对象篡改检测。
我们主要对对象篡改检测进行分析：
现在我们构建一个统计信息收集框架。篡改检测的逻辑被封装在CallTracker接口中，他的一个实现连同自动篡改检测的拦截逻辑被一起引入到合适的对象中。
CallTracker接口
package com.spring.ch06.
public interface CallTracker {
void markNormal();
void markFailing();
int countNormalCalls();
int countFailingCalls();
String describe();
CallTracker接口的一个实现
package com.spring.ch06.
public class DefaultCallTracker implements CallTracker {
private int normalC
private int failingC
public int countFailingCalls() {
return failingC
public int countNormalCalls() {
return normalC
public String describe() {
return toString();
public void markFailing() {
this.failingCalls++;
public void markNormal() {
this.normalCalls++;
public String toString(){
final StringBuilder sb=new StringBuilder();
sb.append("DefaultCallTracker");
sb.append("{normalCalls=").append(this.normalCalls);
sb.append(",failingCalls=").append(this.failingCalls);
sb.append("}");
return sb.toString();
创建一个方面
package com.spring.ch06.
import org.aspectj.lang.annotation.AfterR
import org.aspectj.lang.annotation.AfterT
import org.aspectj.lang.annotation.A
import org.aspectj.lang.annotation.DeclareP
import org.aspectj.lang.annotation.P
public class CallTrackerAspect {
@Pointcut("execution(* com.spring.ch06.service.*.*(..))")
private void serviceCall(){}
* 声明我们将使用DefaultCallTracker实现把CallTracker接口引入到com.spring.ch06.service
* 包下的所有的类中
@DeclareParents(
value="com.spring.ch06.service.*",
defaultImpl=DefaultCallTracker.class)
public static CallT
* serviceCall()代表@Pointcut,而this(tracker)将匹配实现了CallTracker接口的对象上所有方法
* 执行。SpringAOP会将追踪器参数绑定到被通知的对象上。
@AfterReturning(
value="serviceCall()&&this(tracker)",
argNames="tracker")
public void normallCall(CallTracker tracker){
tracker.markNormal();
@AfterThrowing(
value="serviceCall()&&this(tracker)",
throwing="t",
argNames="tracker,t")
public void failingCall(CallTracker tracker,Throwable t){
tracker.markFailing();
现有对象：
package com.spring.ch06.
import com.mon.U
public interface UserService {
public void login(String username);
void setAdministratorUsername(String administratorUsername);
User findById(long id);
package com.spring.ch06.
import com.mon.SecurityC
import com.mon.U
public class DefaultUserService implements UserService{
private String administratorUsername = "janm";
public void login(String username) {
if (this.administratorUsername.equals(username)) {
SecurityContext.setCurrentUser(username);
public void setAdministratorUsername(String administratorUsername) {
this.administratorUsername = administratorU
public User findById(long id) {
User user = new User();
user.setUsername(String.valueOf(id));
user.setPassword("Very secret password");
package com.spring.ch06.
import java.math.BigD
import java.util.D
public interface StockService {
long getStockLevel(String sku);
long getPredictedStockLevel(String sku);
void applyDiscounts(Date cutoffDate, BigDecimal maximumDiscount);
package com.spring.ch06.
import java.util.D
import java.math.BigD
* @author janm
public class DefaultStockService implements StockService {
public long getStockLevel(String sku) {
Thread.sleep(2000L);
} catch (InterruptedException ignored) {
return getPredictedStockLevel(sku) / 2L;
return ((StockService)AopContext.currentProxy()).getPredictedStockLevel(sku) / 2L;
public long getPredictedStockLevel(String sku) {
return 6L * sku.hashCode();
public void applyDiscounts(Date cutoffDate, BigDecimal maximumDiscount) {
// do some work
package com.spring.ch06;
import org.springframework.context.ApplicationC
import org.springframework.context.support.ClassPathXmlApplicationC
import java.math.BigD
import java.util.*;
import com.spring.ch06.service.CallT
import com.spring.ch06.service.StockS
import com.spring.ch06.service.UserS
public class IntroductionDemo {
public static void main(String[] args) {
//ApplicationContext ac=new ClassPathXmlApplicationContext("/introductiondemo1.xml");
ApplicationContext ac=new ClassPathXmlApplicationContext("/introductiondemo2.xml");
UserService userService=(UserService)ac.getBean("userService");
describeTracker(userService);
userService.login("janm");
userService.setAdministratorUsername("x");
describeTracker(userService);
StockService stockService=(StockService)ac.getBean("stockService");
describeTracker(stockService);
stockService.getStockLevel(null);
}catch(Exception ignored){
System.out.println(stockService.getStockLevel("ABC"));
stockService.applyDiscounts(new Date(), new BigDecimal("10.0"));
describeTracker(stockService);
public static void describeTracker(Object o){
CallTracker t=(CallTracker)o;
System.out.println(t.describe());
配置文件：采用两种方式：注解和AOP命名空间配置
&?xml version="1.0" encoding="UTF-8"?&
&beans xmlns="http://www.springframework.org/schema/beans"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
&aop:aspectj-autoproxy/&
&bean id="userService" class="com.spring.ch06.service.DefaultUserService"/&
&bean id="stockService" class="com.spring.ch06.service.DefaultStockService"/&
&bean class="com.spring.ch06.service.CallTrackerAspect"/&
使用CallTrackerAspect的userService bean类型是JdkDynamicAopProxy,它不是一个DefaultUserService
的实例。这个代理双双实现了UserService接口和CallTracker混入体接口。它拦截对所有方法的调用并将UserService
接口上的调用委托给DefaultUserService.这个代理也创建了一个DefaultCallTracker(在@DeclareParents注解中被定义)
的实例并将CallTracker接口上所有的调用委托给DefaultCallTracker实例。
&?xml version="1.0" encoding="UTF-8"?&
&beans xmlns="http://www.springframework.org/schema/beans"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
&bean id="userService" class="com.spring.ch06.service.DefaultUserService"/&
&bean id="stockService" class="com.spring.ch06.service.DefaultStockService"/&
&bean id="aspectBean" class="com.spring.ch06.service.AspectBean"/&
&!-- AOP命名空间中的引入 （引入通过代理被通知对象，向已有对象中添加额外的方法，
并让代理实现那些接口，它是我们在原有是想上声明的接口）--&
&aop:config&
&aop:aspect id="aroundAspect" ref="aspectBean"&
&aop:declare-parents types-matching="com.spring.ch06.service.*"
implement-interface="com.spring.ch06.service.CallTracker"
default-impl="com.spring.ch06.service.DefaultCallTracker"/&
&aop:after-returning method="normalCall"
arg-names="tracker"
pointcut="execution(* com.spring.ch06.service.*.*(..)) and this(tracker)"/&
&aop:after-throwing method="failingCall"
arg-names="tracker"
pointcut="execution(* com.spring.ch06.service.*.*(..)) and this(tracker)"/&
&/aop:aspect&
&/aop:config&
使用CallTrackerAspect的userService bean类型是JdkDynamicAopProxy,它不是一个DefaultUserService
的实例。这个代理双双实现了UserService接口和CallTracker混入体接口。它拦截对所有方法的调用并将UserService
接口上的调用委托给DefaultUserService.这个代理也创建了一个DefaultCallTracker(在@DeclareParents注解中被定义)
的实例并将CallTracker接口上所有的调用委托给DefaultCallTracker实例。
package com.spring.ch06.
import org.aspectj.lang.JoinP
import com.mon.U
public class AspectBean {
public void normalCall(CallTracker tracker){
tracker.markNormal();
public void failingCall(CallTracker tracker){
tracker.markFailing();
imaginecup
浏览: 56859 次
来自: 西安
呵呵……好帖，收藏一下Spring如此受追捧到底是为什么？使用Spring能给我们带来什么？
在招聘网站上找jee开发相关的工作，几乎就没有不要求会使用spring的，为此我花了一段时间来学习spring，我是通过看 spring-framework-reference来学习的。
但是从我开始学到现在一直有个疑问徘徊在我脑海里，为什么要使用spring？spring能给我们带来什么样的好处？我一直没有明白，相反，我觉得使用spring极大的增加了我的代码复杂度。
就是spring框架的那种思想，就算不是用spring都是类spring思想的框架。
首先Java项目中使用Spring开发 现在也算是成为一种“标准”了吧,
如果你再继续深入了解下去的话,你会发现&Spring设计的很好
你可能会觉得有很多冗余的设计,但是有时候你在考虑下Spring出世的出发点原因,等等
公司都是力求稳定,Spring出道到现在差不多有13、14年了,基本上可认为非常稳定,有问题随时issue到github,会有很多程序员关注并回复你
Spring提供的对第三方的支持也比较多,被收购后更是有那么一伙人专门发展Spring
有时候可能你需要的功能,你也可以实现,甚至spring它日常提供的一些常用功能 咱们也可以实现,但是公司要的是一种大家都会的东西,可以快速上手干的东西,所以...
其他方面期待 另外的大神补充..
再回来说说spring历史&
先写写 try catch+ jdbc 回滚
其次考虑两个数据库事务方案
再写写多service嵌套，重用，时回滚方案
回头看一下类名方法名正则覆盖
事务边界控制 ，日志后补
用spring粘合其它系统。
你说的问题一般问题出在其它系统上如你不了解的系统，或没更好的粘合方案，这事与胶水没关系
做个上规模的项目就了解，另外，屁大点项目用spring boot，部署都省了.
spring的目标是简化开发, 它已经超额做到了.
Spring解救程序员脱离EJB的苦海，喷Spring的，请问你们真正用过Spring吗
楼主你适合去学Python&& Java开发者是最不闲啰嗦的人员，屁大点项目一个接口一个实现，里三层 外三层，中间再来几个DO& BO& VO，有多少人脱离框架完全傻逼，面试人员万年抱spring大腿，IOC& AOP啊，动态代理啊， 分层啊 封装啊，问他为神马，有人会告诉你这叫OO，几千行代码的项目打包出来几十M！
--- 共有 6 条评论 ---
: 我可没说学校只教Java，大一教的就是C，数据结构和算法教的也是C，操作系统原理教的还是C。
: 学校教java? 教育没救了。如果教PHP更没救了。至少是应该是C，lisp,学习递归为标准的语法，各式链表处理规则。java,php把这部分都放到SQL中去了。。。
支持，大项目用
这是你自己意识不到位
我只能说这是写代码的人决定的,你完全可以不这么干
软件开发这么多年，老生常谈的问题就是代码重用 组件扩展 ，避免耦合，尽可能避免重复开发
spring提供的ioc方案并不是唯一方案，但在他提出的那个时候相对是一种比较好的方案
spring本身是比较开放的态度，对各种第三方框架和组建都提供了集成的能力
说他是现在j2ee的标准也不为过
我搞javaweb开发之前也对spring的意义不理解，随着系统越做越多，逐渐感觉到离不开spring了
可以大大提高生产率，除了Spring本身的功能，它可以让使用者更容易集成第三方插件
有这样的心态是因为你把它当做一门陌生的技术来学习，如果你把它当做一种辅助工具的话，会发现它很好用。Spring到底有什么用处？ - ITeye问答
引用开发过好几个web项目，从来没有使用过Spring，网上对Spring的吹捧天花乱坠，可是我把google前十页的搜索结果都看了，还是不明白Spring到底能解决什么问题，在我看来，Spring只是增加了开发的复杂度，我没有感觉到web项目中使用Spring的好处。
这是一个非常菜鸟的问题，请各位达人用简单易懂的话说一下自己在项目开发中，Spring为自己解决了什么问题，类似非侵入、IOC/AOP之类的术语，最好举个例子，因为对于一个从来没有使用过Spring的菜鸟来说，这些术语都是天方夜谭。
问题补充：wujianjun 写道Spring就像一个对象池（对象池可以和数据库连接池对应着去看），Spring能很好的对类进行管理，便于程序员对类对象的控制。
太笼统了吧？
你这样回答，就好像我问：什么是轿车，然后你回答：轿车是一种铁盒子
问题补充：wujianjun 写道Spring就像一个对象池（对象池可以和数据库连接池对应着去看），Spring能很好的对类进行管理，便于程序员对类对象的控制。
最好对Spring的好处举个具体的例子，比如一个用户登录的页面，Spring在这个登录过程中能够起到什么作用？
问题补充：回答的达人，请先阅读以下这篇文章：
http://article.yeeyan.org/view/
问题补充：wazhouqian 写道个人认为最大的好处是统一管理，统一整合，特别是工程大的时候比较明显
这个回答更笼统，就好像我问：什么是轿车，然后你回答：轿车是一个器物
问题补充：
问题补充：wujianjun 写道老兄，把你思维放大一点能成吗？
放到多大？放到在这里讨论JAVA EE？
问题补充：我一直很想使用Spring，因为网络上对它的好处吹捧得让人心动，但是我一直在尝试寻找使用它的理由和好处，但是一直都没有找到合适的答案，因此，我没法去用它，因为，我为什么要用它？
问题补充：wujianjun 写道对象池，连接池有概念么？
太笼统了，我明白对象池，连接池的概念，跟Spring有什么关系，我问得是Spring的好处，即使Spring和对象池有关系，也需要你来回答啊，因为问问题的人是我，因为我不明白Spring是什么，所以才来问问问题。
问题补充：我明白Spring的AOP功能，请楼下的大人们回答Spring的其他功能！
问题补充：尤其是ioc功能，这个东西到底有什么用，为什么要在web项目中使用ioc，为什么要把Struts的Action交给Spring来管理？这不是多此一举么？
问题补充：为什么要使用Spring来管理Hibernate？我直接使用Hibernate，感觉很方便啊！
问题补充：为什么要使用Spring来创建对象？为什么要使用Spring来初始化变量的值，为什么？
这不是多此一举么？各位可以说一下这样做的好处么？
问题补充：蔡华江 写道如果你没有找到一个理由去学习它，那么随便给自己一个理由。
如果你无法使用他，是因为你没有理由去学习它，我想这不理由。
先学吧，再决定用不用&
如此看来，我也只能是“先下成本来学习它，用熟了它，然后再自己总结Spring有什么用”
也就是，最终还得靠自己来总结，等我总结出来Spring的还要出，一定得写一篇通俗易懂的介绍文章来给像今天的我这样的人一个介绍。
问题补充：sunquanfeng 写道spring的好处，它可以来管理对象和事务，这是spring的好处，配置了spring就可以对hibernate的事务进行统一的配置和spring自动来new 对象，，省去很多事
我不用Hibernate
问题补充：sunquanfeng 写道你用不用hibernate都一样，，spring实际上管理的是数据库的事务
管理数据库事务跟Spring有什么关系，不适用Spring就无法管理数据库事务了么？
问题补充：sunquanfeng 写道我只是想说这是使用spring的好处可以统一来管理事务，，不用spring没人说不可以。你的问题不就是spring有什么用处吗？你学了就知道spring了，不了解是体会不到的
所有Spring管理事务，我问十个人，有八个人说不出来为什么要用Spring来管理事务，他们的意思好像离开Spring，就无法管理事务。
其实所谓的Spring管理事务，不过是使用AOP面向切面编程的概念，在对数据库进行若干sql后，自动提交事务，或者回滚。
对数据库事务的管理，本来和Spring是没有任何关系的，离开了Spring，对数据库的操作照样进行得很顺利，Hibernate和IBatis(MyBatis)不是为了适应Spring才被设计出来的，离开Spring,直接使用Hibernate或者IBatis照样可以做到运行得很好。
那些唯Spring才可以管理Hibernate或IBatis的人，充其量只是程序流水线上的工人，从来没有考虑过程序架构，他们认为web本来就应该使用Spring来粘合各种框架，离开Spring他们会无能为力，于是我问网络上任何一个人"Spring有什么好处"，到目前为止，他们都无法直接回答出来，其实我要的答案很简单，在一个最简单的Web功能中，比如一个用户登录的页面，Spring在其中起到了什么作用，使用Spring可以有哪些优点，不用Spring有什么不好？
如果你可以把这几个问题回答出来，就足以说明你上升到架构师的水平了。
呵呵~开始的时候我也怀疑过spring,但是用多的时候你就会发现它的好处，重点是AOP和DIC，您的文章我也看了，文章也不错，很有道理。
这个问题应该这样理解，就像hibernate映射文件一样，可以有映射文件也可以用注解方式，这是两个选择，就像两条路，在每个人的心中都有一个较好的路，也许我的心中是spring,而很多人和你一样，选择不是spring，就这么简单。
一千个读者有一千个哈姆雷特
楼上全是天才。
哎。。。。保持沉默。。。恩
引用在我看来，Spring只是增加了开发的复杂度
你这个结论真是有创意。。。。
不用spring的时候，你的数据库事务是如何管理的。
& 用spring的时候，你的数据库事务时如何管理的。
一对比，不就知道好处在哪了？不好在哪了？
其实架构师通常是不会有我们这么多的时间来回答您的问题的。
您自己有了想法，心里有数就成。
我认错，别来数落我们了。&
我只是想说这是使用spring的好处可以统一来管理事务，，不用spring没人说不可以。你的问题不就是spring有什么用处吗？你学了就知道spring了，不了解是体会不到的
你用不用hibernate都一样，，spring实际上管理的是数据库的事务
spring的好处，它可以来管理对象和事务，这是spring的好处，配置了spring就可以对hibernate的事务进行统一的配置和spring自动来new 对象，，省去很多事
如果你没有找到一个理由去学习它，那么随便给自己一个理由。
如果你无法使用他，是因为你没有理由去学习它，我想这不理由。
先学吧，再决定用不用&
对象池，连接池有概念么？
老兄，把你思维放大一点能成吗？
个人认为最大的好处是统一管理，统一整合，特别是工程大的时候比较明显
Spring就像一个对象池（对象池可以和数据库连接池对应着去看），Spring能很好的对类进行管理，便于程序员对类对象的控制。
已解决问题
未解决问题Spring定时任务的几种实现 -
- ITeye技术网站
博客分类：
Spring定时任务的几种实现
近日项目开发中需要执行一些定时任务，比如需要在每天凌晨时候，分析一次前一天的日志信息，借此机会整理了一下定时任务的几种实现方式，由于项目采用spring框架，所以我都将结合
spring框架来介绍。
从实现的技术上来分类，目前主要有三种技术（或者说有三种产品）：
Java自带的java.util.Timer类，这个类允许你调度一个java.util.TimerTask任务。使用这种方式可以让你的程序按照某一个频度执行，但不能在指定时间运行。一般用的较少，这篇文章将不做详细介绍。
使用Quartz，这是一个功能比较强大的的调度器，可以让你的程序在指定时间执行，也可以按照某一个频度执行，配置起来稍显复杂，稍后会详细介绍。
Spring3.0以后自带的task，可以将它看成一个轻量级的Quartz，而且使用起来比Quartz简单许多，稍后会介绍。
从作业类的继承方式来讲，可以分为两类：
作业类需要继承自特定的作业类基类，如Quartz中需要继承自org.springframework.scheduling.quartz.QuartzJobBean；java.util.Timer中需要继承自java.util.TimerTask。
作业类即普通的java类，不需要继承自任何基类。
注:个人推荐使用第二种方式，因为这样所以的类都是普通类，不需要事先区别对待。
从任务调度的触发时机来分，这里主要是针对作业使用的触发器，主要有以下两种：
每隔指定时间则触发一次，在Quartz中对应的触发器为：org.springframework.scheduling.quartz.SimpleTriggerBean
每到指定时间则触发一次，在Quartz中对应的调度器为：org.springframework.scheduling.quartz.CronTriggerBean
注：并非每种任务都可以使用这两种触发器，如java.util.TimerTask任务就只能使用第一种。Quartz和spring task都可以支持这两种触发条件。
二．用法说明
详细介绍每种任务调度工具的使用方式，包括Quartz和spring task两种。
第一种，作业类继承自特定的基类：org.springframework.scheduling.quartz.QuartzJobBean。
第一步：定义作业类
import org.quartz.JobExecutionC
import org.quartz.JobExecutionE
import org.springframework.scheduling.quartz.QuartzJobB
public class Job1 extends QuartzJobBean {
private static int i = 0;
//调度工厂实例化后，经过timeout时间开始执行调度
public void setTimeout(int timeout) {
this.timeout =
* 要调度的具体任务
protected void executeInternal(JobExecutionContext context)
throws JobExecutionException {
System.out.println("定时任务执行中…");
第二步：spring配置文件中配置作业类JobDetailBean
&bean name="job1" class="org.springframework.scheduling.quartz.JobDetailBean"&
&property name="jobClass" value="com.gy.Job1" /&
&property name="jobDataAsMap"&
&entry key="timeout" value="0" /&
&/property&
说明：org.springframework.scheduling.quartz.JobDetailBean有两个属性，jobClass属性即我们在java代码中定义的任务类，jobDataAsMap属性即该任务类中需要注入的属性值。
第三步：配置作业调度的触发方式（触发器）
Quartz的作业触发器有两种，分别是
org.springframework.scheduling.quartz.SimpleTriggerBean
org.springframework.scheduling.quartz.CronTriggerBean
第一种SimpleTriggerBean，只支持按照一定频度调用任务，如每隔30分钟运行一次。
配置方式如下：
&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秒调度一次 --&
第二种CronTriggerBean，支持到指定时间运行一次，如每天12:00运行一次等。
配置方式如下：
&bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean"&
&property name="jobDetail" ref="job1" /&
&!—每天12:00运行一次 --&
&property name="cronExpression" value="0 0 12 * * ?" /&
关于cronExpression表达式的语法参见附录。
第四步：配置调度工厂
&bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean"&
&property name="triggers"&
&ref bean="cronTrigger" /&
&/property&
说明：该参数指定的就是之前配置的触发器的名字。
第五步：启动你的应用即可，即将工程部署至tomcat或其他容器。
第二种，作业类不继承特定基类。
Spring能够支持这种方式，归功于两个类：
org.springframework.scheduling.timer.MethodInvokingTimerTaskFactoryBean
org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean
这两个类分别对应spring支持的两种实现任务调度的方式，即前文提到到java自带的timer task方式和Quartz方式。这里我只写MethodInvokingJobDetailFactoryBean的用法，使用该类的好处是,我们的任务类不再需要继承自任何类，而是普通的pojo。
第一步：编写任务类
public class Job2 {
public void doJob2() {
System.out.println("不继承QuartzJobBean方式-调度进行中...");
可以看出，这就是一个普通的类，并且有一个方法。
第二步：配置作业类
&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" /&&!-- 作业不并发调度 --&
说明：这一步是关键步骤，声明一个MethodInvokingJobDetailFactoryBean，有两个关键属性：targetObject指定任务类，targetMethod指定运行的方法。往下的步骤就与方法一相同了，为了完整，同样贴出。
第三步：配置作业调度的触发方式（触发器）
Quartz的作业触发器有两种，分别是
org.springframework.scheduling.quartz.SimpleTriggerBean
org.springframework.scheduling.quartz.CronTriggerBean
第一种SimpleTriggerBean，只支持按照一定频度调用任务，如每隔30分钟运行一次。
配置方式如下：
&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秒调度一次 --&
第二种CronTriggerBean，支持到指定时间运行一次，如每天12:00运行一次等。
配置方式如下：
&bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean"&
&property name="jobDetail" ref="job2" /&
&!—每天12:00运行一次 --&
&property name="cronExpression" value="0 0 12 * * ?" /&
以上两种调度方式根据实际情况，任选一种即可。
第四步：配置调度工厂
&bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean"&
&property name="triggers"&
&ref bean="cronTrigger" /&
&/property&
说明：该参数指定的就是之前配置的触发器的名字。
第五步：启动你的应用即可，即将工程部署至tomcat或其他容器。
到此，spring中Quartz的基本配置就介绍完了，当然了，使用之前，要导入相应的spring的包与Quartz的包，这些就不消多说了。
其实可以看出Quartz的配置看上去还是挺复杂的，没有办法，因为Quartz其实是个重量级的工具，如果我们只是想简单的执行几个简单的定时任务，有没有更简单的工具，有！
请看我第下文Spring task的介绍。
Spring-Task
上节介绍了在Spring 中使用Quartz，本文介绍Spring3.0以后自主开发的定时任务工具，spring task，可以将它比作一个轻量级的Quartz，而且使用起来很简单，除spring相关的包外不需要额外的包，而且支持注解和配置文件两种
形式，下面将分别介绍这两种方式。
第一种：配置文件方式
第一步：编写作业类
即普通的pojo，如下：
import org.springframework.stereotype.S
public class TaskJob {
public void job1() {
System.out.println(“任务进行中。。。”);
第二步：在spring配置文件头中添加命名空间及描述
&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配置文件中设置具体的任务
&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，我们看看源文件中该注解的定义：
@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
import org.springframework.scheduling.annotation.S
import org.
@Component(“taskJob”)
public class TaskJob {
@Scheduled(cron = "0 0 3 * * ?")
public void job1() {
System.out.println(“任务进行中。。。”);
第二步：添加task相关的配置：
&?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
允许的特殊字符
, - * ? / L W C
1-12 或者 JAN-DEC
1-7 或者 SUN-SAT
, - * ? / L C #
年（可选）
? 你不想设置那个字段
下面只例出几个式子
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触发
浏览 268856
好文好文！谢谢 博猪猪分享。另外请问。出来您说的2种方式。（固定间隔，指定时间）外。有没有按事件触发的。比如我会员积分被减到0分（是不是算数据库变动），触发一个任务。那你在程序里自己调用就行了嘛
您好，我用的您的第一种方法，然后改掉task之后，一直只是输出& 任务进行中。。。& 根本不执行我修改后的task啊，我把& job1中的 public void job1() {& &&&&&&& System.out.println(“任务进行中。。。”);& &&& }&& 注释掉之后还是输出& 任务进行中。。。请问这是为什么啊，急求您指点 谢谢断点& 打桩& 调试调试咯
& 上一页 1
浏览: 357939 次
来自: 北京
谢谢分享。。。
我的配置是这样的：&!-- ActiveMQ 连接工厂
ERROR 8976 --- [erContainer#2-1 ...
你好，为什么我启动报错呢setClientID call no ...
写的很详细谢谢---