轉自：http://blog.csdn.net/huxin1/archive/2008/12/31/3669583.aspx

Java代码

1. public class UserManagerImpl implements UserManager {   
2.     private UserDao userDao;   
3.     public void setUserDao(UserDao userDao) {   
4.         this.userDao = userDao;   
5.     }   
6.     ...   
7. }  

public class UserManagerImpl implements UserManager {
private UserDao userDao;
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
...
}

<bean id="userManagerImpl" class="com.kedacom.spring.annotation.service.UserManagerImpl">
<property name="userDao" ref="userDao" />
</bean>
<bean id="userDao" class="com.kedacom.spring.annotation.persistence.UserDaoImpl">
<property name="sessionFactory" ref="mySessionFactory" />
</bean>

Java代码

1. public class UserManagerImpl implements UserManager {   
2.     @Autowired  
3.     private UserDao userDao;   
4.     ...   
5. }  

public class UserManagerImpl implements UserManager {
@Autowired
private UserDao userDao;
...
}

Java代码

1. public class UserManagerImpl implements UserManager {   
2.     private UserDao userDao;   
3.     @Autowired  
4.     public void setUserDao(UserDao userDao) {   
5.         this.userDao = userDao;   
6.     }   
7.     ...   
8. }  

public class UserManagerImpl implements UserManager {
private UserDao userDao;
@Autowired
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
...
}

Java代码

1. <bean id="userManagerImpl" class="com.kedacom.spring.annotation.service.UserManagerImpl" />   
2. <bean id="userDao" class="com.kedacom.spring.annotation.persistence.UserDaoImpl">   
3.     <property name="sessionFactory" ref="mySessionFactory" />   
4. </bean>  

<bean id="userManagerImpl" class="com.kedacom.spring.annotation.service.UserManagerImpl" />
<bean id="userDao" class="com.kedacom.spring.annotation.persistence.UserDaoImpl">
<property name="sessionFactory" ref="mySessionFactory" />
</bean>

Java代码

1. <bean class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor" />  

<bean class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor" />

Java代码

1. @Autowired  
2. public void setUserDao(@Qualifier("userDao") UserDao userDao) {   
3.     this.userDao = userDao;   
4. }  

	@Autowired
public void setUserDao(@Qualifier("userDao") UserDao userDao) {
this.userDao = userDao;
}

Java代码

1. @Autowired(required = false)   
2. public void setUserDao(UserDao userDao) {   
3.     this.userDao = userDao;   
4. }  

	@Autowired(required = false)
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}

1. 如果同时指定了name和type，则从Spring上下文中找到唯一匹配的bean进行装配，找不到则抛出异常
2. 如果指定了name，则从上下文中查找名称（id）匹配的bean进行装配，找不到则抛出异常
3. 如果指定了type，则从上下文中找到类型匹配的唯一bean进行装配，找不到或者找到多个，都会抛出异常
4. 如果既没有指定name，又没有指定type，则自动按照byName方式进行装配（见2）；如果没有匹配，则回退为一个原始类型（UserDao）进行匹配，如果匹配则自动装配；

Java代码

1. public class UserDaoImpl extends HibernateDaoSupport implements UserDao {   
2.     private SessionFactory mySessionFacotry;   
3.     @Resource  
4.     public void setMySessionFacotry(SessionFactory sessionFacotry) {   
5.         this.mySessionFacotry = sessionFacotry;   
6.     }   
7.     @PostConstruct  
8.     public void injectSessionFactory() {   
9.         super.setSessionFactory(mySessionFacotry);   
10.     }   
11.     ...   
12. }  

public class UserDaoImpl extends HibernateDaoSupport implements UserDao {
private SessionFactory mySessionFacotry;
@Resource
public void setMySessionFacotry(SessionFactory sessionFacotry) {
this.mySessionFacotry = sessionFacotry;
}
@PostConstruct
public void injectSessionFactory() {
super.setSessionFactory(mySessionFacotry);
}
...
}

