Spring学习笔记(五)

莪假裝堅強

于 2022-09-30 11:35:38 发布

阅读量1.5k

点赞数 1

分类专栏： spring 文章标签： java 数据库 spring

本文链接：https://blog.csdn.net/weixin_47994845/article/details/127120792

版权

spring 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

14 事务

什么是事务

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

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

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

事务的四个特性

(1) 原子性

(2) 一致性

(3) 隔离性

(4) 持久性

14.1 搭建事务操作的环境

创建数据表bank,表中有如下字段

新键模块spring5_demo7

依赖复制之前的

最终的目录结构如下所示

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:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

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

	<!-- 数据库连接池 -->
	<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="123456"/>
		<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
	</bean>

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

</beans>

package com.wjiangquan.spring5.dao;

/**
 * @author weijiangquan
 * @date 2022/9/27 -23:09
 * @Description
 */
public interface UserDao {

    //多线
    public void addMoney();

    //少钱
    public void reduceMoney();

}

package com.wjiangquan.spring5.dao;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

/**
 * @author weijiangquan
 * @date 2022/9/27 -23:09
 * @Description
 */

@Repository
public class UserDaoImpl implements UserDao {


    @Autowired
    private JdbcTemplate jdbcTemplate;


    //多钱
    @Override
    public void addMoney() {
        String sql = "update user set money = money-? where username = ?";
        jdbcTemplate.update(sql,100,"luck");
    }

    //少钱
    @Override
    public void reduceMoney() {
        String sql = "update user set money = money + ? where username = ?";
        jdbcTemplate.update(sql,100,"mary");
    }

}

service

package com.wjiangquan.spring5.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.wjiangquan.spring5.dao.UserDao;

/**
 * @author weijiangquan
 * @date 2022/9/27 -23:09
 * @Description
 */

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

测试

package com.wjiangquan.spring5.test;


import com.wjiangquan.spring5.service.UserService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @author weijiangquan
 * @date 2022/9/27 -20:43
 * @Description
 */
public class TestBook {

    @Test
    public void test(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        UserService userService = context.getBean("userService", UserService.class);
        userService.accountMoney();
    }

}

上面代码，如果正常执行没有问题的，但是如果代码执行过程中出现异常，有问题

最终执行之后可以看到在数据库中一个用户多了100,另一个少了100

14.2 非正常情况

public void accountMoney() {
        //lucy 少 100
        userDao.reduceMoney();
    	
    	//模拟异常
    	int i = 10/0;
    
        //mary 多 100
        userDao.addMoney();
    }

当运行的时候发现其中一个账户少了100,而另外一个账户中的钱没有发生变化

想一想,对于上面的情况将如何进行解决呢?

使用事务进行解决

事务的操作过程

14.3 事务操作

1、事务添加到 JavaEE 三层结构里面 Service 层（业务逻辑层）

其实添加在哪一层并没有强制规定,放在Service更加的好

2、在 Spring 进行事务管理操作

有两种方式：

编程式事务管理 (14.2中就是编程式的事务,一般开发中不使用)
声明式事务管理（使用）

3、声明式事务管理

**（**1）基于注解方式（使用）

（2）基于 xml 配置文件方式

4、在Spring 进行声明式事务管理，底层使用 AOP 原理

5、Spring事务管理 API

提供一个接口，代表事务管理器，这个接口针对不同的框架提供不同的实现类,对于在本节中使用到的实现类是DataSourceTransactionManager类

事务操作（注解声明式事务管理）

事务中常见的单词

propagation
英 [ˌprɒpə'ɡeɪʃ(ə)n]  
n.
传播;扩展;宣传;培养

Transactional
英 [trænˈzækʃən(ə)l]   美 [trænˈzækʃən(ə)l]  
事务型;事务处理;交易;交易型;事务

required(REQUIRED)

required_new(REQUIRED_NEW)

supports(SUPPORTS)

not_supportes()

mandatory(MADATORY)

never(NEVER)

nested(NESTED)

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：事务传播行为

**（**1）多事务方法直接进行调用，这个过程中事务是如何进行管理的

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>
<!--2 配置通知--> <tx:advice id="txadvice">
 <!--配置事务参数-->
 <tx:attributes>
 <!--指定哪种规则的方法上面添加事务-->
 <tx:method name="accountMoney" propagation="REQUIRED"/>
 <!--<tx:method name="account*"/>-->
 </tx:attributes>
</tx:advice>
<!--3 配置切入点和切面--> <aop:config>
 <!--配置切入点-->
 <aop:pointcut id="pt" expression="execution(* 
com.wjiangquna.spring5.service.UserService.*(..))"/>
 <!--配置切面-->
 <aop:advisor advice-ref="txadvice" pointcut-ref="pt"/>
</aop:config>

事务操作（完全注解声明式事务管理）

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

@Configuration //配置类
@ComponentScan(basePackages = "com.wjiangquan") //组件扫描
@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;
 } }