spring整合jdbc

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.Driverurl=jdbc\:mysql\://localhost\:3306/itcast?useUnicode\=true&characterEncoding\=UTF-8username=rootpassword=123456initialSize=1maxActive=500maxIdle=2minIdle=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/beans           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd           http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-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/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 @Transactionalpublic 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");    Savepoint savepoint = conn.setSavepoint();    try{               conn.createStatement().executeUpdate("update person set name='222' where sid=2");    }catch(Exception ex){            conn.rollback(savepoint);         }      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(){}        @Resource    public 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.Driverurl=jdbc\:mysql\://localhost/hibernateusername=rootpassword=yingerinitialSize=1maxActive=500maxIdle=2minIdle=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.xsd         http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd         http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd         http://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");        //save        for(int i=0;i<5;i++){            Person person = new Person("personname"+(i+1));            ps3.save(person);                }        //delete        ps3.delete(3);        //getPerson          Person p = ps3.getPerson(2);        p.setName("new name");        //update        ps3.update(p);        //getPersons        List<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.--------personname1new namepersonname4personname5

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

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

假设，如果在 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;@Transactionalpublic class PersonServiceBean5 implements PersonService3{        private JdbcTemplate jdbcTemplate;        //默认的构造器    public PersonServiceBean5(){}        @Resource    public 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*方法是不用使用事务的    @Transactional(propagation=Propagation.NOT_SUPPORTED)    public Person getPerson(int personid) {        return (Person)jdbcTemplate.queryForObject("select * from person where id=?", new Object[]{personid}, new PersonRowMapper());    }    //得到所有的person的方法    @Transactional(propagation=Propagation.NOT_SUPPORTED)    @SuppressWarnings("unchecked")    public List<Person> getPersons() {        return (List<Person>)jdbcTemplate.query("select * from person", new Object[]{}, new PersonRowMapper());    }}