Java：基于注解的Spring使用【AOP容器】和事务管理

news2024/11/17 11:30:02

目录

  • 第十五章 AOP前奏
    • 15.1 代理模式
    • 15.2 为什么需要代理【程序中】
    • 15.3 手动实现动态代理环境搭建
    • 15.4 手动实现动态代理关键步骤
  • 第十六章 Spring中AOP【重点】
    • 16.1 AspectJ框架【AOP框架】
    • 16.2 使用AspectJ步骤（入门）
    • 16.3 Spring中AOP概述
    • 16.4 Spring中AOP相关术语
  • 第十七章 AspectJ详解【重点】
    • 17.1 AspectJ中切入点表达式
    • 17.2 AspectJ中JoinPoint对象
    • 17.3 AspectJ中通知
    • 17.4 定义切面优先级
    • 17.5 基于XML方式配置AOP
  • 第十八章 Spring中JdbcTemplate
    • 18.1 JdbcTemplate简介
    • 18.2 JdbcTemplate基本使用
    • 18.3 JdbcTemplate的常用API
    • 18.4 使用JdbcTemplate搭建Service&Dao层
  • 第十九章 Spring声明式事务管理
    • 19.1 Spring中支持事务管理
    • 19.2 使用声明式事务管理
    • 19.3 Spring声明式事务管理属性

第十五章 AOP前奏

15.1 代理模式

  • 代理模式：我们需要做一件事情，又不期望自己亲力亲为，此时，可以找一个代理【中介】

  • 我们【目标对象】与中介【代理对象】不能相互转换，因为是“兄弟”关系

    在这里插入图片描述

15.2 为什么需要代理【程序中】

  • 需求：实现【加减乘除】计算器类

    • 在加减乘除方法中，添加日志功能【在计算之前，记录日志。在计算之后，显示结果。】

  • 实现后发现问题如下

    • 日志代码比较分散，可以提取日志类
    • 日志代码比较混乱，日志代码【非核心业务代码】与加减乘除方法【核心业务代码】书写一处

  • 总结：在核心业务代码中，需要添加日志功能，但不期望在核心业务代码中书写日志代码。

    • 此时：使用代理模式解决问题【先将日志代码横向提取到日志类中，再动态织入回到业务代码中】

15.3 手动实现动态代理环境搭建

  • 实现方式

    • 基于接口实现动态代理： JDK动态代理
    • 基于继承实现动态代理： Cglib、Javassist动态代理

  • 实现动态代理关键步骤

    • 一个类：Proxy
      • 概述：Proxy代理类的基类【类似Object】
      • 作用：newProxyInstance()：创建代理对象
    • 一个接口：InvocationHandler
      • 概述：实现【动态织入效果】关键接口
      • 作用：invoke()，执行invoke()实现动态织入效果

15.4 手动实现动态代理关键步骤

注意：代理对象与实现类【目标对象】是“兄弟”关系，不能相互转换

  • 创建类【为了实现创建代理对象工具类】
  • 提供属性【目标对象：实现类】
  • 提供方法【创建代理对象】
  • 提供有参构造器【避免目标对为空】
package com.atguigu.beforeaop;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * @author Chunsheng Zhang 尚硅谷
 * @create 2022/3/28 16:22
 */
public class MyProxy {

    /**
     * 目标对象【目标客户】
     */
    private Object target;

    public MyProxy(Object target){
        this.target = target;
    }

    /**
     * 获取目标对象的，代理对象
     * @return
     */
    public Object getProxyObject(){
        Object proxyObj = null;

        /**
            类加载器【ClassLoader loader】,目标对象类加载器
            目标对象实现接口：Class<?>[] interfaces,目标对象实现所有接口
            InvocationHandler h
         */
        ClassLoader classLoader = target.getClass().getClassLoader();
        Class<?>[] interfaces = target.getClass().getInterfaces();
        //创建代理对象
        proxyObj = Proxy.newProxyInstance(classLoader, interfaces, new InvocationHandler() {
            //执行invoke()实现动态织入效果
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                //获取方法名【目标对象】
                String methodName = method.getName();
                //执行目标方法之前，添加日志
                MyLogging.beforeMethod(methodName,args);
                //触发目标对象目标方法
                Object rs = method.invoke(target, args);
                //执行目标方法之后，添加日志
                MyLogging.afterMethod(methodName,rs);
                return rs;
            }
        });
        return proxyObj;
    }

