＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

-------------------------------------------

 ---------------------------------------------

------------------------------------------

For all those out there using Spring together with Struts, i created a small howTo regarding automatic generation of relevant files, especially the boring action-servlet-xml file which must be in synch with your struts-config.xml, at least for all Struts actions which should be injected by Spring.

Lets start with the Action class:

/**

            * Action to delete a Client

            * Date: 09.02.2005

            * Time: 15:29:15

            *

            * @author Logemann - Logentis e.K. (ml@logentis.de)

            * @version $Id$

            * @struts.action path="clientDelete" validate="false"

            *            type="org.springframework.web.struts.DelegatingActionProxy"

            *            name="emptyform"

            * @struts.action-forward name="back" 

            *             path="/clientManager.html" redirect="true"

            * @spring.bean name="clientDelete"

            */

            public class ClientDeleteAction extends Action {

            

            
    ClientManager clientManagerService;
            

            

            
    /**

            

            * Spring injection

            

            *

            

            * @param clientManagerService clientManagerService

            

            * @spring.property ref="clientManagerService"

            

            */

            

            public void setClientManagerService(ClientManager clientManagerService) {

            

            this.clientManagerService = clientManagerService;

            

            }

            

            [..]

            

            
            

With this tags, the ant build target outlined below will create a struts-config.xml and the necessary action-servlet.xml needed by Spring. Lets see how the target looks:

Be sure to modify the classpath definition and the destDir values of springdoclet and webdoclet to suit your needs. Right now the Spring task only searches for Actions in order to create action-servlet.xml, if you also want to create your normal service beans like ClientManagerService, you should create another springdoclet task and output things to applicationContext.xml if you like.

But this is mostly users choice, as you know, Spring supports from one to many bean definition files and its up to you how you want to have your spring xml world.

This will be created when you run the mentioned target:

(action-servlet.xml)

(struts-config.xml)

<!DOCTYPE struts-config PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 1.1//EN" "http://jakarta.apache.org/struts/dtds/struts-config_1_1.dtd">

<struts-config>

<!-- ========== Data Sources Definitions =================================== -->
<!--
Define your Struts data sources in a file called struts-data-sources.xml and place
it in your merge directory.
-->

<!-- ========== Form Bean Definitions =================================== -->
<form-beans>

<!--
If you have non XDoclet forms, define them in a file called struts-forms.xml and
place it in your merge directory.
-->
</form-beans>

<!-- ========== Global Exceptions Definitions =================================== -->
<!--
Define your exceptions in a file called global-exceptions.xml and place
it in your merge directory.
-->

<!-- ========== Global Forward Definitions =================================== -->
<!--
Define your forwards in a file called global-forwards.xml and place
it in your merge directory.
-->

<!-- ========== Action Mapping Definitions =================================== -->
<action-mappings>
<action
path="clientDelete"
type="org.springframework.web.struts.DelegatingActionProxy"
name="emptyform"
scope="request"
unknown="false"
validate="false"
>
<forward
name="back"
path="/clientManager.html"
redirect="true"
/>
</action>

<!-- If you have non XDoclet actions, define them in a file called struts-actions.xml and place it in your merge directory. -->
</action-mappings>

<!-- Define your Struts controller in a file called struts-controller.xml and place it in your merge directory. -->

<!-- Define your Struts message-resources in a file called struts-message-resources.xml and place it in your merge directory. -->

<!-- Define your Struts plugins in a file called struts-plugins.xml and place it in your merge directory. -->

<bean id="transactionManager" //对JDBC Transaction的封装

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

       <property name="dataSource">

              <ref bean="dataSource"/>

       </property>

</bean>

<bean id="transactionManager" //对Hibernate事务的封装

       class="org.springframework.orm.hibernate.HibernateTransactionManager">

       <property name="sessionFactory">

              <ref bean="sessionFactory"/>

       </property>

</bean>

<bean id="transactionManager"//对JDO事务的封装

       class="org.springframework.orm.jdo.JdoTransactionManager">

       <property name="persistenceManagerFactory">

              <ref bean="persistenceManagerFactory"/>

       </property>

</bean>

<bean id="transactionManager" //对JTA 事务的封装

       class="org.springframework.transaction.jta.JtaTransactionManager">

       <property name="transactionManagerName">

              <value>java:/TransactionManager</value>

       </property>

</bean>

<bean id="courseService"//利用AOP，将TransactionManager和普通的Service编织起来，实现事务。

       class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">

       <property name="proxyInterfaces">//编织后对外的接口

              <list>

                     <value>com.springinaction.training.service.CourseService</value>

              </list>

       </property>

       <property name="target">//目标

              <ref bean="courseServiceTarget"/>

       </property>

       <property name="transactionManager">//植入的事务管理者

              <ref bean="transactionManager"/>

       </property>

       <property name="transactionAttributeSource">//事务的参数（隔离度，方法名等）

              <ref bean="attributeSource"/>

       </property>

</bean>

  有两种手段：1、使用HibernateTemplate；2、继承HibernateDaoSupport（实际上，HibernateDaoSupport本身就是对HibernateTemplate的一个封装）

   一切尽在代码中，查看API唉！

注意：hibernate 2.X和hibernate3.X的区别，我用的是2.X 。  
 

package com.company.example.dao;

import java.util.List;

import com.company.example.model.Student;

public interface StudentDao {

    public abstract Student getStudent(final Integer id);

    public abstract void updateStudent(Student student);

    public abstract List findStudentsByLastName(String lastName);

}

==================

package com.company.example.dao.hibernateImpl;

import java.util.List;

import net.sf.hibernate.Hibernate;

import net.sf.hibernate.HibernateException;

import net.sf.hibernate.Session;

import org.springframework.orm.hibernate.HibernateCallback;

import org.springframework.orm.hibernate.HibernateTemplate;

import com.company.example.dao.StudentDao;

import com.company.example.model.Student;

public class StudentDaoHibernate implements StudentDao {

    HibernateTemplate hibernateTemplate;

    public static void main(String[] args) {

    }

    public HibernateTemplate getHibernateTemplate() {

        return hibernateTemplate;

    }

    public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {

        this.hibernateTemplate = hibernateTemplate;

    }

    public Student getStudent(final Integer id) {

        return (Student) hibernateTemplate.execute(new HibernateCallback() {

            public Object doInHibernate(Session session)

                    throws HibernateException {

                return session.load(Student.class, id);

            }

        });

    }

    public Student getStudent2(Integer id) {

        return (Student) hibernateTemplate.load(Student.class, id);

    }

    public void updateStudent(Student student) {

        hibernateTemplate.update(student);

    }

    public List findStudentsByLastName(String lastName) {

        return hibernateTemplate.find("from Student student "

                + "where student.lastName = ?", lastName, Hibernate.STRING);

    }

public class StudentDaoHibernate extends HibernateDaoSupport

implements StudentDao {

 ...........

}
======The Spring XML Configuration===========
<?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="dataSource"
  class="org.springframework.jndi.JndiObjectFactoryBean">
  <property name="jndiName">
   <value>java:comp/env/jdbc/trainingDatasource</value>
  </property>
 </bean>
 
 <bean id="sessionFactory" class="org.springframework.orm.hibernate.LocalSessionFactoryBean">
  <property name="dataSource">
   <ref bean="dataSource"/>
  </property>
  <property name="hibernateProperties">
   <props>
    <prop key="hibernate.dialect">net.sf.hibernate.dialect.MySQLDialect</prop>
   </props>
  </property>
  <property name="mappingResources">
   <list> <!--list of each hbm.xml-->
    <value>Student.hbm.xml</value>
    <value>Course.hbm.xml</value>
   </list>
  </property>
  <property name="mappingDirectoryLocations">
   <list>
    <!--list the directory of the hbm.xml, including each xml file in the dir-->
    <value>classpath:/com/springinaction/training/model</value>
   </list>
  </property>
 </bean>
 
 <bean id="hibernateTemplate"
  class="org.springframework.orm.hibernate.HibernateTemplate">
  <property name="sessionFactory">
   <ref bean="sessionFactory"/>
  </property>
 </bean>

 <bean id="studentDao" class="com.company.example.dao.hibernateImpl.StudentDaoHibernate">
  <property name="hibernateTemplate">
   <ref bean="hibernateTemplate"/>
  </property>
 </bean>

 <bean id="courseDao" class="com.company.example.dao.hibernateImpl.CourseDaoHibernate">
  <property name="hibernateTemplate">
   <ref bean="hibernateTemplate"/>
  </property>
 </bean>
</beans>

封装所有的数据库访问实现，包括JDBC,JDO,Hibernate等。

Spring的异常一般都是RuntimeException，数据访问的根异常是DataAccessException，所有的Spring的数据访问异常都继承DataAccessException。此外DataAccessException的nestedRuntimeException子类中，已经将所有的异常栈都进行了记录。

Spring的DAO异常对所有底层的DAO访问实现层的异常进行了统一的封装，并给出了更为有意义的异常。

CleanupFailureDataAccessException：清除失败异常

DataAccessResourceFailureException：资源访问异常

DataIntegrityViolationException：完整性约束异常

DataRetrievalFailureException：数据获取异常

DeadlockLoserDataAccessException：死锁访问异常

IncorrectUpdateSemanticsDataAccessException：更新出错异常

InvalidDataAccessApiUsageException：无效数据访问API使用异常

InvalidDataAccessResourceUsageException：无效数据访问资源使用异常

OptimisticLockingFailureException：乐观锁失败异常

TypeMismatchDataAccessException：类型匹配失败异常

UncategorizedDataAccessException：其他原因异常


Spring使用Template和Callback模式完成了对底层实现的统一封装，其中Template负责完成那些通用的功能（处理事务、管理资源、处理异常），Callback则完成变化的那部分内容（创建statement、设定参数parameter、生成数据集result）。参考图4.2、4.3太重要了。

正如前面已经提到的，Introduction和前面的四个advice是有很大的区别的，introduction用于给target引入新的接口（例如锁，状态等功能），生成一个mix-in的接口。而普通的advice只是在原有接口基础上增加附加内容。

在Spring中，完成一个introduction需要三个内容：1、将要添加的新接口的定义，2、该新接口的实现，在实现的class中，必须实现Spring的IntroductionInterceptor接口（Spring in action原文有误），3、IntroductionAdvisor接口的实现。

public interface IntroductionInterceptor extends MethodInterceptor {

  boolean implementsInterface(Class intf);

java.lang.Object invoke(MethodInvocation invocation) //此方法来源于MethodInterceptor

}

其中implementsInterface方法返回一个boolean值，此方法用于判断该introduction实现是否实现了某个接口――intf参数。所有对intf接口的调用都会转发给invoke方法，由invoke方法完成相应的任务。下面给出例子（给某个类添加是否auditable功能）：

            public interface Auditable {//1、auditable接口的定义

void setLastModifiedDate(Date date);

Date getLastModifiedDate();

}

public class AuditableMixin

implements IntroductionInterceptor, Auditable {//2、auditable接口的实现，同时要实现IntroductionInterceptor接口

public boolean implementsInterface(Class intf) {

return intf.isAssignableFrom(Auditable.class);  // AuditableMixin实现了Auditable类的功能

}

public Object invoke(MethodInvocation m) throws Throwable {

if (implementsInterface(m.getMethod().getDeclaringClass())) {

//对invoke的参数m进行判断，当前的调用是否在implementsInterface范围内，即，当前的调用是否是auditable接口中的方法？

return m.getMethod().invoke(this, m.getArguments());

//这里的this就是自己，调用引入的方法（属于auditable接口的方法），这样也就给target添加了新的auditable接口。

} else {

return m.proceed();//其他方法的调用。

}

}

private Date lastModifiedDate; //实现auditable接口。

public Date getLastModifiedDate() {

return lastModifiedDate;

}

public void setLastModifiedDate(Date lastModifiedDate) {

this.lastModifiedDate = lastModifiedDate;

}

}

在Spring中，除了上面直接实现IntroductionInterceptor接口之外，还可以通过继承DelegatingIntroductionInterceptor类实现。其中DelegatingIntroductionInterceptor给出了IntroductionInterceptor接口中的两个方法（implementsInterface，invoke）的默认实现，你仅需要实现auditable接口即可。

通过跟踪Spring源代码可以发现：DelegatingIntroductionInterceptor的implementsInterface （在IntroductionInfoSupport类中）和invoke方法与上面的代码的形式基本一致。下面是利用DelegatingIntroductionInterceptor写出的AuditableMixin：

public class AuditableMixin

extends DelegatingIntroductionInterceptor implements Auditable {

private Date lastModifiedDate;

public Date getLastModifiedDate() {

return lastModifiedDate;

}

public void setLastModifiedDate(Date lastModifiedDate) {

this.lastModifiedDate = lastModifiedDate;

}      

}

    注意到一点：上面的两个AuditableMixin的实现都仅仅是给Target添加行为，但是未曾改变Target的原有行为（因为在invoke方法的实现中，还是会转发给Target）。如果需要改变Target的行为（例如给Target增加lock接口，一旦处于locked状态，那么再调用Target的方法就会出现异常），这就需要自己写代码修改invoke方法。

public class ImmutableMixin

extends DelegatingIntroductionInterceptor implements Immutable {

private boolean immutable;

public void setImmutable(boolean immutable) {

this.immutable = immutable;

}

public Object invoke(MethodInvocation mi) throws Throwable {

String name = mi.getMethod().getName();

if (immutable && name.indexOf("set") == 0) { //这里一旦已经是immutable了，那么就不可以调用setXXX方法了，这也就改变了Target的行为，而不是前面的仅增加接口。

throw new IllegalModificationException();

}

return super.invoke(mi);

}

}

Spring中的Introduction需要有自己的advisor: IntroductionAdvisor

PointCuts用于定义所需要“拦截”的class及其method。分为静态、动态两种pointcut。其中静态pointcuts仅和class name, method name相关，可以在配置文件中通过正则表达式进行部署，因此它们都可以在运行前进行确认。而动态pointcuts则需要考虑到方法的参数，在运行时动态的确认pointcuts。一般来说，都是根据method和class的名字来进行。其涉及到的接口如下定义：

public interface Pointcut {

    ClassFilter getClassFilter();

    MethodMatcher getMethodMatcher();

}

public interface ClassFilter {

    boolean matches(Class clazz);

}

public interface MethodMatcher {

    boolean matches(Method m, Class targetClass);

    boolean isRuntime();

    boolean matches(Method m, Class targetClass, Object[] args);

}

两种静态pointcut的实现：

NameMatchMethodPointcut：只能对方法名进行判别。

RegexpMethodPointcut：可以对类名、方法名使用正则表达式判别。

<beans>

       <bean id="maidServiceTarget"

              class="com.springinaction.chapter03.cleaning.MaidService"/>

       <bean id="queryInterceptor" class="com.springinaction.chapter03.cleaning.QueryInterceptor"/>

       <bean id="queryPointcutAdvisor"

              class="org.springframework.aop.support.RegExpPointcutAdvisor">

              <property name="pattern">

                     <value>.*get.+By.+</value>

              </property>

              <property name="advice">

                     <ref bean="queryInterceptor"/>

              </property>

       </bean>

       <bean id="maidService"

              class="org.springframework.aop.framework.ProxyFactoryBean">

              <property name="proxyInterfaces">

                     <value>com.springinaction.chapter03.cleaning.MaidService</value>

              </property>

              <property name="interceptorNames">

                     <list>

                            <value>queryPointcutAdvisor</value>

                     </list>

              </property>

              <property name="target">

                     <value ref="maidServiceTarget">

              </property>

       </bean>

</beans>

一种动态pointcut的实现：

ControlFlowPointcut：根据当前运行栈的情况，决定当前的advice是否需要被触发。因为它完全基于运行时栈的情况做决策，所以运行速度肯定会变慢。

<beans>

       <bean id="myServiceTarget" class="MyServiceImpl"/>

       <bean id="servletInterceptor" class="MyServletInterceptor"/>

       <bean id="servletPointcut" class="org.springframework.aop.support.ControlFlowPointcut">

              <constructor-arg>

                     <value>javax.servlet.http.HttpServlet</value>

              </constructor-arg>

       </bean>

       <bean id="servletAdvisor" class="org.springframework.aop.support.DefaultPointcutAdvisor">

              <property name="advice">

                     <ref bean="servletInterceptor"/>

              </property>

              <property name="pointcut">

                     <ref bean="servletPointcut"/>

              </property>

       </bean>

       <bean id="service" class="org.springframework.aop.framework.ProxyFactoryBean">

              <property name="proxyInterfaces">

                     <value>MyService</value>

              </property>

              <property name="interceptorNames">

                     <list>

                            <value>servletAdvisor</value>

                     </list>

              </property>

              <property name="target">

                     <value ref="myServiceTarget">

              </property>

       </bean>

</beans>

前面已经提到，advisor是是PointCut和Advice的综合体，完整描述了一个advice将会在pointcut所定义的位置被触发。也就是说，它包含了pointcut和advice两项内容，这两项内容则用于分别给出advice调用所发生的位置和发生的内容。其接口如下：

public interface PointcutAdvisor {

Pointcut getPointcut();

Advice getAdvice();

1、  around advice：所有around advice必须实现MethodInterceptor接口，注意invoke方法的参数invocation是MethodInvocation接口，在此中包含了许多信息，包括其所封装的方法及其参数，AOP proxy、Jointcut等。

public interface MethodInterceptor extends Interceptor {

                  Object invoke(MethodInvocation invocation) throws Throwable;

}

    在实现around advice时，和before advice、after advice有着两个很大的区别：1、必须在invoke方法中调用MethodInvocation.proceed()，这样才能将所有调用延续下去，调用target对象的method；2、必须自己返回一个object，该object甚至可以与target’s method的返回值不一样。

2、  before advice：在jointcut执行之前，运行advice。必须实现MethodBeforeAdvice接口。

public interface MethodBeforeAdvice extends BeforeAdvice {

    void before(Method m, Object[] args, Object target) throws Throwable;

}

3、  after advice：在jointcut执行之后，运行advice。必须实现AfterReturningAdvice接口。

public interface AfterReturningAdvice extends Advice {

    void afterReturning(Object returnValue, Method m, Object[] args, Object target)

            throws Throwable;

}

4、  throws advice：在jointcut执行出现异常的时候，运行此advice。必须实现ThrowsAdvice接口。但是此接口只是一个标识接口，必须实现此外实现下面的方法： 

afterThrowing([Method], [args], [target], subclassOfThrowable)

连接点（JoinPoint）：程序运行过程中的某个阶段点。如某个方法调用，或者某个异常被抛出。

处理逻辑（Advice）：在某个连接点所采用的处理逻辑。处理逻辑的调用模式通常有三种：

i.        Around：在连接点前后插入预处理过程和后处理过程。

ii.       Before：仅在连接点之前插入预处理过程。

iii.     After：在连接点之后进行处理。

iv.    Throw：在连接点抛出异常时进行异常处理。

切点（PointCut）：一系列连接点的集合，它指明处理方式（Advice）将在何处被触发，可以使用正则表达式表达。

Advisor：是PointCut和Advice的综合体，完整描述了一个advice将会在pointcut所定义的位置被触发。

1、  对于那些使用到有限外部资源的bean，无非必要，请尽量使其singleton

2、  init-method在Bean创建开始时调用，destory-method在销毁时调用.Spring自己提供了InitializingBean，DisposableBean.这两个接口完成这两个功能，一旦Bean对象实现了这两个接口，则无需进行任何配置，容器就会实现这两个功能。（当然，这也就使得你的应用和Spring API捆绑到了一起）

3、  Innner Bean：这样的配置使得inner bean只能被wrapper bean所引用。这点在AOP中尤其有用：BeanFactory只能访问AOProxy，而不能直接得到AOProxy所封装的target object。

4、  集合元素

<list> àjava.awt.List, arrays

<set> àjava.awt.Set

<map> àjava.awt.Map

<props> àjava.awt.Properties

5、  设置空值：<property name="foo"><null/><property>

6、  构造函数注入：用于那些必须的、final的参数。如果构造函数的参数可能引起冲突，可以在配置文件中给各参数加上type。

7、  autowiring：它会带来一定的问题，因为无论如何autowiring，都无法保证其结果一定正确，很可能会出现许多与预期不一致的地方。

在BeanFactory中，所有的bean对象的创建都是lazy的，包括那些singleton bean。只有javabean对象必须被使用的时候，才会创建该对象，才会正式的解析相应的xml标记，解析该bean的property等。但是在ApplicationContext，它可以预先载入sigleton bean，而不是直到使用时才创建。

BeanFactory最常用的实现是XmlBeanFactory，载入“定位xml”文件：

BeanFactory factory = new XmlBeanFactory(new FileInputStream("beans.xml"));

ApplicationContext有三种实现：ClassPathXmlApplicationContext，FileSystemXmlApplicationContext，XmlWebApplicationContext。其中前两者也是基于路径的，和BeanFactory的xml文件定位方式一致。

ApplicationContext context =new FileSystemXmlApplicationContext("c:/foo.xml");

ApplicationContext context = new ClassPathXmlApplicationContext("foo.xml");

BeanFactory管理Bean对象的生命周期：

1、  使用构造函数创建Bean对象

2、  Bean对象autowire被执行

3、  Bean对象调用各项setXXX方法

4、  如果该Bean实现了BeanNameAware接口，则调用该对象的setBeanName()方法，设置其ID（已经在xml配置文件中写好了）

5、  如果该Bean实现了BeanFactoryAware接口，则调用该对象的setBeanFactory()方法，传入BeanFactory对象自身

6、  如果已经配置了BeanPostProcessor，那么调用BeanPostProcessors的pre-

ProcessBeforeInitialization()方法，对该Bean对象进行处理；

7、  如果该bean自定义了init()方法，那么调用此方法

8、 如果已经配置了BeanPostProcessor，那么调用该BeanPostProcessors的post

ProcessBeforeInitialization()方法，对该Bean对象进行处理

9、  正常使用

10、              系统销毁，如果该bean对象实现了DisposableBean接口，则调用其destory()方法，

11、              最后调用用户在配置文件中编写的destroy-method

整个Web应用分为四部分

1、  单独的DAO，负责数据访问，执行CUID(create, update, insert ,delete)，完成O/R映射。不涉及任何的其他逻辑，仅执行这以上的操作，如果有唯一性检查、事务也不需要做。（可以在数据库端加一些trigger,constraint）。该层需要定义DAO接口，DAO实现(hibernate，ibaits，JDBC等)。

2、  简单的Logic Object（Java Bean），data field+setter+getter+Other Logic，可以将一些共有的操作提取到父类中，减少代码。

3、  Business Sevice，实现业务逻辑，在此使用DAO和Logic Object完成业务操作。这里当使用到DAO时，只需要IOC注入，真实对象由外界（Web容器调用Spring容器）注入。

4、  编写Action，将用户界面的操作映射到Busibess service。

使用Spring MVC的具体配置：

1、在web.xml中, 增加dispatcher的定义，配置好URL Mapping分发用户调用。

        <servlet>

           <servlet-name>action</servlet-name>

        <servlet-class>

org.springframework.web.servlet.DispatcherServlet

</servlet-class>

        <load-on-startup>1</load-on-startup>

        </servlet>

    <servlet-mapping>

            <servlet-name>action</servlet-name>

            <url-pattern>*.html</url-pattern>

    </servlet-mapping>

编写相应的action-servlet.xml

2、如果使用了多个context文件（Spring的配置文件），则需要在Web.xml中进行配置，具体如下：

<context-param>

<param-name>contextConfigLocation</param-name>

<param-value>

/WEB-INF/applicationContext1.xml

/WEB-INF/applicationContext2.xml

</param-value>

</context-param>

   其位置在“sitemesh filter”之后，但是在filter-mapping之前。

3. 增加ContextLoaderListener.

       <listener>

          <listener-class>

org.springframework.web.context.ContextLoaderListener

</listener-class>

  </listener>

对照了Spring in action,那个讲的更好哦。从spring的基础开始讲起，很不错。

Usage

Fresh Installation

1. Add Spring Beans project nature
   • select open project nodes in Eclipse resource navigator， or JDT package explorer
   •  在Eclipse的resource navigator窗口中打开项目，（或者在 JDT package explorer窗口）
   • activate context menu item "Add Spring Beans Project Nature" on selected projects -> these projects are now decorated with a small 'S' in the upper right corner (overwriting other decorators, e.g. Java project decorator 'J') 
   • 在所打开的项目中，右键项目名，选择“Add Spring Beans Project Nature”，这时该项目就会在右上角挂上了“S”. :)
2. Add references to other Spring projects
   • open project's properties dialog in Eclipse resource navigator or JDT package explorer 
   •  右键项目名，查看其properties,这就打开了"project properties"窗口
   • select the properties page "Project References" from the list 
   •  这时就可以选择 "Project References"
   • select Spring project(s) containing Spring Beans config files which are referenced from within in this project's Spring Beans config sets 
   • 选择 所依赖引用的项目
3. Add Spring Beans factory config files
   • open project's properties dialog in Eclipse resource navigator or JDT package explorer or via double-clicking a project in the Spring Beans view
   • 同样，再次打开项目的属性对话框，或者也可以打开“Spring Beans View”(这个窗口可以在window->slow view里面打开)
   • select the properties page "Spring Beans Project" from the list
   • 在项目的属性窗口中选择"Spring Beans Project"
   • use button "Add..." to open a selector dialog and select all Spring Beans config files -> added Spring Beans config files are decorated with a small 'S' in the upper right corner
   • 通过“Add”按钮选择Spring配置文件。
   • (optionally) combine config files into config sets with the second tab of the property page (use "New..." to create a new config set and select the config files; use "Move Up" and "Move Down" to change the order of the config files)
4. Open Spring Beans view
   • select from within any of the added Spring Beans config files opened in an Eclipse editor the menu item "Navigate/Show In/Spring Beans" -> Spring Beans view is opened and the corresponding Spring Beans config file is selected in the view's model
   •  Double clicking on an entry in the view navigates to the corresponding location in the config file
5. Validate Spring Beans config file
   • save any of the added Spring Beans config files from within an open Eclipse editor -> all errors occured during validation create a problem marker in Eclipse's task view
   • 保存Spring配置文件，这时就可以看到错误了 （俺没有能够在task窗口中看到，但在Bean.xml文件的编辑窗口看到了，嘻嘻～～～）
   • 另外，可以观察一下"Spring beans"那个窗口，在其上面有三个按钮，第三个是"show in property sheet", 这个功能不错哦，可以试一下。当然了，直接看xml文件也是挺好的。

6、非常好的一个功能，在Spring Beans那个窗口中添加好你的Spring配置文件之后，在其中右键你的配置文件，选择“show graph”，it's such a wonderful function~~~~

在线安装地址：  http://springframework.sourceforge.net/spring-ide/eclipse/updatesite/. 

注意哦，在安装的时候，一定要选“Spring framework”,然后才可以装“Spring IDE”(就是Beans Configuration Support啦。)