8.Spring + JDBC + 事务（注解）

这次，讲述的是如题，Spring+JDBC+事务（注解）。因为涉及到数据库的操作，所以顺道

把事务注解一起述说了，因为很简单。

数据源的配置、配置事务管理器（Spring中配置事务bean）和开启事务注解：

beans_4.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.xsd           http://www.springframework.org/schema/context           http://www.springframework.org/schema/context/spring-context-2.5.xsd           http://www.springframework.org/schema/aop           http://www.springframework.org/schema/aop/spring-aop-2.5.xsd           http://www.springframework.org/schema/tx           http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">    <!-- classpath:jdbc.properties表示类路径（src包）下的jdbc.properties -->    <context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder>    <bean id="dataSource" class="${dataSource}" 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>    <!-- 扫描com.zyy下所有子包的类 -->    <context:component-scan base-package="com.zyy"></context:component-scan>    <!-- 配置事务bean -->    <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">        <property name="dataSource" ref="dataSource"/>    </bean>    <!-- 开启事务注解 -->    <tx:annotation-driven transaction-manager="txManager"/></beans>

数据源的配置就是按照那个配置格式修改就可以了。

配置事务bean利用到了spring对jdbc的事务支持。

开启事务注解就一句话：<tx:annotation-driven transaction-manager="txManager"/>

xml中的value值采用了资源文件的形式存储在jdbc.properties：

dataSource = org.apache.commons.dbcp.BasicDataSourcedriverClassName = org.gjt.mm.mysql.Driverurl = jdbc:mysql://localhost:3306/ceshi_1?useUnicode=true&characterEncoding=UTF-8username = rootpassword = rootinitialSize = 1maxActive = 500maxIdle = 2minIdle = 1

配置一个bean，来执行事务和数据库操作。PersonServiceBean_6：