//    class invocationImpl implements InvocationHandler{
//    }

}

@Test
    public void testBeforeAop(){

//        int add = calc.add(1, 2);
//        System.out.println("add = " + add);

        //目标对象
        Calc calc = new CalcImpl();
        //代理工具类
        MyProxy myProxy = new MyProxy(calc);
        //获取代理对象
        Calc calcProxy = (Calc)myProxy.getProxyObject();
        //测试
//        int add = calcProxy.add(1, 2);
        int div = calcProxy.div(2, 1);

    }

第十六章 Spring中AOP【重点】

16.1 AspectJ框架【AOP框架】

  • AspectJ是Java社区里最完整最流行的AOP框架。
  • 在Spring2.0以上版本中，可以使用基于AspectJ注解或基于XML配置的AOP。

16.2 使用AspectJ步骤（入门）

  1. 添加jar包支持

    <!--        添加AspectJ-->
<!--spirng-aspects的jar包-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
    <version>5.3.1</version>
</dependency>

  2. 配置文件

    • 开启组件扫描
    • 开启AspectJ注解支持
    <!--    开启组件扫描-->
    <context:component-scan base-package="com.atguigu"></context:component-scan>
<!--    开启AspectJ注解支持-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

  3. 将MyLogging类上面添加注解

    • @Component：将当前类标识为一个组件
    • @Aspect：将当前类标识为切面类【非核心业务提取类】

  4. 将MyLogging中的方法中添加通知注解

    • @Before
    @Component      //将当前类标识为一个组件
@Aspect         //将当前类标识为【切面类】【非核心业务提取类】
public class MyLogging {
    /**
     * 方法之前
     */
    @Before(value = "execution(public int com.atguigu.aop.CalcImpl.add(int , int ) )")
     public void beforeMethod(JoinPoint joinPoint){
         //获取方法名称
         String methodName = joinPoint.getSignature().getName();
         //获取参数
         Object[] args = joinPoint.getArgs();
         System.out.println("==>Calc中的"+methodName+"方法()，参数：+" + Arrays.toString(args));
     }
}

  5. 测试

    @Test
public void testAop(){
    //创建容器对象
    ApplicationContext context =
            new ClassPathXmlApplicationContext("applicationContext_aop.xml");

    Calc calc = context.getBean("calc", Calc.class);

     //错误的，代理对象不能转换为目标对象【代理对象与目标对象是兄弟关系】
	 //CalcImpl calc = context.getBean("calc", CalcImpl.class);

    int add = calc.add(1, 2);

}

16.3 Spring中AOP概述

  • AOP：Aspect-Oriented Programming，面向切面编程【面向对象一种补充】
    • 优势：
      • 解决代码分散问题
      • 解决代码混乱问题
  • OOP：Object-Oriented Programming，面向对象编程

16.4 Spring中AOP相关术语

  1. 横切关注点：非核心业务代码【日志】，称之为横切关注点
  2. 切面(Aspect)：将横切关注点提取到类中，这个类称之为切面类
  3. 通知(Advice)：将横切关注点提取到类中之后，横切关注点更名为：通知（切面类定义的方法）
  4. 目标(Target)：目标对象，指的是需要被代理的对象【实现类（CalcImpl）】
  5. 代理(Proxy)：代理对象可以理解为：中介
  6. 连接点(Joinpoint)：通知方法需要指定通知位置，这个位置称之为：连接点【通知之前】
  7. 切入点(pointcut)：通知方法需要指定通知位置，这个位置称之为：切入点【通知之后】

第十七章 AspectJ详解【重点】

