1.与JDBC集成的配置步骤：

①配置数据源,如:

第一种方式：直接在XML中配置数据源：<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close"><property name="driverClassName" value="org.gjt.mm.mysql.Driver"/><property name="url" value="jdbc:mysql://localhost:3306/itcast?useUnicode=true&amp;characterEncoding=UTF-8"/><property name="username" value="root"/><property name="password" value="123456"/><!-- 连接池启动时的初始值 --><property name="initialSize" value="1"/><!-- 连接池的最大值 --><property name="maxActive" value="500"/><!-- 最大空闲值.当经过一个高峰时间后，连接池可以慢慢将已经用不到的连接慢慢释放一部分，一直减少到maxIdle为止 --><property name="maxIdle" value="2"/><!--  最小空闲值.当空闲的连接数少于阀值时，连接池就会预申请去一些连接，以免洪峰来时来不及申请 --><property name="minIdle" value="1"/></bean>第二种方式：使用属性占位符方式配置数据源<context:property-placeholder location=“jdbc.properties”/> <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close"><property name="driverClassName" value="${driverClassName}"/><property name="url" value="${url}"/><property name="username" value="${username}"/><property name="password" value="${password}"/><!-- 连接池启动时的初始值 --><property name="initialSize" value="${initialSize}"/><!-- 连接池的最大值 --><property name="maxActive" value="${maxActive}"/><!-- 最大空闲值.当经过一个高峰时间后，连接池可以慢慢将已经用不到的连接慢慢释放一部分，一直减少到maxIdle为止 --><property name="maxIdle" value="${maxIdle}"/><!--  最小空闲值.当空闲的连接数少于阀值时，连接池就会预申请去一些连接，以免洪峰来时来不及申请 --><property name="minIdle" value="${minIdle}"/></bean>其中，jdbc.properties 文件放在类路径下，内容如下：driverClassName=org.gjt.mm.mysql.Driver
url=jdbc\:mysql\://localhost\:3306/itcast?useUnicode\=true&characterEncoding\=UTF-8
username=root
password=123456
initialSize=1
maxActive=500
maxIdle=2
minIdle=1

两种方式各有优缺点，个人感觉第二种方式更好些，把jdbc的配置提出来，这样直接修改属性文件就可以更改jdbc的配置，

在XML中引用这些配置就像是使用EL表达式一样

initialSize：连接池启动时的初始值，一般2-3就足够了

maxActive：连接池最大的连接数，这个要根据应用的大小来定

maxIdle：最大空闲值.当经过一个高峰时间后，连接池可以慢慢将已经用不到的连接慢慢释放一部分，一直减少到maxIdle为止

minIdle：最小空闲值.当空闲的连接数少于阀值时，连接池就会预申请去一些连接，以免洪峰来时来不及申请

②配置事务。配置事务时，需要在xml配置文件中引入用于声明事务的tx命名空间

<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:aop="http://www.springframework.org/schema/aop"xmlns:context="http://www.springframework.org/schema/context"xmlns:tx="http://www.springframework.org/schema/tx"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-2.5.xsdhttp://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsdhttp://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsdhttp://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd"></beans>

注意要添加 tx 命名空间 以及 相应的 schemaLocation

事务的配置方式有两种：注解方式和基于XML配置方式。

①注解方式：

采用注解方式
<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"><property name="dataSource" ref="dataSource"/></bean><!– 采用@Transactional注解方式使用事务  --><tx:annotation-driven transaction-manager="txManager"/>@Service
public class PersonServiceBean implements PersonService {
}

[注意] 注解的使用建议：

②XML方式：

<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"><property name="dataSource" ref="dataSource"/>
</bean><aop:config><aop:pointcut id="transactionPointcut" expression="execution(* cn.itcast.service..*.*(..))"/><aop:advisor advice-ref="txAdvice" pointcut-ref="transactionPointcut"/>
</aop:config> <tx:advice id="txAdvice" transaction-manager="txManager"><tx:attributes><tx:method name="get*" read-only="true" propagation="NOT_SUPPORTED"/><tx:method name="*"/></tx:attributes>
</tx:advice>