Java代码

1. <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"  
2.     xsi:schemaLocation="http://www.springframework.org/schema/beans   
3.     http://www.springframework.org/schema/beans/spring-beans-2.5.xsd   
4.     http://www.springframework.org/schema/context   
5.     http://www.springframework.org/schema/context/spring-context-2.5.xsd">   
6.     <context:annotation-config />   
7. </beans>  

<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"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-2.5.xsd">
<context:annotation-config />
</beans>

Java代码

1. @Component  
2. public class UserDaoImpl extends HibernateDaoSupport implements UserDao {   
3.     ...   
4. }  

@Component
public class UserDaoImpl extends HibernateDaoSupport implements UserDao {
...
}

Java代码

1. <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"  
2.     xsi:schemaLocation="http://www.springframework.org/schema/beans   
3.     http://www.springframework.org/schema/beans/spring-beans-2.5.xsd   
4.     http://www.springframework.org/schema/context   
5.     http://www.springframework.org/schema/context/spring-context-2.5.xsd">   
6.     <context:component-scan base-package="com.kedacom.ksoa" />   
7. </beans>  

<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"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-2.5.xsd">
<context:component-scan base-package="com.kedacom.ksoa" />
</beans>

• 过滤器类型 表达式范例 说明
• 注解 org.example.SomeAnnotation 将所有使用SomeAnnotation注解的类过滤出来
• 类名指定 org.example.SomeClass 过滤指定的类
• 正则表达式 com\.kedacom\.spring\.annotation\.web\..* 通过正则表达式过滤一些类
• AspectJ表达式 org.example..*Service+ 通过AspectJ表达式过滤一些类

Java代码

1. <context:component-scan base-package="com.casheen.spring.annotation">   
2.     <context:exclude-filter type="regex" expression="com\.casheen\.spring\.annotation\.web\..*" />   
3. </context:component-scan>  

	<context:component-scan base-package="com.casheen.spring.annotation">
<context:exclude-filter type="regex" expression="com\.casheen\.spring\.annotation\.web\..*" />
</context:component-scan>

Java代码

1. @Scope("session")   
2. @Component()   
3. public class UserSessionBean implements Serializable {   
4.     ...   
5. }  

@Scope("session")
@Component()
public class UserSessionBean implements Serializable {
...
}

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1418938

启动JBOSS服务器.先运行TestMsgConsumer.java;再运行TestMsgProducer.java,即可看到控制台的输出了,嘻嘻~~~~~

jdbc.driver=org.postgresql.Driver

jdbc.url=jdbc:postgresql://localhost/test

jdbc.user=postgres

jdbc.password=

　　我们的Bean配置如下：

<bean id="propertyConfigurer" 

class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">

<property name="location">

<value>/WEB-INF/jdbc.properties</value>

</property>

</bean>



<bean id="dataSource" 

class="org.springframework.jdbc.datasource.DriverManagerDataSource">

<property name="driverClassName">

<value>${jdbc.driver}</value>

</property>

<property name="url">

<value>${jdbc.url}</value>

</property>

<property name="username">

<value>${jdbc.user}</value>

</property>

<property name="password">

<value>${jdbc.password}</value>

</property>

</bean>

　　如上所述，我们定义了一个PropertyPlaceholderConfigurer类的实例，并将其位置属性设置为我们的属性文件。该类被实现为Bean工厂的后处理器，并将使用定义在文件中的属性来代替所有的占位符（${...}value）。

　　利用这种技术，我们可以从applicationContext.xml中移除所有特定于主机的配置属性。通过这种方式，我们可以自由地为该文件添加新的Bean，而不必担心特定于主机属性的同步性。这样可以简化生产部署和维护。

PropertyPlaceholderConfigurer作为一个bean factory post-processor实现，可以用来将BeanFactory定义中的属性值放置到另一个单独的Java Properties格式的文件中。这使得用户不用对BeanFactory的主XML定义文件进行复杂和危险的修改，就可以定制一些基本的属性（比如说数据库的urls,用户名和密码）。

