Spring对JDBC的支持

1.jdbctemplate

为了使 jdbc 更加易于使用, spring 在 jdbc api 上定义了一个抽象层, 以此建立一个 jdbc 存取框架.作为 spring jdbc 框架的核心, jdbctemplate的设计目的是为不同类型的 jdbc 操作提供模板方法. 每个模板方法都能控制整个过程, 并允许覆盖过程中的特定任务. 通过这种方式, 可以在尽可能保留灵活性的情况下, 将数据库存取的工作量降到最低。

1.1 使用jdbctemplate更新数据库

db.properties

jdbc.user=root
jdbc.password=0404
jdbc.driverclass=com.mysql.jdbc.driver
jdbc.jdbcurl=jdbc:mysql://localhost:3303/extra

jdbc.initpoolsize=5
jdbc.maxpoolsize=10

在applicationcontext.xml中进行配置：

<!-- 导入资源文件 -->
<context:property-placeholder location="classpath:db.properties"/>
<!-- 配置c3p0数据源 -->
<bean id="datasource" class="com.mchange.v2.c3p0.combopooleddatasource">
  <property name="user" value="${jdbc.user}"/>
  <property name="password" value="${jdbc.password}"/>
  <property name="driverclass" value="${jdbc.driverclass}"/>
  <property name="jdbcurl" value="${jdbc.jdbcurl}"/>
  <property name="initialpoolsize" value="${jdbc.initpoolsize}"/>
  <property name="maxpoolsize" value="${jdbc.maxpoolsize}"/>
</bean>
<!-- 配置spring的jdbctemplate -->
<bean id="jdbctemplate" class="org.springframework.jdbc.core.jdbctemplate">
  <property name="datasource" ref="datasource"></property>
</bean>

customer.java

package com.java.spring.jdbc;

public class customer {
	private string id;
	private string name;
	private string email;
	private string birth;
	public string getid() {
		return id;
	}
	public void setid(string id) {
		id = id;
	}
	public string getname() {
		return name;
	}
	public void setname(string name) {
		name = name;
	}
	public string getemail() {
		return email;
	}
	public void setemail(string email) {
		email = email;
	}
	public string getbirth() {
		return birth;
	}
	public void setbirth(string birth) {
		birth = birth;
	}
	@override
	public string tostring() {
		return "customer [id=" + id + ", name=" + name + ", email=" + email + ", birth=" + birth + "]";
	}
}

使用jdbctemplate进行更新数据库：

private jdbctemplate  jdbctemplate=null;
jdbctemplate=(jdbctemplate) ctx.getbean("jdbctemplate");
@test
public void testupdate(){
	string sql="update customer set email=? where id=?";
	jdbctemplate.update(sql,"[e-mail]",1);
	system.out.println("update successful!");
}

1.2 使用jdbctemplate进行批量修改

@test
public void testbatchupdate(){
	string sql="insert into customer(id,name,email,birth) values(?,?,?,?)";
	list<object[]> batchargs=new arraylist<object[]>();
	batchargs.add(new object[]{"7","a","[e-mail]","1993-11-12"});
	batchargs.add(new object[]{"8","b","[e-mail]","1995-10-03"});
	batchargs.add(new object[]{"9","c","[e-mail]","1997-9-04"});
	batchargs.add(new object[]{"10","d","[e-mail]","1992-12-08"});
	jdbctemplate.batchupdate(sql, batchargs);
}

1.3 从数据库中获取一条记录，实际得到对应的一个对象

@test
public void testqueryforobject(){
	string sql = "select name,email,birth from customer where id=?";
	rowmapper<customer> rowmapper = new beanpropertyrowmapper<>(customer.class);
	list<customer> customer = jdbctemplate.query(sql, rowmapper,5);
	system.out.println(customer);
}

1.4 查找实体类的集合

@test
public void testqueryforlist(){
	string sql="select name,email,birth from customer where id>?";
	rowmapper<customer> rowmapper = new beanpropertyrowmapper<>(customer.class);
	list<customer> customers=jdbctemplate.query(sql, rowmapper,"5");
	system.out.println(customers);
}

1.5 获取单个列的值，或做统计查询

