sdustyongz
- 浏览: 85640 次
- 性别:
- 来自: 北京
-
文章分类
最新评论
-
ssy341：
说的简单了点，和官网的文档差不多，多文件上传也不是很好，不过可 ...
jQuery插件AjaxFileUpload文件上传实现Javascript多文件上传功能 -
蓝凝幽偌：
有没有jar包？
org.apache.commons.net.ftp.FTPClient 的简单用法 -
tinguo002：
在这里缓缓走过，很为楼主钻研精神感动，也感谢楼主分享。
关于Struts2资源文件的配置
转载于：http://blog.csdn.net/java_min/article/details/4427523
我们都知道spring提供两种管理事务的方式，一种是声明式事务，一种是编程式事务。
Spring的声明式事务管理，基于Spring的AOP，不再需要不停地写commit，rollback，（但Spring仍然没有放弃编程式的事务管理策略）。
Spring的编程式事务管理，为我们提供了一个TransactionTemplate，使用回调机制，将应用代码从样板式的资源获取和释放代码中解放出来，不再有大量的try/catch/finally/try/catch代码块。
这两种事务处理方式都非常地优雅，它不需要与任何特定的事务API耦合，并支持多种持久层方案。
（1）声明式事务：基于Spring AOP实现，几乎就是xml文件的配置
（2）编程式事务：统一的事务编码风格，几乎是一个模板化的。
以下将对这两种事务管理方式进行探讨：
首先探讨一下声明式事务：
我们知道Spring事务管理的核心接口是：
org.springframework.transaction.PlatformTransactionManager
它定义了三个待实现的方法：
（1）public TransactionStatus getTransaction(TransactionDefinition definition);
//返回当前活动的事务或根据相应的行为创建一个新的事务（可以查阅API理解）
（2）public void commit(TransactionStatus status);//提交事务
（3）public void rollback(TransactionStatus status); //回滚事务
PlatformTransactionManager是一个与特定平台无关的事务操作接口，不同的底层事务平台应通过Spring的Ioc注入相应的事务操作实现类 (这些实现类也不需要我们去完成，Spring已经为我们提供了)。那么我们来看看针对不同的底层持久化平台，我们需要为PlatformTransactionManager接口注入何种实现类：
Xml代码
（1）利用JDBC作为持久层的局部事务：
<?xml version="1.0" encoding="utf-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
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">
<!-- 定义数据源Bean，使用C3P0数据源 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy- method="close">
<!-- 指定连接数据库的驱动 -->
<property name="driverClass" value="com.mysql.jdbc.Driver"/>
<!-- 指定连接数据库的URL -->
<property name="jdbcUrl" value="jdbc:mysql:3306//127.0.0.1/ssh"/>
<!-- 指定连接数据库的用户名 -->
<property name="user" value="root"/>
<!-- 指定连接数据库的密码 -->
<property name="password" value="123"/>
<!-- 指定连接数据库连接池的最大连接数 -->
<property name="maxPoolSize" value="40"/>
<!-- 指定连接数据库连接池的最小连接数 -->
<property name="minPoolSize" value="1"/>
<!-- 指定连接数据库连接池的初始化连接数 -->
<property name="initialPoolSize" value="1"/>
<!-- 指定连接数据库连接池的连接最大空闲时间 -->
<property name="maxIdleTime" value="20"/>
</bean>
<!—定义JDBC数据源的局部事务管理器 -->
<!-- 使用DataSourceTransactionManager类，该类实现PlatformTransactionManager接口 ，是针对采用数据源连接的特定实现 -->
<bean id="transactionManager"
class="org.springframework.jdbc.datasource.
DataSourceTransactionManager">
<!—DataSourceTransactionManager需要注入一个DataSource的引用-->
<property name="dataSource" ref="dataSource"/>
</bean>
</beans>
（2）利用Hibernate作为持久层的局部事务：
<?xml version="1.0" encoding="utf-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
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">
<!-- 定义数据源Bean，使用C3P0数据源 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.
ComboPooledDataSource" destroy-method="close">
<!-- 指定连接数据库的驱动 -->
<property name="driverClass" value="com.mysql.jdbc.Driver"/>
<!-- 指定连接数据库的URL -->
<property name="jdbcUrl" value="jdbc:mysql:3306//127.0.0.1/ssh"/>
<!-- 指定连接数据库的用户名 -->
<property name="user" value="root"/>
<!-- 指定连接数据库的密码 -->
<property name="password" value="123"/>
<!-- 指定连接数据库连接池的最大连接数 -->
<property name="maxPoolSize" value="40"/>
<!-- 指定连接数据库连接池的最小连接数 -->
<property name="minPoolSize" value="1"/>
<!-- 指定连接数据库连接池的初始化连接数 -->
<property name="initialPoolSize" value="1"/>
<!-- 指定连接数据库连接池的连接最大空闲时间 -->
<property name="maxIdleTime" value="20"/>
</bean>
<!-- 定义Hibernate的SessionFactory -->
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.
LocalSessionFactoryBean">
<!-- 注入SessionFactory所需的数据源 -->
<property name="dataSource" ref="dataSource"/>
<!--列出全部映射文件 -->
<property name="mappingResources">
<list>
<!--列出所有的PO映射文件 -->
<value>org/hnylj/vo/User.hbm.xml</value>
</list>
</property>
<!-- 定义Hibernate的SessionFactory属性 -->
<property name="hibernateProperties">
<props>
<!-- 指定Hibernate的连接方言 -->
<prop key="hibernate.dialect">org.hibernate.dialect.
MySQLDialect</prop>
</property>
</bean>
<!-- 配置Hibernate的局部事务管理器 -->
<!-- 使用HibernateTransactionManager类，该类实现PlatformTransactionManager
接口，是针对采用Hibernate持久化连接的特定实现 -->
<bean id="transactionManager"
class="org.springframework.orm.hibernate3.
HibernateTransactionManager">
<!--注入一个SessionFactorybean的引用 -->
<property name="sessionFactory" ref="sessionFactory"/>
</bean>
</beans>
（3）利用Hibernate作为持久层的全局事务：
<?xml version="1.0" encoding="utf-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
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">
<!—定义JNDI数据源Bean -->
<bean id="dataSource" class="org.springframework.jndi.
JndiObjectFactoryBean">
<!-- 容器管理数据源的JNDI -->
<property name="jndiName" value="jdbc/jtest"/>
</bean>
<!--定义Hibernate的SessionFactory -->
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.
LocalSessionFactoryBean">
<!-- 注入SessionFactory所需的数据源-->
<property name="dataSource" ref="dataSource"/>
<!--列出全部映射文件 -->
<property name="mappingResources">
<list>
<!-- 列出所有的PO映射文件 -->
<value>org/hnylj/vo/User.hbm.xml</value>
</list>
</property>
<!-- 定义Hibernate的SessionFactory的属性 -->
<property name="hibernateProperties">
<props>
<!-- 指定Hibernate的连接方言 -->
<prop key="hibernate.dialect">org.hibernate.dialect.
MySQLDialect</prop>
</property>
</bean>
<!-- 使用JtaTransactionManager类，该类实现PlatformTransactionManager接口-->
<!-- JtaTransactionManager不需要知道数据源，或任何其他特定资源，
因为使用容器的全局事务管理 -->
<bean id="transactionManager"
class="org.springframework.transaction.jta.
JtaTransactionManager" />
</beans>
[xml] view plaincopy
（1）利用JDBC作为持久层的局部事务：
<?xml version="1.0" encoding="utf-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
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">
<!-- 定义数据源Bean，使用C3P0数据源 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy- method="close">
<!-- 指定连接数据库的驱动 -->
<property name="driverClass" value="com.mysql.jdbc.Driver"/>
<!-- 指定连接数据库的URL -->
<property name="jdbcUrl" value="jdbc:mysql:3306//127.0.0.1/ssh"/>
<!-- 指定连接数据库的用户名 -->
<property name="user" value="root"/>
<!-- 指定连接数据库的密码 -->
<property name="password" value="123"/>
<!-- 指定连接数据库连接池的最大连接数 -->
<property name="maxPoolSize" value="40"/>
<!-- 指定连接数据库连接池的最小连接数 -->
<property name="minPoolSize" value="1"/>
<!-- 指定连接数据库连接池的初始化连接数 -->
<property name="initialPoolSize" value="1"/>
<!-- 指定连接数据库连接池的连接最大空闲时间 -->
<property name="maxIdleTime" value="20"/>
</bean>
<!—定义JDBC数据源的局部事务管理器 -->
<!-- 使用DataSourceTransactionManager类，该类实现PlatformTransactionManager接口 ，是针对采用数据源连接的特定实现 -->
<bean id="transactionManager"
class="org.springframework.jdbc.datasource.
DataSourceTransactionManager">
<!—DataSourceTransactionManager需要注入一个DataSource的引用-->
<property name="dataSource" ref="dataSource"/>
</bean>
</beans>
（2）利用Hibernate作为持久层的局部事务：
<?xml version="1.0" encoding="utf-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
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">
<!-- 定义数据源Bean，使用C3P0数据源 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.
ComboPooledDataSource" destroy-method="close">
<!-- 指定连接数据库的驱动 -->
<property name="driverClass" value="com.mysql.jdbc.Driver"/>
<!-- 指定连接数据库的URL -->
<property name="jdbcUrl" value="jdbc:mysql:3306//127.0.0.1/ssh"/>
<!-- 指定连接数据库的用户名 -->
<property name="user" value="root"/>
<!-- 指定连接数据库的密码 -->
<property name="password" value="123"/>
<!-- 指定连接数据库连接池的最大连接数 -->
<property name="maxPoolSize" value="40"/>
<!-- 指定连接数据库连接池的最小连接数 -->
<property name="minPoolSize" value="1"/>
<!-- 指定连接数据库连接池的初始化连接数 -->
<property name="initialPoolSize" value="1"/>
<!-- 指定连接数据库连接池的连接最大空闲时间 -->
<property name="maxIdleTime" value="20"/>
</bean>
<!-- 定义Hibernate的SessionFactory -->
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.
LocalSessionFactoryBean">
<!-- 注入SessionFactory所需的数据源 -->
<property name="dataSource" ref="dataSource"/>
<!--列出全部映射文件 -->
<property name="mappingResources">
<list>
<!--列出所有的PO映射文件 -->
<value>org/hnylj/vo/User.hbm.xml</value>
</list>
</property>
<!-- 定义Hibernate的SessionFactory属性 -->
<property name="hibernateProperties">
<props>
<!-- 指定Hibernate的连接方言 -->
<prop key="hibernate.dialect">org.hibernate.dialect.
MySQLDialect</prop>
</property>
</bean>
<!-- 配置Hibernate的局部事务管理器 -->
<!-- 使用HibernateTransactionManager类，该类实现PlatformTransactionManager
接口，是针对采用Hibernate持久化连接的特定实现 -->
<bean id="transactionManager"
class="org.springframework.orm.hibernate3.
HibernateTransactionManager">
<!--注入一个SessionFactorybean的引用 -->
<property name="sessionFactory" ref="sessionFactory"/>
</bean>
</beans>
（3）利用Hibernate作为持久层的全局事务：
<?xml version="1.0" encoding="utf-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
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">
<!—定义JNDI数据源Bean -->
<bean id="dataSource" class="org.springframework.jndi.
JndiObjectFactoryBean">
<!-- 容器管理数据源的JNDI -->
<property name="jndiName" value="jdbc/jtest"/>
</bean>
<!--定义Hibernate的SessionFactory -->
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.
LocalSessionFactoryBean">
<!-- 注入SessionFactory所需的数据源-->
<property name="dataSource" ref="dataSource"/>
<!--列出全部映射文件 -->
<property name="mappingResources">
<list>
<!-- 列出所有的PO映射文件 -->
<value>org/hnylj/vo/User.hbm.xml</value>
</list>
</property>
<!-- 定义Hibernate的SessionFactory的属性 -->
<property name="hibernateProperties">
<props>
<!-- 指定Hibernate的连接方言 -->
<prop key="hibernate.dialect">org.hibernate.dialect.
MySQLDialect</prop>
</property>
</bean>
<!-- 使用JtaTransactionManager类，该类实现PlatformTransactionManager接口-->
<!-- JtaTransactionManager不需要知道数据源，或任何其他特定资源，
因为使用容器的全局事务管理 -->
<bean id="transactionManager"
class="org.springframework.transaction.jta.
JtaTransactionManager" />
</beans>
在上面的配置中，对于采用jdbc，hibernate等，我们只要提供相应的PlatformTransactionManager实现类即可。可见Spring对事务的操作仅仅修改一下配置文件，不需要修改任何实际的代码，就可以在不同的事务管理策略之间切换，非常地方便，Spring为我们提供了高度的解耦。
以上就是我们在spring中处理事务所需要的事务管理器的配置，那么在具体的业务处理bean中我们如何控制事务呢？
一般都推荐事务最好做在service层，底层的dao可以不考虑事务，有时设计得不好可能会出现事务的嵌套，增加程序复杂度。而且将事务的处理放在service层中进行，对于我们异常体系的设计也带来好处，service层抛出的异常可以在web捕获，并将异常信息在web页面给用户提示。所以接下来我们就将在service层开始事务，提交事务，回滚事务等。作为声明式事务管理，spring已经帮我们做好了这一切，基本上就是代理模式。
以下就是Spring提供的4种事务代理方式：
1.使用TransactionProxyFactoryBean为目标bean生成事务代理，此方式是最传统，也是配置文件最臃肿的一种方式。
2.使用bean继承的事务代理方式，此方式比较简洁，但依然是增量式配置，bean越多配置文件越臃肿。
3.使用BeanNameAutoProxyCreator，根据bean name自动生成事务代理的方式，这是直接利用Spring的AOP框架配置事务代理的方式，需要对Spring的AOP框架有所了解，但也不必成为AOP专家，这种方式避免了增量式配置，也是推荐的方式。
4.使用DefaultAdvisorAutoProxyCreator，这也是直接利用Spring的AOP框架配置事务代理的方式，只是这种配置方式的可读性不如第三种方式。
对于第一种：使用TransactionProxyFactoryBean为目标bean生成事务代理：
因为TransactionProxyFactoryBean产生的是代理Bean，所以我们在配置TransactionProxyFactoryBean时，需要指定目标Bean。每个TransactionProxyFactoryBean为一个目标Bean生成事务代理，事务代理的方法改写了目标Bean的方法，就是在目标Bean的方法执行之前加入开始事务，在目标Bean的方法正常结束之前提交事务，如果遇到特定异常则回滚事务。TransactionProxyFactoryBean创建事务代理时，需要了解当前事务所处的环境，该环境属性通过PlatformTransactionManager实例传入，而相关事务传入规则在TransactionProxyFactoryBean的定义中给出。
下面该方法的配置方式：
Xml代码
<?xml version="1.0" encoding="utf-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
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">
<!-- 定义数据源Bean，使用C3P0数据源 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.
ComboPooledDataSource" destroy-method="close">
<!-- 指定连接数据库的驱动 -->
<property name="driverClass" value="com.mysql.jdbc.Driver"/>
<!-- 指定连接数据库的URL -->
<property name="jdbcUrl" value="jdbc:mysql:3306//127.0.0.1/ssh"/>
<!-- 指定连接数据库的用户名 -->
<property name="user" value="root"/>
<!-- 指定连接数据库的密码 -->
<property name="password" value="123"/>
<!-- 指定连接数据库连接池的最大连接数 -->
<property name="maxPoolSize" value="40"/>
<!-- 指定连接数据库连接池的最小连接数 -->
<property name="minPoolSize" value="1"/>
<!-- 指定连接数据库连接池的初始化连接数 -->
<property name="initialPoolSize" value="1"/>
<!-- 指定连接数据库连接池的连接最大空闲时间 -->
<property name="maxIdleTime" value="20"/>
</bean>
<!-- 定义Hibernate的SessionFactory -->
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.
LocalSessionFactoryBean">
<!-- 注入SessionFactory所需的数据源-->
<property name="dataSource" <refref="dataSource"/>
<!--列出全部映射文件 -->
<property name="mappingResources">
<list>
<!--列出所有的PO映射文件 -->
<value>org/hnylj/vo/User.hbm.xml</value>
</list>
</property>
<!-- 定义Hibernate的SessionFactory属性 -->
<property name="hibernateProperties">
<props>
<!-- 指定Hibernate的连接方言 -->
<prop key="hibernate.dialect">org.hibernate.dialect.
MySQLDialect</prop>
</props>
</property>
</bean>
<!-- 配置DAO Bean -->
<bean id="userDAO" class="org.hnylj.dao.impl.UserDaoImpl">
<property name="sessionFactory">
<ref bean="sessionFactory" />
</property>
</bean>
<!-- 配置Service Bean，该Bean将作为目标Bean使用 -->
<bean id="userServiceTarget" class="org.hnylj.service.impl.UserServiceImpl">
<!-- 依赖注入userDAO的引用 -->
<property name="userDAO" ref="userDAO"/>
</bean>
<!-- 配置Hibernate的事务管理器 -->
<!-- 使用HibernateTransactionManager类，该类实现PlatformTransactionManager
接口，针对采用Hibernate持久化连接的特定实现 -->
<bean id="transactionManager"
class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<!-- HibernateTransactionManager Bean，它需要依赖注入一个SessionFactory
Bean的引用 -->
<property name="sessionFactory" ref="sessionFactory"/>
</bean>
<!-- 配置userServiceTarget Bean的事务代理 -->
<bean id="userService"
class="org.springframework.transaction.interceptor.
TransactionProxyFactoryBean">
<!-- 依赖注入PlatformTransactionManager的bean引用，此处使用
Hibernate的bean -->
<!-- 局部事务器，传入Hibernate事务管理器的引用 -->
<property name="transactionManager" ref="transactionManager"/>
<!-- 需要生成代理的目标bean -->
<property name="target" ref="userServiceTarget"/>
<!-- 指定事务属性 -->
<property name="transactionAttributes">
<props>
<!-- 以下部分为定义事务回滚规则 -->
<prop key="insert*">PROPAGATION_REQUIRED,-MyCheckedException</prop>
<prop key="update*">PROPAGATION_REQUIRED</prop>
<prop key="*">PROPAGATION_REQUIRED,readOnly</prop>
</props>
</property>
</bean>
</beans>
[xml] view plaincopy
<?xml version="1.0" encoding="utf-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
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">
<!-- 定义数据源Bean，使用C3P0数据源 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.
ComboPooledDataSource" destroy-method="close">
<!-- 指定连接数据库的驱动 -->
<property name="driverClass" value="com.mysql.jdbc.Driver"/>
<!-- 指定连接数据库的URL -->
<property name="jdbcUrl" value="jdbc:mysql:3306//127.0.0.1/ssh"/>
<!-- 指定连接数据库的用户名 -->
<property name="user" value="root"/>
<!-- 指定连接数据库的密码 -->
<property name="password" value="123"/>
<!-- 指定连接数据库连接池的最大连接数 -->
<property name="maxPoolSize" value="40"/>
<!-- 指定连接数据库连接池的最小连接数 -->
<property name="minPoolSize" value="1"/>
<!-- 指定连接数据库连接池的初始化连接数 -->
<property name="initialPoolSize" value="1"/>
<!-- 指定连接数据库连接池的连接最大空闲时间 -->
<property name="maxIdleTime" value="20"/>
</bean>
<!-- 定义Hibernate的SessionFactory -->
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.
LocalSessionFactoryBean">
<!-- 注入SessionFactory所需的数据源-->
<property name="dataSource" <refref="dataSource"/>
<!--列出全部映射文件 -->
<property name="mappingResources">
<list>
<!--列出所有的PO映射文件 -->
<value>org/hnylj/vo/User.hbm.xml</value>
</list>
</property>
<!-- 定义Hibernate的SessionFactory属性 -->
<property name="hibernateProperties">
<props>
<!-- 指定Hibernate的连接方言 -->
<prop key="hibernate.dialect">org.hibernate.dialect.
MySQLDialect</prop>
</props>
</property>
</bean>
<!-- 配置DAO Bean -->
<bean id="userDAO" class="org.hnylj.dao.impl.UserDaoImpl">
<property name="sessionFactory">
<ref bean="sessionFactory" />
</property>
</bean>
<!-- 配置Service Bean，该Bean将作为目标Bean使用 -->
<bean id="userServiceTarget" class="org.hnylj.service.impl.UserServiceImpl">
<!-- 依赖注入userDAO的引用 -->
<property name="userDAO" ref="userDAO"/>
</bean>
<!-- 配置Hibernate的事务管理器 -->
<!-- 使用HibernateTransactionManager类，该类实现PlatformTransactionManager
接口，针对采用Hibernate持久化连接的特定实现 -->
<bean id="transactionManager"
class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<!-- HibernateTransactionManager Bean，它需要依赖注入一个SessionFactory
Bean的引用 -->
<property name="sessionFactory" ref="sessionFactory"/>
</bean>
<!-- 配置userServiceTarget Bean的事务代理 -->
<bean id="userService"
class="org.springframework.transaction.interceptor.
TransactionProxyFactoryBean">
<!-- 依赖注入PlatformTransactionManager的bean引用，此处使用
Hibernate的bean -->
<!-- 局部事务器，传入Hibernate事务管理器的引用 -->
<property name="transactionManager" ref="transactionManager"/>
<!-- 需要生成代理的目标bean -->
<property name="target" ref="userServiceTarget"/>
<!-- 指定事务属性 -->
<property name="transactionAttributes">
<props>
<!-- 以下部分为定义事务回滚规则 -->
<prop key="insert*">PROPAGATION_REQUIRED,-MyCheckedException</prop>
<prop key="update*">PROPAGATION_REQUIRED</prop>
<prop key="*">PROPAGATION_REQUIRED,readOnly</prop>
</props>
</property>
</bean>
</beans>
关于以上配置文件的几个事务传播规则可以查阅相应的API
程序面向UserServiceImpl类所实现的接口编程，事务处理由Spring为UserServiceImpl类所实现的接口IUserService生成的代理bean来完成。（Spring不仅支持对接口的代理，Spring结合CGLIB还可以为具体类生成代理，在此不做讨论）
对于第二种：采用bean继承的事务代理
仔细观察第一种配置方式，我们可以发现，如果配置文件中有多个这样的事务代理Bean，配置文件将变得非常臃肿。所以可以使用Bean继承来简化事务代理的配置。考虑到所有事务代理Bean中，事务代理Bean所使用的事务管理器和事务传播规则大致是相同的,所以我们可以定义一个事务代理bean的模板。
即：
Xml代码
<!-- 定义所有事务代理Bean的模板 -->
<bean id="txProxyTemplate" abstract="true"
class="org.springframework.transaction.interceptor.
TransactionProxyFactoryBean">
<!-- 为事务代理Bean注入生成代理所需的PlatformTransactionManager实例 -->
<property name="transactionManager" ref="transactionManager"/>
<!-- 定义生成事务代理通用的事务属性 -->
<property name="transactionAttributes">
<props>
<!-- 所有的方法都应用PROPAGATION_REQUIRED的事务传播规则 -->
<prop key="*">PROPAGATION_REQUIRED</prop>
</props>
</property>
</bean>
[xml] view plaincopy
<!-- 定义所有事务代理Bean的模板 -->
<bean id="txProxyTemplate" abstract="true"
class="org.springframework.transaction.interceptor.
TransactionProxyFactoryBean">
<!-- 为事务代理Bean注入生成代理所需的PlatformTransactionManager实例 -->
<property name="transactionManager" ref="transactionManager"/>
<!-- 定义生成事务代理通用的事务属性 -->
<property name="transactionAttributes">
<props>
<!-- 所有的方法都应用PROPAGATION_REQUIRED的事务传播规则 -->
<prop key="*">PROPAGATION_REQUIRED</prop>
</props>
</property>
</bean>
接下来让真正的事务代理Bean继承上面的事务模板Bean
Xml代码
<!-- 让事务代理Bean继承模板Bean -->
<bean id="userService" parent="txProxyTemplate">
<!-- 这里是嵌套Bean的配置方式 -->
<property name="target">
<bean class="org.hnylj.service.impl.userServiceImpl"/>
</property>
</bean>
[xml] view plaincopy
<!-- 让事务代理Bean继承模板Bean -->
<bean id="userService" parent="txProxyTemplate">
<!-- 这里是嵌套Bean的配置方式 -->
<property name="target">
<bean class="org.hnylj.service.impl.userServiceImpl"/>
</property>
</bean>
我们知道,继承中子类可以复写父类的方法，这里也一样，子Bean重新定义事务属性将覆盖事务代理模板里的事务属性定义：
即：
Xml代码 <!-- 让事务代理bean继承模板Bean -->
<bean id="userService" parent="txProxyTemplate">
<!-- 这里引用已存在的bean的方式来定义目标Bean -->
<property name="target" ref ="userServiceTarget"/>
<!-- 覆盖事务代理模板bean中的事务属性定义 -->
<property name="transactionAttributes">
<props>
<prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>
<prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>
<prop key="load*">PROPAGATION_REQUIRED,readOnly</prop>
</props>
</property>
</bean>
[xml] view plaincopy
<!-- 让事务代理bean继承模板Bean -->
<bean id="userService" parent="txProxyTemplate">
<!-- 这里引用已存在的bean的方式来定义目标Bean -->
<property name="target" ref ="userServiceTarget"/>
<!-- 覆盖事务代理模板bean中的事务属性定义 -->
<property name="transactionAttributes">
<props>
<prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>
<prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>
<prop key="load*">PROPAGATION_REQUIRED,readOnly</prop>
</props>
</property>
</bean>
可见，采用Bean继承方式定义事务代理的方式，可以很好地简化事务代理的配置，可以避免配置事务代理Bean时的冗余配置。
对于第三种：使用BeanNameAutoProxyCreator
使用BeanNameAutoProxyCreator来创建代理时，并不一定是创建事务代理，关键在于传入的拦截器，如果传入事务拦截器，将可自动生成事务代理。
下面是使用BeanNameAutoProxyCreator自动生成事务代理的配置方式：
[xml] view plaincopy
<?xml version="1.0" encoding="utf-8"?>
<!-- 指定Spring配置文件的根元素，以及相应的Schema信息 -->
<beans xmlns="http://www.springframework.org/schema/beans"
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">
<!-- 定义数据源Bean，使用C3P0数据源实现 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.
ComboPooledDataSource" destroy-method="close">
<!-- 指定连接数据库的驱动 -->
<property name="driverClass" value="com.mysql.jdbc.Driver"/>
<!-- 指定连接数据库的URL -->
<property name="jdbcUrl" value="jdbc:mysql:3306/127.0.0.1/ssh"/>
<!-- 指定连接数据库的用户名 -->
<property name="user" value="root"/>
<!-- 指定连接数据库的密码 -->
<property name="password" value="123"/>
<!-- 指定连接数据库连接池的最大连接数 -->
<property name="maxPoolSize" value="40"/>
<!-- 指定连接数据库连接池的最小连接数 -->
<property name="minPoolSize" value="1"/>
<!-- 指定连接数据库连接池的初始化连接数 -->
<property name="initialPoolSize" value="1"/>
<!-- 指定连接数据库连接池的连接最大空闲时间 -->
<property name="maxIdleTime" value="20"/>
</bean>
<!-- 使用JDBC的局部事务策略 -->
<bean id="transactionManager"
class="org.springframework.jdbc.datasource.DataSource-
TransactionManager">
<!-- 为事务管理器注入所需的数据源Bean -->
<property name="dataSource" ref="dataSource"/>
</bean>
<!-- 配置目标Bean，该目标Bean将由Bean后处理器自动生成代理 -->
<bean id="userBean" class="org.hnylj.service.impl.UserServiceImpl">
<!-- 依赖注入目标Bean所必需的数据源Bean -->
<property name="userDAO">
<ref bean="userDAO" />
</property>
</bean>
<!-- 配置目标Bean，该目标Bean将由Bean后处理器自动生成代理 -->
<bean id="personBean" class="org.hnylj.service.impl.PersonServiceImpl">
<!-- 依赖注入目标Bean所必需的数据源Bean -->
<property name="personDAO">
<ref bean="personDAO" />
</property>
</bean>
<!-- 配置事务拦截器Bean -->
<bean id="transactionInterceptor"
class="org.springframework.transaction.interceptor.
TransactionInterceptor">
<!-- 事务拦截器bean需要依赖注入一个事务管理器 -->
<property name="transactionManager" ref="transactionManager"/>
<property name="transactionAttributes">
<!-- 下面定义事务传播属性 -->
<props>
<prop key="insert*">PROPAGATION_REQUIRED</prop>
<prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>
<prop key="*">PROPAGATION_REQUIRED</prop>
</props>
</property>
</bean>
<!-- 定义BeanNameAutoProxyCreator的Bean后处理器 -->
<bean class="org.springframework.aop.framework.autoproxy.
BeanNameAutoProxyCreator">
<!-- 指定对满足哪些bean name的bean自动生成业务代理 -->
<property name="beanNames">
<!-- 下面是所有需要自动创建事务代理的Bean -->
<list>
<value>userBean</value>
<value>personBean</value>
</list>
<!-- 此处可增加其他需要自动创建事务代理的Bean -->
</property>
<!-- 下面定义BeanNameAutoProxyCreator所需的拦截器 -->
<property name="interceptorNames">
<list>
<value>transactionInterceptor</value>
<!-- 此处可增加其他新的Interceptor -->
</list>
</property>
</bean>
</beans>
如果配置文件中仅有两个目标Bean，可能不能很清楚地看出这种自动创建代理配置方式的优势，但如果有更多目标Bean需要自动创建事务代理，则可以很好地体会到这种配置方式的优势：配置文件只需要简单地配置目标Bean，然后在BeanNameAutoProxyCreator配置中增加一行即可。
对于第四种：DefaultAdvisorAutoProxyCreator：
这种配置方式与BeanNameAutoProxyCreator自动创建代理的方式非常相似，都是使用bean后处理器为目标bean生成事务代理，区别是前者使用事务拦截器创建代理，后者需要使用Advisor创建事务代理。事实上，采用DefaultAdvisorAutoProxyCreator的事务代理配置方式更加简洁，这个代理生成器自动搜索Spring容器中的Advisor，并为容器中所有的bean创建代理。相对前一种方式，这种方式的可读性不如前一种直观。
使用DefaultAdvisorAutoProxyCreator的配置方式：
[xml] view plaincopy
<?xml version="1.0" encoding="utf-8"?>
<!-- 指定Spring配置文件的根元素，以及相应的Schema信息 -->
<beans xmlns="http://www.springframework.org/schema/beans"
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">
<!-- 定义数据源Bean，使用C3P0数据源实现 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.
ComboPooledDataSource" destroy-method="close">
<!-- 指定连接数据库的驱动 -->
<property name="driverClass" value="com.mysql.jdbc.Driver"/>
<!-- 指定连接数据库的URL -->
<property name="jdbcUrl" value="jdbc:mysql:3306/127.0.0.1/ssh"/>
<!-- 指定连接数据库的用户名 -->
<property name="user" value="root"/>
<!-- 指定连接数据库的密码 -->
<property name="password" value="123"/>
<!-- 指定连接数据库连接池的最大连接数 -->
<property name="maxPoolSize" value="40"/>
<!-- 指定连接数据库连接池的最小连接数 -->
<property name="minPoolSize" value="1"/>
<!-- 指定连接数据库连接池的初始化连接数 -->
<property name="initialPoolSize" value="1"/>
<!-- 指定连接数据库连接池的连接最大空闲时间 -->
<property name="maxIdleTime" value="20"/>
</bean>
<!--定义一个hibernate的SessionFactory-->
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<!-- 定义SessionFactory必须注入DataSource-->
<property name="dataSource"><ref local="dataSource"/></property>
<property name="mappingResources">
<list>
<!--列出所有的PO映射文件-->
<value>org/hnylj/vo/User.hbm.xml</value>
</list>
</property>
<property name="hibernateProperties">
<props>
<!--定义hibernate的SessionFactory的属性-->
<prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
</props>
</property>
</bean>
<!-- 定义hibernate的局部事务管理器-->
<bean id="transactionManager"
class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<!-- 注入SessionFactory bean的引用-->
<property name="sessionFactory"><ref local="sessionFactory"/></property>
</bean>
<!-- 配置事务拦截器-->
<bean id="transactionInterceptor"
class="org.springframework.transaction.interceptor.TransactionInterceptor">
<!-- 事务拦截器bean需要依赖注入一个事务管理器 -->
<property name="transactionManager" ref="transactionManager"/>
<property name="transactionAttributes">
<!-- 下面定义事务传播属性-->
<props>
<prop key="insert*">PROPAGATION_REQUIRED</prop>
<prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>
<prop key="*">PROPAGATION_REQUIRED</prop>
</props>
</property>
</bean>
<!-- 定义事务Advisor-->
<bean class="org.springframework.transaction.interceptor.TransactionAttributeSourceAdvisor">
<!-- 定义advisor时，必须传入Interceptor-->
<property name="transactionInterceptor" ref="transactionInterceptor"/>
</bean>
<!-- DefaultAdvisorAutoProxyCreator搜索容器中的 advisor,并为每个bean创建代理 -->
<bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"/>
<!--定义DAO Bean ,由BeanNameAutoProxyCreator自动生成事务代理-->
<bean id="userService" class="org.hnylj.service.impl.UserServiceImpl">
<property name="userDAO"><ref local="userDAO"/></property>
</bean>
</beans>
我们都知道spring提供两种管理事务的方式，一种是声明式事务，一种是编程式事务。
Spring的声明式事务管理，基于Spring的AOP，不再需要不停地写commit，rollback，（但Spring仍然没有放弃编程式的事务管理策略）。
Spring的编程式事务管理，为我们提供了一个TransactionTemplate，使用回调机制，将应用代码从样板式的资源获取和释放代码中解放出来，不再有大量的try/catch/finally/try/catch代码块。
这两种事务处理方式都非常地优雅，它不需要与任何特定的事务API耦合，并支持多种持久层方案。
（1）声明式事务：基于Spring AOP实现，几乎就是xml文件的配置
（2）编程式事务：统一的事务编码风格，几乎是一个模板化的。
以下将对这两种事务管理方式进行探讨：
首先探讨一下声明式事务：
我们知道Spring事务管理的核心接口是：
org.springframework.transaction.PlatformTransactionManager
它定义了三个待实现的方法：
（1）public TransactionStatus getTransaction(TransactionDefinition definition);
//返回当前活动的事务或根据相应的行为创建一个新的事务（可以查阅API理解）
（2）public void commit(TransactionStatus status);//提交事务
（3）public void rollback(TransactionStatus status); //回滚事务
PlatformTransactionManager是一个与特定平台无关的事务操作接口，不同的底层事务平台应通过Spring的Ioc注入相应的事务操作实现类 (这些实现类也不需要我们去完成，Spring已经为我们提供了)。那么我们来看看针对不同的底层持久化平台，我们需要为PlatformTransactionManager接口注入何种实现类：
Xml代码
（1）利用JDBC作为持久层的局部事务：
<?xml version="1.0" encoding="utf-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
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">
<!-- 定义数据源Bean，使用C3P0数据源 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy- method="close">
<!-- 指定连接数据库的驱动 -->
<property name="driverClass" value="com.mysql.jdbc.Driver"/>
<!-- 指定连接数据库的URL -->
<property name="jdbcUrl" value="jdbc:mysql:3306//127.0.0.1/ssh"/>
<!-- 指定连接数据库的用户名 -->
<property name="user" value="root"/>
<!-- 指定连接数据库的密码 -->
<property name="password" value="123"/>
<!-- 指定连接数据库连接池的最大连接数 -->
<property name="maxPoolSize" value="40"/>
<!-- 指定连接数据库连接池的最小连接数 -->
<property name="minPoolSize" value="1"/>
<!-- 指定连接数据库连接池的初始化连接数 -->
<property name="initialPoolSize" value="1"/>
<!-- 指定连接数据库连接池的连接最大空闲时间 -->
<property name="maxIdleTime" value="20"/>
</bean>
<!—定义JDBC数据源的局部事务管理器 -->
<!-- 使用DataSourceTransactionManager类，该类实现PlatformTransactionManager接口 ，是针对采用数据源连接的特定实现 -->
<bean id="transactionManager"
class="org.springframework.jdbc.datasource.
DataSourceTransactionManager">
<!—DataSourceTransactionManager需要注入一个DataSource的引用-->
<property name="dataSource" ref="dataSource"/>
</bean>
</beans>
（2）利用Hibernate作为持久层的局部事务：
<?xml version="1.0" encoding="utf-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
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">
<!-- 定义数据源Bean，使用C3P0数据源 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.
ComboPooledDataSource" destroy-method="close">
<!-- 指定连接数据库的驱动 -->
<property name="driverClass" value="com.mysql.jdbc.Driver"/>
<!-- 指定连接数据库的URL -->
<property name="jdbcUrl" value="jdbc:mysql:3306//127.0.0.1/ssh"/>
<!-- 指定连接数据库的用户名 -->
<property name="user" value="root"/>
<!-- 指定连接数据库的密码 -->
<property name="password" value="123"/>
<!-- 指定连接数据库连接池的最大连接数 -->
<property name="maxPoolSize" value="40"/>
<!-- 指定连接数据库连接池的最小连接数 -->
<property name="minPoolSize" value="1"/>
<!-- 指定连接数据库连接池的初始化连接数 -->
<property name="initialPoolSize" value="1"/>
<!-- 指定连接数据库连接池的连接最大空闲时间 -->
<property name="maxIdleTime" value="20"/>
</bean>
<!-- 定义Hibernate的SessionFactory -->
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.
LocalSessionFactoryBean">
<!-- 注入SessionFactory所需的数据源 -->
<property name="dataSource" ref="dataSource"/>
<!--列出全部映射文件 -->
<property name="mappingResources">
<list>
<!--列出所有的PO映射文件 -->
<value>org/hnylj/vo/User.hbm.xml</value>
</list>
</property>
<!-- 定义Hibernate的SessionFactory属性 -->
<property name="hibernateProperties">
<props>
<!-- 指定Hibernate的连接方言 -->
<prop key="hibernate.dialect">org.hibernate.dialect.
MySQLDialect</prop>
</property>
</bean>
<!-- 配置Hibernate的局部事务管理器 -->
<!-- 使用HibernateTransactionManager类，该类实现PlatformTransactionManager
接口，是针对采用Hibernate持久化连接的特定实现 -->
<bean id="transactionManager"
class="org.springframework.orm.hibernate3.
HibernateTransactionManager">
<!--注入一个SessionFactorybean的引用 -->
<property name="sessionFactory" ref="sessionFactory"/>
</bean>
</beans>
（3）利用Hibernate作为持久层的全局事务：
<?xml version="1.0" encoding="utf-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
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">
<!—定义JNDI数据源Bean -->
<bean id="dataSource" class="org.springframework.jndi.
JndiObjectFactoryBean">
<!-- 容器管理数据源的JNDI -->
<property name="jndiName" value="jdbc/jtest"/>
</bean>
<!--定义Hibernate的SessionFactory -->
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.
LocalSessionFactoryBean">
<!-- 注入SessionFactory所需的数据源-->
<property name="dataSource" ref="dataSource"/>
<!--列出全部映射文件 -->
<property name="mappingResources">
<list>
<!-- 列出所有的PO映射文件 -->
<value>org/hnylj/vo/User.hbm.xml</value>
</list>
</property>
<!-- 定义Hibernate的SessionFactory的属性 -->
<property name="hibernateProperties">
<props>
<!-- 指定Hibernate的连接方言 -->
<prop key="hibernate.dialect">org.hibernate.dialect.
MySQLDialect</prop>
</property>
</bean>
<!-- 使用JtaTransactionManager类，该类实现PlatformTransactionManager接口-->
<!-- JtaTransactionManager不需要知道数据源，或任何其他特定资源，
因为使用容器的全局事务管理 -->
<bean id="transactionManager"
class="org.springframework.transaction.jta.
JtaTransactionManager" />
</beans>
[xml] view plaincopy
（1）利用JDBC作为持久层的局部事务：
<?xml version="1.0" encoding="utf-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
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">
<!-- 定义数据源Bean，使用C3P0数据源 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy- method="close">
<!-- 指定连接数据库的驱动 -->
<property name="driverClass" value="com.mysql.jdbc.Driver"/>
<!-- 指定连接数据库的URL -->
<property name="jdbcUrl" value="jdbc:mysql:3306//127.0.0.1/ssh"/>
<!-- 指定连接数据库的用户名 -->
<property name="user" value="root"/>
<!-- 指定连接数据库的密码 -->
<property name="password" value="123"/>
<!-- 指定连接数据库连接池的最大连接数 -->
<property name="maxPoolSize" value="40"/>
<!-- 指定连接数据库连接池的最小连接数 -->
<property name="minPoolSize" value="1"/>
<!-- 指定连接数据库连接池的初始化连接数 -->
<property name="initialPoolSize" value="1"/>
<!-- 指定连接数据库连接池的连接最大空闲时间 -->
<property name="maxIdleTime" value="20"/>
</bean>
<!—定义JDBC数据源的局部事务管理器 -->
<!-- 使用DataSourceTransactionManager类，该类实现PlatformTransactionManager接口 ，是针对采用数据源连接的特定实现 -->
<bean id="transactionManager"
class="org.springframework.jdbc.datasource.
DataSourceTransactionManager">
<!—DataSourceTransactionManager需要注入一个DataSource的引用-->
<property name="dataSource" ref="dataSource"/>
</bean>
</beans>
（2）利用Hibernate作为持久层的局部事务：
<?xml version="1.0" encoding="utf-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
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">
<!-- 定义数据源Bean，使用C3P0数据源 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.
ComboPooledDataSource" destroy-method="close">
<!-- 指定连接数据库的驱动 -->
<property name="driverClass" value="com.mysql.jdbc.Driver"/>
<!-- 指定连接数据库的URL -->
<property name="jdbcUrl" value="jdbc:mysql:3306//127.0.0.1/ssh"/>
<!-- 指定连接数据库的用户名 -->
<property name="user" value="root"/>
<!-- 指定连接数据库的密码 -->
<property name="password" value="123"/>
<!-- 指定连接数据库连接池的最大连接数 -->
<property name="maxPoolSize" value="40"/>
<!-- 指定连接数据库连接池的最小连接数 -->
<property name="minPoolSize" value="1"/>
<!-- 指定连接数据库连接池的初始化连接数 -->
<property name="initialPoolSize" value="1"/>
<!-- 指定连接数据库连接池的连接最大空闲时间 -->
<property name="maxIdleTime" value="20"/>
</bean>
<!-- 定义Hibernate的SessionFactory -->
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.
LocalSessionFactoryBean">
<!-- 注入SessionFactory所需的数据源 -->
<property name="dataSource" ref="dataSource"/>
<!--列出全部映射文件 -->
<property name="mappingResources">
<list>
<!--列出所有的PO映射文件 -->
<value>org/hnylj/vo/User.hbm.xml</value>
</list>
</property>
<!-- 定义Hibernate的SessionFactory属性 -->
<property name="hibernateProperties">
<props>
<!-- 指定Hibernate的连接方言 -->
<prop key="hibernate.dialect">org.hibernate.dialect.
MySQLDialect</prop>
</property>
</bean>
<!-- 配置Hibernate的局部事务管理器 -->
<!-- 使用HibernateTransactionManager类，该类实现PlatformTransactionManager
接口，是针对采用Hibernate持久化连接的特定实现 -->
<bean id="transactionManager"
class="org.springframework.orm.hibernate3.
HibernateTransactionManager">
<!--注入一个SessionFactorybean的引用 -->
<property name="sessionFactory" ref="sessionFactory"/>
</bean>
</beans>
（3）利用Hibernate作为持久层的全局事务：
<?xml version="1.0" encoding="utf-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
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">
<!—定义JNDI数据源Bean -->
<bean id="dataSource" class="org.springframework.jndi.
JndiObjectFactoryBean">
<!-- 容器管理数据源的JNDI -->
<property name="jndiName" value="jdbc/jtest"/>
</bean>
<!--定义Hibernate的SessionFactory -->
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.
LocalSessionFactoryBean">
<!-- 注入SessionFactory所需的数据源-->
<property name="dataSource" ref="dataSource"/>
<!--列出全部映射文件 -->
<property name="mappingResources">
<list>
<!-- 列出所有的PO映射文件 -->
<value>org/hnylj/vo/User.hbm.xml</value>
</list>
</property>
<!-- 定义Hibernate的SessionFactory的属性 -->
<property name="hibernateProperties">
<props>
<!-- 指定Hibernate的连接方言 -->
<prop key="hibernate.dialect">org.hibernate.dialect.
MySQLDialect</prop>
</property>
</bean>
<!-- 使用JtaTransactionManager类，该类实现PlatformTransactionManager接口-->
<!-- JtaTransactionManager不需要知道数据源，或任何其他特定资源，
因为使用容器的全局事务管理 -->
<bean id="transactionManager"
class="org.springframework.transaction.jta.
JtaTransactionManager" />
</beans>
在上面的配置中，对于采用jdbc，hibernate等，我们只要提供相应的PlatformTransactionManager实现类即可。可见Spring对事务的操作仅仅修改一下配置文件，不需要修改任何实际的代码，就可以在不同的事务管理策略之间切换，非常地方便，Spring为我们提供了高度的解耦。
以上就是我们在spring中处理事务所需要的事务管理器的配置，那么在具体的业务处理bean中我们如何控制事务呢？
一般都推荐事务最好做在service层，底层的dao可以不考虑事务，有时设计得不好可能会出现事务的嵌套，增加程序复杂度。而且将事务的处理放在service层中进行，对于我们异常体系的设计也带来好处，service层抛出的异常可以在web捕获，并将异常信息在web页面给用户提示。所以接下来我们就将在service层开始事务，提交事务，回滚事务等。作为声明式事务管理，spring已经帮我们做好了这一切，基本上就是代理模式。
以下就是Spring提供的4种事务代理方式：
1.使用TransactionProxyFactoryBean为目标bean生成事务代理，此方式是最传统，也是配置文件最臃肿的一种方式。
2.使用bean继承的事务代理方式，此方式比较简洁，但依然是增量式配置，bean越多配置文件越臃肿。
3.使用BeanNameAutoProxyCreator，根据bean name自动生成事务代理的方式，这是直接利用Spring的AOP框架配置事务代理的方式，需要对Spring的AOP框架有所了解，但也不必成为AOP专家，这种方式避免了增量式配置，也是推荐的方式。
4.使用DefaultAdvisorAutoProxyCreator，这也是直接利用Spring的AOP框架配置事务代理的方式，只是这种配置方式的可读性不如第三种方式。
对于第一种：使用TransactionProxyFactoryBean为目标bean生成事务代理：
因为TransactionProxyFactoryBean产生的是代理Bean，所以我们在配置TransactionProxyFactoryBean时，需要指定目标Bean。每个TransactionProxyFactoryBean为一个目标Bean生成事务代理，事务代理的方法改写了目标Bean的方法，就是在目标Bean的方法执行之前加入开始事务，在目标Bean的方法正常结束之前提交事务，如果遇到特定异常则回滚事务。TransactionProxyFactoryBean创建事务代理时，需要了解当前事务所处的环境，该环境属性通过PlatformTransactionManager实例传入，而相关事务传入规则在TransactionProxyFactoryBean的定义中给出。
下面该方法的配置方式：
Xml代码
<?xml version="1.0" encoding="utf-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
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">
<!-- 定义数据源Bean，使用C3P0数据源 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.
ComboPooledDataSource" destroy-method="close">
<!-- 指定连接数据库的驱动 -->
<property name="driverClass" value="com.mysql.jdbc.Driver"/>
<!-- 指定连接数据库的URL -->
<property name="jdbcUrl" value="jdbc:mysql:3306//127.0.0.1/ssh"/>
<!-- 指定连接数据库的用户名 -->
<property name="user" value="root"/>
<!-- 指定连接数据库的密码 -->
<property name="password" value="123"/>
<!-- 指定连接数据库连接池的最大连接数 -->
<property name="maxPoolSize" value="40"/>
<!-- 指定连接数据库连接池的最小连接数 -->
<property name="minPoolSize" value="1"/>
<!-- 指定连接数据库连接池的初始化连接数 -->
<property name="initialPoolSize" value="1"/>
<!-- 指定连接数据库连接池的连接最大空闲时间 -->
<property name="maxIdleTime" value="20"/>
</bean>
<!-- 定义Hibernate的SessionFactory -->
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.
LocalSessionFactoryBean">
<!-- 注入SessionFactory所需的数据源-->
<property name="dataSource" <refref="dataSource"/>
<!--列出全部映射文件 -->
<property name="mappingResources">
<list>
<!--列出所有的PO映射文件 -->
<value>org/hnylj/vo/User.hbm.xml</value>
</list>
</property>
<!-- 定义Hibernate的SessionFactory属性 -->
<property name="hibernateProperties">
<props>
<!-- 指定Hibernate的连接方言 -->
<prop key="hibernate.dialect">org.hibernate.dialect.
MySQLDialect</prop>
</props>
</property>
</bean>
<!-- 配置DAO Bean -->
<bean id="userDAO" class="org.hnylj.dao.impl.UserDaoImpl">
<property name="sessionFactory">
<ref bean="sessionFactory" />
</property>
</bean>
<!-- 配置Service Bean，该Bean将作为目标Bean使用 -->
<bean id="userServiceTarget" class="org.hnylj.service.impl.UserServiceImpl">
<!-- 依赖注入userDAO的引用 -->
<property name="userDAO" ref="userDAO"/>
</bean>
<!-- 配置Hibernate的事务管理器 -->
<!-- 使用HibernateTransactionManager类，该类实现PlatformTransactionManager
接口，针对采用Hibernate持久化连接的特定实现 -->
<bean id="transactionManager"
class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<!-- HibernateTransactionManager Bean，它需要依赖注入一个SessionFactory
Bean的引用 -->
<property name="sessionFactory" ref="sessionFactory"/>
</bean>
<!-- 配置userServiceTarget Bean的事务代理 -->
<bean id="userService"
class="org.springframework.transaction.interceptor.
TransactionProxyFactoryBean">
<!-- 依赖注入PlatformTransactionManager的bean引用，此处使用
Hibernate的bean -->
<!-- 局部事务器，传入Hibernate事务管理器的引用 -->
<property name="transactionManager" ref="transactionManager"/>
<!-- 需要生成代理的目标bean -->
<property name="target" ref="userServiceTarget"/>
<!-- 指定事务属性 -->
<property name="transactionAttributes">
<props>
<!-- 以下部分为定义事务回滚规则 -->
<prop key="insert*">PROPAGATION_REQUIRED,-MyCheckedException</prop>
<prop key="update*">PROPAGATION_REQUIRED</prop>
<prop key="*">PROPAGATION_REQUIRED,readOnly</prop>
</props>
</property>
</bean>
</beans>
[xml] view plaincopy
<?xml version="1.0" encoding="utf-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
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">
<!-- 定义数据源Bean，使用C3P0数据源 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.
ComboPooledDataSource" destroy-method="close">
<!-- 指定连接数据库的驱动 -->
<property name="driverClass" value="com.mysql.jdbc.Driver"/>
<!-- 指定连接数据库的URL -->
<property name="jdbcUrl" value="jdbc:mysql:3306//127.0.0.1/ssh"/>
<!-- 指定连接数据库的用户名 -->
<property name="user" value="root"/>
<!-- 指定连接数据库的密码 -->
<property name="password" value="123"/>
<!-- 指定连接数据库连接池的最大连接数 -->
<property name="maxPoolSize" value="40"/>
<!-- 指定连接数据库连接池的最小连接数 -->
<property name="minPoolSize" value="1"/>
<!-- 指定连接数据库连接池的初始化连接数 -->
<property name="initialPoolSize" value="1"/>
<!-- 指定连接数据库连接池的连接最大空闲时间 -->
<property name="maxIdleTime" value="20"/>
</bean>
<!-- 定义Hibernate的SessionFactory -->
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.
LocalSessionFactoryBean">
<!-- 注入SessionFactory所需的数据源-->
<property name="dataSource" <refref="dataSource"/>
<!--列出全部映射文件 -->
<property name="mappingResources">
<list>
<!--列出所有的PO映射文件 -->
<value>org/hnylj/vo/User.hbm.xml</value>
</list>
</property>
<!-- 定义Hibernate的SessionFactory属性 -->
<property name="hibernateProperties">
<props>
<!-- 指定Hibernate的连接方言 -->
<prop key="hibernate.dialect">org.hibernate.dialect.
MySQLDialect</prop>
</props>
</property>
</bean>
<!-- 配置DAO Bean -->
<bean id="userDAO" class="org.hnylj.dao.impl.UserDaoImpl">
<property name="sessionFactory">
<ref bean="sessionFactory" />
</property>
</bean>
<!-- 配置Service Bean，该Bean将作为目标Bean使用 -->
<bean id="userServiceTarget" class="org.hnylj.service.impl.UserServiceImpl">
<!-- 依赖注入userDAO的引用 -->
<property name="userDAO" ref="userDAO"/>
</bean>
<!-- 配置Hibernate的事务管理器 -->
<!-- 使用HibernateTransactionManager类，该类实现PlatformTransactionManager
接口，针对采用Hibernate持久化连接的特定实现 -->
<bean id="transactionManager"
class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<!-- HibernateTransactionManager Bean，它需要依赖注入一个SessionFactory
Bean的引用 -->
<property name="sessionFactory" ref="sessionFactory"/>
</bean>
<!-- 配置userServiceTarget Bean的事务代理 -->
<bean id="userService"
class="org.springframework.transaction.interceptor.
TransactionProxyFactoryBean">
<!-- 依赖注入PlatformTransactionManager的bean引用，此处使用
Hibernate的bean -->
<!-- 局部事务器，传入Hibernate事务管理器的引用 -->
<property name="transactionManager" ref="transactionManager"/>
<!-- 需要生成代理的目标bean -->
<property name="target" ref="userServiceTarget"/>
<!-- 指定事务属性 -->
<property name="transactionAttributes">
<props>
<!-- 以下部分为定义事务回滚规则 -->
<prop key="insert*">PROPAGATION_REQUIRED,-MyCheckedException</prop>
<prop key="update*">PROPAGATION_REQUIRED</prop>
<prop key="*">PROPAGATION_REQUIRED,readOnly</prop>
</props>
</property>
</bean>
</beans>
关于以上配置文件的几个事务传播规则可以查阅相应的API
程序面向UserServiceImpl类所实现的接口编程，事务处理由Spring为UserServiceImpl类所实现的接口IUserService生成的代理bean来完成。（Spring不仅支持对接口的代理，Spring结合CGLIB还可以为具体类生成代理，在此不做讨论）
对于第二种：采用bean继承的事务代理
仔细观察第一种配置方式，我们可以发现，如果配置文件中有多个这样的事务代理Bean，配置文件将变得非常臃肿。所以可以使用Bean继承来简化事务代理的配置。考虑到所有事务代理Bean中，事务代理Bean所使用的事务管理器和事务传播规则大致是相同的,所以我们可以定义一个事务代理bean的模板。
即：
Xml代码
<!-- 定义所有事务代理Bean的模板 -->
<bean id="txProxyTemplate" abstract="true"
class="org.springframework.transaction.interceptor.
TransactionProxyFactoryBean">
<!-- 为事务代理Bean注入生成代理所需的PlatformTransactionManager实例 -->
<property name="transactionManager" ref="transactionManager"/>
<!-- 定义生成事务代理通用的事务属性 -->
<property name="transactionAttributes">
<props>
<!-- 所有的方法都应用PROPAGATION_REQUIRED的事务传播规则 -->
<prop key="*">PROPAGATION_REQUIRED</prop>
</props>
</property>
</bean>
[xml] view plaincopy
<!-- 定义所有事务代理Bean的模板 -->
<bean id="txProxyTemplate" abstract="true"
class="org.springframework.transaction.interceptor.
TransactionProxyFactoryBean">
<!-- 为事务代理Bean注入生成代理所需的PlatformTransactionManager实例 -->
<property name="transactionManager" ref="transactionManager"/>
<!-- 定义生成事务代理通用的事务属性 -->
<property name="transactionAttributes">
<props>
<!-- 所有的方法都应用PROPAGATION_REQUIRED的事务传播规则 -->
<prop key="*">PROPAGATION_REQUIRED</prop>
</props>
</property>
</bean>
接下来让真正的事务代理Bean继承上面的事务模板Bean
Xml代码
<!-- 让事务代理Bean继承模板Bean -->
<bean id="userService" parent="txProxyTemplate">
<!-- 这里是嵌套Bean的配置方式 -->
<property name="target">
<bean class="org.hnylj.service.impl.userServiceImpl"/>
</property>
</bean>
[xml] view plaincopy
<!-- 让事务代理Bean继承模板Bean -->
<bean id="userService" parent="txProxyTemplate">
<!-- 这里是嵌套Bean的配置方式 -->
<property name="target">
<bean class="org.hnylj.service.impl.userServiceImpl"/>
</property>
</bean>
我们知道,继承中子类可以复写父类的方法，这里也一样，子Bean重新定义事务属性将覆盖事务代理模板里的事务属性定义：
即：
Xml代码 <!-- 让事务代理bean继承模板Bean -->
<bean id="userService" parent="txProxyTemplate">
<!-- 这里引用已存在的bean的方式来定义目标Bean -->
<property name="target" ref ="userServiceTarget"/>
<!-- 覆盖事务代理模板bean中的事务属性定义 -->
<property name="transactionAttributes">
<props>
<prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>
<prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>
<prop key="load*">PROPAGATION_REQUIRED,readOnly</prop>
</props>
</property>
</bean>
[xml] view plaincopy
<!-- 让事务代理bean继承模板Bean -->
<bean id="userService" parent="txProxyTemplate">
<!-- 这里引用已存在的bean的方式来定义目标Bean -->
<property name="target" ref ="userServiceTarget"/>
<!-- 覆盖事务代理模板bean中的事务属性定义 -->
<property name="transactionAttributes">
<props>
<prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>
<prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>
<prop key="load*">PROPAGATION_REQUIRED,readOnly</prop>
</props>
</property>
</bean>
可见，采用Bean继承方式定义事务代理的方式，可以很好地简化事务代理的配置，可以避免配置事务代理Bean时的冗余配置。
对于第三种：使用BeanNameAutoProxyCreator
使用BeanNameAutoProxyCreator来创建代理时，并不一定是创建事务代理，关键在于传入的拦截器，如果传入事务拦截器，将可自动生成事务代理。
下面是使用BeanNameAutoProxyCreator自动生成事务代理的配置方式：
[xml] view plaincopy
<?xml version="1.0" encoding="utf-8"?>
<!-- 指定Spring配置文件的根元素，以及相应的Schema信息 -->
<beans xmlns="http://www.springframework.org/schema/beans"
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">
<!-- 定义数据源Bean，使用C3P0数据源实现 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.
ComboPooledDataSource" destroy-method="close">
<!-- 指定连接数据库的驱动 -->
<property name="driverClass" value="com.mysql.jdbc.Driver"/>
<!-- 指定连接数据库的URL -->
<property name="jdbcUrl" value="jdbc:mysql:3306/127.0.0.1/ssh"/>
<!-- 指定连接数据库的用户名 -->
<property name="user" value="root"/>
<!-- 指定连接数据库的密码 -->
<property name="password" value="123"/>
<!-- 指定连接数据库连接池的最大连接数 -->
<property name="maxPoolSize" value="40"/>
<!-- 指定连接数据库连接池的最小连接数 -->
<property name="minPoolSize" value="1"/>
<!-- 指定连接数据库连接池的初始化连接数 -->
<property name="initialPoolSize" value="1"/>
<!-- 指定连接数据库连接池的连接最大空闲时间 -->
<property name="maxIdleTime" value="20"/>
</bean>
<!-- 使用JDBC的局部事务策略 -->
<bean id="transactionManager"
class="org.springframework.jdbc.datasource.DataSource-
TransactionManager">
<!-- 为事务管理器注入所需的数据源Bean -->
<property name="dataSource" ref="dataSource"/>
</bean>
<!-- 配置目标Bean，该目标Bean将由Bean后处理器自动生成代理 -->
<bean id="userBean" class="org.hnylj.service.impl.UserServiceImpl">
<!-- 依赖注入目标Bean所必需的数据源Bean -->
<property name="userDAO">
<ref bean="userDAO" />
</property>
</bean>
<!-- 配置目标Bean，该目标Bean将由Bean后处理器自动生成代理 -->
<bean id="personBean" class="org.hnylj.service.impl.PersonServiceImpl">
<!-- 依赖注入目标Bean所必需的数据源Bean -->
<property name="personDAO">
<ref bean="personDAO" />
</property>
</bean>
<!-- 配置事务拦截器Bean -->
<bean id="transactionInterceptor"
class="org.springframework.transaction.interceptor.
TransactionInterceptor">
<!-- 事务拦截器bean需要依赖注入一个事务管理器 -->
<property name="transactionManager" ref="transactionManager"/>
<property name="transactionAttributes">
<!-- 下面定义事务传播属性 -->
<props>
<prop key="insert*">PROPAGATION_REQUIRED</prop>
<prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>
<prop key="*">PROPAGATION_REQUIRED</prop>
</props>
</property>
</bean>
<!-- 定义BeanNameAutoProxyCreator的Bean后处理器 -->
<bean class="org.springframework.aop.framework.autoproxy.
BeanNameAutoProxyCreator">
<!-- 指定对满足哪些bean name的bean自动生成业务代理 -->
<property name="beanNames">
<!-- 下面是所有需要自动创建事务代理的Bean -->
<list>
<value>userBean</value>
<value>personBean</value>
</list>
<!-- 此处可增加其他需要自动创建事务代理的Bean -->
</property>
<!-- 下面定义BeanNameAutoProxyCreator所需的拦截器 -->
<property name="interceptorNames">
<list>
<value>transactionInterceptor</value>
<!-- 此处可增加其他新的Interceptor -->
</list>
</property>
</bean>
</beans>
如果配置文件中仅有两个目标Bean，可能不能很清楚地看出这种自动创建代理配置方式的优势，但如果有更多目标Bean需要自动创建事务代理，则可以很好地体会到这种配置方式的优势：配置文件只需要简单地配置目标Bean，然后在BeanNameAutoProxyCreator配置中增加一行即可。
对于第四种：DefaultAdvisorAutoProxyCreator：
这种配置方式与BeanNameAutoProxyCreator自动创建代理的方式非常相似，都是使用bean后处理器为目标bean生成事务代理，区别是前者使用事务拦截器创建代理，后者需要使用Advisor创建事务代理。事实上，采用DefaultAdvisorAutoProxyCreator的事务代理配置方式更加简洁，这个代理生成器自动搜索Spring容器中的Advisor，并为容器中所有的bean创建代理。相对前一种方式，这种方式的可读性不如前一种直观。
使用DefaultAdvisorAutoProxyCreator的配置方式：
[xml] view plaincopy
<?xml version="1.0" encoding="utf-8"?>
<!-- 指定Spring配置文件的根元素，以及相应的Schema信息 -->
<beans xmlns="http://www.springframework.org/schema/beans"
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">
<!-- 定义数据源Bean，使用C3P0数据源实现 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.
ComboPooledDataSource" destroy-method="close">
<!-- 指定连接数据库的驱动 -->
<property name="driverClass" value="com.mysql.jdbc.Driver"/>
<!-- 指定连接数据库的URL -->
<property name="jdbcUrl" value="jdbc:mysql:3306/127.0.0.1/ssh"/>
<!-- 指定连接数据库的用户名 -->
<property name="user" value="root"/>
<!-- 指定连接数据库的密码 -->
<property name="password" value="123"/>
<!-- 指定连接数据库连接池的最大连接数 -->
<property name="maxPoolSize" value="40"/>
<!-- 指定连接数据库连接池的最小连接数 -->
<property name="minPoolSize" value="1"/>
<!-- 指定连接数据库连接池的初始化连接数 -->
<property name="initialPoolSize" value="1"/>
<!-- 指定连接数据库连接池的连接最大空闲时间 -->
<property name="maxIdleTime" value="20"/>
</bean>
<!--定义一个hibernate的SessionFactory-->
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<!-- 定义SessionFactory必须注入DataSource-->
<property name="dataSource"><ref local="dataSource"/></property>
<property name="mappingResources">
<list>
<!--列出所有的PO映射文件-->
<value>org/hnylj/vo/User.hbm.xml</value>
</list>
</property>
<property name="hibernateProperties">
<props>
<!--定义hibernate的SessionFactory的属性-->
<prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
</props>
</property>
</bean>
<!-- 定义hibernate的局部事务管理器-->
<bean id="transactionManager"
class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<!-- 注入SessionFactory bean的引用-->
<property name="sessionFactory"><ref local="sessionFactory"/></property>
</bean>
<!-- 配置事务拦截器-->
<bean id="transactionInterceptor"
class="org.springframework.transaction.interceptor.TransactionInterceptor">
<!-- 事务拦截器bean需要依赖注入一个事务管理器 -->
<property name="transactionManager" ref="transactionManager"/>
<property name="transactionAttributes">
<!-- 下面定义事务传播属性-->
<props>
<prop key="insert*">PROPAGATION_REQUIRED</prop>
<prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>
<prop key="*">PROPAGATION_REQUIRED</prop>
</props>
</property>
</bean>
<!-- 定义事务Advisor-->
<bean class="org.springframework.transaction.interceptor.TransactionAttributeSourceAdvisor">
<!-- 定义advisor时，必须传入Interceptor-->
<property name="transactionInterceptor" ref="transactionInterceptor"/>
</bean>
<!-- DefaultAdvisorAutoProxyCreator搜索容器中的 advisor,并为每个bean创建代理 -->
<bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"/>
<!--定义DAO Bean ,由BeanNameAutoProxyCreator自动生成事务代理-->
<bean id="userService" class="org.hnylj.service.impl.UserServiceImpl">
<property name="userDAO"><ref local="userDAO"/></property>
</bean>
</beans>
分享到：
发表评论
相关推荐
Spring事务管理Demo
Spring事务管理.pdf 1.资料 2.本地事务与分布式事务 3.编程式模型 4.宣告式模型
Synchronized锁在Spring事务管理下，导致线程不安全。
spring 事务管理的理解
Spring事务管理(全),需要的可下载！
此包含有所有Spring事务管理开发所需要的Jar包，包含框架、核心、表达式、日志、编译、事务切面aop、数据库连接、单元测试、框架文本等jar包。
spring事务管理几种方式代码实例：涉及编程式事务，声明式事务之拦截器代理方式、AOP切面通知方式、AspectJ注解方式，通过不同方式实例代码展现，总结spring事务管理的一般规律，从宏观上加深理解spring事务管理特性...
在该JAR包的org.springframework.transaction包中，有3个接口文件PlatformTransactionManager、TransactionDefinition和TransactionStatus，如下图所示： Spring事务管理的三个核心接口 5.1.1 事务管理的核心接口 1....
Spring事务管理4种方式 入门级 最简单demo PlatformTransactionManager TransactionTemplate
Spring事务管理中所需要的jar包是 spring-tx-3.2.0.RELEASE.jar
Spring 事务管理，Spring 事务管理，Spring 事务管理，Spring 事务管理
Spring事务管理教程，详细讲解了Spring中的事务管理，包括声明式事务，注解式事务，以及事务配置等等
详细介绍Spring事务管理
Spring事务管理A方法内部调用B方法的回滚问题测试代码