17.1 AspectJ中切入点表达式

  • 语法：@Before(value=“execution(权限修饰符 返回值类型 包名.类名.方法名(参数类型))”)

  • 通配符

    • 【*】：

      • ​ 【*】：可以代表任意权限修饰符&返回值类型

      • ​ 【*】：可以代表任意包名、任意类名、任意方法名

    • 【…】：

      • ​【…】：代表任意参数类型及参数个数

  • 重用切入点表达式

    1. 使用@PointCut注解，提取可重用的切入点表达式

      @Pointcut("execution(* com.atguigu.aop.CalcImpl.*(..) )")
public void myPointCut(){}

    2. 使用**方法名()**引入切入点表达式

      // @Before(value = "execution(public int com.atguigu.aop.CalcImpl.add(int , int ) )")
@Before(value = "myPointCut()")
public void beforeMethod(JoinPoint joinPoint){}

17.2 AspectJ中JoinPoint对象

  • JoinPont【切入点对象】

  • 作用：

    • 获取方法名称

      //获取方法签名【方法签名=方法名+参数列表】
joinPoint.getSignature();
//获取方法名称
String methodName = joinPoint.getSignature().getName();

    • 获取参数

      Object[] args = joinPoint.getArgs();

17.3 AspectJ中通知

  • 前置通知

    • 语法：@Before

    • 执行时机：指定方法执行之前执行【如目标方法中有异常，会执行】

      • 指定方法：切入点表达式设置位置

    • 示例代码

      //重用切入点表达式
@Pointcut("execution(* com.atguigu.aop.CalcImpl.*(..) )")
public void myPointCut(){}
@Before(value = "myPointCut()")
public void beforeMethod(JoinPoint joinPoint){
    //获取方法名称
    String methodName = joinPoint.getSignature().getName();
    //获取参数
    Object[] args = joinPoint.getArgs();
    System.out.println("==>Calc中"+methodName+"方法(),参数："+ Arrays.toString(args));
}

  • 后置通知

    • 语法：@After

    • 执行时机：指定方法所有通知执行之后执行【如目标方法中有异常，会执行】

    • 示例代码

      /**
 * 后置通知
 */
@After("myPointCut()")
public void afterMethod(JoinPoint joinPoint){
    //获取方法名称
    String methodName = joinPoint.getSignature().getName();
    //获取参数
    Object[] args = joinPoint.getArgs();
    System.out.println("==>Calc中"+methodName+"方法,之后执行!"+Arrays.toString(args));
}

  • 返回通知

    • 语法：@AfterReturnning

    • 执行时机：指定方法返回结果时执行，【如目标方法中有异常，不执行】

    • 注意事项：@AfterReturnning中returning属性与入参中参数名一致

    • 示例代码

      /**
 * 返回通知
 */
@AfterReturning(value = "myPointCut()",returning = "rs")
public void afterReturnning(JoinPoint joinPoint,Object rs){
    //获取方法名称
    String methodName = joinPoint.getSignature().getName();
    //获取参数
    Object[] args = joinPoint.getArgs();

    System.out.println("【返回通知】==>Calc中"+methodName+"方法,返回结果执行!结果："+rs);

}

  • 异常通知

    • 语法：@AfterThrowing

    • 执行时机：指定方法出现异常时执行，【如目标方法中无异常，不执行】

    • 注意事项：@AfterThrowing中的throwing属性值与入参参数名一致

    • 示例代码：

      /**
 * 异常通知
 */
@AfterThrowing(value = "myPointCut()",throwing = "ex")
public void afterThrowing(JoinPoint joinPoint,Exception ex){
    //获取方法名称
    String methodName = joinPoint.getSignature().getName();
    //获取参数
    Object[] args = joinPoint.getArgs();

    System.out.println("【异常通知】==>Calc中"+methodName+"方法,出现异常时执行!异常："+ex);

}

    • 总结

      • 有异常：前置通知=》异常通知=》后置通知
      • 无异常：前置通知=》返回通知=》后置通知

  • 环绕通知【前四个通知整合】

    • 语法：@Around

    • 作用：整合前四个通知

    • 注意：

      • 参数中必须使用ProceedingJoinPoint
      • 环绕通知必须将返回结果，作为返回值

    • 示例代码

      @Around(value = "myPointCut()")
