Spring对JDBC的支持

阅读精选内容,加入我们投稿,点这里!

点击蓝字“程序员考拉”欢迎关注!

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,"1232343536@163.com",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","2324341342@163.com","1993-11-12"});
 batchArgs.add(new Object[]{"8","B","2342554466@163.com","1995-10-03"});
 batchArgs.add(new Object[]{"9","C","8775643232@163.com","1997-9-04"});
 batchArgs.add(new Object[]{"10","D","4546765768@163.com","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("D@163.com");
 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-->书单价;


Spring对JDBC的支持


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: 余额不足。


Spring对JDBC的支持


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


Spring对JDBC的支持


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


public void bookShopService(String username, String isbn) {
   //查找书的价格
   int price=bookShopDao.findBookPriceByIsbn(isbn);
   //更新书的库存
   bookShopDao.updateBookStock(isbn);
   //更新用户余额
   bookShopDao.UserAccount(username, price);
 }


3.4 事务的传播行为

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


Spring对JDBC的支持


3.4.1 示例

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


Spring对JDBC的支持


定义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"));
}


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


Spring对JDBC的支持


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


再看数据库:

Spring对JDBC的支持


可以发现即使余额够其中一本书的价格,也没有支付成功。这是因为当 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);
}


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


Spring对JDBC的支持


3.5 事务的隔离级别

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


3.5.1 Spring支持的事务隔离级别


Spring对JDBC的支持


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)



 

Spring对JDBC的支持


发表评论