开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> Java知识库 -> Spring5框架--事务管理 -> 正文阅读

[Java知识库]Spring5框架--事务管理

Spring5框架–事务管理

文章目录

Spring5框架--事务管理

JdbcTemplate概念

1、什么是 JdbcTemplate
（1）Spring 框架对 JDBC 进行封装，使用 JdbcTemplate 方便实现对数据库操作。
（2）在 spring 配置文件配置数据库连接池

<!-- 数据库连接池 -->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" 
 destroy-method="close">
 <property name="url" value="jdbc:mysql:///user_db" />
 <property name="username" value="root" />
 <property name="password" value="root" />
 <property name="driverClassName" value="com.mysql.jdbc.Driver" />
</bean>

（3）配置 JdbcTemplate 对象，注入 DataSource

<!-- JdbcTemplate 对象 -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
 <!--注入 dataSource-->
 <property name="dataSource" ref="dataSource"></property>
</bean>

（4）创建 service 类，创建 dao 类，在 dao 注入 jdbcTemplate 对象

配置文件

<!-- 组件扫描 -->
<context:component-scan base-package="com.kx"></context:component-scan>

Service类

@Service
public class BookService {
 //注入 dao
 @Autowired
 private BookDao bookDao;
}

DAO

@Repository
public class BookDaoImpl implements BookDao {
 //注入 JdbcTemplate
 @Autowired
 private JdbcTemplate jdbcTemplate;
}

JdbcTemplate 操作数据库

添加

1、对应数据库创建实体类

public class Student {
    private int id;
    private String name;

    public Student(){}
    public Student(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}

2、编写 service 和 dao
（1）在 dao 进行数据库添加操作
（2）调用 JdbcTemplate 对象里面 insert方法实现添加操作

在这里插入图片描述
? 有两个参数
? 第一个参数：sql 语句
? 第二个参数：可变参数，设置 sql 语句值

@Repository
public class StudentDaoImpl implements StudentDao{
    //注入jdbcTemplate对象
    @Autowired
    private JdbcTemplate jdbcTemplate;

    //添加一条数据
    @Override
    public void add(Student student) {
        String sql="insert into t_student values (?,?)";
        Object[] obj={student.getId(),student.getName()};
        int update = jdbcTemplate.update(sql, obj);
        System.out.println(update);
    }
}

3、测试类

public class TestJdbcTemplate {
    @Test
    public void test(){
        ApplicationContext context=new ClassPathXmlApplicationContext("bean.xml");
        StudentService studentService = context.getBean("studentService", StudentService.class);
        Student student = context.getBean("student", Student.class);
        student.setId(5);
        student.setName("lili");
        studentService.addStudent(student);
    }

修改和删除

1、修改

   @Override
    public void update(Student student) {
        String sql = "update  t_student set name=? where id=?";
        Object[] args={student.getName(),student.getId()};
        int update = jdbcTemplate.update(sql, args);
        System.out.println(update);
    }

2、删除

 @Override
    public void delete(int id) {
        String sql = "delete from t_student where id=?";
        int update = jdbcTemplate.update(sql, id);
        System.out.println(update);
    }

查询返回某个值

1、查询表里面有多少条记录，返回是某个值
2、使用 JdbcTemplate 实现查询返回某个值代码
在这里插入图片描述

? 有两个参数
? 第一个参数：sql 语句
? 第二个参数：返回类型 Class

查询表记录数

//查询表记录数
@Override
public int selectCount() {
 String sql = "select count(*) from t_book";
 Integer count = jdbcTemplate.queryForObject(sql, Integer.class);
 return count;
}

查询返回对象

应用场景：JdbcTemplate 实现查询返回对象
在这里插入图片描述

? 有三个参数
? 第一个参数：sql 语句
? 第二个参数：RowMapper 是接口，针对返回不同类型数据，使用这个接口里面实现类完成数据封装。
? 第三个参数：sql 语句值

    @Override
    public Student selectStudent(int id) {
        String sql ="select * from t_student where id=?";

        //queryForObject不能返回空值
        Student student = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<Student>(Student.class), id);
        return student;
    }

查询返回集合

应用场景：调用 JdbcTemplate 方法实现查询返回集合
在这里插入图片描述
? 有三个参数
? 第一个参数：sql 语句
? 第二个参数：RowMapper 是接口，针对返回不同类型数据，使用这个接口里面实现类完成数据封装
? 第三个参数：sql 语句值

查询返回集合