public Object aroundMethod(ProceedingJoinPoint pjp){
    //获取方法名称
    String methodName = pjp.getSignature().getName();
    //获取参数
    Object[] args = pjp.getArgs();
    //定义返回值
    Object rs = null;
    try {
        //前置通知
        System.out.println("【前置通知】==>Calc中"+methodName+"方法(),参数："+ Arrays.toString(args));
        //触发目标对象的目标方法【加减乘除方法】
        rs = pjp.proceed();
        //返回通知【有异常不执行】
        System.out.println("【返回通知】==>Calc中"+methodName+"方法,返回结果执行!结果："+rs);
    } catch (Throwable throwable) {
        throwable.printStackTrace();
        //异常通知
        System.out.println("【异常通知】==>Calc中"+methodName+"方法,出现异常时执行!异常："+throwable);
    } finally {
        //后置通知【有异常执行】
        System.out.println("【后置通知】==>Calc中"+methodName+"方法,之后执行!"+Arrays.toString(args));
    }
    return rs;
}

17.4 定义切面优先级

  • 语法：@Order(value=index)

    • index是int类型，默认值是int可存储的最大值
    • 数值越小，优先级越高【一般建议使用正整数】

  • 示例代码

       // com/atguigu/aop/MyLogging.java
   @Component
   @Aspect
   public class MyLogging{}

// com/atguigu/aop/MyValidate.java
  @Component  //将当前类标识为一个组件
  @Aspect     //将当前类标识为【切面类】【非核心业务提取类】
  @Order(1)   // 切面的优先级，数越小，优先级越高
  public class MyValidate {
  
      /**
       * 添加数据验证功能
       */
      @Before(value = "com.atguigu.aop.MyLogging.myPointCut()")
      public void methodBefore(JoinPoint joinPoint){
  //        获取方法名
          String methodName = joinPoint.getSignature().getName();
  //        获取参数
          Object[] args = joinPoint.getArgs();
          System.out.println("~~~~~~~=============>数据验证切面············");
      }
  }

17.5 基于XML方式配置AOP

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

    <!--配置计算器实现类-->
    <bean id="calculator" class="com.atguigu.spring.aop.xml.CalculatorImpl"></bean>

    <!--配置切面类-->
    <bean id="loggingAspect" class="com.atguigu.spring.aop.xml.LoggingAspect"></bean>

    <!--AOP配置-->
    <aop:config>
        <!--配置切入点表达式-->
        <aop:pointcut id="pointCut"
                      expression="execution(* com.atguigu.spring.aop.xml.Calculator.*(..))"/>
        <!--配置切面-->
        <aop:aspect ref="loggingAspect">
            <!--前置通知-->
            <aop:before method="beforeAdvice" pointcut-ref="pointCut"></aop:before>
            <!--返回通知-->
            <aop:after-returning method="returningAdvice" pointcut-ref="pointCut" returning="result"></aop:after-returning>
            <!--异常通知-->
            <aop:after-throwing method="throwingAdvice" pointcut-ref="pointCut" throwing="e"></aop:after-throwing>
            <!--后置通知-->
            <aop:after method="afterAdvice" pointcut-ref="pointCut"></aop:after>
            <!--环绕通知-->
            <aop:around method="aroundAdvice" pointcut-ref="pointCut"></aop:around>
        </aop:aspect>
    </aop:config>
</beans>

第十八章 Spring中JdbcTemplate

18.1 JdbcTemplate简介

  • Spring提供的JdbcTemplate是一个小型持久化层框架，简化Jdbc代码。
    • Mybatis是一个半自动化的ORM持久化层框架

18.2 JdbcTemplate基本使用

  • 导入jar包

    <!--spring-context-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.3.1</version>
</dependency>
<!--spring-jdbc-->
<!--spring-orm-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-orm</artifactId>
    <version>5.3.1</version>
</dependency>
<!--导入druid的jar包-->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.10</version>
</dependency>
<!--导入mysql的jar包-->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.37</version>
</dependency>
<!--junit-->
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
    <scope>test</scope>
</dependency>

  • 编写配置文件

    • db.properties：设置连接数据库属性

      #key=value
