Spring容器中有两种思想很重要，也就是我们常用的Ioc和Aop，如果理解了这两种思想，对于我们学习设计模式和编程有很大的帮助，美国四人帮（GOF）写的设计模式中，有很多都用到了Ioc的思想。简单的说就是依赖注入的思想。常见的一种情况：如果一个类中要复用另外一个类中的功能时，我们可能会首先想到继承，如果你知道Ioc这种思想的话，我想你不会用继承，你会马上想到把要用到功能抽取出来，在我们要用到的类中只需通过set方法简单的注入就可以了，其实这里用到了对象的组合代替继承，这样不仅避免了单一继承，还很好的实现了松耦合。同时也遵循了面向对象的编程的设计原则：多用组合，少用继承。在这里对于Ioc和Aop这两种思想的好处。我就不介绍了。接下来我要说的是Spring中几种常见的事务配置，是Aop和Ioc的充分体现。
--------------------------------------
一、Propagation ：
对于特定的方法或方法命名模式，代理的具体事务行为由事务属性驱动，如下面的例子所示：
<prop key="load*">PROPAGATION_REQUIRED,readOnly</prop>
<prop key="store*">PROPAGATION_REQUIRED</prop>
key属性确定代理应该给哪个方法增加事务行为。这样的属性最重要的部份是传播行为。有以下选项可供使用：
PROPAGATION_REQUIRED--支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。
PROPAGATION_SUPPORTS--支持当前事务，如果当前没有事务，就以非事务方式执行。
PROPAGATION_MANDATORY--支持当前事务，如果当前没有事务，就抛出异常。
PROPAGATION_REQUIRES_NEW--新建事务，如果当前存在事务，把当前事务挂起。
PROPAGATION_NOT_SUPPORTED--以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
PROPAGATION_NEVER--以非事务方式执行，如果当前存在事务，则抛出异常。
前六个策略类似于EJB CMT：常量名相同，因此，对EJB开发人员来说，应该立刻就感到熟悉。第七个（PROPAGATION_NESTED）是Spring所提供的一个特殊变量。它要求事务管理器或者使用JDBC 3.0 Savepoint API提供嵌套事务行为（如Spring的DataSourceTransactionManager），或者通过JTA支持嵌套事务。
二、Isolation Level(事务隔离等级):
1、Serializable：最严格的级别，事务串行执行，资源消耗最大；
2、REPEATABLE READ：保证了一个事务不会修改已经由另一个事务读取但未提交（回滚）的数据。避免了“脏读取”和“不可重复读取”的情况，但是带来了更多的性能损失。
3、READ COMMITTED:大多数主流数据库的默认事务等级，保证了一个事务不会读到另一个并行事务已修改但未提交的数据，避免了“脏读取”。该级别适用于大多数系统。
4、Read Uncommitted：保证了读取过程中不会读取到非法数据。
spring中的Isolation属性：
1、ISOLATION_DEFAULT ：使用当前数据源的默认级别
2、ISOLATION_READ_UNCOMMITTED ：Dirty reads, non-repeatable reads, and phantom reads can occur.
3、ISOLATION_READ_COMMITTED
irty reads are prevented; non-repeatable reads and phantom reads can occur.
4、ISOLATION_REPEATABLE_READ:Dirty reads and non-repeatable reads are prevented; phantom reads can occur.
5、ISOLATION_SERIALIZABLE:Dirty reads, non-repeatable reads, and phantom reads are prevented.
三、readOnly
事务属性中的readOnly标志表示对应的事务应该被最优化为只读事务。这是一个最优化提示。在一些情况下，一些事务策略能够起到显著的最优化效果，例如在使用Object/Relational映射工具（如：Hibernate或TopLink）时避免dirty checking（试图“刷新”）。
四、Timeout
在事务属性中还有定义“timeout”值的选项，指定事务超时为几秒。在JTA中，这将被简单地传递到J2EE服务器的事务协调程序，并据此得到相应的解释。
事务划分策略
1、推荐在业务层使用事务，这样可以允许业务层捕获导致rollback的异常，并抛出恰当的业务层异常；不在dao层使用事务是因为这会限制了dao重用其他事务需求，并且dao层没有实现业务逻辑，并且原子性也是业务层的概念。
spring声明性事务的划分：
1、有四个地方需要配置：The four participants are transaction manager, proxy factory, transaction interceptor, and a set of transaction attributes.
2、使用ProxyFactoryBean/Transaction Interceptor（transactionInterceptor）配置spring事务
以下为配置实例：
<!-- The DBCP DataSource -->
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
destroy-method="close">
<property name="driverClassName">
<value>${jdbc.driverClassName}</value>
</property>
<property name="url"><value>${jdbc.url}</value></property>
<property name="username"><value>${jdbc.username}</value></property>
<property name="password"><value>${jdbc.password}</value></property>
</bean>
<!-- The DAO class -->
<bean id="dao"
class="org.springframework.prospring.ticket.dao.jdbc.JdbcBoxOfficeDao">
<property name="dataSource">
<ref local="dataSource"/>
</property>
</bean>
<!-- The transactionmanager to use for regular non JTA datasource -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource">
<ref local="dataSource"/>
</property>
</bean>
<!-- TransactionInterceptor -->
<bean id="transactionInterceptor" class="org.springframework.transaction.interceptor.TransactionInterceptor"> <property name="transactionManager"> <ref bean="transactionManager"/> </property> <property name="transactionAttributeSource"> <value>org.springframework.prospring.ticket.service.BoxOffice.get*=PROPAGATION_SUPPORTS,readOnlyorg.springframework.prospring.ticket.service.BoxOffice.allocate*=PROPAGATION_REQUIRED
</value>
</property>
</bean>
<!-- Transactional proxy for the primary business object -->
<bean id="boxOffice" class="org.springframework.aop.framework.ProxyFactoryBean"> <property name="target"> <ref local="boxOfficeTarget"/> </property> <property name="proxyInterfaces"> <value>org.springframework.prospring.ticket.service.BoxOffice</value> </property> <property name="interceptorNames"> <value>transactionInterceptor</value> </property>
</bean>
<!-- Business Object -->
<bean id="boxOfficeTarget"
class="org.springframework.prospring.ticket.service.BoxOfficeImpl">
<property name="boxOfficeDao">
<ref local="dao"/>
</property>
</bean>
3、使用TransactionProxyFactoryBean配置spring事务
以下为配置实例：
<!-- The DBCP DataSource -->
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
destroy-method="close">
<property name="driverClassName">
<value>${jdbc.driverClassName}</value>
</property>
<property name="url"><value>${jdbc.url}</value></property>
<property name="username"><value>${jdbc.username}</value></property>
<property name="password"><value>${jdbc.password}</value></property>
</bean>
<!-- The DAO class -->
<bean id="dao"
class="org.springframework.prospring.ticket.dao.jdbc.JdbcBoxOfficeDao">
<property name="dataSource">
<ref local="dataSource"/>
</property>
</bean>
<!-- The transactionmanager to use for regular non JTA datasource -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource">
<ref local="dataSource"/>
</property>
</bean>
<!-- Transactional proxy and the primary business object -->
<bean id="boxOffice" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"> <property name="transactionManager"><ref bean="transactionManager"/></property> <property name="target"> <bean class="org.springframework.prospring.ticket.service.BoxOfficeImpl">
<property name="boxOfficeDao">
<ref local="dao"/>
</property>
</bean>
</property>
<property name="transactionAttributes"> <props> <prop key="get*">PROPAGATION_SUPPORTS,readOnly</prop> <prop key="allocate*">PROPAGATION_REQUIRED</prop> </props> </property>
</bean>
4、使用BeanNameAutoProxyCreator配置spring事务
如果有大量的bean需要使用事物，那么只要在配置文件中提供bean name给BeanNameAutoProxyCreator，spring就会个给该bean提供事务代理，配置实例如下：
<!-- The DBCP DataSource -->
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
destroy-method="close">
<property name="driverClassName">
<value>${jdbc.driverClassName}</value>
</property>
<property name="url"><value>${jdbc.url}</value></property>
<property name="username"><value>${jdbc.username}</value></property>
<property name="password"><value>${jdbc.password}</value></property>
</bean>
<!-- The DAO class -->
<bean id="dao"
class="org.springframework.prospring.ticket.dao.jdbc.JdbcBoxOfficeDao">
<property name="dataSource">
<ref local="dataSource"/>
</property>
</bean>
<!-- The transactionmanager to use for regular non JTA datasource -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource">
<ref local="dataSource"/>
</property>
</bean>
<!-- TransactionInterceptor -->
<bean id="transactionInterceptor" class="org.springframework.transaction.interceptor.TransactionInterceptor"> <property name="transactionManager"> <ref bean="transactionManager"/> </property> <property name="transactionAttributeSource"> <value>org.springframework.prospring.ticket.service.BoxOffice.get*=PROPAGATION_SUPPORTS,readOnlyorg.springframework.prospring.ticket.service.BoxOffice.allocate*=PROPAGATION_REQUIRED </value> </property>
</bean>
<!-- BeanNameAutoProxyCreator -->
<bean id="autoProxyCreator" class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator"> <property name="interceptorNames"> <value>transactionInterceptor</value> </property> <property name="beanNames"> <list> <idref local="boxOffice"/> </list> </property>
</bean>
<!-- Business Object -->
<bean id="boxOffice"
class="org.springframework.prospring.ticket.service.BoxOfficeImpl">
<property name="boxOfficeDao">
<ref local="dao"/>
</property>
</bean>
http://www.blogjava.net/280211429/articles/75529.html
-----------------------------------------------------
Spring AOP特性的声明式事务管理，就可以避免编程式事务带来的难维护性。声明式事务只需要在配置文件中声明即可。这样的好处是业务逻辑（Dao）就不会意识到事务管理的存在，而且维护起来极其方便。
简化配置：
<bean id="TransactionProxyFactoryBean" lazy-init="true"
class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
<property name="transactionManager">
<ref bean="transactionManager" />
</property>
<property name="transactionAttributes">
<props>
<prop key="do*">PROPAGATION_REQUIRED</prop>
<prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>
</props>
</property>
</bean>
<bean id="ForumService" parent="TransactionProxyFactoryBean">
<property name="target">
<bean class="ForumServiceImp">
</property>
</bean>
<bean id="ForumServiceImp" class="com.bbs.service.imp.ForumServiceImp">
<property name="forumDAO">
<ref local="ForumDAO" />
</property>
</bean>
-------------------------------------------------------
TransactionProxyFactoryBean里的transactionAttributes，他的prop元素中的key属性定义了target类的某个方法，可以使用通配符，如save*，prop元素的值定义了对key中定义方法应用的事务执行属性，指定格式如下：
传播行为，隔离等级，只读，+异常，-异常
其中传播行为必须定义，其他可省，例如：
......
<prop key="xxxx">PROPAGATION_REQUIRED,readOnly,-DataAccessException</prop>
......
"-"表示发生指定异常后立即回滚，"+"表示发生指定异常后立即提交。
经过上面xml定义，就相当于在UserDaoImpl的saveOrUpdate方法前后加入了事务处理的代码。
定义了userDaoProxy后，我们在想使用userDaoImpl，就需要注入userDaoProxy的bean了，而不是userDaoImpl的bean
<property name="userDao">
<ref bean="userDaoProxy"/>
</property>
当不想使用事务管理时，把userController注入的userDaoProxy改为注入userDaoImpl就行了。
proxyTargetClass需要配置的情况只有一种:
当TestTram类有实现某个接口,而TestProxyClass类中配置的类对象是TestTram时(而不是TestTram实现的接口),这时候你需要配置proxyTargetClass=true
如果TestTram没有实现某个接口，而TestProxyClass类中配置的类对象是TestTram,这个时候我们是不需要配置proxyTargetClass=true的.(使用cgilib来动态代理)
如果TestTram实现某个接口, 而TestProxyClass类中配置的是TestTram实现的interface的话.那样我既不需要配置proxyInterface,也不需要配置proxyTargetClass
为什么我们在没有配置proxyInterface情况下,去配置proxyTargetClass.因为spring会去拿到当前配置的target实现的所有接口,然后通过动态代理出类.
--------------------------------------
一、Propagation ：
对于特定的方法或方法命名模式，代理的具体事务行为由事务属性驱动，如下面的例子所示：
<prop key="load*">PROPAGATION_REQUIRED,readOnly</prop>
<prop key="store*">PROPAGATION_REQUIRED</prop>
key属性确定代理应该给哪个方法增加事务行为。这样的属性最重要的部份是传播行为。有以下选项可供使用：
PROPAGATION_REQUIRED--支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。
PROPAGATION_SUPPORTS--支持当前事务，如果当前没有事务，就以非事务方式执行。
PROPAGATION_MANDATORY--支持当前事务，如果当前没有事务，就抛出异常。
PROPAGATION_REQUIRES_NEW--新建事务，如果当前存在事务，把当前事务挂起。
PROPAGATION_NOT_SUPPORTED--以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
PROPAGATION_NEVER--以非事务方式执行，如果当前存在事务，则抛出异常。
前六个策略类似于EJB CMT：常量名相同，因此，对EJB开发人员来说，应该立刻就感到熟悉。第七个（PROPAGATION_NESTED）是Spring所提供的一个特殊变量。它要求事务管理器或者使用JDBC 3.0 Savepoint API提供嵌套事务行为（如Spring的DataSourceTransactionManager），或者通过JTA支持嵌套事务。
二、Isolation Level(事务隔离等级):
1、Serializable：最严格的级别，事务串行执行，资源消耗最大；
2、REPEATABLE READ：保证了一个事务不会修改已经由另一个事务读取但未提交（回滚）的数据。避免了“脏读取”和“不可重复读取”的情况，但是带来了更多的性能损失。
3、READ COMMITTED:大多数主流数据库的默认事务等级，保证了一个事务不会读到另一个并行事务已修改但未提交的数据，避免了“脏读取”。该级别适用于大多数系统。
4、Read Uncommitted：保证了读取过程中不会读取到非法数据。
spring中的Isolation属性：
1、ISOLATION_DEFAULT ：使用当前数据源的默认级别
2、ISOLATION_READ_UNCOMMITTED ：Dirty reads, non-repeatable reads, and phantom reads can occur.
3、ISOLATION_READ_COMMITTED
irty reads are prevented; non-repeatable reads and phantom reads can occur.
4、ISOLATION_REPEATABLE_READ:Dirty reads and non-repeatable reads are prevented; phantom reads can occur.
5、ISOLATION_SERIALIZABLE:Dirty reads, non-repeatable reads, and phantom reads are prevented.
三、readOnly
事务属性中的readOnly标志表示对应的事务应该被最优化为只读事务。这是一个最优化提示。在一些情况下，一些事务策略能够起到显著的最优化效果，例如在使用Object/Relational映射工具（如：Hibernate或TopLink）时避免dirty checking（试图“刷新”）。
四、Timeout
在事务属性中还有定义“timeout”值的选项，指定事务超时为几秒。在JTA中，这将被简单地传递到J2EE服务器的事务协调程序，并据此得到相应的解释。
事务划分策略
1、推荐在业务层使用事务，这样可以允许业务层捕获导致rollback的异常，并抛出恰当的业务层异常；不在dao层使用事务是因为这会限制了dao重用其他事务需求，并且dao层没有实现业务逻辑，并且原子性也是业务层的概念。
spring声明性事务的划分：
1、有四个地方需要配置：The four participants are transaction manager, proxy factory, transaction interceptor, and a set of transaction attributes.
2、使用ProxyFactoryBean/Transaction Interceptor（transactionInterceptor）配置spring事务
以下为配置实例：
<!-- The DBCP DataSource -->
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
destroy-method="close">
<property name="driverClassName">
<value>${jdbc.driverClassName}</value>
</property>
<property name="url"><value>${jdbc.url}</value></property>
<property name="username"><value>${jdbc.username}</value></property>
<property name="password"><value>${jdbc.password}</value></property>
</bean>
<!-- The DAO class -->
<bean id="dao"
class="org.springframework.prospring.ticket.dao.jdbc.JdbcBoxOfficeDao">
<property name="dataSource">
<ref local="dataSource"/>
</property>
</bean>
<!-- The transactionmanager to use for regular non JTA datasource -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource">
<ref local="dataSource"/>
</property>
</bean>
<!-- TransactionInterceptor -->
<bean id="transactionInterceptor" class="org.springframework.transaction.interceptor.TransactionInterceptor"> <property name="transactionManager"> <ref bean="transactionManager"/> </property> <property name="transactionAttributeSource"> <value>org.springframework.prospring.ticket.service.BoxOffice.get*=PROPAGATION_SUPPORTS,readOnlyorg.springframework.prospring.ticket.service.BoxOffice.allocate*=PROPAGATION_REQUIRED
</value>
</property>
</bean>
<!-- Transactional proxy for the primary business object -->
<bean id="boxOffice" class="org.springframework.aop.framework.ProxyFactoryBean"> <property name="target"> <ref local="boxOfficeTarget"/> </property> <property name="proxyInterfaces"> <value>org.springframework.prospring.ticket.service.BoxOffice</value> </property> <property name="interceptorNames"> <value>transactionInterceptor</value> </property>
</bean>
<!-- Business Object -->
<bean id="boxOfficeTarget"
class="org.springframework.prospring.ticket.service.BoxOfficeImpl">
<property name="boxOfficeDao">
<ref local="dao"/>
</property>
</bean>
3、使用TransactionProxyFactoryBean配置spring事务
以下为配置实例：
<!-- The DBCP DataSource -->
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
destroy-method="close">
<property name="driverClassName">
<value>${jdbc.driverClassName}</value>
</property>
<property name="url"><value>${jdbc.url}</value></property>
<property name="username"><value>${jdbc.username}</value></property>
<property name="password"><value>${jdbc.password}</value></property>
</bean>
<!-- The DAO class -->
<bean id="dao"
class="org.springframework.prospring.ticket.dao.jdbc.JdbcBoxOfficeDao">
<property name="dataSource">
<ref local="dataSource"/>
</property>
</bean>
<!-- The transactionmanager to use for regular non JTA datasource -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource">
<ref local="dataSource"/>
</property>
</bean>
<!-- Transactional proxy and the primary business object -->
<bean id="boxOffice" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"> <property name="transactionManager"><ref bean="transactionManager"/></property> <property name="target"> <bean class="org.springframework.prospring.ticket.service.BoxOfficeImpl">
<property name="boxOfficeDao">
<ref local="dao"/>
</property>
</bean>
</property>
<property name="transactionAttributes"> <props> <prop key="get*">PROPAGATION_SUPPORTS,readOnly</prop> <prop key="allocate*">PROPAGATION_REQUIRED</prop> </props> </property>
</bean>
4、使用BeanNameAutoProxyCreator配置spring事务
如果有大量的bean需要使用事物，那么只要在配置文件中提供bean name给BeanNameAutoProxyCreator，spring就会个给该bean提供事务代理，配置实例如下：
<!-- The DBCP DataSource -->
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
destroy-method="close">
<property name="driverClassName">
<value>${jdbc.driverClassName}</value>
</property>
<property name="url"><value>${jdbc.url}</value></property>
<property name="username"><value>${jdbc.username}</value></property>
<property name="password"><value>${jdbc.password}</value></property>
</bean>
<!-- The DAO class -->
<bean id="dao"
class="org.springframework.prospring.ticket.dao.jdbc.JdbcBoxOfficeDao">
<property name="dataSource">
<ref local="dataSource"/>
</property>
</bean>
<!-- The transactionmanager to use for regular non JTA datasource -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource">
<ref local="dataSource"/>
</property>
</bean>
<!-- TransactionInterceptor -->
<bean id="transactionInterceptor" class="org.springframework.transaction.interceptor.TransactionInterceptor"> <property name="transactionManager"> <ref bean="transactionManager"/> </property> <property name="transactionAttributeSource"> <value>org.springframework.prospring.ticket.service.BoxOffice.get*=PROPAGATION_SUPPORTS,readOnlyorg.springframework.prospring.ticket.service.BoxOffice.allocate*=PROPAGATION_REQUIRED </value> </property>
</bean>
<!-- BeanNameAutoProxyCreator -->
<bean id="autoProxyCreator" class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator"> <property name="interceptorNames"> <value>transactionInterceptor</value> </property> <property name="beanNames"> <list> <idref local="boxOffice"/> </list> </property>
</bean>
<!-- Business Object -->
<bean id="boxOffice"
class="org.springframework.prospring.ticket.service.BoxOfficeImpl">
<property name="boxOfficeDao">
<ref local="dao"/>
</property>
</bean>
http://www.blogjava.net/280211429/articles/75529.html
-----------------------------------------------------
Spring AOP特性的声明式事务管理，就可以避免编程式事务带来的难维护性。声明式事务只需要在配置文件中声明即可。这样的好处是业务逻辑（Dao）就不会意识到事务管理的存在，而且维护起来极其方便。
简化配置：
<bean id="TransactionProxyFactoryBean" lazy-init="true"
class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
<property name="transactionManager">
<ref bean="transactionManager" />
</property>
<property name="transactionAttributes">
<props>
<prop key="do*">PROPAGATION_REQUIRED</prop>
<prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>
</props>
</property>
</bean>
<bean id="ForumService" parent="TransactionProxyFactoryBean">
<property name="target">
<bean class="ForumServiceImp">
</property>
</bean>
<bean id="ForumServiceImp" class="com.bbs.service.imp.ForumServiceImp">
<property name="forumDAO">
<ref local="ForumDAO" />
</property>
</bean>
-------------------------------------------------------
<!-- spring中配置 声明式事务的方法 -->
<!-- Transactional proxy and the primary business object -->
<bean id="daytestLogic"
class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
<!-- 代理的目标类 -->
<property name="target">
<bean class="com.xiaonei.wap.app.daytest.logic.impl.DaytestLogicImpl">
<property name="daytestDAO" ref="daytestDAO" />
<property name="optionDAO" ref="optionDAO" />
<property name="questionDAO" ref="questionDAO" />
<property name="answerDAO" ref="answerDAO" />
<property name="globalCacheManager" ref="globalCacheManager" />
</bean>
</property>
<!-- DaytestLogicImpl是类,实现了接口 -->
<property name="proxyTargetClass" value="true" />
<property name="transactionManager" ref="daytestTransactionManager"/>
<!-- 定义了事物的执行策略，如传播属性，隔离等级等 -->
<property name="transactionAttributes">
<props>
<!-- PROPAGATION_REQUIRED支持当前事务，如果当前没有事务，就新建一个事务 -->
<prop key="save*">PROPAGATION_REQUIRED</prop>
<prop key="update*">PROPAGATION_REQUIRED</prop>
<!-- 事务属性中的readOnly标志表示对应的事务应该被最优化为只读事务 -->
<prop key="*">PROPAGATION_REQUIRED, readOnly</prop>
</props>
</property>
</bean>
TransactionProxyFactoryBean里的transactionAttributes，他的prop元素中的key属性定义了target类的某个方法，可以使用通配符，如save*，prop元素的值定义了对key中定义方法应用的事务执行属性，指定格式如下：
传播行为，隔离等级，只读，+异常，-异常
其中传播行为必须定义，其他可省，例如：
......
<prop key="xxxx">PROPAGATION_REQUIRED,readOnly,-DataAccessException</prop>
......
"-"表示发生指定异常后立即回滚，"+"表示发生指定异常后立即提交。
经过上面xml定义，就相当于在UserDaoImpl的saveOrUpdate方法前后加入了事务处理的代码。
定义了userDaoProxy后，我们在想使用userDaoImpl，就需要注入userDaoProxy的bean了，而不是userDaoImpl的bean
<property name="userDao">
<ref bean="userDaoProxy"/>
</property>
当不想使用事务管理时，把userController注入的userDaoProxy改为注入userDaoImpl就行了。
proxyTargetClass需要配置的情况只有一种:
当TestTram类有实现某个接口,而TestProxyClass类中配置的类对象是TestTram时(而不是TestTram实现的接口),这时候你需要配置proxyTargetClass=true
如果TestTram没有实现某个接口，而TestProxyClass类中配置的类对象是TestTram,这个时候我们是不需要配置proxyTargetClass=true的.(使用cgilib来动态代理)
如果TestTram实现某个接口, 而TestProxyClass类中配置的是TestTram实现的interface的话.那样我既不需要配置proxyInterface,也不需要配置proxyTargetClass
为什么我们在没有配置proxyInterface情况下,去配置proxyTargetClass.因为spring会去拿到当前配置的target实现的所有接口,然后通过动态代理出类.
