Spring事务以及三大框架整合

一、Spring事务管理

事务使用ACID特性来衡量事务的质量。介绍如下：
1，原子性
事务必须是原子的，在事务结束的时候，事务中的所有任务必须全部成功完成，否则全部失败，事务回滚到事务开始之间的状态。
2，一致性
事务必须保证和数据库的一致性，即数据库中的所有数据和现实保持一致。如果事务失败数据必须返回到事务执行之前的状态，反之修改数据和现实的同步。
3，隔离性
隔离性是事务与事务之间的屏障，每个事务必须与其他事务的执行结果隔离开，直到该事务执行完毕，它保证了事务的访问的任何数据不会受其他事务执行结果的影响。
4，持久性
如果事务成功执行，无论系统发生任何情况，事务的持久性都必须保证事务的执行结果是永久的。

1.2 Spring事务概念

事务管理在应用程序中起着至关重要的作用：它是一系列任务的组成工作单元，在这个工作单元中，所有的任务必须同时执行。它们只有二种可能执行结果，
要么所有任务全部执行成功，要么所有任务全部执行失败。
Spring中提供了丰富的事务管理功能，它们超过了EJB并且和EJB一样支持声明式事务，重要的是Spring提供了致的事务管理，它有如下优点。
1，为不同的事务的API提供一致的编程模式
2，提供更简单，更易地使用的编程式事务管理
3，支持Spring声明事务
4，整合Spring对数据访问的抽像

1，事务的传播行为
传播行为是事务应用于方法的边界，它定义了事务的建立，暂停等行为属性。

在Spring中共有7种，

*PROPAGATION_MANDATORY:
规定了方法必须在事务中运行，否则会抛出异常

*PROPAGATION_NESTED:
使方法运行在嵌套事务中，否则这个属性和PROPAGATION_REQUIRED属性的义相同

PROPAGATION_NEVER
使当前方法永远不在事务中运行，否则抛出异常

PROPAGATION_NOT_SUPPORTED
定义为当前事务不支持的方法，在该方法运行期间正在运行的事务会被暂停

*PROPAGATION_REQUIRED
规定当前的方法必须在事务中，如果没有事务就创建一个新事务，一个新事务和方法一同开始，随着方法的返回或抛出异常而终止

*PROPAGATION_REQUIRED_NEW
当前方法必须创建新的事务来运行，如果现存的事务正在运行就暂停它

PROPAGATION_SUPPORTS
规定当前方法支持当前事务处理，但如果没有事务在运行就使用非事务方法执行

以上定义Spring在事务中的传播行为分别对应EJB的事务CMT中的所有传播行为，其在PROPAGATION_NESTED是Spring在CMT之外定义的事务传播行为。

例如：
<property name="transactionAttributes">
<props>
<prop key="query*">PROPAGATION_REQUIRED,timeout_5,readOnly</prop>
<prop key="insert*">PROPAGATION_REQUIRED</prop>
<prop key="delete*">PROPAGATION_REQUIRED</prop>
</props>
</property>

2，事务的隔离级别
为解决事务之间的3个缺陷，必须在事务之间建立隔离关系来保证事务的完整性。
ISOLATION_DEFAULT
使用数据库默认的隔离级别
ISOLATION_COMMITTED
允许读取其他并发事务已经提交的更新（防此脏读）
ISOLATION_READ_UNCOMMITTED
允许读取其他并发事务还未提交的更新，会导致事务之间的3个缺陷发生，这是速度最快的一个隔离级别，
但同时它的隔离级别也是最低
ISOLATION_REPEATABLE_READ
除非事务自身修改了数据，否则规定事务多次重复读取        数据必须相同（防此脏读，不可重复读）
ISOLATION_SERIALIZABLE
这是最高的隔离级别，它可以防此脏读，不可重复读和        幻读等问题，但因其侵占式的数据记录完全锁定，导致
它影响事务的性能，成为隔离级别中最展慢的一个。
注意：并不是所有的资源管理器都支持所有的隔离级别，可针对不同的资源管理使用以上的隔离级别。

3，事务的只读属性
在对数据库的操作中，查询是使用最频繁的操作，每次执行查询时都要从数据库中重新读取数据，有时多次读取的数据都是相同的，
这样的数据操作不仅浪费了系统资源，还影响了系统速度。对访问量大的程序来说，节省这部分资源可以大大提升系统速度。
如果将事务声明为只读的，那么数据库可以根据事务的特性优化事务的读取操作。事务的只读属性需要配合事务的传播行为共同设置。例如：
<prop key="query*">PROPAGATION_REQUIRED,readOnly</prop>

4，事务的超时属性
这个属性和事务的只读属性一样需要搭配事务的传播行为共同设置，它设置了事务的超时时间，事务本身可能会因某种原因很长没有回应，
在这期间事务可能锁定了数据库的表格，这样会出现严重的性能问题。通过设置事务的超时时间，从开始执行事务起，在规定的超时时间内如果没有事务就将它回滚。
事务的超时属性以timeout_为前缀和一个整型数字定义，例如：
<prop key="query*">PROPAGATION_REGUIRED,timeout_5,readOnly</prop>

