Spring JDBC使用、事务管理

程序员文章站 2022-07-13 21:20:29

...

Spring之JDBC使用

Spring JDBC模板概述

Spring框架中提供了很多持久层的模板类来简化编程，使用模板类编写程序会变的简单
提供了JDBC模板，Spring框架提供的
- JdbcTemplate类
Spring框架可以整合Hibernate框架，也提供了模板类
- HibernateTemplate类

JDBC模板类使用

步骤一：创建数据库的表结构

create database spring_day03;
use spring_day03;
create table t_account(
id int primary key auto_increment,
name varchar(20),
money double
);

引入开发的jar包
- 先引入IOC基本的6个jar包
- 再引入Spring-aop的jar包
- 最后引入JDBC模板需要的jar包
- MySQL数据库的驱动包
- Spring-jdbc.jar
- Spring-tx.jar

编写测试代码（自己来new对象的方式）

@Test
public void run1(){
// 创建连接池，先使用Spring框架内置的连接池
DriverManagerDataSource dataSource = new DriverManagerDataSource();
dataSource.setDriverClassName("com.mysql.jdbc.Driver");
dataSource.setUrl("jdbc:mysql:///spring_day03");
dataSource.setUsername("root");
dataSource.setPassword("root");
// 创建模板类
JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
// 完成数据的添加
jdbcTemplate.update("insert into t_account values (null,?,?)", "测试",10000);
}

使用Spring管理

刚才编写的代码使用的是new的方式，应该把这些类交给Spring框架来管理。

修改的步骤如下

步骤一：Spring管理内置的连接池

<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql:///spring_day03"/>
<property name="username" value="root"/>
<property name="password" value="root"/>
</bean>

步骤二：Spring管理模板类

<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource"/>
</bean>

步骤三：编写测试程序

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class Demo2 {

@Resource(name="jdbcTemplate")
private JdbcTemplate jdbcTemplate;

@Test
public void run2(){
    jdbcTemplate.update("insert into t_account values (null,?,?)", "测试2",10000);
}
}

Spring框架管理开源的连接池

管理DBCP连接池

先引入DBCP的2个jar包
com.springsource.org.apache.commons.dbcp-1.2.2.osgi.jar
com.springsource.org.apache.commons.pool-1.5.3.jar

编写配置文件

<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql:///spring_day03"/>
<property name="username" value="root"/>
<property name="password" value="root"/>
</bean>

管理C3P0连接池

先引入C3P0的jar包
com.springsource.com.mchange.v2.c3p0-0.9.1.2.jar

编写配置文件

<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="driverClass" value="com.mysql.jdbc.Driver"/>
<property name="jdbcUrl" value="jdbc:mysql:///spring_day03"/>
<property name="user" value="root"/>
<property name="password" value="root"/>
</bean>

JDBC模板的简单操作

增删改查的操作

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class SpringDemo3 {

@Resource(name="jdbcTemplate")
private JdbcTemplate jdbcTemplate;

@Test
// 插入操作
public void demo1(){
    jdbcTemplate.update("insert into account values (null,?,?)", "冠希",10000d);
}

@Test
// 修改操作
public void demo2(){
    jdbcTemplate.update("update account set name=?,money =? where id = ?", "思雨",10000d,5);
}

@Test
// 删除操作
public void demo3(){
    jdbcTemplate.update("delete from account where id = ?", 5);
}

@Test
// 查询一条记录
public void demo4(){
    Account account = jdbcTemplate.queryForObject("select * from account where id = ?", new BeanMapper(), 1);
    System.out.println(account);
}

@Test
// 查询所有记录
public void demo5(){
    List<Account> list = jdbcTemplate.query("select * from t_account", new BeanMapper());
    for (Account account : list) {
        System.out.println(account);
    }
}
}

class BeanMapper implements RowMapper<Account>{
public Account mapRow(ResultSet rs, int arg1) throws SQLException {
    Account account = new Account();
    account.setId(rs.getInt("id"));
    account.setName(rs.getString("name"));
    account.setMoney(rs.getDouble("money"));
    return account;
}
}

Spring框架的事务管理

事务：指的是逻辑上一组操作，组成这个事务的各个执行单元，要么一起成功,要么一起失败！
事务的特性
- 原子性
- 一致性
- 隔离性
- 持久性
如果不考虑隔离性,引发安全性问题
- 读问题:
- 脏读:
- 不可重复读:
- 虚读:
- 写问题:
- 丢失更新:
如何解决安全性问题
- 读问题解决，设置数据库隔离级别
- 写问题解决可以使用悲观锁和乐观锁的方式解决

Spring事务事务管理相关类