考虑一个BeanFactory定义的片断，里面用占位符定义了DataSource：

在下面这个例子中，定义了一个datasource，并且我们会在一个外部Porperties文件中配置一些相关属性。 在运行时，我们为BeanFactory提供一个PropertyPlaceholderConfigurer，它将用Properties文件中的值替换掉这个datasource的属性值：

<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">

<property name="driverClassName"><value>${jdbc.driverClassName}</value></property>

<property name="url"><value>${jdbc.url}</value></property>

<property name="username"><value>${jdbc.username}</value></property>

<property name="password"><value>${jdbc.password}</value></property>

</bean>

真正的值来自于另一个Properties格式的文件:

jdbc.driverClassName=org.hsqldb.jdbcDriver

jdbc.url=jdbc:hsqldb:hsql://production:9002

jdbc.username=sa

jdbc.password=root

如果要在BeanFactory中使用，bean factory post-processor必须手动运行:

XmlBeanFactory factory = new XmlBeanFactory(new FileSystemResource("beans.xml"));

PropertyPlaceholderConfigurer cfg = new PropertyPlaceholderConfigurer();

cfg.setLocation(new FileSystemResource("jdbc.properties"));

cfg.postProcessBeanFactory(factory);

注意，ApplicationContext能够自动辨认和应用在其上部署的实现了BeanFactoryPostProcessor的bean。这就意味着，当使用ApplicationContext的时候应用PropertyPlaceholderConfigurer会非常的方便。由于这个原因，建议想要使用这个或者其他bean factory postprocessor的用户使用ApplicationContext代替BeanFactroy。

PropertyPlaceHolderConfigurer不仅仅在你指定的Porperties文件中查找属性， 如果它在其中没有找到你想使用的属性，它还会在Java的系统properties中查找。 这个行为能够通过设置配置中的systemPropertiesMode 属性来定制。这个属性有三个值， 一个让配置总是覆盖，一个让它永不覆盖，一个让它仅在properties文件中找不到的时候覆盖。 请参考 PropertiesPlaceholderConfigurer的JavaDoc获得更多信息。
文章来源:http://www.cublog.cn/u/9295/showart.php?id=261437

import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.ajaxtags.helpers.AjaxXmlBuilder;
import org.ajaxtags.servlets.BaseAjaxServlet;
import org.springframework.web.context.support.WebApplicationContextUtils;

import dgut.ke.model.Book;
import dgut.ke.service.IBookService;

@SuppressWarnings("serial")
public class BookCallOut extends BaseAjaxServlet {

 private IBookService bookService;

 @Override
 public String getXmlContent(HttpServletRequest request,
   HttpServletResponse response) throws Exception {
  
  request.setCharacterEncoding("UTF-8");
  String bookName = request.getParameter("bookName");
  System.out.println("---- " + bookName);
  Book book = (Book) bookService.findForObject(
    "from Book as b where b.bookName=?",new Object[]{bookName});
  
  AjaxXmlBuilder builder = new AjaxXmlBuilder()
         .addItemAsCData("提示标题", "<P>关于书籍:<b>" + book.getBookNo() +"</b>的信息如下:<br/></p>");

  
  return builder.toString();
 }

 @Override
 public void init(ServletConfig servletConfig) throws ServletException {
  // 必须在重写方法的第一行调用以下语句
  super.init(servletConfig);
  bookService = (IBookService) WebApplicationContextUtils
   .getRequiredWebApplicationContext(getServletContext())
   .getBean("bookService");
 }

}

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.mail.SimpleMailMessage;
import org.springframework.mail.javamail.JavaMailSender;

public class MailTest {