@test
public void testqueryforobject2(){
	string sql="select count(id) from customer";
	long count=jdbctemplate.queryforobject(sql, long.class);
	system.out.println(count);
}

2.在jdbc模板中使用具名参数

在经典的 jdbc 用法中, sql 参数是用占位符 ? 表示,并且受到位置的限制. 定位参数的问题在于, 一旦参数的顺序发生变化, 就必须改变参数绑定.

在 spring jdbc 框架中, 绑定 sql 参数的另一种选择是使用具名参数(named parameter). 具名参数是指sql 按名称(以冒号开头)而不是按位置进行指定. 这种方法更易于维护, 也提升了可读性. 具名参数只在 namedparameterjdbctemplate 中得到支持。

在xml中进行配置：

<bean id="namedparameterjdbctemplate" class="org.springframework.jdbc.core.namedparam.namedparameterjdbctemplate">
<constructor-arg ref="datasource"></constructor-arg>
</bean>

 使用具名参数更新数据库：

private namedparameterjdbctemplate namedparameterjdbctemplate=null;
namedparameterjdbctemplate = ctx.getbean(namedparameterjdbctemplate.class);
@test
public void testnamedparameterjdbctemplate(){
	string sql="insert into customer(name,email,birth) values(:name,:email,:birth)";
	customer customer=new customer();
	customer.setname("d");
	customer.setemail("[e-mail]");
	customer.setbirth("1993-02-12");
	sqlparametersource paramsource=new beanpropertysqlparametersource(customer);
	namedparameterjdbctemplate.update(sql,paramsource);
}

3.spring声明式事务

3.1 事务简介

事务管理是企业级应用程序开发中必不可少的技术,  用来确保数据的完整性和一致性. 事务就是一系列的动作, 它们被当做一个单独的工作单元. 这些动作要么全部完成, 要么全部不起作用。事务的四个关键属性(acid)：

• 原子性(atomicity): 事务是一个原子操作, 由一系列动作组成. 事务的原子性确保动作要么全部完成要么完全不起作用.
• 一致性(consistency): 一旦所有事务动作完成, 事务就被提交. 数据和资源就处于一种满足业务规则的一致性状态中.
• 隔离性(isolation): 可能有许多事务会同时处理相同的数据, 因此每个事物都应该与其他事务隔离开来, 防止数据损坏.
• 持久性(durability): 一旦事务完成, 无论发生什么系统错误, 它的结果都不应该受到影响. 通常情况下, 事务的结果被写到持久化存储器中.

3.2 spring中的事务管理

作为企业级应用程序框架, spring 在不同的事务管理 api 之上定义了一个抽象层. 而应用程序开发人员不必了解底层的事务管理 api, 就可以使用 spring 的事务管理机制.spring 既支持编程式事务管理, 也支持声明式的事务管理.

编程式事务管理: 将事务管理代码嵌入到业务方法中来控制事务的提交和回滚. 在编程式管理事务时, 必须在每个事务操作中包含额外的事务管理代码.

声明式事务管理: 大多数情况下比编程式事务管理更好用. 它将事务管理代码从业务方法中分离出来, 以声明的方式来实现事务管理. 事务管理作为一种横切关注点, 可以通过 aop 方法模块化. spring 通过 spring aop 框架支持声明式事务管理.

3.3 示例

如需要实现如下的需求：想要实现用户购买书，书库存和用户的账户余额正确更新。

有如下的三个数据表：isbn-->书单号； stock-->库存；  balance-->账户余额； price-->书单价；

customer.java

package com.java.spring.jdbc;

public class customer {
	private string id;
	private string name;
	private string email;
	private string birth;
	public string getid() {
		return id;
	}
	public void setid(string id) {
		id = id;
	}
	public string getname() {
		return name;
	}
	public void setname(string name) {
		name = name;
	}
	public string getemail() {
		return email;
	}
	public void setemail(string email) {
		email = email;
	}
	public string getbirth() {
		return birth;
	}
	public void setbirth(string birth) {
		birth = birth;
	}
	@override
	public string tostring() {
		return "customer [id=" + id + ", name=" + name + ", email=" + email + ", birth=" + birth + "]";
	}
}

bookshopdao.java

package com.java.spring.tx;