db.driverClassName=com.mysql.jdbc.Driver
db.url=jdbc:mysql://127.0.0.1:3306/db220106
db.username=root
db.password=123456

    • applicationContext.xml【spring配置文件】

      • 加载外部属性文件
      • 装配数据源【DataSources】
      • 装配JdbcTemplate

    • 示例代码

      <!--    加载外部属性文件-->
<context:property-placeholder location="classpath:db.properties"></context:property-placeholder>

<!--    - 装配数据源【DataSources】-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
    <property name="driverClassName" value="${db.driverClassName}"></property>
    <property name="url" value="${db.url}"></property>
    <property name="username" value="${db.username}"></property>
    <property name="password" value="${db.password}"></property>
</bean>

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

  • 使用核心类库【JdbcTemplate】

18.3 JdbcTemplate的常用API

JdbcTemplate默认：自动提交事务

  • jdbcTemplate.update(String sql,Object… args)：通用的增删改方法
  • jdbcTemplate.batchUpdate(String sql,List<Object[]> args)：通用批处理增删改方法
  • jdbcTemplate.queryForObject(String sql,Class clazz,Object… args)：查询单个数值
    • String sql = “select count(1) from tbl_xxx”;
  • jdbcTemplate.queryForObject(String sql,RowMapper rm,Object… args)：查询单个对象
    • String sql = “select col1,col2… from tbl_xxx”;
  • jdbcTemplate.query(String sql,RowMapper rm,Obejct… args)：查询多个对象

18.4 使用JdbcTemplate搭建Service&Dao层

  • Service层依赖Dao层

  • Dao层依赖JdbcTemplate

  • 示例代码

    /**
 * @author Chunsheng Zhang 尚硅谷
 * @create 2022/3/29 16:27
 */
@Repository
public class DeptDaoImpl implements DeptDao {

    @Autowired
    @Qualifier("jdbcTemplate")
    private JdbcTemplate jdbcTemplate;

    @Override
    public List<Dept> selectAllDepts() {

        String sql = "select dept_id,dept_name from tbl_dept";
        RowMapper<Dept> rowMapper = new BeanPropertyRowMapper<>(Dept.class);
        List<Dept> list = jdbcTemplate.query(sql, rowMapper);

        return list;
    }
}

/**
 * @author Chunsheng Zhang 尚硅谷
 * @create 2022/3/29 16:30
 */
@Service("deptService")
public class DeptServiceImpl implements DeptService {

    @Autowired
    @Qualifier("deptDaoImpl")
    private DeptDao deptDao;

    @Override
    public List<Dept> getAllDepts() {
        return deptDao.selectAllDepts();
    }
}

第十九章 Spring声明式事务管理

回顾事务

  1. 事务四大特征【ACID】
    • 原子性
    • 一致性
    • 隔离性
    • 持久性
  2. 事务三种行为
    • 开启事务：connection.setAutoCommit(false)
    • 提交事务：connection.commit()
    • 回滚事务：connection.rollback()

19.1 Spring中支持事务管理

  • 编程式事务管理【传统事务管理】

    1. 获取数据库连接Connection对象

    2. 取消事务的自动提交【开启事务】

    3. 执行操作

    4. 正常完成操作时手动提交事务

    5. 执行失败时回滚事务

    6. 关闭相关资源

    • 不足：
      • 事务管理代码【非核心业务】与核心业务代码相耦合
        • 事务管理代码分散
        • 事务管理代码混乱

  • 声明式事务管理【使用AOP思想管理事务】

    • 先横向提取【事务管理代码】，再动态织入

19.2 使用声明式事务管理

不用事务管理代码，发现：同一个业务中，会出现局部成功及局部失败的现象【不正常】

  • 添加支持【AspectJ的jar包】

    <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
    <version>5.3.1</version>
</dependency>

  • 编写配置文件

    • 配置事务管理器
    • 开启事务注解支持
    <?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"
       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
       https://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/tx
       http://www.springframework.org/schema/tx/spring-tx.xsd">	
<!--  配置事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

	<!-- 开启事务注解支持
       transaction-manager默认值：transactionManager-->
    <tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>
</beans>

  • 在需要事务管理的业务方法上，添加注解**@Transactional**

    @Transactional
