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)：
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[] 类型的, 因此可以为这两个属性指定多个异常类.
3.5.4 超时和只读属性
由于事务可以在行和表上获得锁, 因此长事务会占用资源, 并对整体性能产生影响. 如果一个事物只读取数据但不做修改, 数据库引擎可以对这个事务进行优化.
超时和只读属性可以在 @transactional 注解中定义.超时属性以秒为单位来计算。
@transactional(propagation=propagation.requires_new,readonly=true,timeout=30)
如对本文有疑问， 点击进行留言回复！！
详解SpringBoot修改启动端口server.port的四种方式
网友评论