Spring JdbcTemplate 与 事务管理

Spring的JDBC框架能够承担资源管理和异常处理的工作,从而简化我们的JDBC代码,
让我们只需编写从数据库读写数据所必需的代码。Spring把数据访问的样板代码隐藏到模板类之下,
结合Spring的事务管理,可以大大简化我们的代码.

Spring提供了3个模板类：

JdbcTemplate：Spring里最基本的JDBC模板，利用JDBC和简单的索引参数查询提供对数据库的简单访问。
NamedParameterJdbcTemplate：能够在执行查询时把值绑定到SQL里的命名参数，而不是使用索引参数。
SimpleJdbcTemplate：利用Java 5的特性，比如自动装箱、通用（generic）和可变参数列表来简化JDBC模板的使用。
具体使用哪个模板基本上取决于个人喜好。

使用Spring的JdbcTemplate来实现简单的增删改查,首先建立测试数据表person
create table person(
id int not null primary key auto_increment,
name varchar(20) not null
)

导入依赖的jar包,由于测试中数据源使用的是dbcp数据源,需要以下jar包支持:
commons-logging.jar
commons-pool.jar
commons-dbcp.jar
同时还必须导入数据库驱动jar包:mysql-connector-java-3.1.8-bin.jar

建立实体bean
Person.java

package com.royzhou.jdbc; 
 
public class PersonBean { 
    private int id; 
    private String name; 
 
    public PersonBean() { 
    } 
     
    public PersonBean(String name) { 
        this.name = name; 
    } 
     
    public PersonBean(int id, String name) { 
        this.id = id; 
        this.name = name; 
    } 
      
    public int getId() { 
        return id; 
    } 
 
    public void setId(int id) { 
        this.id = id; 
    } 
 
    public String getName() { 
        return name; 
    } 
 
    public void setName(String name) { 
        this.name = name; 
    } 
     
    public String toString() { 
        return this.id + ":" + this.name; 
    } 
}

接口类:
PersonService.java

package com.royzhou.jdbc; 
 
import java.util.List; 
 
public interface PersonService { 
     
    public void addPerson(PersonBean person); 
     
    public void updatePerson(PersonBean person); 
     
    public void deletePerson(int id); 
     
    public PersonBean queryPerson(int id); 
     
    public List<PersonBean> queryPersons(); 
}

实现类:
PersonServiceImpl.java

package com.royzhou.jdbc; 
 
import java.util.List; 
 
import javax.sql.DataSource; 
import java.sql.Types; 
 
import org.springframework.jdbc.core.JdbcTemplate; 
 
public class PersonServiceImpl implements PersonService { 
 
    private JdbcTemplate jdbcTemplate; 
     
    /**
     * 通过Spring容器注入datasource
     * 实例化JdbcTemplate,该类为主要操作数据库的类
     * @param ds
     */ 
    public void setDataSource(DataSource ds) { 
        this.jdbcTemplate = new JdbcTemplate(ds); 
    } 
     
    public void addPerson(PersonBean person) { 
        /**
         * 第一个参数为执行sql
         * 第二个参数为参数数据
         * 第三个参数为参数类型
         */ 
        jdbcTemplate.update("insert into person values(null,?)", new Object[]{person.getName()}, new int[]{Types.VARCHAR}); 
    } 
 
    public void deletePerson(int id) { 
        jdbcTemplate.update("delete from person where id = ?", new Object[]{id}, new int[]{Types.INTEGER}); 
    } 
 
    public PersonBean queryPerson(int id) { 
        /**
         * new PersonRowMapper()是一个实现RowMapper接口的类,
         * 执行回调,实现mapRow()方法将rs对象转换成PersonBean对象返回
         */ 
        PersonBean pb = (PersonBean) jdbcTemplate.queryForObject("select id,name from person where id = ?", new Object[]{id}, new PersonRowMapper()); 
        return pb; 
    } 
 
    @SuppressWarnings("unchecked") 
    public List<PersonBean> queryPersons() { 
        List<PersonBean> pbs = (List<PersonBean>) jdbcTemplate.query("select id,name from person", new PersonRowMapper()); 
        return pbs; 
    } 
 
    public void updatePerson(PersonBean person) { 
        jdbcTemplate.update("update person set name = ? where id = ?", new Object[]{person.getName(), person.getId()}, new int[]{Types.VARCHAR, Types.INTEGER}); 
    } 
}

