MyException - 我的异常网
当前位置:我的异常网» 数据库 » spring调整jdbc

spring调整jdbc

www.MyException.Cn  网友分享于:2013-09-23  浏览:11次
spring整合jdbc

框架学习之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&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/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 {
}

 

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

15

 

②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配置事务:

13

 

<tx:advice> 有关的设置:

14

 

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

参考文档:

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

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

 

事务传播属性:

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

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

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

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

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

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

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

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

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

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

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

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

它只对DataSourceTransactionManager事务管理器起效

图解:

16

 

17

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  来修改默认的设置,决定事务是否回滚

指定回滚事务的方法:

12

 

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());
    }

}

文章评论

 程序员的样子
程序员的样子
我是如何打败拖延症的
我是如何打败拖延症的
写给自己也写给你 自己到底该何去何从
写给自己也写给你 自己到底该何去何从
程序员必看的十大电影
程序员必看的十大电影
程序猿的崛起——Growth Hacker
程序猿的崛起——Growth Hacker
总结2014中国互联网十大段子
总结2014中国互联网十大段子
那些争议最大的编程观点
那些争议最大的编程观点
鲜为人知的编程真相
鲜为人知的编程真相
为啥Android手机总会越用越慢?
为啥Android手机总会越用越慢?
为什么程序员都是夜猫子
为什么程序员都是夜猫子
亲爱的项目经理,我恨你
亲爱的项目经理,我恨你
老美怎么看待阿里赴美上市
老美怎么看待阿里赴美上市
程序员眼里IE浏览器是什么样的
程序员眼里IE浏览器是什么样的
程序员和编码员之间的区别
程序员和编码员之间的区别
5款最佳正则表达式编辑调试器
5款最佳正则表达式编辑调试器
团队中“技术大拿”并非越多越好
团队中“技术大拿”并非越多越好
初级 vs 高级开发者 哪个性价比更高?
初级 vs 高级开发者 哪个性价比更高?
中美印日四国程序员比较
中美印日四国程序员比较
我跳槽是因为他们的显示器更大
我跳槽是因为他们的显示器更大
做程序猿的老婆应该注意的一些事情
做程序猿的老婆应该注意的一些事情
Web开发人员为什么越来越懒了?
Web开发人员为什么越来越懒了?
Java程序员必看电影
Java程序员必看电影
什么才是优秀的用户界面设计
什么才是优秀的用户界面设计
编程语言是女人
编程语言是女人
十大编程算法助程序员走上高手之路
十大编程算法助程序员走上高手之路
10个帮程序员减压放松的网站
10个帮程序员减压放松的网站
旅行,写作,编程
旅行,写作,编程
一个程序员的时间管理
一个程序员的时间管理
代码女神横空出世
代码女神横空出世
60个开发者不容错过的免费资源库
60个开发者不容错过的免费资源库
程序员的鄙视链
程序员的鄙视链
我的丈夫是个程序员
我的丈夫是个程序员
不懂技术不要对懂技术的人说这很容易实现
不懂技术不要对懂技术的人说这很容易实现
程序员的一天:一寸光阴一寸金
程序员的一天:一寸光阴一寸金
每天工作4小时的程序员
每天工作4小时的程序员
程序员都该阅读的书
程序员都该阅读的书
“懒”出效率是程序员的美德
“懒”出效率是程序员的美德
科技史上最臭名昭著的13大罪犯
科技史上最臭名昭著的13大罪犯
Java 与 .NET 的平台发展之争
Java 与 .NET 的平台发展之争
如何区分一个程序员是“老手“还是“新手“?
如何区分一个程序员是“老手“还是“新手“?
看13位CEO、创始人和高管如何提高工作效率
看13位CEO、创始人和高管如何提高工作效率
要嫁就嫁程序猿—钱多话少死的早
要嫁就嫁程序猿—钱多话少死的早
程序员周末都喜欢做什么?
程序员周末都喜欢做什么?
老程序员的下场
老程序员的下场
聊聊HTTPS和SSL/TLS协议
聊聊HTTPS和SSL/TLS协议
软件开发程序错误异常ExceptionCopyright © 2009-2015 MyException 版权所有