Spring的事务管理器有5个，都实现了PlatformTransactionManager接口，如下所示：

DataSourceTransactionManager           JDBC事务管理器
HibernateTransactionManager            Hibernate事务管理器
JdoTransactionManager                  JDO事务管理器
JtaTransactionManager                   JTA事务管理器
PersistenceBrokerTransactionManager    Apache的OJB事务管理器
<!-- 配置JDBC事务管理器 -->
<bean id="transactionManager"
class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource">
<ref bean="dataSource"/>
</property>
</bean>

<!-- 配置HibernateSessionFactory工厂 -->
<bean id="sessionFactory"
class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="dataSource" ref="dataSource" />
<property name="mappingResources">
<list>
<value>tarena/hbm/catelog.hbm.xml</value>
<value>tarena/hbm/bookinfo.hbm.xml</value>
<value>tarena/hbm/userinfo.hbm.xml</value>
<value>tarena/hbm/order.hbm.xml</value>
</list>
</property>
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">
org.hibernate.dialect.MySQL5Dialect
</prop>
<prop key="hibernate.query.substitutions">
true 'Y', false 'N'
</prop>
<prop key="hibernate.show_sql">true</prop>
</props>
</property>
</bean>

<!-- 配置Hibernate事务管理器 -->
<bean id="transactionManager"
class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory" />
</bean>

因为Spring中的事务是基于AOP实现的，而Spring的AOP是以方法为单位的，所以Spring的事务属性就对事务应用到方法上的策略描述，
这些属性为：传播行为，隔离级别，只读和超时属性。
Spring的声明式事务不涉及组建依赖关系，它通过AOP实现事务管理。Spring本身就是一个容器，相对EJB容器而言，Spring显得更为轻便，
在使用Spring的声明式事务时不须编写任何代码，便可通过实现基于容器的事务管理。Spring提供了一些可供选择的辅助类，这些辅助类简化了传统的数据库操作流程，
在一定程度上节省了工作量，提高了编码效率，所以推荐使用声明事务。
1，优化DataSource
DriverManagerDataSource数据源，它在每次获得数据连接时都创建一个新的连接对象，完全没有缓冲能力。
Spring没有提供连接的实现，因为一些开源项目已经实现了带有连接池功能的数据源，例如Apache Commons DBCP的BasicDataSource数据源。
这个数据源不仅提供了缓冲的连接池功能，而且它是一个完全轻量级的数据源。
在Spring中的配置方法如下：
<bean id="dataSource"
class="org.apache.commons.dbcp.BasicDataSource">
<property name="driverClassName">
<value>org.gjt.mm.mysql.Driver</value>
</property>
<property name="url">
<value>jdbc:mysql://localhost:3306/dbname</value>
</property>
<property name="username">
<value>root</value>
</property>
<property name="password">
<value>admin</value>
</property>
</bean>

2，使用事务代理工厂
事务代理工厂TransactionProxyFactoryBean包括了事务拦截器，目标代理和事务的属性设置，它配置方便，使用灵活，在声明式事务中广泛使用。
使用TransactionProxyFactoryBean需要注入它所依赖的事务管理器，设置代理的目标对象，代理对象的生成方式和事务属性。
代理对象是在目标对象上生成的包括事物和AOP切面的新对象，
这个新的对象用来替代目标对象以支持事物或AOP提供的切面功能。
其中对象代理的生成方式可根据CGLIB生成代理，例如：
<property name="proxyTargetClass" value="true"/>
最后再介绍一个TransactionProxyFactoryBean中如何设置事务的属性。TransactionProxyFactoryBean的transactionAttributes属性用于指定事务的属性，
它是一个Properties类型的属性集合，以方法名和事务属性组成键值对，给不同的方法指定不同的事务属性。例如:
<prop key="query*">PROPAGATION_REQUIRED,timeout_5,readOnly</prop>
方法名作为声明时，可以使用*通配符，上述代码定义对所有以query作前缀的方法，并在定义的事务中完成操作，事务的不同属性之间以","分隔。
通过一个实例介绍如何使用TransactionProxyFactoryBean完全成Spring的声明式事务管理。

<!-- 配置数据源 -->
<bean id="dataSource"
class="org.apache.commons.dbcp.BasicDataSource">
<property name="driverClassName">
<value>org.gjt.mm.mysql.Driver</value>
</property>
<property name="url">
<value>jdbc:mysql://localhost:3306/数据库Schema</value>
</property>
<property name="username">
<value>root</value>
</property>
<property name="password">
<value>admin</value>
</property>
</bean>
<!-- 配置JDBC事务管理器 -->
<bean id="transactionManager"
class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource">
<ref bean="dataSource" />
</property>
</bean>

<!-- 配置事件代理工厂 -->
<bean id="transactionProxy"
class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
<!-- 要依赖事务管理器 -->
<property name="transactionManager">
<ref bean="transactionManager"/>
</property>

<!-- 要依赖目标对象 -->
<property name="target">
<bean id="userDAO" class="tarena.dao.UserDAO">
<property name="dataSource">
<ref bean="dataSource"/>
</property>
</bean>
</property>