  @Override
    public List<Student> listStduent() {
        String sql="select * from t_student";
        List<Student> query = jdbcTemplate.query(sql, new BeanPropertyRowMapper<Student>(Student.class));
        return query;
    }

批量操作

1、批量操作：操作表里面多条记录
2、JdbcTemplate 实现批量添加操作

在这里插入图片描述
? 有两个参数
? 第一个参数：sql 语句
? 第二个参数：List 集合，添加多条记录数据

批量添加

@Override
public void batchAddBook(List<Object[]> batchArgs) {
 String sql = "insert into t_book values(?,?,?)";
 int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
 System.out.println(Arrays.toString(ints));
}

测试

List<Object[]> batchArgs = new ArrayList<>();
Object[] o1 = {"3","java","a"};
Object[] o2 = {"4","c++","b"};
Object[] o3 = {"5","MySQL","c"};
batchArgs.add(o1);
batchArgs.add(o2);
batchArgs.add(o3);
//调用批量添加
bookService.batchAdd(batchArgs);

3、JdbcTemplate 实现批量修改操作
批量修改

@Override
public void batchUpdateBook(List<Object[]> batchArgs) {
 String sql = "update t_book set username=?,ustatus=? where user_id=?";
 int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
 System.out.println(Arrays.toString(ints));
}

测试

List<Object[]> batchArgs = new ArrayList<>();
Object[] o1 = {"java0909","a3","3"};
Object[] o2 = {"c++1010","b4","4"};
Object[] o3 = {"MySQL1111","c5","5"};
batchArgs.add(o1);
batchArgs.add(o2);
batchArgs.add(o3);
//调用方法实现批量修改
bookService.batchUpdate(batchArgs);

4、JdbcTemplate 实现批量删除操作
批量删除

@Override
public void batchDeleteBook(List<Object[]> batchArgs) {
 String sql = "delete from t_book where user_id=?";
 int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
 System.out.println(Arrays.toString(ints));
}

测试

List<Object[]> batchArgs = new ArrayList<>();
Object[] o1 = {"3"};
Object[] o2 = {"4"};
batchArgs.add(o1);
batchArgs.add(o2);
//调用方法实现批量删除
bookService.batchDelete(batchArgs);

事务操作

概念

1、什么事务
（1）事务是数据库操作最基本单元，逻辑上一组操作，要么都成功，如果有一个失败所有操作都失败。

（2）典型场景：银行转账

lucy 转账 100 元给 mary
lucy 少 100，mary 多 100

2、事务四个特性（ACID）
（1）原子性
（2）一致性
（3）隔离性
（4）持久性

搭建事务操作环境

在这里插入图片描述

1、创建数据库表，添加记录
在这里插入图片描述

2、创建 service，搭建 dao，完成对象创建和注入关系
（1）service 注入 dao，在 dao 注入 JdbcTemplate，在 JdbcTemplate 注入 DataSource。

@Service
public class UserService {
 //注入 dao
 @Autowired
 private UserDao userDao;
}
@Repository
public class UserDaoImpl implements UserDao {
 @Autowired
 private JdbcTemplate jdbcTemplate;
}

3、在 dao 创建两个方法：多钱和少钱的方法，在 service 创建方法（转账的方法）

@Repository
public class UserDaoImpl implements UserDao {
 @Autowired
 private JdbcTemplate jdbcTemplate;
 //lucy 转账 100 给 mary
 //少钱
 @Override
 public void reduceMoney() {
 String sql = "update t_account set money=money-? where username=?";
 jdbcTemplate.update(sql,100,"lucy");
 }
 //多钱
 @Override
 public void addMoney() {
 String sql = "update t_account set money=money+? where username=?";
 jdbcTemplate.update(sql,100,"mary");
 }
}

4.在service类中调用两个方法

@Service
public class UserService {
 //注入 dao
 @Autowired
 private UserDao userDao;
 //转账的方法
 public void accountMoney() {
 //lucy 少 100
 userDao.reduceMoney();
 //mary 多 100
 userDao.addMoney();
 }
}

4、上面代码，如果正常执行没有问题的，但是如果代码执行过程中出现异常，有问题如下：
在这里插入图片描述

（1）上面问题如何解决呢？

使用事务进行解决

（2）事务操作过程
在这里插入图片描述

Spring 事务管理介绍

1、事务添加到 JavaEE 三层结构里面 Service 层（业务逻辑层）
2、在 Spring 进行事务管理操作
（1）有两种方式：编程式事务管理和声明式事务管理（使用）
3、声明式事务管理
（1）基于注解方式（使用）
（2）基于 xml 配置文件方式
4、在 Spring 进行声明式事务管理，底层使用 AOP 原理
5、Spring 事务管理 API
（1）提供一个接口，代表事务管理器，这个接口针对不同的框架提供不同的实现类

在这里插入图片描述

注解声明式事务管理

1、在 spring 配置文件配置事务管理器

<!--创建事务管理器-->
<bean id="transactionManager" 
class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
 <!--注入数据源-->
 <property name="dataSource" ref="dataSource"></property>
</bean>

2、在 spring 配置文件，开启事务注解
（1）在 spring 配置文件引入名称空间 tx

<beans xmlns="http://www.springframework.org/schema/beans" 
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
 xmlns:context="http://www.springframework.org/schema/context" 
 xmlns:aop="http://www.springframework.org/schema/aop" 
 xmlns:tx="http://www.springframework.org/schema/tx" 
 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/aop 
http://www.springframework.org/schema/aop/spring-aop.xsd 
 http://www.springframework.org/schema/tx 
http://www.springframework.org/schema/tx/spring-tx.xsd">

（2）开启事务注解

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

3、在 service 类上面（或者 service 类里面方法上面）添加事务注解
（1）@Transactional，这个注解添加到类上面，也可以添加方法上面
（2）如果把这个注解添加类上面，这个类里面所有的方法都添加事务
（3）如果把这个注解添加方法上面，为这个方法添加事务

@Service
@Transactional
public class UserService {}

声明式事务管理参数配置

1、在 service 类上面添加注解@Transactional，在这个注解里面可以配置事务相关参数。
在这里插入图片描述

2、propagation：事务传播行为

spring框架定义了7种类传播行为。
在这里插入图片描述

3、ioslation：事务隔离级别

（1）事务有特性成为隔离性，多事务操作之间不会产生影响。不考虑隔离性产生很多问题
（2）有三个读问题：脏读、不可重复读、虚（幻）读
（3）脏读：一个未提交事务读取到另一个未提交事务的数据

在这里插入图片描述

（4）不可重复读：一个未提交事务读取到另一提交事务修改数据。
在这里插入图片描述

（5）虚读：一个未提交事务读取到另一提交事务添加数据
（6）解决：通过设置事务隔离级别，解决读问题
在这里插入图片描述

4、timeout：超时时间

（1）事务需要在一定时间内进行提交，如果不提交进行回滚
（2）默认值是 -1 ，设置时间以秒单位进行计算

5、readOnly：是否只读
（1）读：查询操作，写：添加修改删除操作
（2）readOnly 默认值 false，表示可以查询，可以添加修改删除操作
（3）设置 readOnly 值是 true，设置成 true 之后，只能查询

6、rollbackFor：回滚

（1）设置出现哪些异常进行事务回滚

7、noRollbackFor：不回滚
（1）设置出现哪些异常不进行事务回滚

XML 声明式事务管理

1、在 spring 配置文件中进行配置
第一步配置事务管理器

<!--1 创建事务管理器-->
<bean id="transactionManager" 
class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
 <!--注入数据源-->
 <property name="dataSource" ref="dataSource"></property>
</bean>

第二步配置通知

<tx:advice id="txadvice">
 <!--配置事务参数-->
 <tx:attributes>
 <!--指定哪种规则的方法上面添加事务-->
 <tx:method name="accountMoney" propagation="REQUIRED"/>
 <!--<tx:method name="account*"/>-->
 </tx:attributes>
</tx:advice>

第三步配置切入点和切面

<aop:config>
 <!--配置切入点-->
 <aop:pointcut id="pt" expression="execution(* 
com.atguigu.spring5.service.UserService.*(..))"/>
 <!--配置切面-->
 <aop:advisor advice-ref="txadvice" pointcut-ref="pt"/>
