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

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

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

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

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><