PersonRowMapper.java

package com.royzhou.jdbc; 
 
import java.sql.ResultSet; 
import java.sql.SQLException; 
 
import org.springframework.jdbc.core.RowMapper; 
 
public class PersonRowMapper implements RowMapper { 
    //默认已经执行rs.next(),可以直接取数据 
    public Object mapRow(ResultSet rs, int index) throws SQLException { 
        PersonBean pb = new PersonBean(rs.getInt("id"),rs.getString("name")); 
        return pb; 
    } 
}

我们需要在bean.xml中配置DataSource,并且将datasource注入到我们的业务类中

<?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" 
       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"> 
 
     <context:property-placeholder location="classpath: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> 
     
</beans>

jdbc.properties

driverClassName=org.gjt.mm.mysql.Driver 
url=jdbc:mysql://localhost:3306/royzhou?useUnicode=true&characterEncoding=UTF-8 
username=root 
password=123456 
initialSize=1 
maxActive=500 
maxIdle=2 
minIdle=1

编写我们的测试类:TestJdbcTemplate.java

package com.royzhou.jdbc;

import org.springframework.context.ApplicationContext; 
import org.springframework.context.support.ClassPathXmlApplicationContext; 
 
public class TestJdbcTemplate { 
    public static void main(String[] args) { 
        ApplicationContext ctx = new ClassPathXmlApplicationContext("bean.xml"); 
        PersonService ps = (PersonService)ctx.getBean("personService"); 
        ps.addPerson(new PersonBean("royzhou")); 
        PersonBean pb = ps.queryPerson(1); 
        System.out.println(pb); 
        pb.setName("haha"); 
        ps.updatePerson(pb); 
        pb = ps.queryPerson(1); 
        System.out.println(pb); 
        ps.deletePerson(1); 
        pb = ps.queryPerson(1); 
        System.out.println(pb); 
    } 
}

上面代码先插入一条记录,然后修改,之后删除,运行之后出现异常,异常信息:
EmptyResultDataAccessException: Incorrect result size: expected 1, actual 0

难道Spring的queryForObject在查找不到记录的时候会抛出异常,看了一下Spring的源代码 发现确实如此:

public Object queryForObject(String sql, Object[] args, int[] argTypes, RowMapper rowMapper) throws DataAccessException { 
        List results = (List) query(sql, args, argTypes, new RowMapperResultSetExtractor(rowMapper, 1)); 
        return DataAccessUtils.requiredUniqueResult(results); 
    } 
 
    public Object queryForObject(String sql, Object[] args, RowMapper rowMapper) throws DataAccessException { 
        List results = (List) query(sql, args, new RowMapperResultSetExtractor(rowMapper, 1)); 
        return DataAccessUtils.requiredUniqueResult(results); 
    } 
 
    public Object queryForObject(String sql, RowMapper rowMapper) throws DataAccessException { 
        List results = query(sql, rowMapper); 
        return DataAccessUtils.requiredUniqueResult(results); 
    } 
 
    public static Object requiredUniqueResult(Collection results) throws IncorrectResultSizeDataAccessException { 
        int size = (results != null ? results.size() : 0); 
        if (size == 0) { 
            throw new EmptyResultDataAccessException(1); // 问题在这里 
        } 
        if (!CollectionUtils.hasUniqueObject(results)) { 
            throw new IncorrectResultSizeDataAccessException(1, size); 
        } 
        return results.iterator().next(); 
    }

发现当查找不到记录是,requiredUniqueResult方法做了判断,抛出异常, 想不明白为什么Spring要在这里做这样的判断,为啥不返回null????

重新修改PersonServiceImple类,把queryPerson方法改为使用列表查询的方式再去根据index取
PersonServiceImpl.java

package com.royzhou.jdbc; 
 
import java.util.List; 
 
import javax.sql.DataSource; 
import java.sql.Types; 
 
import org.springframework.jdbc.core.JdbcTemplate; 
 
public class PersonServiceImpl implements PersonService { 
 
    private JdbcTemplate jdbcTemplate; 
     
    /**
     * 通过Spring容器注入datasource
     * 实例化JdbcTemplate,该类为主要操作数据库的类
     * @param ds
     */ 
    public void setDataSource(DataSource ds) { 
        this.jdbcTemplate = new JdbcTemplate(ds); 
    } 
     