public void purchase(String username, String isbn) {
    //查询book价格
    Integer price = bookShopDao.findBookPriceByIsbn(isbn);
    //修改库存
    bookShopDao.updateBookStock(isbn);
    //修改余额
    bookShopDao.updateUserAccount(username, price);
}

  • 总结：

    • 添加声明式事务管理之后，获取是代理对象，代理对象不能转换为目标对象【实现类】

19.3 Spring声明式事务管理属性

@Transactional注解属性

  • 事务传播行为【Propagation】

    • 当事务方法被另一个事务方法调用时，必须指定事务应该如何传播。

      • 如：执行事务方法method()1【事务x】之后，调用事务方法method2()【事务y】，此时需要设置method()2方法的事务传播行为。

    • Spring的7种传播行为

      传播属性描述
      REQUIRED如果有事务在运行，当前的方法就在这个事务内运行；否则就启动一个新的事务，并在自己的事务内运行。
      REQUIRES_NEW当前的方法****必须****启动新事务，并在自己的事务内运行；如果有事务正在运行，应该将它挂起。
      SUPPORTS如果有事务在运行，当前的方法就在这个事务内运行，否则可以不运行在事务中。
      NOT_SUPPORTED当前的方法不应该运行在事务中，如果有运行的事务将它挂起
      MANDATORY当前的方法必须运行在事务中，如果没有正在运行的事务就抛出异常。
      NEVER当前的方法不应该运行在事务中，如果有正在运行的事务就抛出异常。
      NESTED如果有事务正在运行，当前的方法就应该在这个事务的嵌套事务内运行，否则就启动一个新的事务，并在它自己的事务内运行。

    • 图解事务传播行为

      • REQUIRED

        [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BQxmVcn6-1675002617917)(03_Spring.assets\image-20220330105232095.png)]

      • REQUIRES_NEW

        [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5VXTzxqF-1675002617918)(03_Spring.assets\image-20220330105540637.png)]

    • 使用场景

      /**
	1. 去结账时判断余额是否充足，余额不足：一本书都不能卖
*/
@Transactional(propagation=Propagation.REQUIRED)
public void purchase(String username, String isbn) {
    //查询book价格
    Integer price = bookShopDao.findBookPriceByIsbn(isbn);
    //修改库存
    bookShopDao.updateBookStock(isbn);
    //修改余额
    bookShopDao.updateUserAccount(username, price);
}

/**
	2. 去结账时判断余额是否充足，余额不足：最后导致余额不足的那本书，不让购买
*/
@Transactional(propagation=Propagation.REQUIRES_NEW)
    public void purchase(String username, String isbn) {
        //查询book价格
        Integer price = bookShopDao.findBookPriceByIsbn(isbn);
        //修改库存
        bookShopDao.updateBookStock(isbn);
        //修改余额
        bookShopDao.updateUserAccount(username, price);
    }

  • 事务隔离级别【Isolation】

  • 事务超时

  • 事务只读

  • 事务回滚【不回滚】

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/184374.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

AMQP 0-9-1 模型解释

AMQP 0-9-1 模型解释

官方文档链接&#xff1a;https://www.rabbitmq.com/tutorials/amqp-concepts.html 文章目录1. AMQP协议是什么2. AMQP模型2.1 工作过程2.2 深入理解3. 交换机3.1 默认交换机3.2 直连交换机3.3 扇形交换机3.4 主题交换机3.5 头交换机3.6 交换机小结4. Queue队列队列属性队列创建…
阅读更多...
BM7 链表中环的入口结点

BM7 链表中环的入口结点

目录 描述 输入描述&#xff1a; 返回值描述&#xff1a; 示例1 示例2 示例3 思路&#xff1a; 代码 描述 给一个长度为n链表&#xff0c;若其中包含环&#xff0c;请找出该链表的环的入口结点&#xff0c;否则&#xff0c;返回null。 例如&#xff0c;输入{1,…
阅读更多...
DW 2023年1月Free Excel 第九次打卡 Excel数据透视

DW 2023年1月Free Excel 第九次打卡 Excel数据透视