 public static void main(String[] args) {
  
  ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
  JavaMailSender mailSender = (JavaMailSender) context.getBean("mailSender");
  SimpleMailMessage mail = new SimpleMailMessage();
  mail.setFrom("sskwfnihc@gmail.com");
  mail.setTo("sskwfnihc@163.com");
  mail.setSubject("KE给你发了一封邮件");
  mail.setText("This is a mailTest example");
  mailSender.send(mail);
  System.out.println("成功发送文本文件！");
 }
}
spring配置文件:
... ...
<!-- 发送电子邮件 -->
 <bean id="mailSender"
  class="org.springframework.mail.javamail.JavaMailSenderImpl"
  abstract="false" lazy-init="default" autowire="default"
  dependency-check="default">
  <property name="host" value="smtp.gmail.com"></property>
  <property name="port" value="465"></property>
  <property name="username">
   <value>sskwfnihc</value>
  </property>
  <property name="password">
   <value>write your password here</value>
  </property>
  <property name="javaMailProperties">
   <props>
    <prop key="mail.smtp.auth">true</prop>
    <prop key="mail.smtp.starttls.enable">true</prop>
    <prop key="mail.smtp.socketFactory.class">javax.net.ssl.SSLSocketFactory</prop>
   </props>
  </property>
 </bean>
... ...

  在spring2.0中，一共定义了5种作用域，分别是singleton、prototype、request、session、
globalSession。其中后面三种仅对WEB应用程序有效。
  spring2.0通过scope=""属性来定义Bean有作用域，而在spring1.x中，由于只有singleton 和
prototype这两种作用域，因此，spring1.x中定义Bean的作用域是通过singleton=“true|false" 来
定义的。在spring2.0中首先应该考虑用scope属性来定义Bean 的作用域。

Singleton作用域
  
  spring2.0是默认Bean的作用域是scope="singleton"。即spring的IoC容器仅为每个Bean创建一个
实例并且保持Bean的引用，换言之，每次调用getBean()方法请求返回的Bean总是同一个实例。这类似
于《设计模式》一书中的Singleton（单例）模式。

  public class Singleton {
    private static Singleton instance = new Singleton();
    private Singleton() {};
    pubilc static Singleton getInstance() {
      return instance;
    }
  }
  由于构造方法被申明为private，因此，在类的外部不可实例化该类，唯一的实例持有在静态引用中
从外部获取该实例的唯一入口是调用Singleton的静态方法Singleton.getInstance().

Prototype作用域

  如果需要每次返回Bean的新实例，即每次都新建一个实例，则可以通过设置scope="prototype"来
实现。这样我们就告诉了spring容器采用Prototype作用域。采用prototype作用域时，spring容器总会
返回一个创建的新实例，因此spring容器一旦将实例交给客户端，就不再对其进行跟踪引用了，所以
无法对prototype作用域的Bean定义destory-method,不过仍可以使用init-method。
其它三个属性值仅对WEB程序有效，这里不作讨论。

  IoC全称Inversion of Control,直译为控制反转.何谓IoC?在解释此概念之前,我们来看看下面的例子
import ...

public class BookService {
  private BookDAO bookDAO = new DbBookDAO();
  
  public List<Book> listBooks(String author) {
    List<Book> books = bookDAO.listAll();
    return books ;
  }
}

可以看到,listBooks方法的功能非常简单,即列出所有书籍.而列出所有书籍的功能被委托给bookDAO对象.
考虑到书籍可能存在多种形式,如数据库,XML文件等,将BookDAO申明为接口,因此我们实现了一个具体
子类DbBookDAO.
  现在需要考虑的是,BookService如何持有bookDAO对象.最简单的办法是,在BookService的内部持有
一个DbBookDAO的实例,上面的例子确实是这么做的.考虑一下会发现以下的问题:
(1)在BookService中硬编码创建了BookDAO,如果需要另一种BookDAO的实现,则需要修改BookService的
 代码,换句话就是BookService组件不能脱离BookDAO的具体实现.
(2)BookDAO的实例无法被其它组件共享.假设其它的组件也需要引用BookDAO,则多个组件很难共享一个
 BookDAO实例,因为该实例的生命周期定义在了BookService组件中了,从而难以共享.
