spring的事务处理分为两种：
1、编程式事务：在程序中控制事务开始，执行和提交；（不建议使用，所以这里我就不说明太多）
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:jee="http://www.springframework.org/schema/jee"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd
http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-4.2.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.2.xsd">
<!-- 类似于财务部门一样，类就是钱，所有需要类的实例都由srping去管理 -->
<!-- <context:component-scan>：
有一个use-default-filters属性，该属性默认为true,
这就意味着会扫描指定包下的全部的标有注解的类，并注册成bean.
可以发现这种扫描的粒度有点太大，如果你只想扫描指定包下面的Controller，
该怎么办？此时子标签<context:incluce-filter>就起到了勇武之地。如下所示
<context:component-scan base-package="news" use-default-filters="false">
<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>
如果use-dafault-filters在上面并没有指定，默认就为true，
也就意味着你现在加<context:exclude-filter/>跟没加是一样的
所有你要记住，你若想要用到<context:component-scan>的子标签，
必须要把use-dafault-filters的值改为false
当然还有一个是与之相反的而已这里就不啰嗦了
上面这一对解释换成一句话就是：
Use-dafault-filters=”false”的情况下：<context:exclude-filter>指定的不扫描，<context:include-filter>指定的扫描
<context:component-scan>的base-package属性作用：设置要被扫描的包 -->
<!-- （本案例不用到，只是用了一个全盘扫描，以上内容只是为了让大家了解它） -->
<context:component-scan base-package="news.."/>
<context:property-placeholder location="classpath:jdbc.properties"/>
<!-- <tx:annotation-driven transaction-manager="transactionManager"/> -->
<bean id="myDataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="driverClass" value="${jdbc.driver}"/>
<property name="jdbcUrl" value="${jdbc.url}"/>
<property name="user" value="${jdbc.user}"/>
<property name="password" value="${jdbc.password}"/>
<!-- 每300秒检查所有连接池中的空闲连接 -->
<property name="idleConnectionTestPeriod" value="300"/>
<!-- 最大空闲时间,900秒内未使用则连接被丢弃。若为0则永不丢弃 -->
<property name="maxIdleTime" value="900"/>
<!-- 最大连接数 -->
<property name="maxPoolSize" value="2"/>
</bean>
<bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
<property name="dataSource" ref="myDataSource"/>
<property name="hibernateProperties">
<props>
<prop key="hibernate.show_sql">true</prop>
<prop key="hibernate.format_sql">true</prop>
<prop key="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</prop>
<prop key="hibernate.connection.autocommit">false</prop>
<prop key="hibernate.hbm2ddl.auto">update</prop>
</props>
</property>
<property name="mappingResources">
<list>
<value>news/entity/News.hbm.xml</value>
</list>
</property>
</bean>
<bean id="transactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager">
<!-- 创建事务管理器, 管理sessionFactory(因为所有的session都是从sessionFactory获取的) -->
<property name="sessionFactory" ref="sessionFactory" />
</bean>
<!-- 配置通知, 那些方法需要切入什么类型的事务 -->
<tx:advice id="advice" transaction-manager="transactionManager">
<tx:attributes>
<tx:method name="add*" propagation="REQUIRED"/>
<tx:method name="del*" propagation="REQUIRED"/>
<tx:method name="update*" propagation="REQUIRED"/>
<tx:method name="*" propagation="SUPPORTS" read-only="true"/>
</tx:attributes>
</tx:advice>
<!-- 配置切面表达式, 并且让 tx与切面表达式合二为一 -->
<aop:config>
<!-- 表达式, 定义哪个包的哪些类需要切入事务,但是此处并且没有制定类中哪些方法,需要切入什么样 事务 -->
<aop:pointcut expression="execution(* news.service.*.*(..))" id="pointcut" />
<aop:advisor advice-ref="advice" pointcut-ref="pointcut"/>
</aop:config>
</beans>
相信这段代码对于我们初学者来说不是那么容易看懂，下面我来给大家分析吧：
1、创建事务管理器
2、配置通知
| 属性 | 必须 | 默认值 | 描述 |
| name | 是 | 要切入的方法名，可以用通配符 | |
| propagation | 不是 | REQUIRED | 事务传播行为 |
| isolation | 不是 | DEFAULT | 事务隔离级别 |
| timeout | 不是 | -1 | 事务超时的时间（以秒为单位） |
| read-only | 不是 | false | 事务是否只读？ |
| rollback-for | 不是 | 将被触发进行回滚的 Exception(s)；以逗号分开。 如：'news.serviceImpl' |
|
| no-rollback-for | 不是 | 不 被触发进行回滚的 Exception(s)；以逗号分开。 如：'news.serviceImpl' |
我解释一下execution(* news.service.*.*(..))"中几个通配符的含义：
第一个 * —— 通配 任意返回值类型
第二个 * —— 通配 包news.service下的任意class
第三个 * —— 通配 包news.service下的任意class的任意方法
第四个 .. —— 通配 方法可以有0个或多个参数
综上：包news.service下的任意class的具有任意返回值类型、任意数目参数和任意名称的方法
做到这里xml方式的事务管理基本就做完了，还差最后一步，那就是导入它相关的缺包（无论哪种形式的事务管理都要导入这些包）
如果没有这些包的朋友们可以去一下网址下载：http://pan.baidu.com/s/1eSlyY1G
最后再给大家讲一下注解形式的声明式事务管理吧
注解形式的声明式事务管理只要在applicationContext.xml这份文件里面加入一句
<tx:annotation-driven transaction-manager="transactionManager"/>
就可以从上面的代码中把下面写的那一大串xml去掉了，
<tx:advice id="advice" transaction-manager="transactionManager">
<tx:attributes>
<tx:method name="add*" propagation="REQUIRED"/>
<tx:method name="del*" propagation="REQUIRED"/>
<tx:method name="update*" propagation="REQUIRED"/>
<tx:method name="*" propagation="SUPPORTS" read-only="true"/>
</tx:attributes>
</tx:advice>
配置切面表达式, 并且让 tx与切面表达式合二为一
<aop:config>
表达式, 定义哪个包的哪些类需要切入事务,但是此处并且没有制定类中哪些方法,需要切入什么样 事务
<aop:pointcut expression="execution(* news.service.*.*(..))" id="pointcut" />
<aop:advisor advice-ref="advice" pointcut-ref="pointcut"/>
</aop:config>
有人会问，那怎么才能实现事务管理呢？
很简单，就不如你的那个类里面的全部方法都要加入事务管理，就可以直接在此类上面加入一个@Transactional注解就可以了
如果你只想一个方法加入事务管理，也可以直接单独在一个方法上面加入@Transactional注解
当然，这个注解还有一些属性比较常用的
| 参数名称 | 功能描述 |
| readOnly | 该属性用于设置当前事务是否为只读事务，设置为true表示只读，false则表示可读写，默认值为false。例如：@Transactional(readOnly=true) |
| rollbackFor |
该属性用于设置需要进行回滚的异常类数组，当方法中抛出指定异常数组中的异常时，则进行事务回滚。例如： 指定单一异常类：@Transactional(rollbackFor=RuntimeException.class) 指定多个异常类：@Transactional(rollbackFor={RuntimeException.class, Exception.class}) |
| rollbackForClassName |
该属性用于设置需要进行回滚的异常类名称数组，当方法中抛出指定异常名称数组中的异常时，则进行事务回滚。例如： 指定单一异常类名称：@Transactional(rollbackForClassName="RuntimeException") 指定多个异常类名称：@Transactional(rollbackForClassName={"RuntimeException","Exception"}) |
| noRollbackFor |
该属性用于设置不需要进行回滚的异常类数组，当方法中抛出指定异常数组中的异常时，不进行事务回滚。例如： 指定单一异常类：@Transactional(noRollbackFor=RuntimeException.class) 指定多个异常类：@Transactional(noRollbackFor={RuntimeException.class, Exception.class}) |
| noRollbackForClassName |
该属性用于设置不需要进行回滚的异常类名称数组，当方法中抛出指定异常名称数组中的异常时，不进行事务回滚。例如： 指定单一异常类名称：@Transactional(noRollbackForClassName="RuntimeException") 指定多个异常类名称： @Transactional(noRollbackForClassName={"RuntimeException","Exception"}) |
| propagation |
该属性用于设置事务的传播行为，具体取值可参考下面 例如：@Transactional(propagation=Propagation.NOT_SUPPORTED,readOnly=true) |
| isolation | 该属性用于设置底层数据库的事务隔离级别，事务隔离级别用于处理多事务并发的情况，通常使用数据库的默认隔离级别即可，基本不需要进行设置 |
| timeout | 该属性用于设置事务的超时秒数，默认值为-1表示永不超时 |
事物传播行为介绍:
@Transactional(propagation=Propagation.REQUIRED) ：如果有事务, 那么加入事务, 没有的话新建一个(默认情况下)
@Transactional(propagation=Propagation.NOT_SUPPORTED) ：容器不为这个方法开启事务
@Transactional(propagation=Propagation.REQUIRES_NEW) ：不管是否存在事务,都创建一个新的事务,原来的挂起,新的执行完毕,继续执行老的事务
@Transactional(propagation=Propagation.MANDATORY) ：必须在一个已有的事务中执行,否则抛出异常
@Transactional(propagation=Propagation.NEVER) ：必须在一个没有的事务中执行,否则抛出异常(与Propagation.MANDATORY相反)
@Transactional(propagation=Propagation.SUPPORTS) ：如果其他bean调用这个方法,在其他bean中声明事务,那就用事务.如果其他bean没有声明事务,
在以下情况中spring的事务管理会失效: ● private 方法无法添加事务管理. ● final 方法无法添加事务管理. ● static 方法无法添加事务管理. ● 当绕过代理对象, 直接调用添加事务管理的方法时, 事务管理将无法生效.