- 浏览: 1493778 次
- 性别:
- 来自: 深圳
文章分类
- 全部博客 (523)
- JAVA (334)
- J2EE (18)
- JSP (21)
- JavaScript (14)
- it life (2)
- mobile develop (4)
- UBUNTU (14)
- Algorithm (14)
- DataBase (56)
- Browser/Server (1)
- linux (6)
- fedora (2)
- CSS (1)
- AjAX (3)
- HTML5 (1)
- EJB (1)
- osworkflow (2)
- Java face (5)
- spring (4)
- ICE (1)
- webService (2)
- MongoDB (1)
- JavaThread (4)
- JavaCollections (3)
- Hibernate (2)
- JavaMail (1)
- JavaBasic (1)
- Cache (1)
- https (4)
- DOM4J (1)
- JDOM (0)
- Mybatis (1)
- JUNIT (1)
- eclipse (1)
- easyMock (2)
最新评论
-
yadongliang:
...
自己认为的一些技术点 -
yadongliang:
每次看你头像都看的荷尔蒙分泌失调
WebService的两种方式SOAP和REST比较 (转) -
yadongliang:
hollo 写道一直有这种感觉,盲目的跟风,确实有一些人为了潮 ...
WebService的两种方式SOAP和REST比较 (转) -
welss:
博主,JNative怎么调用dll中的这种方法: int ...
JNative调用DLL -
Java_Antelope:
session.setAttribute和session.getAttribute(
我们都知道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>
(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 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>
</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>
<!-- 定义所有事务代理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>
<!-- 让事务代理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>
<!-- 让事务代理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 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的配置方式:
view plaincopy to clipboardprint?
<?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>
<?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> 发表于 @ 2009年08月09日 11:18:00 | 评论( 1 ) | 编辑| 举报| 收藏
本文来自CSDN博客,转载请标明出处:http://blog.csdn.net/java_min/archive/2009/08/09/4427523.aspx
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>
(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 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>
</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>
<!-- 定义所有事务代理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>
<!-- 让事务代理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>
<!-- 让事务代理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 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的配置方式:
view plaincopy to clipboardprint?
<?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>
<?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> 发表于 @ 2009年08月09日 11:18:00 | 评论( 1 ) | 编辑| 举报| 收藏
本文来自CSDN博客,转载请标明出处:http://blog.csdn.net/java_min/archive/2009/08/09/4427523.aspx
发表评论
-
Spring官网改版后下载
2014-04-11 10:39 767Spring官网改版后找了好久都没有找到直接下载Jar包的链接 ... -
Java 系统架构设计
2014-03-31 21:18 1479首先分为网关和引擎等多个部分: 第一部分:网关 1、主要负责转 ... -
Java 提高系统性能
2014-03-03 22:22 2610首先是从三方面来提高的,应用层面,服务器端层面,数据库层面。 ... -
2013年11月份艺龙旅行网面试题
2013-11-22 23:39 12611.给你两个字符串s1="abc",s2= ... -
国猪555555555
2013-11-22 00:16 1092国足第一招:场地太差,不适应。 国足第二招:场地太好,不适应。 ... -
自己认为的一些技术点
2013-08-14 00:12 12271.rest风格的编程。 2.memcached的命中率低的问 ... -
HttpClient
2013-01-14 23:57 1049package org.abin.lee.test.http; ... -
JAVA单例模式读取properties配置文件
2012-12-16 01:12 2661前段时间出差去做一个数据接口的项目,有很多参数需要从工程中的配 ... -
Java 反射调用方法
2012-10-22 23:52 975package lc.abin.lee.reflect; i ... -
Java Https单向,双向验证
2012-09-23 22:47 3007https一般来说有单项SSL和双向SSL连接之分。 单项 ... -
Java中的transient,volatile和strictfp关键字
2012-09-12 18:00 831http://www.iteye.com/topic/5295 ... -
Server JBoss v5.0 at localhost was unable to start within 50 seconds.
2012-09-05 11:35 1879[标题]:[转]JBoss was unable to sta ... -
HttpUrlConnection 开发例子
2012-03-25 16:23 3358/*** * * 发送HTTP请求 * @ ... -
Java Enum类型定义的方法
2012-03-12 12:34 2344//枚举接口 package com.abin.info.s ... -
Rational Rose 2003 下载及破解方法
2012-03-06 12:49 1392FROM:http://blog.csdn.net/fengl ... -
使用Spring进行面向切面(AOP)编程
2012-02-22 10:35 23431.aop理论知识 横切性关注点:对哪些方法拦截,拦截后怎么处 ... -
BASE64、MD5、SHA、HMAC几种加密算法
2012-02-21 12:53 8802BASE64编码算法不算是真正的加密算法。 MD5、 ... -
文本文件和二进制文件区别及java中字节流和字符流归纳
2012-02-17 15:48 2989首先在物理上文本文件和二进制文件并没有区别,都是以二进制01的 ... -
Java 字节流转化为文件
2012-02-17 15:46 5747已知:byte[] bytes=new FileToBytes ... -
Java核心之Java内存分配原理
2012-02-17 13:40 951JAVA内存分配与管理是Java的核心技术之一,之前我们曾介绍 ...
相关推荐
Spring事务管理的目的是确保数据的一致性和完整性,尤其是在多操作、多资源的环境中。本Demo将深入探讨Spring如何实现事务的管理。 首先,Spring提供了两种主要的事务管理方式:编程式事务管理和声明式事务管理。 ...
本资源包提供了进行Spring事务管理开发所需的所有关键库,包括框架基础、核心组件、AOP(面向切面编程)支持、日志处理、编译工具以及与数据库交互的相关jar包。下面将对这些知识点进行详细解释: 1. **Spring框架*...
本篇将深入探讨Spring事务管理的核心概念、工作原理以及如何使用`spring-tx-3.2.0.RELEASE.jar`这个jar包。 首先,我们需要理解什么是事务。在数据库系统中,事务是一组操作,这些操作被视为一个整体,要么全部完成...
标题“Spring事务管理失效原因汇总”指出了本文的核心内容是分析在使用Spring框架进行事务管理时可能遇到的问题及其原因。描述部分进一步说明了事务失效的后果往往不明显,容易在测试环节被忽略,但在生产环境中出现...
Spring 框架是Java开发中...理解并熟练掌握Spring事务管理,对于提升应用程序的稳定性和可靠性至关重要。在实际开发中,结合声明式事务管理、事务传播行为、隔离级别和回滚规则,可以有效地确保数据的完整性和一致性。
Spring事务管理.pdf 1.资料 2.本地事务与分布式事务 3.编程式模型 4.宣告式模型
本篇文章将深入探讨Spring事务管理的五种方法,旨在帮助开发者更好地理解和运用这一核心特性。 首先,我们来了解什么是事务。在数据库操作中,事务是一组逻辑操作,这些操作要么全部成功,要么全部失败,确保数据的...
### Spring事务管理详解 #### 一、Spring事务管理概述 Spring框架提供了强大的事务管理功能,使得开发者能够更方便地管理应用程序中的事务。Spring事务管理主要包括两种类型:编程式事务管理和声明式事务管理。 -...
实验 "Spring 声明事务" 是 Java 高级编程中的一个重要环节,旨在让学生掌握 Spring 框架中声明式事务管理的配置和使用。在实际应用中,事务管理是确保数据一致性、完整性和可靠性的关键组件。Spring 提供了声明式...
在Spring框架中,事务管理是核心功能之一,它确保了数据操作的一致性和完整性。本教程将深入探讨如何在Spring中实现自定义事务管理器...这将加深你对Spring事务管理的理解,帮助你在实际项目中更加熟练地运用这些技术。
Spring事务管理是Spring框架的核心特性之一,主要用于处理应用程序中的数据一致性问题。在Spring中,事务管理分为编程式和声明式两种方式。本篇文章将详细解释Spring事务管理的流程,以及如何通过时序图来理解这一...
### Spring事务与数据库操作 #### 一、Spring的声明式事务管理 在现代软件开发中,事务处理是非常关键的一部分,特别是在涉及多个数据操作时。Spring框架提供了强大的事务管理能力,可以方便地集成到应用程序中。...
首先,Spring事务管理的核心概念是ACID(原子性、一致性、隔离性和持久性),这是所有事务系统的基础。在Spring中,事务管理分为两种模式:声明式事务管理和编程式事务管理。声明式事务管理通过配置元数据(如XML或...
在本文中,我们将深入探讨Spring框架中的事务管理。Spring是一个广泛应用的Java企业级应用开发框架,它提供...如果你想要深入了解,可以参考提供的博客链接或其他相关资料,进一步学习Spring事务管理的细节和最佳实践。
Spring 框架的事务管理是其核心特性之一,它为开发者提供了强大的支持,确保了在多线程和并发环境中数据的一致性和完整性。本教程将深入探讨 Spring 的编程式事务管理和声明式事务管理,帮助你理解这两种方式的差异...
Spring 3.0 提供了两种事务管理配置方法:基于 XML 的事务管理和基于 @Transactional 的事务管理,这两种方法都是为了实现事务管理的目标,分别具有不同的配置方式和优缺点。 基于 XML 的事务管理 这种方法不需要...
Spring事务管理就是围绕这些特性来确保数据的一致性。 四、事务的传播行为 在Spring中,我们可以配置事务的传播行为,比如REQUIRED(默认,如果当前存在事务,则加入当前事务,否则新建一个事务)、PROPAGATION_...
Spring事务管理是企业级Java应用中不可或缺的一部分,它确保了数据的一致性和完整性,尤其是在多线程和分布式环境中。本实例将深入探讨Spring事务管理的实现与应用。 首先,Spring事务管理分为编程式事务管理和声明...