框架学习之Spring 第四节 Spring集成JDBC组件开发

• Z时代
• 2024-01-10
• 分类：综合

本文内容纲要：框架学习之Spring 第四节 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&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/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 @Transactional
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");
    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.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.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.
--------
personname1
new name
personname4
personname5

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

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

假设，如果在 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;
@Transactional
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方法    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());
    }
}

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

本文内容总结：框架学习之Spring 第四节 Spring集成JDBC组件开发

原文链接：https://www.cnblogs.com/yinger/archive/2011/08/23/2151168.html

以上是 框架学习之Spring 第四节 Spring集成JDBC组件开发 的全部内容， 来源链接： utcz.com/z/362652.html