</aop:config>

完全注解声明式事务管理

1、创建配置类，使用配置类替代 xml 配置文件

@Configuration //配置类
@ComponentScan(basePackages = "com.atguigu") //组件扫描
@EnableTransactionManagement //开启事务
public class TxConfig {
 //创建数据库连接池
 @Bean
 public DruidDataSource getDruidDataSource() {
 DruidDataSource dataSource = new DruidDataSource();
 dataSource.setDriverClassName("com.mysql.jdbc.Driver");
 dataSource.setUrl("jdbc:mysql:///user_db");
 dataSource.setUsername("root");
 dataSource.setPassword("root");
 return dataSource;
//创建 JdbcTemplate 对象
 @Bean
 public JdbcTemplate getJdbcTemplate(DataSource dataSource) {
 //到 ioc 容器中根据类型找到 dataSource
 JdbcTemplate jdbcTemplate = new JdbcTemplate();
 //注入 dataSource
 jdbcTemplate.setDataSource(dataSource);
 return jdbcTemplate;
 }
 //创建事务管理器
 @Bean
 public DataSourceTransactionManager 
getDataSourceTransactionManager(DataSource dataSource) {
 DataSourceTransactionManager transactionManager = new 
DataSourceTransactionManager();
 transactionManager.setDataSource(dataSource);
 return transactionManager;
 }
}