    public void addPerson(PersonBean person) { 
        /**
         * 第一个参数为执行sql
         * 第二个参数为参数数据
         * 第三个参数为参数类型
         */ 
        jdbcTemplate.update("insert into person values(null,?)", new Object[]{person.getName()}, new int[]{Types.VARCHAR}); 
    } 
 
    public void deletePerson(int id) { 
        jdbcTemplate.update("delete from person where id = ?", new Object[]{id}, new int[]{Types.INTEGER}); 
    } 
 
    @SuppressWarnings("unchecked") 
    public PersonBean queryPerson(int id) { 
        /**
         * new PersonRowMapper()是一个实现RowMapper接口的类,
         * 执行回调,实现mapRow()方法将rs对象转换成PersonBean对象返回
         */ 
        List<PersonBean> pbs = (List<PersonBean>)jdbcTemplate.query("select id,name from person where id = ?", new Object[]{id}, new PersonRowMapper()); 
        PersonBean pb = null; 
        if(pbs.size()>0) { 
            pb = pbs.get(0); 
        } 
        return pb; 
    } 
 
    @SuppressWarnings("unchecked") 
    public List<PersonBean> queryPersons() { 
        List<PersonBean> pbs = (List<PersonBean>) jdbcTemplate.query("select id,name from person", new PersonRowMapper()); 
        return pbs; 
    } 
 
    public void updatePerson(PersonBean person) { 
        jdbcTemplate.update("update person set name = ? where id = ?", new Object[]{person.getName(), person.getId()}, new int[]{Types.VARCHAR, Types.INTEGER}); 
    } 
}

再次运行测试类,输出:
1:royzhou
1:haha
null

得到预期的结果.

从上面代码可以看出,使用Spring提供的JDBCTemplate类很大程度减少了我们的代码量,
比起以前我们写JDBC操作,需要先获取Connection,然后是PreparedStatement,再到Result,
使用Spring JDBCTemplate写出来的代码看起来更加简洁,开发效率也比较快.

在数据库的操作中,事务是一个重要的概念,举个例子:

大概每个人都有转账的经历。当我们从A帐户向B帐户转100元后，银行的系统会从A帐户上扣除100而在B帐户上加100，这是一般的正常现象。
但是一旦系统出错了怎么办呢，这里我们假设可能会发生两种情况：
（1）A帐户上少了100元，但是B帐户却没有多100元。
（2）B帐户多了100元钱，但是A帐户上却没有被扣钱。
这种错误一旦发生就等于出了大事，那么再假如一下，你要转账的是1亿呢？
所以上面的两种情况分别是你和银行不愿意看到的，因为谁都不希望出错。那么有没有什么方法保证一旦A帐户上没有被扣钱而B帐户上也没有被加钱；
或者A帐户扣了100元而B帐户准确无误的加上100元呢。也就是说要么转账顺利的成功进行，要么不转账呢？可以，这就是数据库事务机制所要起到的作用和做的事情。

Spring对事务的管理有丰富的支持,Spring提供了编程式配置事务和声明式配置事务:

声明式事务有以下两种方式
一种是使用Annotation注解的方式(官方推荐)
一种是基于Xml的方式

采用任何一种方式我们都需要在我们的bean.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"> 
 
    <context:property-placeholder location="classpath: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="personService" 
        class="com.royzhou.jdbc.PersonServiceImpl"> 
        <property name="dataSource" ref="dataSource"></property> 
    </bean> 
     
    <bean id="txManager" 
        class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> 
        <property name="dataSource" ref="dataSource" /> 
    </bean> 
     
    <tx:annotation-driven transaction-manager="txManager" />  
</beans>

<tx:annotation-driven transaction-manager="txManager" />  这句话的作用是注册事务注解处理器
定义好配置文件后我们只需要在我们的类上加上注解@Transactional,就可以指定这个类需要受Spring的事务管理
默认Spring为每个方法开启一个事务,如果方法发生运行期错误unchecked(RuntimeException),事务会进行回滚
如果发生checked Exception,事务不进行回滚.

例如在下面的例子中,我们为PersonServiceImpl添加事务支持.

package com.royzhou.jdbc; 
 
import java.util.List; 
 
import javax.sql.DataSource; 
import java.sql.Types; 
 