(3)如果BookDAO仍需要引用其它资源,例如DataSource,则BookService可能还需要负责管理和维护一个
 DataSource,而这实例不是作为上层组件BookService的职责.
(4)测试BookService是复杂的,因为首先编写DbBookDAO,倘若DbBookDAO还依赖于DataSource,是相当复杂.
  从以上几点可以看出,如果系统中有大量的组件,其它生命周期和相互之间的依赖关系,如果由组件
自己维护,不但加大的系统的复杂度,而且会导致组件之间的极为紧密的耦合,继而给测试和维护带来了
极大的困难.
  在IoC模式下,控制权发生了反转:从应用程序转移到了IoC容器.组件不再由应用程序负责创建和配置
而是由容器负责,应用程序只需直接使用已经创建并配置好的组件.

import ...

public class BookService {
  private BookDAO bookDAO ;
  public void setBookDAO(BookDAO bookDAO) {
   this.bookDAO = bookDAO ;
  }
  
  public List<Book> listBooks(String author) {
    List<Book> books = bookDAO.listAll();
    return books ;
  }
}
修改后的bookDAO实例不再由BookService创建,而是由IoC容器负责将某个BookDAO实例通过setBookDAO()
注入.这样做的好处:
(1)BookService不必关心如何创建BookDAO的实例,也不必关心BookDAO的具体实现,只需要使用它就可以了
 因此简化了BookService的编码.
(2)BookDAO的实例由IoC容器管理,因此,可以在多个组件之间共享,只要它们也实现了相应的setBookDAO()
 方法就可以了.
(3)测试BookService也变成十分容易了.

IoC容器负责实例化所有的组件,因此需要告诉容器如何创建组件和各组件之间的依赖关系.

 spring的Ioc容器根据XML配置文件来初始化Bean.需要注意的一点是,ApplicationContext初始化Bean和基
本的BeanFactory有所不同,基本的BeanFactory总是延迟加载Bean,直到第一次调用getBean("BeanId")方法
请求Bean实例时,BeanFactory才会创建这个Bean,而ApplicationContext在自身初始化时就一次性创建了
所有的Bean,了解这一点是非常重要的,因为ApplicationContext在初始化时就能验证XML配置文件的正确性.
而使用BeanFactory,直到调用getBean("BeanId")方法获取Bean实例时,才可能会发现配置错误而导致抛出
异常.
 只有在非常简单的情况下,使用基本的BeanFactory才可能满足我们的需求.绝大多时候我们使用
ApplicationContext是最佳的选择.在启动的时候就能检测配置文件的错误,这比使用基本的BeanFactory
在运行一段时间后调用getBean("BeanId")抛出异常要好得多.并且,延迟加载会带来性能上的损失.
ApplicationContext由于在启动时需要一次性别实例化所有的Bean,如果定义的Bean比较多,则启动的时间
会比较长.

public class CharacterEncodingFilter
extends OncePerRequestFilter

Servlet 2.3/2.4 Filter that allows one to specify a character encoding for requests. This is useful because current browsers typically do not set a character encoding even if specified in the HTML page or form.

This filter can either apply its encoding if the request does not already specify an encoding, or enforce this filter's encoding in any case ("forceEncoding"="true"). In the latter case, the encoding will also be applied as default response encoding on Servlet 2.4+ containers (although this will usually be overridden by a full content type set in the view).

public interface TimeBookInterface{

 public void doAuditing(String name);
}
(2)编写接口实现类,代码如下
/*******TimeBook.java********/
package com.gc.dao.impl;

public class TimeBook implements TimeBookInterface{

 public void doAuditing(String name){
 
  //审查数据的相关程序
  ......
 }
}
(3)编写一个代理类,用来实现日志输出,其代码如下
/*******TimeBookProxy.java********/
package com.gc.dao.impl;

import org.apache.log4j.Level;
import org.apache.log4j.Logger;

public class TimeBookProxy{