第九章 Excel数据透视 数据下载地址与参考链接&#xff1a;https://d9ty988ekq.feishu.cn/docx/Wdqld1mVroyTJmxicTTcrfXYnDd 数据透视是Excel中个强大的数据处理和分析工具&#xff0c;能够快速实现数据的汇总与统计分析&#xff0c;本节重点讲解Excel数据透视的相关操作。 1…
阅读更多...
NSSCTF Round#7 Team ez_rce和0o0讲解

NSSCTF Round#7 Team ez_rce和0o0讲解

强烈建议NSSCTF延长时间&#xff0c;大过年的逛亲戚回来就剩两个小时了。。。。 ez_rce <!-- A EZ RCE IN REALWORLD _ FROM CHINA.TW --> <!-- By 探姬 --> <?PHPif(!isset($_POST["action"]) && !isset($_POST["data"]))show_s…
阅读更多...
MySQL8中jdbc的url设置

MySQL8中jdbc的url设置

JDBC spring.datasource.urljdbc:mysql://${MYSQL_HOST:localhost}:3306/xxxx?sslModeREQUIRED&characterEncodingUTF-8&connectionTimeZoneGMT%2B8&forceConnectionTimeZoneToSessiontruesslMode:设置为REQUIRED表示必须启用ssl加密传输&#xff1b;characterEn…
阅读更多...
svn客户端add无法添加上子文件夹及其子文件——解决办法

svn客户端add无法添加上子文件夹及其子文件——解决办法

1、问题描述 svn客户端add文件夹后&#xff0c;无法添加上子文件夹及其子文件&#xff0c;需要先add最外层文件夹&#xff0c;再逐层add子文件夹&#xff0c;最后add最里层子文件夹中的文件&#xff0c;很影响add速度啊。现象如下图所示&#xff1a; 正常情况下&#xff0c;add…
阅读更多...
公派访问学者申请优势有哪些？

公派访问学者申请优势有哪些？

人的一生&#xff0c;若从职业生涯论&#xff0c;无非为官、为学、为商三条路。为官者&#xff0c;出国访学一年半载&#xff0c;对仕途并无太大作用&#xff0c;并且在此期间有可能丧失国内提拔的大好机会;为学者&#xff0c;公派访问学者是对学术水平的认可&#xff0c;并且对…
阅读更多...
vue.js 实现导入json解析成动态el-table树表格（接口文档功能）

vue.js 实现导入json解析成动态el-table树表格（接口文档功能）

一、需求描述&#xff1a;前段时间接到一个需求是做一个类似接口文档的显示功能&#xff0c;将一段json数据贴到里面就可以自动解析出json数据的每个字段的类型和层级关系&#xff0c;用element组件的树表格的形式展示&#xff0c;并且可以手动新增、修改和删除某个数据字段。二…
阅读更多...
Vue路由和路由器简介

Vue路由和路由器简介

前言 路由(route)是vue中非常重要的技术&#xff0c;几乎每一个用vue所写的项目都会用到路由&#xff0c;它是一个vue的插件库&#xff0c;专门实现SPA应用 路由(route)的简介 说到路由&#xff0c;大多数人会想到路由器(router),可以这么说&#xff0c;路由器上的每一个口都…
阅读更多...
Python类变量和实例变量

Python类变量和实例变量

类变量&#xff08;类属性&#xff09;类变量指的是在类中&#xff0c;但在各个类方法外定义的变量。举个例子&#xff1a;class CLanguage : # 下面定义了2个类变量name "CSDN社区"add "http://csdn.net" # 下面定义了一个say实例方法 defsay(self, conte…
阅读更多...
【Linux】进程信号的产生与捕捉、核心转储

【Linux】进程信号的产生与捕捉、核心转储

目录 一、信号的引入 二、信号捕捉 三、核心转储 四、系统调用发送信号 五、软件条件产生信号 六、硬件异常产生信号 一、信号的引入 Linux信号本质是一种通知机制&#xff0c;用户 or 操作系统通过发送一定的信号&#xff0c;通知进程&#xff0c;某些事件已经发生&…
阅读更多...
JavaWeb-MyBatis | Mapper代理开发及案例

JavaWeb-MyBatis | Mapper代理开发及案例

