SSM之Spring（二）

我就是我 2023-09-23 20:53 97阅读 0赞

**目录**

2.3 基于注解管理bean

2.3.1 标记与扫描

2.3.2 基于注解的自动装配

三：AOP

3.1 场景模拟

3.1.1 声明接口

3.1.2 创建实现类

3.1.3 创建带日志功能的实现类

3.1.4 提出问题

3.2 代理模式

3.2.1 概念

3.2.2 静态代理

3.2.3 动态代理

3.2.4 测试

3.3 AOP概念及相关术语

3.3.1、概述

3.3.2、相关术语

3.3.3、作用

3.4 基于注解的AOP

3.4.1 技术说明

3.4.2 准备工作

3.4.3 创建切面类并配置

3.4.4 各种通知

3.4.5 重用切入点表达式

3.4.6 切面的优先级

四：声明式事务

4.1 JdbcTemplate

4.1.1 简介

4.1.2 准备工作

4.1.3 测试

4.2 声明式事务概念

4.2.1 编程式事务

4.3基于注解的声明式事务

4.3.1准备工作

4.3.2 测试无事务情况

4.3.3 加入事务

4.3.4 @Transactional注解标识的位置

4.3.5 事务属性：只读

4.3.6 事务属性：超时

4.3.7 事务属性：回滚策略

4.3.8 事务属性：事务隔离级别

4.3.9 事务属性：事务传播行为

--------------------

## 2.3 基于注解管理bean ##

### 2.3.1 **标记与扫描**  ###

**①注解**

> 和  XML  配置文件一样，注解本身并不能执行，注解本身仅仅只是做一个标记，具体的功能是框架检测到注解标记的位置，然后针对这个位置按照注解标记的功能来执行具体操作。 
> 
> 本质上：所有一切的操作都是 Java 代码来完成的， XML 和注解只是告诉框架中的 Java 代码如何执行。

**②扫描**

> Spring  为了知道程序员在哪些地方标记了什么注解，就需要通过扫描的方式，来进行检测。然后根据注解进行后续操作。

**③新建** **Maven Module**

<dependencies>
    
    <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.3.1</version>
    </dependency>
    
    <dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
    <scope>test</scope>
    </dependency>
    </dependencies>

**④创建** **Spring** **配置文件**

**⑤标识组件的常用注解**

>  *  @Component：将类标识为普通组件 
>  *  @Controller：将类标识为控制层组件 
>  *  @Service：将类标 识为业务层组件 
>  *  @Repository：将类标识为持久层组件 
> 
> 通过查看源码我们得知， @Controller 、 @Service 、 @Repository 这三个注解只是在 @Component 的基础上起了三个新的名字。 
> 
> 对于 Spring 使用 IOC 容器管理这些组件来说没有区别。所以 @Controller 、 @Service 、 @Repository 这三个注解只是给开发人员看的，让我们能够便于分辨组件的作用。 
> 
> 注意：**虽然它们本质上一样，但是为了代码的可读性，为了程序结构严谨我们肯定不能随便胡乱标记。**

**⑥创建组件**

创建 **控制层组件**

@Controller
    public class UserController {
    }

创建接口 UserService

public interface UserService {
    }

创建 **业务层组件** UserServiceImpl

@Service
    public class UserServiceImpl implements UserService {
    }

创建接口 UserDao

public interface UserDao {
    }

创建 **持久层组件** UserDaoImpl

@Repository
    public class UserDaoImpl implements UserDao {
    }

**⑦扫描组件**

情况一：最基本的扫描方式

<context:component-scan base-package="com.atguigu">
    </context:component-scan>

情况二：指定要排除的组件

<context:component-scan base-package="com.atguigu">
    
    
    <context:exclude-filter type="annotation"
    expression="org.springframework.stereotype.Controller"/>
    
    </context:component-scan>

情况三：仅扫描指定组件

<context:component-scan base-package="com.atguigu" use-default-filters="false">
    
    
    
    
    <context:include-filter type="annotation"
    expression="org.springframework.stereotype.Controller"/>
    
    </context:component-scan>

**⑧测试**