PlatformTransactionManager接口 – 平台事务管理器.(真正管理事务的类)。该接口有具体的实现类，根据不同的持久层框架，需要选择不同的实现类！
1. TransactionDefinition接口 – 事务定义信息.(事务的隔离级别,传播行为,超时,只读)
2. TransactionStatus接口– 事务的状态
总结：上述对象之间的关系：平台事务管理器真正管理事务对象.根据事务定义的信息TransactionDefinition 进行事务管理，在管理事务中产生一些状态.将状态记录到TransactionStatus中
PlatformTransactionManager接口中实现类和常用的方法
1. 接口的实现类
  - 如果使用的Spring的JDBC模板或者MyBatis框架，需要选择DataSourceTransactionManager实现类
  - 如果使用的是Hibernate的框架，需要选择HibernateTransactionManager实现类
2. 该接口的常用方法
  - void commit(TransactionStatus status)
  - TransactionStatus getTransaction(TransactionDefinition definition)
  - void rollback(TransactionStatus status)
TransactionDefinition
1. 事务隔离级别的常量
  - static int ISOLATION_DEFAULT – 采用数据库的默认隔离级别
  - static int ISOLATION_READ_UNCOMMITTED
  - static int ISOLATION_READ_COMMITTED
  - static int ISOLATION_REPEATABLE_READ
  - static int ISOLATION_SERIALIZABLE
2. 事务的传播行为常量（不用设置，使用默认值）
  - 先解释什么是事务的传播行为：解决的是业务层之间的方法调用！！
  - PROPAGATION_REQUIRED（默认值）– A中有事务,使用A中的事务.如果没有，B就会开启一个新的事务,将A包含进来.(保证A,B在同一个事务中)，默认值！！
  - PROPAGATION_SUPPORTS– A中有事务,使用A中的事务.如果A中没有事务.那么B也不使用事务.
  - PROPAGATION_MANDATORY– A中有事务,使用A中的事务.如果A没有事务.抛出异常.
  - PROPAGATION_REQUIRES_NEW（记）– A中有事务,将A中的事务挂起.B创建一个新的事务.(保证A,B没有在一个事务中)
  - PROPAGATION_NOT_SUPPORTED– A中有事务,将A中的事务挂起.
  - PROPAGATION_NEVER – A中有事务,抛出异常.
  - PROPAGATION_NESTED（记）– 嵌套事务.当A执行之后,就会在这个位置设置一个保存点.如果B没有问题.执行通过.如果B出现异常,运行客户根据需求回滚(选择回滚到保存点或者是最初始状态)

转账案例

步骤一：创建WEB工程，引入需要的jar包
- IOC的6个包
- AOP的4个包
- C3P0的1个包
- MySQL的驱动包
- JDBC目标2个包
- 整合JUnit测试包

步骤二：引入配置文件

引入配置文件
引入log4j.properties

引入applicationContext.xml

<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <property name="driverClass" value="com.mysql.jdbc.Driver"/>
    <property name="jdbcUrl" value="jdbc:mysql:///spring_day03"/>
    <property name="user" value="root"/>
    <property name="password" value="root"/>
</bean>

步骤三：创建对应的包结构和类
- com.xx.demo1
- AccountService
- AccountServlceImpl
- AccountDao
- AccountDaoImpl

步骤四:引入Spring的配置文件,将类配置到Spring中

<bean id="accountService" class="com.xx.demo1.AccountServiceImpl">
</bean>

<bean id="accountDao" class="com.xx.demo1.AccountDaoImpl">
</bean>

步骤五：在业务层注入DAO ,在DAO中注入JDBC模板（强调：简化开发，以后DAO可以继承JdbcDaoSupport类）

<bean id="accountService" class="com.xx.demo1.AccountServiceImpl">
    <property name="accountDao" ref="accountDao"/>
</bean>

<bean id="accountDao" class="com.xx.demo1.AccountDaoImpl">
    <property name="dataSource" ref="dataSource"/>
</bean>

步骤六：编写DAO和Service中的方法

public class AccountDaoImpl extends JdbcDaoSupport implements AccountDao {
    public void outMoney(String out, double money) {
        this.getJdbcTemplate().update("update t_account set money = money = ? where name = ?", money,out);
    }
    public void inMoney(String in, double money) {
        this.getJdbcTemplate().update("update t_account set money = money + ? where name = ?", money,in);
    }
}

步骤七：编写测试程序.

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class Demo1 {

    @Resource(name="accountService")
    private AccountService accountService;

    @Test
    public void run1(){
        accountService.pay("冠希", "美美", 1000);
    }
}

事务管理的分类

Spring的事务管理的分类
1. Spring的编程式事务管理（不推荐使用）
  - 通过手动编写代码的方式完成事务的管理（不推荐）