import org.springframework.jdbc.core.JdbcTemplate; 
import org.springframework.transaction.annotation.Transactional; 
 
@Transactional 
public class PersonServiceImpl implements PersonService { 
 
    private JdbcTemplate jdbcTemplate; 
     
    /**
     * 通过Spring容器注入datasource
     * 实例化JdbcTemplate,该类为主要操作数据库的类
     * @param ds
     */ 
    public void setDataSource(DataSource ds) { 
        this.jdbcTemplate = new JdbcTemplate(ds); 
    } 
     
    public void addPerson(PersonBean person) { 
        /**
         * 第一个参数为执行sql
         * 第二个参数为参数数据
         * 第三个参数为参数类型
         */ 
        jdbcTemplate.update("insert into person values(null,?)", new Object[]{person.getName()}, new int[]{Types.VARCHAR}); 
        throw new RuntimeException("运行期例外"); 
    } 
 
    public void deletePerson(int id) { 
        jdbcTemplate.update("delete from person where id = ?", new Object[]{id}, new int[]{Types.INTEGER}); 
    } 
 
    @SuppressWarnings("unchecked") 
    public PersonBean queryPerson(int id) { 
        /**
         * new PersonRowMapper()是一个实现RowMapper接口的类,
         * 执行回调,实现mapRow()方法将rs对象转换成PersonBean对象返回
         */ 
        List<PersonBean> pbs = (List<PersonBean>)jdbcTemplate.query("select id,name from person where id = ?", new Object[]{id}, new PersonRowMapper()); 
        PersonBean pb = null; 
        if(pbs.size()>0) { 
            pb = pbs.get(0); 
        } 
        return pb; 
    } 
 
    @SuppressWarnings("unchecked") 
    public List<PersonBean> queryPersons() { 
        List<PersonBean> pbs = (List<PersonBean>) jdbcTemplate.query("select id,name from person", new PersonRowMapper()); 
        return pbs; 
    } 
 
    public void updatePerson(PersonBean person) { 
        jdbcTemplate.update("update person set name = ? where id = ?", new Object[]{person.getName(), person.getId()}, new int[]{Types.VARCHAR, Types.INTEGER}); 
    } 
}

在addPerson方法中我们抛出了一个运行期例外,以此来检查Spring的事务管理.

编写测试类运行:

package com.royzhou.jdbc; 
 
import org.springframework.context.ApplicationContext; 
import org.springframework.context.support.ClassPathXmlApplicationContext; 
 
public class TestJdbcTemplate { 
    public static void main(String[] args) { 
        ApplicationContext ctx = new ClassPathXmlApplicationContext("bean.xml"); 
        PersonService ps = (PersonService)ctx.getBean("personService"); 
        ps.addPerson(new PersonBean("royzhou")); 
    } 
}

再次测试修改为抛出checked Exception

package com.royzhou.jdbc; 
 
import java.util.List; 
 
import javax.sql.DataSource; 
import java.sql.Types; 
 
import org.springframework.jdbc.core.JdbcTemplate; 
import org.springframework.transaction.annotation.Transactional; 
 
@Transactional 
public class PersonServiceImpl implements PersonService { 
 
    private JdbcTemplate jdbcTemplate; 
     
    /**
     * 通过Spring容器注入datasource
     * 实例化JdbcTemplate,该类为主要操作数据库的类
     * @param ds
     */ 
    public void setDataSource(DataSource ds) { 
        this.jdbcTemplate = new JdbcTemplate(ds); 
    } 
     
    public void addPerson(PersonBean person) throws Exception { 
        /**
         * 第一个参数为执行sql
         * 第二个参数为参数数据
         * 第三个参数为参数类型
         */ 
        jdbcTemplate.update("insert into person values(null,?)", new Object[]{person.getName()}, new int[]{Types.VARCHAR}); 
        throw new Exception("checked 例外"); 
    } 
 
    public void deletePerson(int id) { 
        jdbcTemplate.update("delete from person where id = ?", new Object[]{id}, new int[]{Types.INTEGER}); 
    } 
 