配置中 <aop:config/> 的定义， 它确保由 'txAdvice' bean定义的事务通知在应用中合适的点被执行。 首先我们定义了 一个切面，

它匹配 Service 接口定义的所有操作， 我们把该切面叫做 'ServiceOperation'。然后我们用一个通知器（advisor）把这个切面与

'txAdvice' 绑定在一起， 表示当 'ServiceOperation' 执行时，'txAdvice' 定义的通知逻辑将被执行。

为不同的bean配置事务：

<tx:advice> 有关的设置：

2.使用Spring注解方式管理事务与传播行为

参考文档：

在理解Spring的声明式事务管理方面最重要的概念是：Spring的事务管理是通过AOP代理实现的。 其中的事务通知由元数据（目前基于XML或注解）驱动。

代理对象与事务元数据结合产生了一个AOP代理，它使用一个PlatformTransactionManager 实现品配合TransactionInterceptor，在方法调用前后实施事务。

事务传播属性：

REQUIRED：业务方法需要在一个事务中运行。如果方法运行时，已经处在一个事务中，那么加入到该事务，否则为自己创建一个新的事务。

NOT_SUPPORTED：声明方法不需要事务。如果方法没有关联到一个事务，容器不会为它开启事务。

如果方法在一个事务中被调用，该事务会被挂起，在方法调用结束后，原先的事务便会恢复执行。

REQUIRESNEW：属性表明不管是否存在事务，业务方法总会为自己发起一个新的事务。如果方法已经运行在一个事务中，则原有事务会被挂起，

新的事务会被创建，直到方法执行结束，新事务才算结束，原先的事务才会恢复执行。

MANDATORY：该属性指定业务方法只能在一个已经存在的事务中执行，业务方法不能发起自己的事务。

如果业务方法在没有事务的环境下调用，容器就会抛出例外。

SUPPORTS：这一事务属性表明，如果业务方法在某个事务范围内被调用，则方法成为该事务的一部分。

如果业务方法在事务范围外被调用，则方法在没有事务的环境下执行。

Never：指定业务方法绝对不能在事务范围内执行。如果业务方法在某个事务中执行，容器会抛出例外，只有业务方法没有关联到任何事务，才能正常执行。

NESTED：如果一个活动的事务存在，则运行在一个嵌套的事务中. 如果没有活动事务, 则按REQUIRED属性执行.

它使用了一个单独的事务，这个事务拥有多个可以回滚的保存点。内部事务的回滚不会对外部事务造成影响。

它只对DataSourceTransactionManager事务管理器起效

图解：

nested  介绍

Connection conn = null;
try {conn.setAutoCommit(false);Statement stmt = conn.createStatement();stmt.executeUpdate("update person set name='888' where id=1");try{   conn.createStatement().executeUpdate("update person set name='222' where sid=2");}catch(Exception ex){}stmt.executeUpdate("delete from person where id=9");conn.commit();stmt.close();} catch (Exception e) {conn.rollback();}finally{try {if(null!=conn && !conn.isClosed()) conn.close();} catch (SQLException e) { e.printStackTrace(); }}
}

上面的代码中间部分是由spring可我们创建的，它共有三条sql更新语句，中间的那个方法在外围是声明为nested！

中间的方法的事务对上下两个方法是不会有影响的

注意：默认情况下，遇到了运行期异常（unchecked异常的一种），事务会回滚；

遇到了checked异常，事务不会回滚。但是也可以用注解方式改变

参考文档：我们推荐做法是在Spring框架的事务架构里指出当context的事务里的代码抛出 Exception 时事务进行回滚。

Spring框架的事务基础架构代码将从调用的堆栈里捕获到任何未处理的 Exception，并将标识事务将回滚。

然而，请注意Spring框架的事务基础架构代码将默认地 只 在抛出运行时和unchecked exceptions时才标识事务回滚。

也就是说，当抛出一个 RuntimeException 或其子类例的实例时，（Errors 也一样 - 默认地 - 标识事务回滚。）从事务方法中