本专栏主要是记录学习完JavaSE后学习JavaWeb部分的一些知识点总结以及遇到的一些问题等&#xff0c;如果刚开始学习Java的小伙伴可以点击下方连接查看专栏 本专栏地址&#xff1a;&#x1f525;JDBC Java入门篇&#xff1a; &#x1f525;Java基础学习篇 Java进阶学习篇&#x…
阅读更多...
【5G NTN】5G NTN（非地面组网）介绍

【5G NTN】5G NTN（非地面组网）介绍

博主未授权任何人或组织机构转载博主任何原创文章&#xff0c;感谢各位对原创的支持&#xff01; 博主链接 本人就职于国际知名终端厂商&#xff0c;负责modem芯片研发。 在5G早期负责终端数据业务层、核心网相关的开发工作&#xff0c;目前牵头6G算力网络技术标准研究。 博客…
阅读更多...
DTD语法详细介绍

DTD语法详细介绍

在编写XML文档时&#xff0c;需要掌握XML语法。同理&#xff0c;在编写DTD文档时&#xff0c;也需要遵循一定的语法。DTD的结构一般由元素类型定义、属性定义、实体定义、记号(notation)定义等构成&#xff0c;一个典型的文档类型定义会把将来要创建的XML文档的元素结构、属性类…
阅读更多...
LeetCode Hot100 ---- 双指针算法专题

LeetCode Hot100 ---- 双指针算法专题

167, 88, 142, 76双指针双指针法&#xff0c;有时也叫快慢指针&#xff0c;在数组里是用两个整型值代表下标&#xff0c;在链表里是两个指针&#xff0c;一般能实现O(n)的时间解决问题&#xff0c;两个指针的位置一般在第一个元素和第二个元素或者第一个元素和最后一个元素&…
阅读更多...
【Leetcode每日一题】844. 比较含退格的字符串|重构字符串/双指针

【Leetcode每日一题】844. 比较含退格的字符串|重构字符串/双指针

博主简介&#xff1a;努力学习的预备程序媛一枚~博主主页&#xff1a; 是瑶瑶子啦所属专栏: LeetCode每日一题–进击大厂 前言&#xff1a; 昨天的【Leetcode每日一题】27. 原地移除元素|神级理解双指针一文中&#xff0c;生动形象的为大家讲解如何理解双指针&#xff0c;受到…
阅读更多...
《收获，不止Oracle》表的连接学以致用

《收获，不止Oracle》表的连接学以致用

6.2 三大类型 6.2.1 连接类型 嵌套循环 排序合并及散列连接 第一种方式就是数据库表连接中的嵌套循环连接&#xff08;Nested Loops Join&#xff09;&#xff0c;而第二种方式就是表连接中的排序合并连接&#xff08;Merge Sort Join&#xff09;或者散列连接&#xff08;…
阅读更多...
【SpringCloud】Gateway服务网关的基本使用

【SpringCloud】Gateway服务网关的基本使用

一、初识Gateway服务网关为什么需要网关&#xff1f;在微服务中&#xff0c;各个模块之间的调用&#xff0c;也可以称其为远程调用&#xff01;但是&#xff0c;如果是外部&#xff08;用户&#xff09;对微服务进行访问时&#xff0c;发的请求能不加处理的直接访问微服务吗&am…
阅读更多...
使用Client Java构建Exporter程序

使用Client Java构建Exporter程序

一、client_java client_java是Prometheus针对JVM类开发语言的client library库&#xff0c;我们可以直接基于client_java用户可以快速实现独立运行的Exporter程序&#xff0c;也可以在我们的项目源码中集成client_java以支持Prometheus。注意&#xff1a;Prometheus 提供的cl…
阅读更多...
WordPress默认数据库中的12个数据表

WordPress默认数据库中的12个数据表

WordPress 安装的时候数据库会有 12 张默认的数据表&#xff0c;每张表的数据都包含了 WordPress 不同的功能。看看这些表的结构&#xff0c;你能很容易的了解网站不同的部分都是存在哪里的。目前&#xff0c;默认的 WordPress 安装会创建如下12个数据表。表名描述wp_users您的…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023