2. Spring的声明式事务管理（底层采用AOP的技术）
  - 通过一段配置的方式完成事务的管理（重点掌握注解的方式）

编程式事务管理

说明：Spring为了简化事务管理的代码:提供了模板类 TransactionTemplate，所以手动编程的方式来管理事务，只需要使用该模板类即可！！

手动编程方式的具体步骤如下：

步骤一:配置一个事务管理器，Spring使用PlatformTransactionManager接口来管理事务，所以咱们需要使用到他的实现类！！

<!-- 配置事务管理器 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"/>
</bean>

步骤二:配置事务管理的模板

<!-- 配置事务管理的模板 -->
<bean id="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate">
<property name="transactionManager" ref="transactionManager"/>
</bean>

步骤三:在需要进行事务管理的类中,注入事务管理的模板.

<bean id="accountService" class="com.xx.demo1.AccountServiceImpl">
<property name="accountDao" ref="accountDao"/>
<property name="transactionTemplate" ref="transactionTemplate"/>
</bean>

步骤四:在业务层使用模板管理事务:

// 注入事务模板对象
private TransactionTemplate transactionTemplate;
public void setTransactionTemplate(TransactionTemplate transactionTemplate) {
this.transactionTemplate = transactionTemplate;
}

public void pay(final String out, final String in, final double money) {
transactionTemplate.execute(new TransactionCallbackWithoutResult() {

    protected void doInTransactionWithoutResult(TransactionStatus status) {
        // 扣钱
        accountDao.outMoney(out, money);
        int a = 10/0;
        // 加钱
        accountDao.inMoney(in, money);
    }
});
}

声明式事务管理

基于AspectJ的XML方式（重点掌握）

步骤一:恢复转账开发环境
步骤二:引入AOP的开发包

步骤三:配置事务管理器

<!-- 配置事务管理器 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
</bean>

步骤四:配置事务增强

<!-- 配置事务增强 -->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
    <tx:attributes>
        <!--
            name        ：绑定事务的方法名，可以使用通配符，可以配置多个。
            propagation ：传播行为
            isolation   ：隔离级别
            read-only   ：是否只读
            timeout     ：超时信息
            rollback-for：发生哪些异常回滚.
            no-rollback-for：发生哪些异常不回滚.
         -->
        <!-- 哪些方法加事务 -->
        <tx:method name="pay" propagation="REQUIRED"/>
    </tx:attributes>
</tx:advice>

步骤五:配置AOP的切面

<!-- 配置AOP切面产生代理 -->
<aop:config>
    <aop:advisor advice-ref="myAdvice" pointcut="execution(* com.xx.demo2.AccountServiceImpl.pay(..))"/>
</aop:config>

* 注意：如果是自己编写的切面，使用<aop:aspect>标签，如果是系统制作的，使用<aop:advisor>标签。

步骤六:编写测试类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext2.xml")
public class Demo2 {

    @Resource(name="accountService")
    private AccountService accountService;

    @Test
    public void run1(){
        accountService.pay("冠希", "美美", 1000);
    }
}

和基于AspectJ的注解方式（重点掌握）

步骤一:恢复转账的开发环境

步骤二:配置事务管理器

<!-- 配置事务管理器  -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
</bean>

步骤三:开启注解事务

<!-- 开启注解事务 -->
<tx:annotation-driven transaction-manager="transactionManager"/>

步骤四:在业务层上添加一个注解:@Transactional（类或者方法上）

编写测试类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext3.xml")
public class Demo3 {

    @Resource(name="accountService")
    private AccountService accountService;

    @Test
    public void run1(){
        accountService.pay("冠希", "美美", 1000);
    }
}

上一篇： spring JDBC事务管理

下一篇： spring事务 jdbc_Spring事务管理示例JDBC

Spring JDBC使用、事务管理

Spring之JDBC使用

Spring JDBC模板概述

JDBC模板类使用

使用Spring管理

Spring框架管理开源的连接池

JDBC模板的简单操作

Spring框架的事务管理

Spring事务事务管理相关类

转账案例

事务管理的分类

编程式事务管理

声明式事务管理

基于AspectJ的XML方式（重点掌握）

和基于AspectJ的注解方式（重点掌握）

Java使用Jdbc连接Oracle执行简单查询操作示例

Spring中Bean的生命周期使用解析

spring如何使用命名空间p简化bean的配置

spring boot tomcat jdbc pool的属性绑定

spring boot 使用Aop通知打印控制器请求报文和返回报文问题

Spring JDBC

Spring-使用注解实现AOP(九)

Apache shiro的简单介绍与使用教程(与spring整合使用）

使用Spring安全表达式控制系统功能访问权限

[Spring Boot]使用自定义注解统一请求返回值