    @SuppressWarnings("unchecked") 
    public PersonBean queryPerson(int id) { 
        /**
         * new PersonRowMapper()是一个实现RowMapper接口的类,
         * 执行回调,实现mapRow()方法将rs对象转换成PersonBean对象返回
         */ 
        List<PersonBean> pbs = (List<PersonBean>)jdbcTemplate.query("select id,name from person where id = ?", new Object[]{id}, new PersonRowMapper()); 
        PersonBean pb = null; 
        if(pbs.size()>0) { 
            pb = pbs.get(0); 
        } 
        return pb; 
    } 
 
    @SuppressWarnings("unchecked") 
    public List<PersonBean> queryPersons() { 
        List<PersonBean> pbs = (List<PersonBean>) jdbcTemplate.query("select id,name from person", new PersonRowMapper()); 
        return pbs; 
    } 
 
    public void updatePerson(PersonBean person) { 
        jdbcTemplate.update("update person set name = ? where id = ?", new Object[]{person.getName(), person.getId()}, new int[]{Types.VARCHAR, Types.INTEGER}); 
    } 
}

后台输出异常:java.lang.Exception: checked 例外
查看数据库发现数据插入,说明事务没有进行了回滚.

说明了Spring的事务支持默认只对运行期异常(RuntimeException)进行回滚,这里可能有个疑问,我们执行sql操作的时候会发生sql异常,不属于运行期异常,那Spring是怎么进行事务回滚的呢 ????
查看了一下JdbcTemplate的源代码发现,JdbcTemplate的处理方法如下:

public int[] batchUpdate(String sql, final BatchPreparedStatementSetter pss) throws DataAccessException { 
    if (logger.isDebugEnabled()) { 
        logger.debug("Executing SQL batch update [" + sql + "]"); 
    } 
    return (int[]) execute(sql, new PreparedStatementCallback() { 
        public Object doInPreparedStatement(PreparedStatement ps) throws SQLException { 
            try { 
                int batchSize = pss.getBatchSize(); 
                if (JdbcUtils.supportsBatchUpdates(ps.getConnection())) { 
                    for (int i = 0; i < batchSize; i++) { 
                        pss.setValues(ps, i); 
                        ps.addBatch(); 
                    } 
                    return ps.executeBatch(); 
                } 
                else { 
                    int[] rowsAffected = new int[batchSize]; 
                    for (int i = 0; i < batchSize; i++) { 
                        pss.setValues(ps, i); 
                        rowsAffected[i] = ps.executeUpdate(); 
                    } 
                    return rowsAffected; 
                } 
            } 
            finally { 
                if (pss instanceof ParameterDisposer) { 
                    ((ParameterDisposer) pss).cleanupParameters(); 
                } 
            } 
        } 
    }); 
}

在代码中捕获了SQLException然后抛出一个org.springframework.dao.DataAcceddException,该异常继承自org.springframework.core.NestedRuntimeException,NestedRuntimeException
是一个继承自RuntimeException的抽象类,Spring jdbcTemplate处理发生异常处理后抛出来得异常基本上都会继承NestedRuntimeException,看完之后才确信了Spring默认只对RuntimeException进行回滚

当然我们可可以修改Spring的默认配置,当发生RuntimeException我们也可以不让他进行事务回滚
只需要加上一个@Transactional(noRollbackFor=RuntimeException.class)
注意@Transactional只能针对public属性范围内的方法添加

package com.royzhou.jdbc; 
 
import java.util.List; 
 
import javax.sql.DataSource; 
import java.sql.Types; 
 
import org.springframework.jdbc.core.JdbcTemplate; 
import org.springframework.transaction.annotation.Transactional; 
 
@Transactional 
public class PersonServiceImpl implements PersonService { 
 
    private JdbcTemplate jdbcTemplate; 
     
    /**
     * 通过Spring容器注入datasource
     * 实例化JdbcTemplate,该类为主要操作数据库的类
     * @param ds
     */ 
    public void setDataSource(DataSource ds) { 
        this.jdbcTemplate = new JdbcTemplate(ds); 
    } 
     
    @Transactional(noRollbackFor=RuntimeException.class) 
    public void addPerson(PersonBean person) { 
        /**
         * 第一个参数为执行sql
         * 第二个参数为参数数据
         * 第三个参数为参数类型
         */ 
        jdbcTemplate.update("insert into person values(null,?)", new Object[]{person.getName()}, new int[]{Types.VARCHAR}); 
        throw new RuntimeException("运行期例外"); 
    } 
 