@Test
    public void testAutowireByAnnotation(){
    ApplicationContext ac = new
    ClassPathXmlApplicationContext("applicationContext.xml");
    UserController userController = ac.getBean(UserController.class);
    System.out.println(userController);
    UserService userService = ac.getBean(UserService.class);
    System.out.println(userService);
    UserDao userDao = ac.getBean(UserDao.class);
    System.out.println(userDao);
    }

**⑨组件所对应的** **bean** **的** **id**

在我们使用 XML 方式管理 bean 的时候，每个 bean 都有一个唯一标识，便于在其他地方引用。现在使用

注解后，每个组件仍然应该有一个唯一标识。

> 默认情况 
> 
> **类名首字母小写就是bean的id。** 例如： UserController 类对应的 bean 的 id 就是 userController 。 
> 
> 自定义 bean 的 id 
> 
> 可通过标识组件的注解的 value 属性**设置自定义的** **bean的id** 
> 
> @Service("userService")// 默认为 userServiceImpl 
> 
> public class UserServiceImpl implements UserService \{\}

### 2.3.2 **基于注解的自动装配**  ###

**①场景模拟**

参考基于xml的自动装配
    在UserController中声明UserService对象
    在UserServiceImpl中声明UserDao对象

**②** **@Autowired** **注解**

> **在成员变量上直接标记@Autowired注解即可完成自动装配，不需要提供setXxx()方法。以后我们在项目中的正式用法就是这样。**

@Controller
    public class UserController {
    @Autowired
    private UserService userService;
    public void saveUser(){
    userService.saveUser();
    }
    }

**③** **@Autowired** **注解其他细节**

> @Autowired 注解可以标记在构造器和 set 方法上

@Controller
    public class UserController {
    private UserService userService;
    @Autowired
    public UserController(UserService userService){
    this.userService = userService;
    }
    public void saveUser(){
    userService.saveUser();
    }
    }

**④****@Autowired****工作流程**

首先根据所需要的组件类型到 IOC 容器中查找

*  能够找到唯一的bean：直接执行装配 
 *  如果完全找不到匹配这个类型的bean：装配失败 
 *  和所需类型匹配的bean不止一个 
 *  没有@Qualifier注解：根据@Autowired标记位置成员变量的变量名作为bean的id进行匹配

> 能够找到：执行装配 
> 
> 找不到：装配失败

*  使用@Qualifier注解：根据@Qualifier注解中指定的名称作为bean的id进行匹配

> 能够找到：执行装配 
> 
> 找不到：装配失败

# 三：AOP #

## **3.1** **场景模拟**  ##

### **3.1.1** **声明接口**  ###

声明计算器接口 Calculator ，包含加减乘除的抽象方法

public interface Calculator {
    int add(int i, int j);
    int sub(int i, int j);
    int mul(int i, int j);
    int div(int i, int j);
    }

### **3.1.2** **创建实现类**  ###

### **3.1.3** **创建带日志功能的实现类**  ###

### **3.1.4** **提出问题**  ###

**①现有代码缺陷**

>  *  针对带日志功能的实现类，我们发现有如下缺陷： 
>  *  对核心业务功能有干扰，导致程序员在开发核心业务功能时分散了精力 
>  *  附加功能分散在各个业务功能方法中，不利于统一维护

**②解决思路**

> 解决这两个问题，核心就是：解耦。我们需要把附加功能从业务功能代码中抽取出来。

**③困难**

> 解决问题的困难：要抽取的代码在方法内部，靠以前把子类中的重复代码抽取到父类的方式没法解决。所以需要引入新的技术。

## **3.2** **代理模式**  ##

### **3.2.1** **概念**  ###

**①介绍 --（将核心代码封装）**

二十三种设计模式中的一种，属于结构型模式。它的作用就是通过提供一个代理类，让我们在调用目标方法的时候，不再是直接对目标方法进行调用，而是通过代理类**间接** 调用。让不属于目标方法核心逻辑的代码从目标方法中剥离出来—— **解耦** 。调用目标方法时先调用代理对象的方法，减少对目标方法的调用和打扰，同时让附加功能能够集中在一起也有利于统一维护。

![5a9536d39ff44bacae24cee0117121f4.png][]

### **3.2.2** **静态代理** ###

创建静态代理类：