抛出的Checked exceptions将 不 被标识进行事务回滚。

可以通过设置 rollback-for 和  no-rollback-for  来修改默认的设置，决定事务是否回滚

指定回滚事务的方法：

3.数据库提供了四种事务隔离级别

数据库系统提供了四种事务隔离级别供用户选择。不同的隔离级别采用不同的锁类型来实现，在四种隔离级别中，

Serializable的隔离级别最高，Read Uncommited的隔离级别最低。大多数据库默认的隔离级别为Read Commited，如SqlServer

当然也有少部分数据库默认的隔离级别为Repeatable Read ，如Mysql

Read Uncommited：读未提交数据(会出现脏读,不可重复读和幻读)。

Read Commited：读已提交数据(会出现不可重复读和幻读)

Repeatable Read：可重复读(会出现幻读)

Serializable：串行化

脏读：一个事务读取到另一事务未提交的更新新据。

不可重复读：在同一事务中，多次读取同一数据返回的结果有所不同。换句话说就是，后续读取可以读到另一事务已提交的更新数据。

相反，“可重复读”在同一事务中多次读取数据时，能够保证所读数据一样，也就是，后续读取不能读到另一事务已提交的更新数据。

幻读：一个事务读取到另一事务已提交的insert数据。

本节测试代码：

首先，假设不使用事务！

新建一个接口：

package com.yinger.service;import java.util.List;import com.yinger.domain.Person;public interface PersonService3 {public void save(Person p);public void update(Person p);public void delete(int personid);public Person getPerson(int personid);public List<Person> getPersons();}

新建实现类：