    public void deletePerson(int id) { 
        jdbcTemplate.update("delete from person where id = ?", new Object[]{id}, new int[]{Types.INTEGER}); 
    } 
 
    @SuppressWarnings("unchecked") 
    public PersonBean queryPerson(int id) { 
        /**
         * new PersonRowMapper()是一个实现RowMapper接口的类,
         * 执行回调,实现mapRow()方法将rs对象转换成PersonBean对象返回
         */ 
        List<PersonBean> pbs = (List<PersonBean>)jdbcTemplate.query("select id,name from person where id = ?", new Object[]{id}, new PersonRowMapper()); 
        PersonBean pb = null; 
        if(pbs.size()>0) { 
            pb = pbs.get(0); 
        } 
        return pb; 
    } 
 
    @SuppressWarnings("unchecked") 
    public List<PersonBean> queryPersons() { 
        List<PersonBean> pbs = (List<PersonBean>) jdbcTemplate.query("select id,name from person", new PersonRowMapper()); 
        return pbs; 
    } 
 
    public void updatePerson(PersonBean person) { 
        jdbcTemplate.update("update person set name = ? where id = ?", new Object[]{person.getName(), person.getId()}, new int[]{Types.VARCHAR, Types.INTEGER}); 
    } 
}
package com.royzhou.jdbc; 
 
import org.springframework.context.ApplicationContext; 
import org.springframework.context.support.ClassPathXmlApplicationContext; 
 
public class TestJdbcTemplate { 
    public static void main(String[] args) { 
        ApplicationContext ctx = new ClassPathXmlApplicationContext("bean.xml"); 
        PersonService ps = (PersonService)ctx.getBean("personService"); 
        ps.addPerson(new PersonBean("royzhou")); 
    } 
}

后台抛出异常,查看数据库,记录插入进去了,说明我们配置事务不对RuntimeException回滚生效了.
既然可以配置不对RuntimeException回滚,那我们也可以配置对Exception进行回滚,主要用到的是
@Transactional(rollbackFor=Exception.class)

对于一些查询工作,因为不需要配置事务支持,我们配置事务的传播属性:
@Transactional(propagation=Propagation.NOT_SUPPORTED,readOnly=true)

readOnly=true表示事务中不允许存在更新操作.

关于事务的传播属性有下面几种配置:
REQUIRED：业务方法需要在一个事务中运行,如果方法运行时,已经处于一个事务中,那么加入到该事务中,否则自己创建一个新的事务.(Spring默认的事务传播属性)
NOT_SUPPORTED：声明方法不需要事务,如果方法没有关联到一个事务,容器不会为它开启事务,如果方法在一个事务中被调用,该事务被挂起,在方法调用结束后,原先的事务便会恢复执行
REQUIRESNEW：不管是否存在事务,业务方法总会为自己发起一个新的事务,如果方法运行时已经存在一个事务,则该事务会被挂起,新的事务被创建,知道方法执行结束,新事务才结束,原先的事务才恢复执行.
MANDATORY：指定业务方法只能在一个已经存在的事务中执行,业务方法不能自己发起事务,如果业务方法没有在事务的环境下调用,则容器会抛出异常
SUPPORTS:如果业务方法在事务中被调用,则成为事务中的一部分,如果没有在事务中调用,则在没有事务的环境下执行
NEVER：指定业务方法绝对不能在事务范围内运行,否则会抛出异常.
NESTED：如果业务方法运行时已经存在一个事务,则新建一个嵌套的事务,该事务可以有多个回滚点,如果没有事务,则按REQUIRED属性执行. 注意:业务方法内部事务的回滚不会对外部事务造成影响,但是外部事务的回滚会影响内部事务

关于使用注解的方式来配置事务就到这里,
我们还可以使用另外一种方式实现事务的管理,通过xml文件的配置,主要通过AOP技术实现:

首先把我们的业务类的注解去掉:

package com.royzhou.jdbc; 
 
import java.util.List; 
 
import javax.sql.DataSource; 
import java.sql.Types; 
 
import org.springframework.jdbc.core.JdbcTemplate; 
 
public class PersonServiceImpl implements PersonService { 
 
    private JdbcTemplate jdbcTemplate; 
     
    /**
     * 通过Spring容器注入datasource
     * 实例化JdbcTemplate,该类为主要操作数据库的类
     * @param ds
     */ 
    public void setDataSource(DataSource ds) { 
        this.jdbcTemplate = new JdbcTemplate(ds); 
    } 
     