package com.zyy.service.impl;import com.zyy.dao.Person;import com.zyy.service.PersonService_6;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.jdbc.core.JdbcTemplate;import org.springframework.stereotype.Service;import org.springframework.transaction.annotation.Propagation;import org.springframework.transaction.annotation.Transactional;import javax.annotation.PostConstruct;import javax.sql.DataSource;import java.sql.Types;import java.util.List;/** * Created by CaMnter on 2014/8/22. *//** * @Transactional 事务注解 可以表示 这个bean下执行每一个方法的前都会打开失误 执行后都会关闭失误 * * 假如一个方法有多条sql语句 那么都会在一个事务内 ，不加注解则在不同的事务中执行 * @Transactional(noRollbackFor = Exception.class)  Exception异常不回滚 这样即使有异常也执行Sql * @Transactional(rollbackFor = Exception.class)    Exception异常回滚  有Exception异常 不执行 * * * 事务如果有异常 不处理 都会回滚 不执行sql * 如果有异常 处理了 不回滚 继续执行    这两点可以利用以上的特性修改 * @Transactional(propagation=Propagation.NOT_SUPPORTED) 表示不经过事务管理  被标注的方法不会开启事务 * * 事务的传播属性 * (80%使用)REQUIRED：业务方法需要在一个事务中运行。如果方法运行时，已经处在一个事务中，那么加入到该事务 *                    否则为自己创建一个新的事务。 * * NOT_SUPPORTED：声明方法不需要事务。如果方法没有关联到一个事务，容器不会为它开启事务。如果方法在一个事 *                务中被调用，该事务会被挂起，在方法调用结束后，原先的事务便会恢复执行。 * * REQUIRESNEW：属性表明不管是否存在事务，业务方法总会为自己发起一个新的事务。如果方法已经运行在一个事务中 *              则原有事务会被挂起，新的事务会被创建，直到方法执行结束，新事务才算结束，原先的事务才会恢复 *              执行。 * * MANDATORY：该属性指定业务方法只能在一个已经存在的事务中执行，业务方法不能发起自己的事务。如果业务方法在 *            没有事务的环境下调用，容器就会抛出例外。 * * SUPPORTS：这一事务属性表明，如果业务方法在某个事务范围内被调用，则方法成为该事务的一部分。如果业务方法在 *           事务范围外被调用，则方法在没有事务的环境下执行。 * * Never：指定业务方法绝对不能在事务范围内执行。如果业务方法在某个事务中执行，容器会抛出例外，只有业务方法没 *        有关联到任何事务，才能正常执行。 * * NESTED：如果一个活动的事务存在，则运行在一个嵌套的事务中. 如果没有活动事务, 则按REQUIRED属性执行.它使用了 *         一个单独的事务， 这个事务拥有多个可以回滚的保存点。内部事务的回滚不会对外部事务造成影响。它只对 *         DataSourceTransactionManager事务管理器起效 * * * 如果一个类标注了事务@Transactional * * 那么它的每一个方法都是默认标注了 @Transactional(propagation = Propagation.REQUIRED) * @Transactional(propagation=Propagation.NOT_SUPPORTED,readOnly = true)  只读事务 一般读取数据的时候用 * 可以提高性能 * * * * 数据库系统提供了四种事务隔离级别供用户选择。不同的隔离级别采用不同的锁类型来实现，在四种隔离级别中 * Serializable的隔离级别最高，Read Uncommited的隔离级别最低。大多数据库默认的隔离级别为 * Read Commited，如SqlServer，当然也有少部分数据库默认的隔离级别为Repeatable Read ，如Mysql * * (基本不用) Read Uncommited：读未提交数据(会出现脏读,不可重复读和幻读)。 * * Read Commited：读已提交数据(会出现不可重复读和幻读) * * (一般使用) Repeatable Read：可重复读(会出现幻读) * * Serializable：串行化 * * * 脏读：一个事务读取到另一事务未提交的更新新据。 * * 不可重复读：在同一事务中，多次读取同一数据返回的结果有所不同。换句话说就是，后续读取可以读到另一事务 * 已提交的更新数据。相反，“可重复读”在同一事务中多次读取数据时，能够保证所读数据一样，也就是，后续读取 * 不能读到另一事务已提交的更新数据。 * * * 幻读：一个事务读取到另一事务已提交的insert数据。 * * * Mysql 默认的是 ：Repeatable Read 可重复读(会出现幻读) * * 级别越高对于并发性能影响越大 */@Service("personServiceBean_6")@Transactionalpublic class PersonServiceBean_6 implements PersonService_6 {    /**     * Spring 提供的 org.springframework.jdbc.core.JdbcTemplate     * 用语操作数据库     */    private JdbcTemplate jdbcTemplate;    @Autowired()    private DataSource dataSource;    /**     * 实例化personServiceBean_6 前执行的方法     *      * 用于实例化JdbcTemplate 对象进行数据库操作     */    @PostConstruct    public void initJdbcTemplate() {        //System.out.println(dataSource);        this.jdbcTemplate = new JdbcTemplate(dataSource);    }    public void save(Person peroson) {        /**         * 第一参数：sql语句         * 第二参数：通配符（?）的值         * 第三参数：通配符（?）的值的类型         *           java.sql.Types中取得         */        this.jdbcTemplate.update("insert into person(name) values(?)",                new Object[]{peroson.getName()},                new int[]{Types.VARCHAR});    }    public void update(Person peroson) {        /**         * 第一参数：sql语句         * 第二参数：通配符（?）的值         * 第三参数：通配符（?）的值的类型         *           java.sql.Types中取得         */        this.jdbcTemplate.update("update person set name = ? where id = ?",                new Object[]{peroson.getName(), peroson.getId()},                new int[]{Types.VARCHAR, Types.INTEGER});    }    public void delete(Integer personId) {        /**         * 第一参数：sql语句         * 第二参数：通配符（?）的值         * 第三参数：通配符（?）的值的类型         *           java.sql.Types中取得         */        this.jdbcTemplate.update("delete from person where id = ?",                new Object[]{personId},                new int[]{Types.INTEGER});    }    /**     * 查询数据不需要事务，所有配成了propagation = Propagation.NOT_SUPPORTED     *     * 和readOnly = true     *     * 只读事务     *     * @param personId     * @return     */    @Transactional(propagation = Propagation.NOT_SUPPORTED, readOnly = true)    public Person getPerson(Integer personId) {        /**         * 第一参数：sql语句         * 第二参数：通配符（?）的值         * 第三参数：通配符（?）的值的类型         *           java.sql.Types中取得         * 第四参数：RowMapper类型         *          (这里需要设计一个RowMapper的子类用于返回数据)         */        return (Person) this.jdbcTemplate.queryForObject("select * from person where id = ?",                new Object[]{personId},                new int[]{Types.INTEGER},                new PersonRowMapper());    }    @Transactional(propagation = Propagation.NOT_SUPPORTED, readOnly = true)    public List<Person> getPersons() {        /**         * 第一参数：sql语句         * 第二参数：通配符（?）的值         * 第三参数：通配符（?）的值的类型         *           java.sql.Types中取得         * 第四参数：RowMapper类型         *          (这里需要设计一个RowMapper的子类用于返回数据)         */        return (List<Person>) this.jdbcTemplate.query("select * from person", new PersonRowMapper());    }}

需要的RowMapper的子类用于返回数据，PersonRowMapper：

package com.zyy.service.impl;import com.zyy.dao.Person;import org.springframework.jdbc.core.RowMapper;import java.sql.ResultSet;import java.sql.SQLException;/** * 外部已经做过了 if(resultSet.next()) */public class PersonRowMapper implements RowMapper {    public Object mapRow(ResultSet resultSet, int i) throws SQLException {        Person person = new Person(resultSet.getString("name")) ;        person.setId(resultSet.getInt("id"));        return person;    }}

配置事务很简单，只需要在类名上添加注解：@Transactional。

1.可以表示 这个bean下执行每一个方法的前都会打开失误 执行后都会关闭失误。

2.假如一个方法有多条sql语句 那么都会在一个事务内 ，不加注解则在不同的事务中执行。

3.@Transactional(noRollbackFor = Exception.class)  Exception异常不回

  滚 这样即使有异常也执行Sql
  @Transactional(rollbackFor = Exception.class)    Exception异常回滚

  有Exception异常 不执行

4.事务如果有异常 不处理 都会回滚 不执行sql。

5.如果有异常，处理了，不回滚，继续执行    这两点可以利用以上的特性修改然后使其回滚。

 （ @Transactional(rollbackFor = Exception.class) ）

接下来，介绍一下 事务的传播属性：

REQUIRED(80%使用率)：业务方法需要在一个事务中运行。如果方法运行时，已经处在一个事务中

                    那么加入到该事务，否则为自己创建一个新的事务。

NOT_SUPPORTED(查询操作可以加)：声明方法不需要事务。如果方法没有关联到一个事务，容器不会为

              它开启事务。如果方法在一个事务中被调用，该事务会被挂起，在方

              法调用结束后，原先的事务便会恢复执行。

REQUIRESNEW：属性表明不管是否存在事务，业务方法总会为自己发起一个新的事务。

             如果方法已经运行在一个事务中，则原有事务会被挂起，新的事务会被

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

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

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

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

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

          执行。

Never：指定业务方法绝对不能在事务范围内执行。如果业务方法在某个事务中执行，容器会

       抛出例外，只有业务方法没有关联到任何事务，才能正常执行。

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

       REQUIRED属性执行.它使用了一个单独的事务，这个事务拥有多个可以回滚的保存

       点。内部事务的回滚不会对外部事务造成影响。它只对DataSourceTransactionManager

       事务管理器起效

然后在了解一下，数据库系统提供了四种事务隔离级：

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

在四种隔离级别中，Serializable的隔离级别最高，Read Uncommited的隔离级别最

低。大多数据库默认的隔离级别为Read Commited，如SqlServer，当然也有少部分数

据库默认的隔离级别为Repeatable Read ，如Mysql

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

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

RepeatableRead：可重复读(会出现幻读)

Serializable：串行化

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

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

         可以读到另一事务已提交的更新数据。相反，“可重复读”在同一事务中多次读取数

         据时，能够保证所读数据一样，也就是，后续读取不能读到另一事务已提交的更新数

         据。

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

junit4.4测试代码：

package test.junit.test;import com.zyy.dao.Person;import com.zyy.service.PersonService_6;import org.junit.After;import org.junit.Before;import org.junit.Test;import org.springframework.context.ApplicationContext;import org.springframework.context.support.ClassPathXmlApplicationContext;/** * SpringJDBCTest Tester. * * @author <Authors name> * @version 1.0 */public class SpringJDBCTestTest {    private PersonService_6 personService_6 ;    @Before    public void before() throws Exception {        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans_4.xml");        this.personService_6 = (PersonService_6)applicationContext.getBean("personServiceBean_6");    }    @After    public void after() throws Exception {    }    @Test    public void save() {        personService_6.save(new Person("CaMnter"));    }    @Test    public void update() {        Person person = new Person("CaMnter_update") ;        person.setId(2);        personService_6.update(person);    }    @Test    public void delete() {        personService_6.delete(3);    }    @Test    public void getPerson() {        Person person = personService_6.getPerson(new Integer(2)) ;        System.out.println("id："+person.getId()+"   name："+person.getName());    }    @Test    public void getPersons() {        for (Person person : this.personService_6.getPersons()) {            System.out.println("id："+person.getId()+"   name："+person.getName());        }    }} 

那么，就来测试getPerson和getPersons吧：