<!-- 要依赖代理方式 -->
<property name="proxyTargetClass" value="true"></property>

<!-- 要依赖事务属性 -->
<property name="transactionAttributes">
<props>
<prop key="query*">PROPAGATION_REQUIRED,timeout_1,readOnly</prop>
<prop key="insert*">PROPAGATION_REQUIRED,timeout_2</prop>
<prop key="delete*">PROPAGATION_REQUIRED</prop>
</props>
</property>
</bean>

１、 applicationContext.xml
<!-- 扫描注解组件 -->
<context:component-scan base-package="cn.lx"></context:component-scan>
<!--开启事务注解驱动,并指明使用的事务管理器 -->
<tx:annotation-driven transaction-manager="transactionManager"/>
<!-- C3P0数据源 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="driverClass" value="com.mysql.jdbc.Driver"></property>
<property name="jdbcUrl" value="jdbc:mysql://localhost:3306/shhtest"></property>
<property name="user" value="root"></property>
<property name="password" value="root"></property>
</bean>

<!-- 配置JabcTemplate -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource"></property>
</bean>

<!--  配置事务管理器-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"></property>
</bean>
2、DAO实现类
@Repository("accountDao")
public class AccountDaoImpl  implements AccountDao{
@Autowired
@Qualifier("jdbcTemplate")
private JdbcTemplate jdbcTemplate;}
3、Servcie实现类
@Service("accountService")
@Transactional//表示该类中的方法都要开启事务，也可以单独放在指定方法上，将指定方法开启事务
public class AccountServiceimpl implements AccountService {
@Autowired
@Qualifier("accountDao")
private AccountDao accountDao;

public void setAccountDao(AccountDao accountDao) {
this.accountDao = accountDao;
}
}

二、Struts2、Spring、Hibernate三大框架整合

1、web.xml配置文件
a.配置Struts2核心控制器
<!--配置Struts2核心控制器  -->
<filter>
<filter-name>struts2</filter-name>
<filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
b.配置监听器，用于加载Spring配置文件
listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
配置全局参数，用于指明spring配置文件位置
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:applicationContext.xml</param-value>
</context-param>
2、applicationContext.xml
将struts2中用到的对象都由Spring生成进行管理
<!--配置AccountAction  -->
<bean id="accountAction" class="cn.lx.web.action.AccountAction" scope="prototype">
<property name="accountService" ref="accountService"></property>
</bean>
3、struts.xml
配置action时，class属性原来写的是类全限定类名，现在改成applicationContext.xml中配置的id
<action name="accountAction_*" class="accountAction" method="{1}">
<result name="success">/index1.jsp</result>
</action>
4、整合完成
重点是struts中用的对象的class属性都为spring中配置对象的id值

1、ApplicationContext.xml文件中
a.配置数据源
<!--配置C3P0数据源  -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="driverClass" value="com.mysql.jdbc.Driver"></property>
<property name="jdbcUrl" value="jdbc:mysql://localhost:3306/shhtest"></property>
<property name="user" value="root"></property>
<property name="password" value="root"></property>
</bean>
b.配置SessionFactory对象
<!--配置SessionFactory 此步为Spring与Hibernate整合的关键  -->
<bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
<property name="dataSource" ref="dataSource"></property>
<property name="configLocations" value="classpath:hibernate.cfg.xml"></property>
</bean>
c.配置Hibernate事务管理器
<!-- 配置Hibernate事务管理器 -->
<bean id="transactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory"></property>
</bean>
d.配置Hibernate模板
<!--配置Hibernate模板  -->
<bean id="hibernateTemplate" class="org.springframework.orm.hibernate5.HibernateTemplate">
<property name="sessionFactory" ref="sessionFactory"></property>
</bean>
e.配置事务通知
<!-- 配置事务通知 -->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<tx:attributes>
<tx:method name="find*" read-only="true"/>
<tx:method name="save*" propagation="REQUIRED"/>
<tx:method name="update*" propagation="REQUIRED"/>
<tx:method name="delete*" propagation="REQUIRED"/>
<tx:method name="*" propagation="REQUIRED"/>
</tx:attributes>
</tx:advice>
f.配置AOP切点与事务通知组装
<!--配置事务通知与aop切点组装  -->
<aop:config>
<aop:pointcut expression="execution(* cn.lx.service.impl.*.*(..))" id="myPointcut"/>
<aop:advisor advice-ref="txAdvice" pointcut-ref="myPointcut"/>
</aop:config>
2、hibernate.cfg.xml文件中
除了不需要配置连接数据库信息，其他和以前一样
3、DAO实现类
//HiernateTemplate模板，用于简化JDBC操作
private HibernateTemplate hibernateTemplate;

public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {
this.hibernateTemplate = hibernateTemplate;
}

其他知识点

1、Spring与Junit单元测试集成
导入spring-test.jar包
测试类中，加上注解
@RunWith(SpringJUnit4ClassRunner.class)//表示使用spring的junit测试
@ContextConfiguration("classpath:applicationContext.xml")//加载配置文件，获取容器
@Autowired
@Qualifier("accountService")
private AccountService accountService;