 private Logger logger = Logger.getLogger(this.getClass().getName());
 private TimeBookInterface timeBookInterface;
 public TimeBookProxy(TimeBookInterface timeBookInterface){
 
  this.timeBookInterface = timeBookInterface;
 }
 //实际业务处理
 public void doAuditing(String name){
 
  logger.log(Level.INFO,name+"开始审核数据");
  timeBookInterface.doAuditing(name);
  logger.log(Level.INFO,name+"审核数据结束");
 }
}
(4)编写测试代码类
......
public static void main(String[] args){
//针对接口进行编程
 TimeBookProxy timeBookProxy = new TimeBookProxy(new TimeBook());
 timeBookProxy.doAuditing("张三");
}

 使用java的代理机制进行日志输出
(1)编写一个日志信息的代理类LogProxy,这个代理类实现了接口InvocationHandler,
 可以对任何接口实现日志信息的输出.其代理如下
package com.gc.dao;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

import org.apache.log4j.Level;
import org.apache.log4j.Logger;
//代理类实现了接口InvocationHandler
public class LogProxy implements InvocationHandler{

 private Logger logger = Logger.getLogger(this.getClass().getName());
 private Object delegate;
 //绑定对象
 public Object bing(Object delegate){
  this.delegate = delegate;
  return Proxy.new ProxyInstance(delegate.getClass().getClassLoader(),delegate.getClass().getInterfaces(),this);
 }
 //针对接口编程
 public Object invoke(Object proxy,Mehtod method,Object[] args)throws Throwable{
 
  Object result = null;
  try{
  //在方法调用前后进行日志输出
   logger.log(Level.INFO,args[0] + "开始审核数据");
   result = method.invoke(delegate,args);
   logger.log(Level.INFO,args[0] + "审核数据结束");
  }
  catch(Exception e){
   logger.log(Level.INFO,e.toString());
  }
  return result;
 }
}
(2)建立一个接口TimeBookInterface,代码如下
/*******TimeBookInterface.java********/
package com.gc.dao;

public interface TimeBookInterface{

 public void doAuditing(String name);
}
(3)编写接口实现类,代码如下
/*******TimeBook.java********/
package com.gc.dao.impl;

public class TimeBook implements TimeBookInterface{

 public void doAuditing(String name){
 
  //审查数据的相关程序
  ......
 }
}
(4)编写测试代码类
......
public static void main(String[] args){
 //实现了对日志类的重用
 LogProxy logProxy = new LogProxy();
 TimeBookInterface timeBookInterface = (TimeBookInterface)logProxy.bind(new TimeBook());
 timeBookProxy.doAuditing("张三");
}
代码来自spring从入门到精通一书

List
 <bean id="helloWorld" class="...">
  <property name="message">
   <list>
    <value>one</value>
    <value>two</value>
    <value>three</value>
   </list>
  </property>
 </bean>
Set
 <bean id="helloWorld" class="...">
  <property name="message">
   <set>
    <value>one</value>
    <value>two</value>
    <value>three</value>
   </set>
  </property>
 </bean>
Map
 <bean id="helloWorld" class="...">
  <property name="message">
   <map>
    <entry key="keytwo">
     <value>one</value>
    </entry>
    <entry key="keytwo">
     <value>two</value>
    </entry>
   </map>
  </property>
 </bean>
Properties
 <bean id="helloWorld" class="...">
  <property name="message">
   <props>
    <prop key="keyone">one</prop>
    <prop key="keytwo">two</prop>
   </props>
  </property>
 </bean>

<? xml version="1.0" encoding="gb2312" ?>
<! DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
 "http://www.springframework.org/dtd/spring-beans.dtd" >