package com.yinger.service.impl;import java.util.List;import javax.annotation.Resource;
import javax.sql.DataSource;import org.springframework.jdbc.core.JdbcTemplate;import com.yinger.domain.Person;
import com.yinger.service.PersonService3;public class PersonServiceBean5 implements PersonService3{private JdbcTemplate jdbcTemplate;//默认的构造器public PersonServiceBean5(){}@Resourcepublic void setDataSource(DataSource dataSource){jdbcTemplate = new JdbcTemplate(dataSource); // 用dataSource构造一个JdbcTemplate}//save方法public void save(Person p) {jdbcTemplate.update("insert into person(name) values(?)", new Object[]{p.getName()}, new int[]{java.sql.Types.VARCHAR});}//update方法public void update(Person p) {jdbcTemplate.update("update person set name=? where id=?", new Object[]{p.getName(),p.getId()}, new int[]{java.sql.Types.VARCHAR,java.sql.Types.INTEGER});}//delete方法public void delete(int personid) {jdbcTemplate.update("delete from person where id=?", new Object[]{personid}, new int[]{java.sql.Types.INTEGER});}//根据id得到person方法public Person getPerson(int personid) {return (Person)jdbcTemplate.queryForObject("select * from person where id=?", new Object[]{personid}, new PersonRowMapper());}//得到所有的person的方法@SuppressWarnings("unchecked")public List<Person> getPersons() {return (List<Person>)jdbcTemplate.query("select * from person", new Object[]{}, new PersonRowMapper());}}

在 Mysql 数据库中新建一个数据库 hibernate，新建一张表 person，里面有两个字段 id（int）[设置为主键，自增长]，name（varchar）

数据库连接的属性文件：

driverClassName=org.gjt.mm.mysql.Driver
url=jdbc\:mysql\://localhost/hibernate
username=root
password=yinger
initialSize=1
maxActive=500
maxIdle=2
minIdle=1

beans.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" xmlns:context="http://www.springframework.org/schema/context"xmlns:aop="http://www.springframework.org/schema/aop"xmlns:tx="http://www.springframework.org/schema/tx"xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsdhttp://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsdhttp://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsdhttp://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd"><context:annotation-config/><context:property-placeholder location="jdbc.properties" /><bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"destroy-method="close"><property name="driverClassName" value="${driverClassName}" /><property name="url" value="${url}" /><property name="username" value="${username}" /><property name="password" value="${password}" /><!-- 连接池启动时的初始值 --><property name="initialSize" value="${initialSize}" /><!-- 连接池的最大值 --><property name="maxActive" value="${maxActive}" /><!-- 最大空闲值.当经过一个高峰时间后，连接池可以慢慢将已经用不到的连接慢慢释放一部分，一直减少到maxIdle为止 --><property name="maxIdle" value="${maxIdle}" /><!-- 最小空闲值.当空闲的连接数少于阀值时，连接池就会预申请去一些连接，以免洪峰来时来不及申请 --><property name="minIdle" value="${minIdle}" /></bean><bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"><property name="dataSource" ref="dataSource" /></bean><!--  采用@Transactional注解方式使用事务  --><tx:annotation-driven transaction-manager="txManager" /><bean id="personService5" class="com.yinger.service.impl.PersonServiceBean5"></bean></beans>

测试代码：

    @Test  //用于测试事务管理的方法public void testTrancation() throws Exception {AbstractApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");System.out.println("--------");PersonService3 ps3 = (PersonService3)ctx.getBean("personService5");//savefor(int i=0;i<5;i++){Person person = new Person("personname"+(i+1));ps3.save(person);        }//deleteps3.delete(3);//getPerson  Person p = ps3.getPerson(2);p.setName("new name");//updateps3.update(p);//getPersonsList<Person> persons = ps3.getPersons();for(int i=0,size=persons.size();i<size;i++){System.out.println(persons.get(i).getName());}ctx.close();}

测试结果：

log4j:WARN No appenders could be found for logger (org.springframework.context.support.ClassPathXmlApplicationContext).
log4j:WARN Please initialize the log4j system properly.
--------

查看数据库也是如此，说明这个测试时可以的！

但是，想想，没有事务真的可以吗？ 不可以的！

假设，如果在 delete 方法中在添加一句 insert 语句

    //delete方法public void delete(int personid) {jdbcTemplate.update("delete from person where id=?", new Object[]{personid}, new int[]{java.sql.Types.INTEGER});jdbcTemplate.update("delete from person where id=?", new Object[]{personid}, new int[]{java.sql.Types.INTEGER});}

如果是这种方法，那么两次插入操作是在不同的事务中的，很显然这样就会造成一些问题！

如果希望两个操作要么都成功，要么都失败，那么就不可以了！

为了解决这些麻烦，Spring提供了事务管理器，通过一些配置就可以将方法设置成我们想要的事务类型

package com.yinger.service.impl;import java.util.List;import javax.annotation.Resource;
import javax.sql.DataSource;import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;import com.yinger.domain.Person;
import com.yinger.service.PersonService3;public class PersonServiceBean5 implements PersonService3{private JdbcTemplate jdbcTemplate;//默认的构造器public PersonServiceBean5(){}@Resourcepublic void setDataSource(DataSource dataSource){jdbcTemplate = new JdbcTemplate(dataSource); // 用dataSource构造一个JdbcTemplate}//save方法public void save(Person p) {jdbcTemplate.update("insert into person(name) values(?)", new Object[]{p.getName()}, new int[]{java.sql.Types.VARCHAR});}//update方法public void update(Person p) {jdbcTemplate.update("update person set name=? where id=?", new Object[]{p.getName(),p.getId()}, new int[]{java.sql.Types.VARCHAR,java.sql.Types.INTEGER});}//delete方法public void delete(int personid) {jdbcTemplate.update("delete from person where id=?", new Object[]{personid}, new int[]{java.sql.Types.INTEGER});}//根据id得到person方法    get*方法是不用使用事务的public Person getPerson(int personid) {return (Person)jdbcTemplate.queryForObject("select * from person where id=?", new Object[]{personid}, new PersonRowMapper());}//得到所有的person的方法@SuppressWarnings("unchecked")public List<Person> getPersons() {return (List<Person>)jdbcTemplate.query("select * from person", new Object[]{}, new PersonRowMapper());}}

OK 了！以上就是使用注解方式实现事务管理