    public void addPerson(PersonBean person) { 
        /**
         * 第一个参数为执行sql
         * 第二个参数为参数数据
         * 第三个参数为参数类型
         */ 
        jdbcTemplate.update("insert into person values(null,?)", new Object[]{person.getName()}, new int[]{Types.VARCHAR}); 
        throw new RuntimeException("运行期例外"); 
    } 
 
    public void deletePerson(int id) { 
        jdbcTemplate.update("delete from person where id = ?", new Object[]{id}, new int[]{Types.INTEGER}); 
    } 
     
    @SuppressWarnings("unchecked") 
    public PersonBean queryPerson(int id) { 
        /**
         * new PersonRowMapper()是一个实现RowMapper接口的类,
         * 执行回调,实现mapRow()方法将rs对象转换成PersonBean对象返回
         */ 
        List<PersonBean> pbs = (List<PersonBean>)jdbcTemplate.query("select id,name from person where id = ?", new Object[]{id}, new PersonRowMapper()); 
        PersonBean pb = null; 
        if(pbs.size()>0) { 
            pb = pbs.get(0); 
        } 
        return pb; 
    } 
 
    @SuppressWarnings("unchecked") 
    public List<PersonBean> queryPersons() { 
        List<PersonBean> pbs = (List<PersonBean>) jdbcTemplate.query("select id,name from person", new PersonRowMapper()); 
        return pbs; 
    } 
 
    public void updatePerson(PersonBean person) { 
        jdbcTemplate.update("update person set name = ? where id = ?", new Object[]{person.getName(), person.getId()}, new int[]{Types.VARCHAR, Types.INTEGER}); 
    } 
}

然后我们需要在bean.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"> 
 
    <context:property-placeholder location="classpath: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="personService" 
        class="com.royzhou.jdbc.PersonServiceImpl"> 
        <property name="dataSource" ref="dataSource"></property> 
    </bean> 
     
    <bean id="txManager" 
        class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> 
        <property name="dataSource" ref="dataSource" /> 
    </bean> 
     
    <!-- 定义事务传播属性 --> 
    <tx:advice id="txAdvice" transaction-manager="txManager"> 
        <tx:attributes> 
            <tx:method name="query*" propagation="NOT_SUPPORTED" read-only="true"/> 
            <tx:method name="*" propagation="REQUIRED"/> 
        </tx:attributes> 
    </tx:advice> 
     
    <aop:config> 
        <aop:pointcut id="transactionPointCut" expression="execution(* com.royzhou.jdbc..*.*(..))"/> 
        <aop:advisor pointcut-ref="transactionPointCut" advice-ref="txAdvice"/> 
    </aop:config> 
</beans>

从新运行测试类
后台抛出RuntimeException异常,查看数据库,没有插入数据,说明事务进行回滚,XML方式的配置也生效了.

另外还有一个编程式的事务处理,但是它有些侵入性。通常我们的事务需求并没有要求在事务的边界上进行如此精确的控制。
我们一般采用"声明式事务"。

总结一下:
事务是企业应用开发的重要组成部分，他使软件更加可靠。它们确保一种要么全有要么全无的行为，防止数据不一致而导致的不可预测的错误发生。
它们同时也支持并发，防止并发应用线程在操作同一数据时互相影响。以前我们写Jdbc代码的时候,可能需要自己手动去开启事务,然后方法执行结束之后
再去提交事务,全部都嵌套在我们的业务代码之中,具有很强的侵入性....
使用Spring提供事务管理机制,我们只需要配置XML或使用Annotion进行注解就可以实现事务的管理和配置,减少了代码之间的耦合,配置也很方便,很大程度上提升了我们的开发效率.

时间： 2024-11-16 16:29:26

Spring JdbcTemplate 与 事务管理的相关文章

Spring JdbcTemplate 与 事务管理 学习

Spring的JDBC框架能够承担资源管理和异常处理的工作,从而简化我们的JDBC代码, 让我们只需编写从数据库读写数据所必需的代码.Spring把数据访问的样板代码隐藏到模板类之下, 结合Spring的事务管理,可以大大简化我们的代码. Spring提供了3个模板类: JdbcTemplate:Spring里最基本的JDBC模板,利用JDBC和简单的索引参数查询提供对数据库的简单访问. NamedParameterJdbcTemplate:能够在执行查询时把值绑定到SQL里的命名参数,而不是使