< beans >

  < bean  id ="chinese"  class ="Chinese" >
  < property  name ="friends" >
             < list >
                 < value > 张三 </ value >
                 < value > 李四 </ value >
                 < value > 王五 </ value >
             </ list >
   </ property >
   < property  name ="score" >
             < map >
                 < entry  key ="数学" >
                     < value > 60 </ value >
                 </ entry >
                 < entry  key ="英语" >
                     < value > 70 </ value >
                 </ entry >
                 < entry  key ="语文" >
                     < value > 80 </ value >
                 </ entry >
                 < entry  key ="物理" >
                     < value > 90 </ value >
                 </ entry >
                 < entry  key ="化学" >
                     < value > 95 </ value >
                 </ entry >
             </ map >
   </ property >
   < property  name ="basicInfo" >
             < props >
                 < prop  key ="身高" > 165 </ prop >
                 < prop  key ="体重" > 45kg </ prop >
                 < prop  key ="学历" > 大学本科 </ prop >
             </ props >
    </ property >
    < property  name ="interest" >
             < set >
                 < value > 唱歌 </ value >
                 < value > 跳舞 </ value >
                 < value > 书法 </ value >
             </ set >
    </ property >

</ bean >

</ beans >

  对应的java类为:

public   class  Chinese  implements  People  {
     private  List friends  =   new  ArrayList();
     private  Map score  =   new  HashMap();
     private  Properties basicInfo  =   new  Properties();
     private  Set interest  =   new  HashSet();
     // 省略对应set方法
    .
}

import java.util.TimerTask;

public class MainTask extends TimerTask {

 @Override
 public void run() {
  // TODO Auto-generated method stub
  System.out.println("--------------执行定时任务---------------");
 }

}
------------------------------------------------------------------------------------------------------------
文件/WEB-INF/TimerConfig.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd" >
<beans>
 <!-- 注册定时执行实体 -->
 <bean id="mainTask" class="dgut.ke.timer.MainTask"></bean>
 <!-- 注册定时信息 -->
 <bean id="stTask" class="org.springframework.scheduling.timer.ScheduledTimerTask">
  <!-- 首次执行任务前需要等待2秒钟 -->
  <property name="delay">
   <value>2000</value>
  </property>
  <!-- 任务执行的周期 -->
  <property name="period">
   <value>4000</value>
  </property>
  <!-- 具体的执行任务 -->
  <property name="timerTask">
   <ref local="mainTask"/>
  </property>
 </bean>
 <!-- 配置任务调度器 -->
 <bean id="timeFactory" class="org.springframework.scheduling.timer.TimerFactoryBean">
  <!-- 注入定时器列表 -->
  <property name="scheduledTimerTasks">
   <list>
    <ref local="stTask"/>
   </list>
  </property>
 </bean>
</beans>
------------------------------------------------------------------------------------------------------------

import java.util.Calendar;

import javax.servlet.RequestDispatcher;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;

public class NotLeaveWord extends HandlerInterceptorAdapter
{
 private int startTime;
 private int endTime;
 private String interceptorPage;
  
 /*通过依赖注入*/
 public void setStartTime(int startTime) {
  this.startTime = startTime;
 }
 public void setEndTime(int endTime) {
  this.endTime = endTime;
 }
 public void setInterceptorPage(String interceptorPage) {
  this.interceptorPage = interceptorPage;
 }
 public int getStartTime() {
  return startTime;
 }
 public int getEndTime() {
  return endTime;
 }
 public String getInterceptorPage() {
  return interceptorPage;
 }
 /*进行拦截处理*/
 public boolean preHandle(HttpServletRequest request,
       HttpServletResponse response,
       Object handler)throws Exception
 {
  Calendar cal = Calendar.getInstance();
  int hour = cal.get(java.util.Calendar.HOUR_OF_DAY);
  if( hour > startTime && hour < endTime)
  {
   request.setAttribute("startTime", this.getStartTime());
   request.setAttribute("endTime", this.getEndTime());
   RequestDispatcher rd = request.getRequestDispatcher(this.getInterceptorPage());
   rd.forward(request, response);
   return false;
  }
  else
  {
   return true ;
  } 
 }
 
}
-----------------------------------------------------------------------------------------------------------------