Spring JdbcTemplate&声明式事务
1、JdbcTemplate基本使用
1)、JdbcTemplate基本使用-概述(了解)
JdbcTemplate是spring框架中提供的一个对象,是对原始繁琐的Jdbc API对象的简单封装。spring框架为我们提供了很多的操作模板类。例如:操作关系型数据的JdbcTemplate和HibernateTemplate,操作nosql数据库的RedisTemplate,操作消息队列的JmsTemplate等等。
2)、JdbcTemplate基本使用-开发步骤(理解)
①导入spring-jdbc和spring-tx(事务)坐标
②创建数据库表和实体
③创建JdbcTemplate对象 设置连接池
④执行数据库操作
3)、JdbcTemplate基本使用-快速入门代码实现(应用)
①导入Spring-jdbc和Spring-tx坐标(依赖)
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.0.5.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
<version>5.0.5.RELEASE</version>
</dependency>
<!--使用jdk1.8版本编译-->
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.1</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
</plugins>
</build>
②创建数据库表和实体
package com.ppvir.domain;
public class Account {
private String name;
private double money;
public String getNa me() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getMoney() {
return money;
}
public void setMoney(double money) {
this.money = money;
}
@Override
public String toString() {
return "Account{" +
"name='" + name + '\'' +
", money=" + money +
'}';
}
}
③创建JdbcTemplate对象 设置连接池
④执行数据库操作
@Test
//测试JdbcTemplate开发步骤
public void test1() throws PropertyVetoException {
//2,创建数据源对象,c3p0连接池
ComboPooledDataSource dataSource = new ComboPooledDataSource();
//数据库参数设置
dataSource.setDriverClass("com.mysql.jdbc.Driver");
dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/test");
dataSource.setUser("root");
dataSource.setPassword("root");
JdbcTemplate jdbcTemplate = new JdbcTemplate();
//1,设置数据源对象 知道数据库在哪
jdbcTemplate.setDataSource(dataSource);
//3、执行数据库操作
int row = jdbcTemplate.update("insert into account values(?,?)", "java", 18000);
System.out.println(row);
}
4)、JdbcTemplate基本使用-spring产生模板对象分析(理解)
我们可以将JdbcTemplate的创建权交给Spring,
将数据源DataSource的创建权也交给Spring,
在Spring容器内部将数据源DataSource注入到JdbcTemplate模版对象中,
然后通过Spring容器获得JdbcTemplate对象来执行操作。
注入与被注入对象都必须在spring容器中
5)、JdbcTemplate基本使用-spring产生模板对象代码实现(应用)
在上面例子的基础上,编写applicationContext.xml配置数据源对象
配置:
applicationContext.xml
<!--数据源连接池对象-->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPoolDataSource">
<property name="driverClass" value="com.mysql.jdbc.Driver"></property>
<property name="jdbcUrl" value="jdbc:mysql://localhost:3306/aop"/>
<property name="user" value="root"/>
<property name="password" value="root"/>
</bean>
<!--jdbc模版对象-->
<bean class="org.springframework.jdbc.core.JdbcTemplate" id="jdbcTemplate">
<property name="dataSource" ref="dataSource"></property>
</bean>
测试代码:
/**
* 测试Spring产生jdbcTemplate对象
*/
@Test
public void testTemplate() throws Exception{
//加载配置文件
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
//获取spring容器中初始化的getBean
JdbcTemplate jdbcTemplate = context.getBean(JdbcTemplate.class);
//c操作数据库
jdbcTemplate.update("insert into account(name,money) VALUES(?,?)","js",19990);
}
6)、JdbcTemplate基本使用-spring产生模板对象代码实现(抽取jdbc.properties)(应用)
将数据库的连接信息抽取到外部配置文件中,和spring的配置文件分离开,有利于后期维护
jdbc.propreties
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/aop
jdbc.username=root
jdbc.password=root
修改配置文件:
<!--加载jdbc.properties-->
<context:property-placeholder location="classpath:jdbc,properties">
<!--数据源对象-->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="driverClass" value="${jdbc.driver}"/>
<property name="jdbcUrl" value="${jdbc.url}"/>
<property name="user" value="${jdbc.username}"/>
<property name="password" value="${jdbc.password}"/>
</bean>
7)、JdbcTemplate基本使用-常用操作-更新操作&查询操作(应用)
使用注解注入
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class JdbcTemplateAnnoTest {
@Autowired
private JdbcTemplate jdbcTemplate;
/**
* 更新操作
*/
@Test
public void updateTest(){
jdbcTemplate.update("update account set money=? where name=?",10000,"java");
}
@Test
/**
* 删除操作
*/
public void delTest(){
jdbcTemplate.update("delete from account where name=?","php");
}
//查询所有
@Test
public void queryAllTest(){
List<Account> accountList = jdbcTemplate.query("select * from account", new BeanPropertyRowMapper<>(Account.class));
for (Account account : accountList) {
System.out.println(account);
}
}
//查询一个
@Test
public void queryOneTest(){
Account name = jdbcTemplate.queryForObject("select * from account where name=?", new BeanPropertyRowMapper<>(Account.class), "java");
System.out.println(name);
}
//聚合查询
@Test
public void queryCountTest(){
Long aLong = jdbcTemplate.queryForObject("select count(*) from account", long.class);//requiedType
System.out.println(aLong);
}
}
9)、JdbcTemplate基本使用-知识要点(理解,记忆)
- 导入spring-jdbc和spring-tx坐标依赖
- 创建数据库表和实体
- 创建jdbcTemplate对象
JdbcTemplate jdbcTemplate = newJdbcTemplate();
jdbcTemplate.setDataSource(dataSource);
- 执行数据库CRUB操作
更新操作:
jdbcTemplate.update (sql,params)
查询操作:
jdbcTemplate.query (sql,Mapper,params)//多个对象
jdbcTemplate.queryForObject(sql,Mapper,params)//单个对象
2、声明式事务控制
事务:不可分割的操作要么同时成功要么同时失败
声明式事务控制=AOP+编程式事务控制,在xml配置文件中声明
2.1、编程式事务控制相关的对象
概念:通过java代码手动开启事务,提交事务,回滚事务。
2.1.1、PlatformTransactionManager (平台事务管理器)
PlatformTransactionManager 接口是 spring 的事务管理器,它里面提供了我们常用的操作事务的方法
![平台事务管理器](https://upload-images.jianshu.io/upload_images/19332549-d876368a767ccd26.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
注意:
PlatformTransactionManager 是接口类型,不同的 Dao 层技术则有不同的实现类,通过配置告诉spring,集成的哪个框架,spring根据不同的框架选择不同的操作。
Dao层的技术 | 实现类 |
---|---|
jdbc 或 mybatis | org.springframework.jdbc.datasource.DataSourceTransactionManager |
hibernate(架构) | org.springframework.orm.hibernate5.HibernateTransactionManager |
2.1.2、 TransactionDefinition(事务的详细配置信息存放)
封装事务的参数
TransactionDefinition 是事务的定义信息对象,里面有如下方法:
方法 | 说明 |
---|---|
int getIsolationLevel() |
获得事务的隔离级别 |
int getPropogationBehavior() |
获得事务的传播行为 |
int getTimeout() |
获得超时时间 |
boolean isReadOnly |
是否只读 |
- 1.事务的隔离级别
设置隔离级别,可以解决事务并发产生的问题,如脏读、不可重复读和虚读(幻读)。- ISOLATION_DEFAULT
- ISOLATION_READ_UNCOMMITTED//读未提交的数据 脏读不可重复读
- ISOLATION_READ-COMMITTED//读已提交数据,但是允许其他人修改
- ISOLATION-REPEATABLE_READ//读到提交的数据,同时不允许别人修改,允许增删。
- ISOLATION_SERIALIZEBLE//读到提交的数据,同时不允许别人任何操作。
- 2.事务的传播行为
主要作用是 解决业务方法调用业务方法时统一- REQUIRED:required如果当前没有事务,就新建一个事务,如果已经存在一个事务中,加入到这个事务中。一般的选择(默认值)有就用,没有就创建
- SUPPORTS:支持当前事务,如果当前没有事务,就以非事务方式执行(没有事务)有就用,没有就不用
- MANDATORY:使用当前的事务,如果当前没有事务,就抛出异常
- REQUERS_NEW:新建事务,如果当前在事务中,把当前事务挂起。
- NOT_SUPPORTED:以非事务方式执行操作,如果当前存在事务,就把当前事务挂起 有没有都不用
- NEVER:以非事务方式运行,如果当前存在事务,抛出异常
- NESTED:如果当前存在事务,则在嵌套事务内执行。如果当前没有事务,则执行 REQUIRED 类似的操作
- 超时时间:默认值是-1,没有超时限制。如果有,以秒为单位进行设置 timwout
- 是否只读:建议查询时设置为只读 read-only
2.1.3、 TransactionStatus(获取事务的状态信息)
TransactionStatus 接口提供的是事务具体的运行状态,方法介绍如下。
状态是被动信息,不是主动设置的。
平台事务管理器(指定事务控制行为)+事务定义对象(封装事务的参数)=事务状态对象(被动的封装程序的动态信息)
方法 | 说明 |
---|---|
boolean hasSavepoint() |
是否存储滚回点 |
boolean isCompleted() |
事务是否完成 |
boolean isNewTransaction() |
是否是新事务 |
boolean isRollbackOnly() |
事务是否滚回 |
2.2、 基于xml的声明式事务控制(方便统一配置)
2.2.1 什么是声明式事务控制
Spring 的声明式事务顾名思义就是采用声明的方式来处理事务。这里所说的声明,就是指在配置文件中声明,用在 Spring 配置文件中声明式的处理事务来代替代码式的处理事务。
声明式事务控制=AOP+编程式事务控制,在xml配置文件中声明
声明式事务处理的作用
- 事务管理不侵入开发的组件(解耦性)。具体来说,业务逻辑对象就不会意识到正在事务管理之中,事实上也应该如此,因为事务管理是属于系统层面的服务,而不是业务逻辑的一部分,如果想要改变事务管理策划的话,也只需要在定义文件中重新配置即可
- 在不需要事务管理的时候,只要在设定文件上修改一下,即可移去事务管理服务,无需改变代码重新编译,这样维护起来极其方便
注意:Spring 声明式事务控制底层就是AOP。
2.2.2、声明式事务控制的体现
声明式事务控制 明确事项:
谁是切点,哪个是将要被增强的方法
谁是通知,增强方法
配置切面
①配置文件引入tx命名空间
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
">
②配置事务增强 & 事务AOP织入
<!--在上面引入tx aop命名空间-->
<!--
配置事务增强:
1.平台事务管理器
2.事务增强配置
3.配置事务AOP织入
-->
<!--1.告诉spring使用什么框架来操作数据库,不同的框架,底层操作事务的方式是不同的bean-->
<bean class="org.springframework.jdbc.datasource.DataSourceTransactionManager" id="transactionManager">
<property name="dataSource" ref="dataSource"/>
</bean>
<!--2.事务增强配置 tx-->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<tx:attributes><!--事务的属性-->
<tx:method name="*"/><!--对切点(方法)进行增强 *:代表增强所有的切点(方法)-->
</tx:attributes>
<!--
切点方法的事务参数配置
<tx:method name="transfer" isolation="REPEATABLE_READ" propagation="REQUIRED" timeout="-1" read-only="false"/>
- name:切点方法名称
- isolation:事务的隔离级别
- propogation:事务的传播行为
- timeout:超时时间
- read-only:是否只读
-->
</tx:advice>
<!--3.配置事务AOP织入-->
<aop:config>
<!--抽取切点表达式-->
<aop:pointcut id="myPointcut" expression="execution(* *cn.ppvir.service.impl.*.*(..))"/>
<!--织入-->
<aop:advisor advice-ref="txAdvice" pointcut-ref="myPointcut"></aop:advisor>
</aop:config>
2.2.3、小结要点
声明式事务控制的配置要点
- 平台事务管理器的配置,告诉spring将要使用哪套api进行配置
- 事务通知的配置,事务增强
- 参数配置,通配或者单独配置
- 事务aop织入的配置
- adviser代表只有一个通知
- 切点表达式也可以对外进行抽取
<aop:pointcut id="myPointcut" expression="execution(* *cn.ppvir.service.impl.*.*(..))"/>
2.3、基于注解的声明式事务控制
2.3.1、 使用注解配置声明式事务控制
使用注解在xml中配置组件扫描
<context:componet-scan/>
,建议使用场景:注解使用一般是自定义的bean,因为可以拿到源码
*XML * 一般是非自定义的bean
注解@Transactional(事务参数),可以在类上或方法上,或单独配置,如包含多层注解事务控制,就近原则执行。
- 编写AccountDao,@Respostitory() 注解DAO配置bean、@Autowired自动注入
- 编写AccountService, @Service()注解Service配置bean @Transactional()注解事务通知的配置
/**
1) AccountDao
* 数据库操作的实现类
* 注解方式@Respository("accountDao")
*/
@Repository("accountDao")
public class AccountDao implements IAccountDao {
public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
this.jdbcTemplate = jdbcTemplate;
}
@Autowired
private JdbcTemplate jdbcTemplate;
@Override
public void out(String outMan, double money) {
jdbcTemplate.update("update account set money=money-? where name=?",money,outMan);
}
@Override
public void in(String inMan, double money) {
jdbcTemplate.update("update account SET money=money+? where name=?",money,inMan);
}
@Override
public void queryAll() {
List<Account> accountList = jdbcTemplate.query("select * from account", new BeanPropertyRowMapper<>(Account.class));
for (Account account : accountList) {
System.out.println(account);
}
}
}
/**
2)AccountService
* 具体的业务操作实现类
*/
@Service("accountService")
@Transactional(isolation = Isolation.READ_COMMITTED)//注解事务通知配置
public class AccountServiceImpl implements IAccountService {
@Autowired
private IAccountDao accountDao;
public void setAccountDao(IAccountDao accountDao) {
this.accountDao = accountDao;
}
@Transactional(isolation = Isolation.REPEATABLE_READ,propagation = Propagation.REQUIRED)
public void transfer(String outMan, String inMan, double money) {
accountDao.out(outMan,money);
//int m= 2/0;//java.lang.ArithmeticException: / by zero
accountDao.in(inMan,money);
}
@Override
public void findAll() {
accountDao.queryAll();
}
}
- 编写applicationContext.xml配置文件
<!--只包含新添加的组件扫描 和 事务的注解驱动 配置-->
<!--组件扫描-->
<context:component-scan base-package="cn.ppvir"></context:component-scan>
<!--事务注解驱动--><!--驱动是开关,加上以后注解才能启动-->
<tx:annotation-driven transaction-manager="transactionManager"/>
2.3.2、注解配置声明式事务控制解析
①使用 @Transactional 在需要进行事务控制的类或是方法上修饰,注解可用的属性同 xml 配置方式,例如隔离级别、传播行为等。
②注解使用在类上,那么该类下的所有方法都使用同一套注解参数配置。
③使用在方法上,不同的方法可以采用不同的事务参数配置。
④Xml配置文件中要开启事务的注解驱动<tx:annotation-driven />
2.3.3、小结要点
注解声明式事务控制的配置要点
- 平台事务管理器配置(xml方式)
- 事务通知的配置(@Transactional注解配置)
- 事务注解驱动的配置
<tx:annotation-driven transaction-manager="transactionManager"/>