public interface bookshopdao {
	//根据书号获取书单价
	public int findbookpricebyisbn(string isbn);
	//更新书的库存
	public void updatebookstock(string isbn);
	//更新用户的账户余额
	public void useraccount(string username,int price);
}

bookshopdaoimpl.java

package com.java.spring.tx;

import org.springframework.beans.factory.annotation.autowired;
import org.springframework.jdbc.core.jdbctemplate;
import org.springframework.stereotype.repository;

@repository("bookshopdao")
public class bookshopdaoimpl implements bookshopdao {
    @autowired
    private jdbctemplate jdbctemplate;
    
	@override
	public int findbookpricebyisbn(string isbn) {
		string sql="select price from book where isbn=?";
		return jdbctemplate.queryforobject(sql,integer.class,isbn);
	}

	@override
	public void updatebookstock(string isbn) {
		string sql2="select stock from book_stock where isbn=?";
		int book_stock=jdbctemplate.queryforobject(sql2,integer.class,"1001");
		if(book_stock==0){
			throw new bookstockexception("库存不足");
		}
		string sql="update book_stock set stock=stock-1 where isbn=?";
		jdbctemplate.update(sql,isbn);
	}

	@override
	public void useraccount(string username, int price) {
		string sql2="select balance from account where username=?";
		int balance=jdbctemplate.queryforobject(sql2,integer.class,"a");
		if(balance<price){
			throw new useraccountexception("余额不足");
		}
		string sql="update account set balance=balance-? where username=?";
		jdbctemplate.update(sql,price,username);
	}

}

bookstockexception.java

package com.java.spring.tx;

public class bookstockexception extends runtimeexception{

	public bookstockexception() {
		super();
	}

	public bookstockexception(string message, throwable cause, boolean enablesuppression, boolean writablestacktrace) {
		super(message, cause, enablesuppression, writablestacktrace);
	}

	public bookstockexception(string message, throwable cause) {
		super(message, cause);
	}

	public bookstockexception(string message) {
		super(message);
	}

	public bookstockexception(throwable cause) {
		super(cause);
	}
	
}

useraccountexception.java

package com.java.spring.tx;

public class useraccountexception extends runtimeexception{

	public useraccountexception() {
		super();
	}

	public useraccountexception(string message, throwable cause, boolean enablesuppression,
			boolean writablestacktrace) {
		super(message, cause, enablesuppression, writablestacktrace);
	}

	public useraccountexception(string message, throwable cause) {
		super(message, cause);
	}

	public useraccountexception(string message) {
		super(message);
	}

	public useraccountexception(throwable cause) {
		super(cause);
	}
	
}

bookshopservicedao.java

package com.java.spring.tx;

public interface bookshopservicedao {
	public void bookshopservice(string username,string isbn);
}

bookshopservicedaoimpl.java

package com.java.spring.tx;

import org.springframework.beans.factory.annotation.autowired;
import org.springframework.context.applicationcontext;
import org.springframework.context.support.classpathxmlapplicationcontext;
import org.springframework.jdbc.core.jdbctemplate;
import org.springframework.stereotype.repository;
import org.springframework.transaction.annotation.transactional;

@repository("bookshopservicedao")
public class bookshopservicedaoimpl implements bookshopservicedao {
	@autowired
	private bookshopdao bookshopdao;
	@transactional
	@override
	public void bookshopservice(string username, string isbn) {
		//查找书的价格
		int price=bookshopdao.findbookpricebyisbn(isbn);
		//更新书的库存
		bookshopdao.updatebookstock(isbn);
		//更新用户余额
		bookshopdao.useraccount(username, price);
	}

}

springtransactiontest.java

package com.java.spring.tx;

import org.junit.test;
import org.springframework.context.applicationcontext;
import org.springframework.context.support.classpathxmlapplicationcontext;

public class springtransactiontest {
    private applicationcontext ctx=null;
    private bookshopdaoimpl bookshopdao=null;
    private bookshopservicedao bookshopservicedao;
    {
    	ctx=new classpathxmlapplicationcontext("applicationcontext.xml");
    	bookshopdao=ctx.getbean(bookshopdaoimpl.class);
    	bookshopservicedao=(bookshopservicedao) ctx.getbean("bookshopservicedao");
    }
    @test
    public void testbookshopservice(){
    	bookshopservicedao.bookshopservice("a","1001");
    }
	@test
	public void testfindbookpricebyisbn() {
		system.out.println(bookshopdao.findbookpricebyisbn("1001"));
	}