Spring jdbctemplate和事务管理器 全注解配置 不使用xml

/** * spring的配置类,相当于bean.xml */@Configuration//@Configuration标注在类上,相当于把该类作为spring的xml配置文件中的<beans>// 作用为:配置spring容器(应用上下文)@ComponentScan("com.zxh")//需要扫描的包@Import({JdbcConfig.class,TransactionConfig.class})//子配置类@PropertySource("jdbcC

Spring声明式事务管理（基于注解方式实现）

----------------------siwuxie095 Spring 声明式事务管理(基于注解方式实现) 以转账为例 1.导入相关 jar 包(共 10 个包) (1)导入核心 jar 包和日志相关的 jar 包 (2)导入 JdbcTemplate 的 jar 包 (3)导入 MySQL 的 JDBC 驱动包 mysql-connector-java 下载链接: https://dev.mysql.com/downloads/connector/j/ (4)导入 AOP 的 jar

spring 声明式事务管理注解方式实现

使用注解实现Spring的声明式事务管理,更加简单! 步骤: 1) 必须引入Aop相关的jar文件 2) bean.xml中指定注解方式实现声明式事务管理以及应用的事务管理器类 3)在需要添加事务控制的地方,写上: @Transactional @Transactional注解: 1)应用事务的注解 2)定义到方法上: 当前方法应用spring的声明式事务 3)定义到类上:   当前类的所有的方法都应用Spring声明式事务管理; 4)定义到父类上: 当执行父类的方法时候应用事务. 案例: 1.

Spring中的事务管理

一.Spring事务管理用到的三个接口 a. PlatformTransactionManager 事务管理器 b. TransactionDefinition 事务定义信息(隔离.传播.超时.只读) c. TransactionStatus 事务具体的运行状态 二.Spring为不同的持久化框架提供了不同的PlatformTransactionManager接口实现 事务 说明 org.springframework.jdbc.datasource.DataSourceTransactionM

使用Spring配置文件实现事务管理

前面我们讲解了使用Spring注解方式来管理事务,现在我们就来学习使用Spring配置文件实现事务管理.本文是建立在使用Spring注解方式管理事务与传播行为详解案例基础之上的. 首先我们在cn.itcast.service.impl包下再新建一个业务bean——PersonServiceBean2.java,其代码为: /** * 使用JdbcTemplate进行insert/update/delete/select操作 * @author li ayun * */ public class

Spring对Hibernate事务管理【转】

在谈Spring事务管理之前我们想一下在我们不用Spring的时候,在Hibernate中我们是怎么进行数据操作的.在Hibernate中我们每次进行一个操作的的时候我们都是要先开启事务,然后进行数据操作,然后提交事务,关闭事务,我们这样做的原因是因为Hibernate默认的事务自动提交是false,他是需要我们人为的手动提交事务,假如你不想每次都手动提交事务的话,你可以在hibernate.cfg.xml我文件中把它设置为事务自动提交: <property name="hibernate

spring 声明式事务管理

简单理解事务: 比如你去ATM机取1000块钱,大体有两个步骤:首先输入密码金额,银行卡扣掉1000元钱:然后ATM出1000元钱.这两个步骤必须是要么都执行要么都不执行.如果银行卡扣除了1000块但是ATM出钱失败的话,你将会损失1000元:如果银行卡扣钱失败但是ATM却出了1000块,那么银行将损失1000元.所以,如果一个步骤成功另一个步骤失败对双方都不是好事,如果不管哪一个步骤失败了以后,整个取钱过程都能回滚,也就是完全取消所有操作的话,这对双方都是极好的. 当这两个步骤提交了,执行完毕

Spring框架的事务管理及应用

Spring框架简介 Spring框架是一个2003年2月才出现的开源项目,该开源项目起源自Rod Johnson在2002年末出版的<Expert One-on-One J2EE Design and Development>一书中的基础性代码.在该书中,Rod Johnson倡导J2EE实用主义的设计思想,而Spring框架正是这一思想的更全面和具体的实现.Spring框架由一个容器,一个配置和组织组件的框架,和一组内置的为事务.持久化和Web用户接口提供的服务组成.作为一种轻量级的J2E