public class CalculatorStaticProxy implements Calculator {
    // 将被代理的目标对象声明为成员变量
    private Calculator target;
    public CalculatorStaticProxy(Calculator target) {
    this.target = target;
    }
    @Override
    public int add(int i, int j) {
    // 附加功能由代理类中的代理方法来实现
    System.out.println("[日志] add 方法开始了，参数是：" + i + "," + j);
    // 通过目标对象来实现核心业务逻辑
    int addResult = target.add(i, j);
    System.out.println("[日志] add 方法结束了，结果是：" + addResult);
    return addResult;
    }
    }

> 静态代理确实实现了解耦，但是由于代码都写死了，完全不具备任何的灵活性。就拿日志功能来说，将来其他地方也需要附加日志，那还得再声明更多个静态代理类，那就产生了大量重复的代码，日志功能还是分散的，没有统一管理。 
> 
> 提出进一步的需求：将**日志功能集中到一个代理类中，将来有任何日志需求，都通过这一个代理类来实现。**这就需要使用动态代理技术了。

### **3.2.3** **动态代理**  ###

![8ff190af697648e8a2f8dec82f578b02.png][]

生产代理对象的工厂类：

public class ProxyFactory {
    private Object target;
    public ProxyFactory(Object target) {
    this.target = target;
    }
    public Object getProxy(){
    /**
    * newProxyInstance()：创建一个代理实例
    * 其中有三个参数：
    * 1、classLoader：加载动态生成的代理类的类加载器
    * 2、interfaces：目标对象实现的所有接口的class对象所组成的数组
    * 3、invocationHandler：设置代理对象实现目标对象方法的过程，即代理类中如何重写接
    口中的抽象方法
    */
    ClassLoader classLoader = target.getClass().getClassLoader();
    Class<?>[] interfaces = target.getClass().getInterfaces();
    InvocationHandler invocationHandler = new InvocationHandler() {
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
    throws Throwable {
    /**
    * proxy：代理对象
    * method：代理对象需要实现的方法，即其中需要重写的方法
    * args：method所对应方法的参数
    */
    Object result = null;
    try {
    System.out.println("[动态代理][日志] "+method.getName()+"，参
    数："+ Arrays.toString(args));
    result = method.invoke(target, args);
    System.out.println("[动态代理][日志] "+method.getName()+"，结
    果："+ result);
    } catch (Exception e) {
    e.printStackTrace();
    System.out.println("[动态代理][日志] "+method.getName()+"，异
    常："+e.getMessage());
    } finally {
    System.out.println("[动态代理][日志] "+method.getName()+"，方法
    执行完毕");
    }
    return result;
    }
    };
    return Proxy.newProxyInstance(classLoader, interfaces,
    invocationHandler);
    }
    }

### **3.2.4** **测试** ###

@Test
    public void testDynamicProxy(){
    ProxyFactory factory = new ProxyFactory(new CalculatorLogImpl());
    Calculator proxy = (Calculator) factory.getProxy();
    proxy.div(1,0);
    //proxy.div(1,1);
    }

## **3.3** **AOP****概念及相关术语**  ##

### **3.3.1****、概述**  ###

> AOP （ Aspect Oriented Programming ）是一种设计思想，是软件设计领域中的 **面向切面编程** ，它是面向对象编程的一种补充和完善，它以通过预编译方式和运行期动态代理方式实现在不修改源代码的情况下给程序动态统一添加额外功能的一种技术。

### **3.3.2****、相关术语**  ###

**①横切关注点**

> 从每个方法中抽取出来的同一类非核心业务。在同一个项目中，我们可以使用多个横切关注点对相关方法进行多个不同方面的增强。 
> 
> 这个概念不是语法层面天然存在的，而是根据附加功能的逻辑上的需要：有十个附加功能，就有十个横切关注点。

![6e3b36df0f984bb998228978a0271a3b.png][]

**②通知**

每一个横切关注点上要做的事情都需要写一个方法来实现，这样的方法就叫通知方法。

>  *  前置通知：在被代理的目标方法**前**执行 
>  *  返回通知：在被代理的目标方法**成功结束**后执行（**寿终正寝**） 
>  *  异常通知：在被代理的目标方法**异常结束**后执行（**死于非命**） 
>  *  后置通知：在被代理的目标方法**最终结束**后执行（**盖棺定论**） 
>  *  环绕通知：使用try...catch...finally结构围绕**整个**被代理的目标方法，包括上面四种通知对应的所有位置

![f4083ed04428466181f33e64cf8273e6.png][]

**③切面**

封装通知方法的类。

![2d01803efbad4494ab864fd054c71d0b.png][]

**④目标**

> 被代理的目标对象。

**⑤代理**

> 向目标对象应用通知之后创建的代理对象。

**⑥连接点**

> 这也是一个纯逻辑概念，不是语法定义的。 
> 
> 把方法排成一排，每一个横切位置看成 x 轴方向，把方法从上到下执行的顺序看成 y 轴， x 轴和 y 轴的交叉点就是连接点。

**⑦切入点**

> 定位连接点的方式。 
> 
> 每个类的方法中都包含多个连接点，所以连接点是类中客观存在的事物（从逻辑上来说）。 
> 
> 如果把连接点看作数据库中的记录，那么切入点就是查询记录的  SQL  语句。 
> 
> Spring  的  AOP  技术可以通过切入点定位到特定的连接点。 
> 
> 切点通过  org.springframework.aop.Pointcut  接口进行描述，它使用类和方法作为连接点的查询条件。

### **3.3.3****、作用**  ###

*  简化代码：把方法中固定位置的重复的代码**抽取**出来，让被抽取的方法更专注于自己的核心功能，提高内聚性。 
 *  代码增强：把特定的功能封装到切面类中，看哪里有需要，就往上套，被**套用**了切面逻辑的方法就被切面给增强了。

## **3.4** **基于注解的****AOP**  ##

### **3.4.1** **技术说明** ###

*  动态代理（InvocationHandler）：JDK原生的实现方式，需要被代理的目标类必须实现接口。因为这个技术要求**代理对象和目标对象实现同样的接口**（兄弟两个拜把子模式）。 
 *  cglib：通过**继承被代理的目标类**（认干爹模式）实现代理，所以不需要目标类实现接口。 
 *  AspectJ：本质上是静态代理，**将代理逻辑****“****织入****”****被代理的目标类编译得到的字节码文件**，所以最终效果是动态的。weaver就是织入器。Spring只是借用了AspectJ中的注解。

### **3.4.2** **准备工作** ###

**①添加依赖**

**②准备被代理的目标资源**

### **3.4.3** **创建切面类并配置** ###

// @Aspect表示这个类是一个切面类
    @Aspect
    // @Component注解保证这个切面类能够放入IOC容器
    @Component
    public class LogAspect {
    @Before("execution(public int com.atguigu.aop.annotation.CalculatorImpl.*
    (..))")
    public void beforeMethod(JoinPoint joinPoint){
    String methodName = joinPoint.getSignature().getName();
    String args = Arrays.toString(joinPoint.getArgs());
    System.out.println("Logger-->前置通知，方法名："+methodName+"，参
    数："+args);
    }
    @After("execution(* com.atguigu.aop.annotation.CalculatorImpl.*(..))")
    public void afterMethod(JoinPoint joinPoint){
    String methodName = joinPoint.getSignature().getName();
    System.out.println("Logger-->后置通知，方法名："+methodName);
    }
    @AfterReturning(value = "execution(*
    com.atguigu.aop.annotation.CalculatorImpl.*(..))", returning = "result")
    public void afterReturningMethod(JoinPoint joinPoint, Object result){
    String methodName = joinPoint.getSignature().getName();
    System.out.println("Logger-->返回通知，方法名："+methodName+"，结
    果："+result);
    }
    @AfterThrowing(value = "execution(*
    com.atguigu.aop.annotation.CalculatorImpl.*(..))", throwing = "ex")
    public void afterThrowingMethod(JoinPoint joinPoint, Throwable ex){
    String methodName = joinPoint.getSignature().getName();
    System.out.println("Logger-->异常通知，方法名："+methodName+"，异常："+ex);
    }
    @Around("execution(* com.atguigu.aop.annotation.CalculatorImpl.*(..))")
    public Object aroundMethod(ProceedingJoinPoint joinPoint){
    String methodName = joinPoint.getSignature().getName();
    String args = Arrays.toString(joinPoint.getArgs());
    Object result = null;
    try {
    System.out.println("环绕通知-->目标对象方法执行之前");
    //目标对象（连接点）方法的执行
    result = joinPoint.proceed();
    System.out.println("环绕通知-->目标对象方法返回值之后");
    } catch (Throwable throwable) {
    throwable.printStackTrace();
    System.out.println("环绕通知-->目标对象方法出现异常时");
    } finally {
    System.out.println("环绕通知-->目标对象方法执行完毕");
    }
    return result;
    }
    }

在 Spring 的配置文件中配置：

<context:component-scan base-package="com.atguigu.aop.annotation">
    </context:component-scan>
    <aop:aspectj-autoproxy />

### **3.4.4** **各种通知**  ###

>  *  前置通知：使用@Before注解标识，在被代理的目标方法**前**执行 
>  *  返回通知：使用@AfterReturning注解标识，在被代理的目标方法**成功结束**后执行（**寿终正寝**） 
>  *  异常通知：使用@AfterThrowing注解标识，在被代理的目标方法**异常结束**后执行（**死于非命**） 
>  *  后置通知：使用@After注解标识，在被代理的目标方法**最终结束**后执行（**盖棺定论**） 
>  *  环绕通知：使用@Around注解标识，使用try...catch...finally结构围绕**整个**被代理的目标方法，包括上面四种通知对应的所有位置

> 各种通知的执行顺序： 
> 
> Spring 版本 5.3.x 以前： 
> 
> 1.  前置通知 
> 2.  目标操作 
> 3.  后置通知 
> 4.  返回通知或异常通知 
> 
> Spring 版本 5.3.x 以后： 
> 
> 1.  前置通知 
> 2.  目标操作 
> 3.  返回通知或异常通知 
> 4.  后置通知

### **3.4.5** **重用切入点表达式** ###

**①声明**

@Pointcut("execution(* com.atguigu.aop.annotation.*.*(..))")
    public void pointCut(){}

**②在同一个切面中使用**

@Before("pointCut()")
    public void beforeMethod(JoinPoint joinPoint){
    String methodName = joinPoint.getSignature().getName();
    String args = Arrays.toString(joinPoint.getArgs());
    System.out.println("Logger-->前置通知，方法名："+methodName+"，参数："+args);
    }

**③在不同切面中使用**

@Before("com.atguigu.aop.CommonPointCut.pointCut()")
    public void beforeMethod(JoinPoint joinPoint){
    String methodName = joinPoint.getSignature().getName();
    String args = Arrays.toString(joinPoint.getArgs());
    System.out.println("Logger-->前置通知，方法名："+methodName+"，参数："+args);
    }

### **3.4.6** **切面的优先级**  ###

相同目标方法上同时存在多个切面时，切面的优先级控制切面的 **内外嵌套** 顺序。

*  优先级高的切面：外面 
 *  优先级低的切面：里面

使用 @Order 注解可以控制切面的优先级：

*  @Order(较小的数)：优先级高 
 *  @Order(较大的数)：优先级低

# 四：声明式事务 #

## **4.1** **JdbcTemplate** ##

### **4.1.1** **简介**  ###

> Spring  框架对  JDBC  进行封装，使用  **JdbcTemplate**  方便实现**对数据库操作**

### **4.1.2** **准备工作**  ###

**①加入依赖**

**②创建** **jdbc.properties**

**③配置** **Spring** **的配置文件**

<context:property-placeholder location="classpath:jdbc.properties" />
    
    <bean id="druidDataSource" class="com.alibaba.druid.pool.DruidDataSource">
    <property name="url" value="${atguigu.url}"/>
    <property name="driverClassName" value="${atguigu.driver}"/>
    <property name="username" value="${atguigu.username}"/>
    <property name="password" value="${atguigu.password}"/>
    </bean>
    
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
    
    <property name="dataSource" ref="druidDataSource"/>
    </bean>

### **4.1.3** **测试** ###

**①在测试类装配** **JdbcTemplate**

@RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration("classpath:spring-jdbc.xml")
    public class JDBCTemplateTest {
    @Autowired
    private JdbcTemplate jdbcTemplate;
    }

## **4.2** **声明式事务概念**  ##

### **4.2.1** **编程式事务**  ###

事务功能的相关操作全部通过自己编写代码来实现

编程式的实现方式存在缺陷：

>  *  细节没有被屏蔽：具体操作过程中，所有细节都需要程序员自己来完成，比较繁琐。 
>  *  代码复用性不高：如果没有有效抽取出来，每次实现功能都需要自己编写代码，代码就没有得到复用。

**4.2.2** **、声明式事务**

既然事务控制的代码有规律可循，代码的结构基本是确定的，所以框架就可以将固定模式的代码抽取出来，进行相关的封装。

封装起来后，我们只需要在配置文件中进行简单的配置即可完成操作。

>  *  好处1：提高开发效率 
>  *  好处2：消除了冗余的代码 
>  *  好处3：框架会综合考虑相关领域中在实际开发环境下有可能遇到的各种问题，进行了健壮性、性能等各个方面的优化

所以，我们可以总结下面两个概念：

>  *  **编程式**：**自己写代码**实现功能 
>  *  **声明式**：通过**配置**让**框架**实现功能

## **4.3****基于注解的声明式事务**  ##

### **4.3.1****准备工作**  ###

**①加入依赖**

**②创建** **jdbc.properties**

**③配置** **Spring** **的配置文件**

<context:component-scan base-package="com.atguigu.spring.tx.annotation">
    </context:component-scan>
    
    <context:property-placeholder location="classpath:jdbc.properties" />
    
    <bean id="druidDataSource" class="com.alibaba.druid.pool.DruidDataSource">
    <property name="url" value="${jdbc.url}"/>
    <property name="driverClassName" value="${jdbc.driver}"/>
    <property name="username" value="${jdbc.username}"/>
    <property name="password" value="${jdbc.password}"/>
    </bean>
    
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
    
    <property name="dataSource" ref="druidDataSource"/>
    </bean>

**④创建表**

**⑤创建组件**

### **4.3.2** **测试无事务情况**  ###

### **4.3.3** **加入事务**  ###

**①添加事务配置**

在 Spring 的配置文件中添加配置：

**②添加事务注解**

因为 service 层表示业务逻辑层，一个方法表示一个完成的功能，因此处理事务一般在 service 层处理

在 BookServiceImpl 的 buybook() 添加注解 @Transactional

**③观察结果**

由于使用了 Spring 的声明式事务，更新库存和更新余额都没有执行

### **4.3.4** **@Transactional****注解标识的位置** ###

*  @Transactional标识在方法上，咋只会影响该方法 
 *  @Transactional标识的类上，咋会影响类中所有的方法

### **4.3.5** **事务属性：只读** ###

**①介绍**

对一个查询操作来说，如果我们把它设置成只读，就能够明确告诉数据库，这个操作不涉及写操作。这

样数据库就能够针对查询操作来进行优化。

**②使用方式**

@Transactional(readOnly = true)

### **4.3.6** **事务属性：超时** ###

**①介绍**

事务在执行过程中，有可能因为遇到某些问题，导致程序卡住，从而长时间占用数据库资源。而长时间占用资源，大概率是因为程序运行出现了问题（可能是Java 程序或 MySQL 数据库或网络连接等等）。

此时这个很可能出问题的程序应该被回滚，撤销它已做的操作，事务结束，把资源让出来，让其他正常 程序可以执行。

概括来说就是一句话：超时回滚，释放资源。

**②使用方式**

@Transactional(timeout = 3)

### **4.3.7** **事务属性：回滚策略**  ###

**①介绍**

声明式事务默认只针对运行时异常回滚，编译时异常不回滚。

可以通过 @Transactional 中相关属性设置回滚策略

*  rollbackFor属性：需要设置一个Class类型的对象 
 *  rollbackForClassName属性：需要设置一个字符串类型的全类名 
 *  noRollbackFor属性：需要设置一个Class类型的对象 
 *  rollbackFor属性：需要设置一个字符串类型的全类名

**②使用方式**

@Transactional(noRollbackFor = ArithmeticException.class)

### **4.3.8** **事务属性：事务隔离级别**  ###

**①介绍**

数据库系统必须具有隔离并发运行各个事务的能力，使它们不会相互影响，避免各种并发问题。一个事

务与其他事务隔离的程度称为隔离级别。 SQL 标准中规定了多种事务隔离级别，不同隔离级别对应不同

的干扰程度，隔离级别越高，数据一致性就越好，但并发性越弱。

隔离级别一共有四种：

*  读未提交：READ UNCOMMITTED ：允许Transaction01读取Transaction02未提交的修改。 
 *  读已提交：READ COMMITTED：要求Transaction01只能读取Transaction02已提交的修改。 
 *  可重复读：REPEATABLE READ ：确保Transaction01可以多次从一个字段中读取到相同的值，即Transaction01执行期间禁止其它事务对这个字段进行更新。 
 *  串行化：SERIALIZABLE ：确保Transaction01可以多次从一个表中读取到相同的行，在Transaction01执行期间，禁止其它事务对这个表进行添加、更新、删除操作。可以避免任何并发问题，但性能十分低下。

各个隔离级别解决并发问题的能力见下表

![1d7e064089b64a128b3ebf0e9381bfd7.png][]

各种数据库产品对事务隔离级别的支持程度：

![c0d27206e48e448a893f87990f6b76b4.png][]

**②使用方式**

@Transactional(isolation = Isolation.DEFAULT)//使用数据库默认的隔离级别
    @Transactional(isolation = Isolation.READ_UNCOMMITTED)//读未提交
    @Transactional(isolation = Isolation.READ_COMMITTED)//读已提交
    @Transactional(isolation = Isolation.REPEATABLE_READ)//可重复读
    @Transactional(isolation = Isolation.SERIALIZABLE)//串行化

### **4.3.9** **事务属性：事务传播行为** ###

**①介绍**

当事务方法被另一个事务方法调用时，必须指定事务应该如何传播。例如：方法可能继续在现有事务中运行，也可能开启一个新事务，并在自己的事务中运行。

**③观察结果**

可以通过 @Transactional 中的 propagation 属性设置事务传播行为修改BookServiceImpl 中 buyBook() 上，注解 @Transactional 的 propagation 属性 **@Transactional(propagation = Propagation.REQUIRED)，默认情况** ，表示如果当前线程上有已经开启的事务可用，那么就在这个事务中运行。经过观察，购买图书的方法buyBook() 在 checkout() 中被调用，checkout() 上有事务注解，因此在此事务中执行。所购买的两本图书的价格为 80 和 50 ，而用户的余额为100 ，因此在购买第二本图书时余额不足失败，导致整个 checkout() 回滚，**即只要有一本书买不了，就都买不了**

**@Transactional(propagation = Propagation.REQUIRES\_NEW)** ，表示不管当前线程上是否有已经开启的事务，都要开启新事务。同样的场景，每次购买图书都是在buyBook() 的事务中执行，因此第一本图书购买成功，事务结束，第二本图书购买失败，只在第二次的buyBook() 中回滚，购买第一本图书不受影响，**即能买几本就买几本**

[5a9536d39ff44bacae24cee0117121f4.png]: https://img-blog.csdnimg.cn/5a9536d39ff44bacae24cee0117121f4.png
[8ff190af697648e8a2f8dec82f578b02.png]: https://img-blog.csdnimg.cn/8ff190af697648e8a2f8dec82f578b02.png
[6e3b36df0f984bb998228978a0271a3b.png]: https://img-blog.csdnimg.cn/6e3b36df0f984bb998228978a0271a3b.png
[f4083ed04428466181f33e64cf8273e6.png]: https://img-blog.csdnimg.cn/f4083ed04428466181f33e64cf8273e6.png
[2d01803efbad4494ab864fd054c71d0b.png]: https://img-blog.csdnimg.cn/2d01803efbad4494ab864fd054c71d0b.png
[1d7e064089b64a128b3ebf0e9381bfd7.png]: https://img-blog.csdnimg.cn/1d7e064089b64a128b3ebf0e9381bfd7.png
[c0d27206e48e448a893f87990f6b76b4.png]: https://img-blog.csdnimg.cn/c0d27206e48e448a893f87990f6b76b4.png