	@test
	public void testupdatebookstock() {
		bookshopdao.updatebookstock("1001");
		system.out.println("更新成功");
	}

	@test
	public void testuseraccount() {
		bookshopdao.useraccount("a",30);
	}

}

applicationcontext.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:p="http://www.springframework.org/schema/p"
	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-4.1.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.1.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd">
<!-- 导入资源文件 -->
<context:property-placeholder location="classpath:db.properties"/>
<!-- 配置c3p0数据源 -->
<bean id="datasource" class="com.mchange.v2.c3p0.combopooleddatasource">
  <property name="user" value="${jdbc.user}"/>
  <property name="password" value="${jdbc.password}"/>
  <property name="driverclass" value="${jdbc.driverclass}"/>
  <property name="jdbcurl" value="${jdbc.jdbcurl}"/>
  <property name="initialpoolsize" value="${jdbc.initpoolsize}"/>
  <property name="maxpoolsize" value="${jdbc.maxpoolsize}"/>
</bean>
<!-- 配置spring的jdbctemplate -->
<bean id="jdbctemplate" class="org.springframework.jdbc.core.jdbctemplate">
  <property name="datasource" ref="datasource"></property>
</bean>
<context:component-scan base-package="com.java.spring"></context:component-scan>
<!-- 配置事务管理器 -->
<bean id="transactionmanager" class="org.springframework.jdbc.datasource.datasourcetransactionmanager">
<property name="datasource" ref="datasource"></property>
</bean>
<!-- 启用事务注解 -->
<tx:annotation-driven transaction-manager="transactionmanager"/>
</beans>

上述代码中：

（1）bookshopdao.java中定义了一个接口，里面定义了三个方法，分别用来实现根据书单号获取书的价格，根据书单号更新书的库存，以及更新用户的账户余额；bookshopdaoimpl.java是该接口的实现类，采用jdbctemplate实现了数据库的存取操作，并且调用了自定义的异常方法；

（2）bookshopservicedao.java中定义了一个接口，接口中定义的方法用来为用户购买书提供账户更新操作。bookshopservicedaoimpl.java是该接口的实现类；

（3）bookshopservicedaoimpl.java中用了@transactional注解声明式地管理事务，为了将方法定义为支持事务处理的, 可以为方法添加 @transactional 注解. 根据 spring aop 基于代理机制, 只能标注公有方法.也可以在类级别上添加 @transactional 注解. 当把这个注解应用到类上时, 这个类中的所有公共方法都会被定义成支持事务处理的. 在 bean 配置文件中配置事务管理器并且启用 <tx:annotation-driven> 元素, 并为之指定事务管理器就可以了。

<!-- 配置事务管理器 -->
<bean id="transactionmanager" class="org.springframework.jdbc.datasource.datasourcetransactionmanager">
<property name="datasource" ref="datasource"></property>
</bean>
<!-- 启用事务注解 -->
<tx:annotation-driven transaction-manager="transactionmanager"/>

（4）在springtransactiontest.java中进行测试，当用户的账户余额不够书的单价时，抛出异常com.java.spring.tx.useraccountexception: 余额不足。

若没有在bookshopservice方法上加入声明式事务方法的注解，当用户的账户余额不足时，抛出异常com.java.spring.tx.useraccountexception: 余额不足。此时查看数据库：

正常余额不足时，书的库存是不能减少的，只要调用bookshopservice方法，更新书的库存的方法都会实现，即在判断用户余额是否不足之前，书的库存已经减少一本了（虽然用户并没有买这本书），导致用户的信息更新出错。因此需要加入事务管理，用来保证事务的完整性和一致性。也就是前面提到的“事务就是一系列的动作, 它们被当做一个单独的工作单元. 这些动作要么全部完成, 要么全部不起作用。”

public void bookshopservice(string username, string isbn) {
		//查找书的价格
		int price=bookshopdao.findbookpricebyisbn(isbn);
		//更新书的库存
		bookshopdao.updatebookstock(isbn);
		//更新用户余额
		bookshopdao.useraccount(username, price);
	}

3.4 事务的传播行为

当事务方法被另一个事务方法调用时, 必须指定事务应该如何传播. 例如: 方法可能继续在现有事务中运行, 也可能开启一个新事务, 并在自己的事务中运行.事务的传播行为可以由传播属性指定. spring 定义了 7  种类传播行为。

3.4.1 示例

如下修改数据库使得用户余额只够买一本书，不够支付第二本书：

定义cashier接口，用来表示用户的结账操作。

cashier.java

package com.java.spring.tx;

import java.util.list;

public interface cashier {
	public void checkout(string username,list<string> isbns);
}

cashierimpl.java

package com.java.spring.tx;

import java.util.list;

import org.springframework.stereotype.service;
import org.springframework.transaction.annotation.transactional;
@service("cashier")
public class cashierimpl implements cashier {
	private bookshopservicedao bookshopservice;
	@transactional
	@override
	public void checkout(string username, list<string> isbns) {
		for(string isbn:isbns){
			bookshopservice.bookshopservice(username, isbn);
		}
	}
}

在springtransactiontest.java中进行测试，运行一次后：

@test
public void testcashier(){
	cashier.checkout("a",arrays.aslist("1001","1002"));
}

账户余额不够支付两本书的价格：

再次测试，因为账户余额不够，所以抛出异常：com.java.spring.tx.useraccountexception: 余额不足。

再看数据库：

可以发现即使余额够其中一本书的价格，也没有支付成功。这是因为当 bookservice 的 bookshopservice() 方法被另一个事务方法 checkout() 调用时, 它默认会在现有的事务内运行. 这个默认的传播行为就是 required. 因此在 checkout() 方法的开始和终止边界内只有一个事务. 这个事务只在 checkout() 方法结束的时候被提交, 结果用户一本书都买不了。

另一种常见的传播行为是 requires_new. 它表示该方法必须启动一个新事务, 并在自己的事务内（bookshopservice()）运行. 如果有事务（checkout()）在运行, 就应该先挂起它。事务传播属性可以在 @transactional 注解的 propagation 属性中定义，如下在bookshopservice中新开启事务，

@transactional(propagation=propagation.requires_new)
@override
public void bookshopservice(string username, string isbn) {
	//查找书的价格
	int price=bookshopdao.findbookpricebyisbn(isbn);
	//跟新书的库存
	bookshopdao.updatebookstock(isbn);
	//更新用户余额
	bookshopdao.useraccount(username, price);
}

测试后查看数据库，用户的账户余额支付了第一本书的费用。

3.5 事务的隔离级别

从理论上来说, 事务应该彼此完全隔离, 以避免并发事务所导致的问题. 然而, 那样会对性能产生极大的影响, 因为事务必须按顺序运行. 在实际开发中, 为了提升性能, 事务会以较低的隔离级别运行，事务的隔离级别可以通过隔离事务属性指定。

3.5.1 spring支持的事务隔离级别

3.5.2 设置隔离事务属性

用 @transactional 注解声明式地管理事务时可以在 @transactional 的 isolation 属性中设置隔离级别。

3.5.3 设置回滚事务属性

默认情况下只有未检查异常(runtimeexception和error类型的异常)会导致事务回滚. 而受检查异常不会.事务的回滚规则可以通过 @transactional 注解的 rollbackfor 和 norollbackfor 属性来定义. 这两个属性被声明为 class[] 类型的, 因此可以为这两个属性指定多个异常类.

• rollbackfor:  遇到时必须进行回滚
• norollbackfor: 一组异常类，遇到时必须不回滚

3.5.4 超时和只读属性

由于事务可以在行和表上获得锁,  因此长事务会占用资源, 并对整体性能产生影响. 如果一个事物只读取数据但不做修改, 数据库引擎可以对这个事务进行优化.

• 超时事务属性: 事务在强制回滚之前可以保持多久. 这样可以防止长期运行的事务占用资源.
• 只读事务属性: 表示这个事务只读取数据但不更新数据, 这样可以帮助数据库引擎优化事务.

超时和只读属性可以在 @transactional 注解中定义.超时属性以秒为单位来计算。

@transactional(propagation=propagation.requires_new,readonly=true,timeout=30)