Spring学习总结2

最新推荐文章于 2024-02-09 05:30:00 发布
最新推荐文章于 2024-02-09 05:30:00 发布
阅读量117 收藏
点赞数
文章标签： spring 学习 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43525326/article/details/128830685
版权

AOP - 面向切面编程

概念：一种设计思想，是面向对象编程的补充和完善，通过预编译方式和运行期动态代理方式在不修改源代码的情况下向程序动态添加额外功能的一种技术。

相关术语：

  • 横切关注点
    从每个方法中抽取出来的同一类非核心业务
    在这里插入图片描述

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

    • 前置通知：在被代理的目标方法前执行 使用@Before注解标识
    • 返回通知：在被代理的目标方法成功结束后执行 使用@AfterReturning注解标识
    • 异常通知：在被代理的目标方法异常结束后执行 使用@AfterThrowing注解标识
    • 后置通知：在被代理的目标方法最终结束后执行 使用@After注解标识
    • 环绕通知：使用try…catch…finally结构围绕整个被代理的目标方法，包括上述四种通知的所有位置 使用@Around注解标识

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-89Kns48K-1675222427717)(C:\Users\zilvx\AppData\Roaming\Typora\typora-user-images\image-20230129223411947.png)]
    各个通知的执行顺序

Spring版本5.3.x以前：

前置通知 -> 目标操作 -> 后置通知 -> 返回通知或异常通知

Spring版本5.3.x以后：

前置通知 -> 目标操作 -> 返回通知或异常通知 -> 后置通知

  • 切面
    封装通知方法的类
    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KNTHJrhm-1675222427718)(C:\Users\zilvx\AppData\Roaming\Typora\typora-user-images\image-20230129223715161.png)]

  • 目标
    被代理的目标对象

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

  • 连接点
    把方法排成一排，每一个横切位置看成x轴方向，把方法从上到下执行的顺序看成y轴，x轴和y轴的交叉点就是连接点
    在这里插入图片描述

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

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

1、基于注解的AOP

Step1 添加依赖

<!-- spring-aspects会帮我们传递过来aspectjweaver -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
    <version>5.3.1</version>
</dependency>

Step2 准备被代理的目标资源

接口

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);
}

实现类

@Component
public class CalculatorPureImpl implements Calculator {
    @Override
    public int add(int i, int j) {
        int result = i + j;
        System.out.println("方法内部 result = " + result);
        return result;
    }
    
    @Override
    public int sub(int i, int j) {
        int result = i - j;
        System.out.println("方法内部 result = " + result);
        return result;
    }
    
    @Override
    public int mul(int i, int j) {
        int result = i * j;
        System.out.println("方法内部 result = " + result);
        return result;
    }
    
    @Override
    public int div(int i, int j) {
        int result = i / j;
        System.out.println("方法内部 result = " + result);
        return result;
    }
}

Step3 创建切面类并配置

// @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;
        }
    
    
}

Step3 spring配置文件中添加

<!--
基于注解的AOP的实现：
1、将目标对象和切面交给IOC容器管理（注解+扫描）
2、开启AspectJ的自动代理，为目标对象自动生成代理
3、将切面类通过注解@Aspect标识
-->
<context:component-scan base-package="com.atguigu.aop.annotation">
</context:component-scan>
<aop:aspectj-autoproxy />

2、切入点表达式语法

  1. 用*号代替权限修饰符和返回值部分表示权限修饰符和返回值不限。

  2. 在包名部分使用*号只能代表包中的一层，表示这一层是任意的。

  3. 例如*.Hello匹配com.Hello，不匹配com.atguigu.Hello。
    在包名部分使用*..表示包名任意，包的层次深度任意。

  4. 在类名的部分，类名部分整体用*号代替，表示类名任意。
    在类名的部分，可以使用*号代替类名的一部分。
    例如：*Service匹配所有名称以Service结尾的类和接口。

  5. 在方法名的部分，可以使用*号代替方法名的一部分。
    例如：*Operation匹配所有方法名以Operation结尾的方法。

  6. 在方法参数列表部分，使用(..)表示参数列表任意。
    在方法参数列表部分，使用(int,..)表示参数列表以一个int类型的参数开头。
    在方法参数列表部分，基本数据类型和对应的包装类型是不一样的。
    切入点表达式中使用 int 和实际方法中 Integer 是不匹配的。

  7. 在方法返回值部分，如果想要明确指定一个返回值类型，那么必须同时写明权限修饰符。
    例如：execution(public int …Service.(…, int)) 正确
    例如：execution(     int *…Service.(…, int)) 错误

在这里插入图片描述

3、切入点表达式的复用

声明

@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);
}

4、获取通知的相关信息

4.1、 获取连接点信息

在通知方法的参数位置设置JoinPoint类型的形参

@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);
}

4.2、获取目标方法的返回值

@AfterReturning中的属性returning，用来将通知方法的某个形参，接收目标方法的返回值

@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);
}

4.3、 获取目标方法的异常

@AfterThrowing中的属性throwing，用来将通知方法的某个形参，接收目标方法的异常

@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);
}

5、环绕通知

目标方法的执行，目标方法的返回值一定要返回给外界调用者

@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;
}

6、切面的优先级

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

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

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

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

7、声明式事务

7.1、前提准备工作

7.1.1、加入依赖：
<dependencies>
    <!-- 基于Maven依赖传递性，导入spring-context依赖即可导入当前所需所有jar包 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.1</version>
    </dependency>
    <!-- Spring 持久化层支持jar包 -->
    <!-- Spring 在执行持久化层操作、与持久化层技术进行整合过程中，需要使用orm、jdbc、tx三个
    jar包 -->
    <!-- 导入 orm 包就可以通过 Maven 的依赖传递性把其他两个也导入 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-orm</artifactId>
        <version>5.3.1</version>
    </dependency>
    <!-- Spring 测试相关 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>5.3.1</version>
    </dependency>
    <!-- junit测试 -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>
    <!-- MySQL驱动 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.16</version>
    </dependency>
    <!-- 数据源 -->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>1.0.31</version>
    </dependency>
</dependencies>
7.1.2、创建jdbc.properties
jdbc.user=root
jdbc.password=atguigu
jdbc.url=jdbc:mysql://localhost:3306/ssm
jdbc.driver=com.mysql.cj.jdbc.Driver
7.1.3、配置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>
<!-- 配置 JdbcTemplate -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
	<!-- 装配数据源 -->
	<property name="dataSource" ref="druidDataSource"/>
</bean>

<bean id="transactionManager"
class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
	<property name="dataSource" ref="druidDataSource"></property>
</bean>
<!--
开启事务的注解驱动
通过注解@Transactional所标识的方法或标识的类中所有的方法，都会被事务管理器管理事务
-->
<!-- transaction-manager属性的默认值是transactionManager，如果事务管理器bean的id正好就
是这个默认值，则可以省略这个属性 -->
<tx:annotation-driven transaction-manager="transactionManager" />

注意：导入的名称空间需要 tx 结尾的那个。

在这里插入图片描述

7.2、JdbcTemplate

介绍：Spring框架对JDBC进行封装，使用JdbcTemplate对数据库进行操作

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:spring-jdbc.xml")
public class JDBCTemplateTest {
    @Autowired
    private JdbcTemplate jdbcTemplate;
    
    @Test
    //测试增删改功能
    public void testUpdate(){
        String sql = "insert into t_emp values(null,?,?,?)";
        int result = jdbcTemplate.update(sql, "张三", 23, "男");
        System.out.println(result);
    }
    
    @Test
    //查询一条数据为一个实体类对象
    public void testSelectEmpById(){
        String sql = "select * from t_emp where id = ?";
        Emp emp = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<>
        (Emp.class), 1);
        System.out.println(emp);
    }
    
    @Test
    //查询多条数据为一个list集合
    public void testSelectList(){
        String sql = "select * from t_emp";
        List<Emp> list = jdbcTemplate.query(sql, new BeanPropertyRowMapper<>
        (Emp.class));
        list.forEach(emp -> System.out.println(emp));
    }
    
    @Test
    //查询单行单列的值
    public void selectCount(){
        String sql = "select count(id) from t_emp";
        Integer count = jdbcTemplate.queryForObject(sql, Integer.class);
        System.out.println(count);
    }
}

7.3、声明式事务

7.3.1、编程式事务

事务功能的相关操作全部由程序员自己实现

Connection conn = ...;
try {
    // 开启事务：关闭事务的自动提交
    conn.setAutoCommit(false);
    // 核心操作
    // 提交事务
    conn.commit();
}catch(Exception e){
    // 回滚事务
    conn.rollBack();
}finally{
    // 释放数据库连接
    conn.close();
}

缺陷：

  • 细节没有被屏蔽：具体操作过程中，所有细节都需要程序员自己来完成，比较繁琐。

  • 代码复用性不高：如果没有有效抽取出来，每次实现功能都需要自己编写代码，代码就没有得到复用。

7.3.2、声明式事务

介绍：既然事务控制的代码有规律可循，代码的结构基本是确定的，所以框架就可以将固定模式的代码抽取出来，进行相关的封装。封装起来后，我们只需要在配置文件中进行简单的配置即可完成操作。

优点：

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

总结：

编程式：自己写代码实现功能

声明式：通过配置让框架实现功能

8、基于注解的声明式事务

8.1、案例

Step1 创建表
CREATE TABLE `t_book` (
    `book_id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键',
    `book_name` varchar(20) DEFAULT NULL COMMENT '图书名称',
    `price` int(11) DEFAULT NULL COMMENT '价格',
    `stock` int(10) unsigned DEFAULT NULL COMMENT '库存（无符号）',
    PRIMARY KEY (`book_id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;
insert into `t_book`(`book_id`,`book_name`,`price`,`stock`) values (1,'斗破苍
穹',80,100),(2,'斗罗大陆',50,100);
CREATE TABLE `t_user` (
    `user_id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键',
    `username` varchar(20) DEFAULT NULL COMMENT '用户名',
    `balance` int(10) unsigned DEFAULT NULL COMMENT '余额（无符号）',
    PRIMARY KEY (`user_id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;
insert into `t_user`(`user_id`,`username`,`balance`) values (1,'admin',50);
Step2 创建组件

创建BookController：

@Controller
public class BookController {
    @Autowired
    private BookService bookService;
    public void buyBook(Integer bookId, Integer userId){
    	bookService.buyBook(bookId, userId);
	}
}

创建接口BookService：

public interface BookService {
	void buyBook(Integer bookId, Integer userId);
}

创建实现类BookServiceImpl：

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

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

@Service
public class BookServiceImpl implements BookService {
    @Autowired
    private BookDao bookDao;
    @Override
    @Transactional
    public void buyBook(Integer bookId, Integer userId) {
        //查询图书的价格
        Integer price = bookDao.getPriceByBookId(bookId);
        //更新图书的库存
        bookDao.updateStock(bookId);
        //更新用户的余额
        bookDao.updateBalance(userId, price);
    }
}

创建接口BookDao：

public interface BookDao {
    Integer getPriceByBookId(Integer bookId);
    void updateStock(Integer bookId);
    void updateBalance(Integer userId, Integer price);
}

创建实现类BookDaoImpl：

@Repository
public class BookDaoImpl implements BookDao {
    @Autowired
    private JdbcTemplate jdbcTemplate;
    @Override
    public Integer getPriceByBookId(Integer bookId) {
        String sql = "select price from t_book where book_id = ?";
        return jdbcTemplate.queryForObject(sql, Integer.class, bookId);
    }
    @Override
    public void updateStock(Integer bookId) {
        String sql = "update t_book set stock = stock - 1 where book_id = ?";
        jdbcTemplate.update(sql, bookId);
    }
    @Override
    public void updateBalance(Integer userId, Integer price) {
        String sql = "update t_user set balance = balance - ? where user_id =
        ?";
        jdbcTemplate.update(sql, price, userId);
    }
}

@Transactional注解标识的位置：

  • 标识在方法上，咋只会影响该方法

  • l标识的类上，咋会影响类中所有的方法

8.2、事务属性

只读

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

@Transactional(readOnly = true)
public void buyBook(Integer bookId, Integer userId) {
    //查询图书的价格
    Integer price = bookDao.getPriceByBookId(bookId);
    //更新图书的库存
    bookDao.updateStock(bookId);
    //更新用户的余额
    bookDao.updateBalance(userId, price);
    //System.out.println(1/0);
}

对增删改操作设置只读会抛出下面异常：

Caused by: java.sql.SQLException: Connection is read-only. Queries leading to data modificatio are not allowed

超时

事务在执行过程中，有可能因为遇到某些问题，导致程序卡住，从而长时间占用数据库资源。而长时间占用资源，大概率是因为程序运行出现了问题（可能是Java程序或MySQL数据库或网络连接等等）。此时这个很可能出问题的程序应该被回滚，撤销它已做的操作，事务结束，把资源让出来，让其他正常程序可以执行。

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

@Transactional(timeout = 3)
public void buyBook(Integer bookId, Integer userId) {
    try {
    	TimeUnit.SECONDS.sleep(5);
    } catch (InterruptedException e) {
    	e.printStackTrace();
    }
    //查询图书的价格
    Integer price = bookDao.getPriceByBookId(bookId);
    //更新图书的库存
    bookDao.updateStock(bookId);
    //更新用户的余额
    bookDao.updateBalance(userId, price);
    //System.out.println(1/0);
}

执行过程中抛出异常：

org.springframework.transaction.TransactionTimedOutException: Transaction timed out: deadline was Fri Jun 04 16:25:39 CST 2022

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

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

  • rollbackFor属性：需要设置一个Class类型的对象

  • rollbackForClassName属性：需要设置一个字符串类型的全类名

  • noRollbackFor属性：需要设置一个Class类型的对象

  • rollbackFor属性：需要设置一个字符串类型的全类名

@Transactional(noRollbackFor = ArithmeticException.class)
//@Transactional(noRollbackForClassName = "java.lang.ArithmeticException")
public void buyBook(Integer bookId, Integer userId) {
    //查询图书的价格
    Integer price = bookDao.getPriceByBookId(bookId);
    //更新图书的库存
    bookDao.updateStock(bookId);
    //更新用户的余额
    bookDao.updateBalance(userId, price);
    System.out.println(1/0);
}

虽然购买图书功能中出现了数学运算异常（ArithmeticException），但是我们设置的回滚策略是，当出现ArithmeticException不发生回滚，因此购买图书的操作正常执行

事务隔离级别

数据库系统必须具有隔离并发运行各个事务的能力，使它们不会相互影响，避免各种并发问题。一个事务与其他事务隔离的程度称为隔离级别。SQL标准中规定了多种事务隔离级别，不同隔离级别对应不同的干扰程度，隔离级别越高，数据一致性就越好，但并发性越弱。

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

隔离级别：

  • 读未提交：允许Transaction01读取Transaction02未提交的修改。

  • 读已提交：Transaction01只能读取Transaction02已提交的修改。

  • 可重复读：确保Transaction01可以多次从一个字段中读取到相同的值，即Transaction01执行期间禁止其它事务对这个字段进行更新。

  • 串行化：确保Transaction01可以多次从一个表中读取到相同的行，在Transaction01执行期间，禁止其它事务对这个表进行添加、更新、删除操作。可以避免任何并发问题，但性能十分低下。
    在这里插入图片描述
    在这里插入图片描述

在这里插入图片描述

事务传播行为

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

创建接口CheckoutService：

public interface CheckoutService {
	void checkout(Integer[] bookIds, Integer userId);
}

创建实现类CheckoutServiceImpl：

@Service
public class CheckoutServiceImpl implements CheckoutService {
    @Autowired
    private BookService bookService;
    @Override
    @Transactional
    //一次购买多本图书
    public void checkout(Integer[] bookIds, Integer userId) {
        for (Integer bookId : bookIds) {
        	bookService.buyBook(bookId, userId);
        }
    }
}

在BookController中添加方法：

@Autowired
private CheckoutService checkoutService;
public void checkout(Integer[] bookIds, Integer userId){
	checkoutService.checkout(bookIds, userId);
}

在数据库中将用户的余额修改为100元，观测结果。

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

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

HappyWealthy
关注
Spring+mybatis整合声明式事务异常之org.springframework.transaction.TransactionTimedOutException: Transaction ..
静若清池，动如涟漪_
07-23 1万+
1、异常信息 org.springframework.transaction.TransactionTimedOutException: Transaction timed out: deadline was Tue Jul 23 18:06:32 CST 2019... 2、示例代码 @Service public class UserServiceImpl implements ...
Spring之AOP前置通知、后置通知、异常通知
唐昊
08-09 475
一、配置数据源 引入对应的jar包： commons-dbcp-1.4.jar连接池（数据源配置） commons-pool-1.6.jar连接池 ojdbc7.jar spring-jdbc-4.3.9.RELEASE.jar aopalliance-1.0.jar spring-tx-4.3.9.RELEASE.jar spring配置文件(数据源) <!-- 配置事务管理器txManager --> <bean id="txManager" class="org.sprin
spring——AOP的前置通知、后置通知、环绕通知、异常通知
qq_43163943的博客
04-12 1507
准备：aopliance.jar、aspect jweaver.jar 方法：确定一个切入点方法 配置：将通知文件和方法关联起来 举例方法：addStudent StudentServiceImpl.java package com.dt.service.impl; import org.springframework.transaction.annotation.Propagati...
Spring AOP（前置通知方法 、后置通知方法 、环绕通知方法 ）与拦截器的使用
每天就学一点点的博客
06-10 9591
AOP(Aspect Oriented Programming)也就是面向切面编程的技术。AOP基于IoC基础，是对OOP的有益补充。AOP是代码之间解耦的一 种实现。可以这样理解，面向对象编程是从静态角度考虑程序结构，面向切面编程是从动态角度考虑程序运行过程。AOP将应用系统分为两部分: （1）核心业务逻辑(Core Business Concerns)。 （2）横向的通用逻辑，也就是所谓的切面...
记一次线上TransactionTimedOutException问题排查
qq_40344505的博客
02-03 2823
记一次线上TransactionTimedOutException问题排查
springsecurity：Spring安全学习总结
01-29
Spring安全学习总结 关于 spring security 学习总结暑假的时候在学习了Spring安全并成功运用到了项目中。在实践中摸索出了一套结合JSON +智威汤逊（JSON网络令牌）+Spring引导+ Spring Security的技术的权限方案趁着...
Spring MVC 学习记录总结1
08-03
在这个学习记录总结中，我们将深入理解Spring MVC的核心概念、主要组件以及其工作流程。 1. Spring MVC 概述 Spring MVC 是Spring框架的一部分，它基于Spring IoC（Inversion of Control，控制反转）容器，简化了...
Spring学习笔记 自我总结
11-02
spring学习笔记
已解决org.springframework.transaction.TransactionTimedOutException异常的正确解决方法，亲测有效！！！
最新发布
小明的Java问道之路
02-09 2903
已解决org.springframework.transaction.TransactionTimedOutException异常的正确解决方法，亲测有效！！！
事务超时
热门推荐
08-29 1万+
事务超时       本文概览：介绍了超时有关的概念：@Transaction的timeout、mybatis的timeout、mysql的innodb_lock_wait_timeout。 1 问题 1.1 背景 在一个事务中完成解析一个大文件，分批存入到数据库。遇到问题，执行时间比较长，就讨论了事务超时的问题，担心执行时间太长，事务超时自动回滚了。 为了考虑这个问题，需要考虑如下...
数据库相关各种超时时间
04stone37
04-27 8709
事务超时时间Transaction Timeout   事务超时时间规定了事务执行时间的上限，通常包含两大部分：SQL执行时间，以及业务处理时间，即Transaction timeout = Statement Timeout * N（所有SQL执行总时间） + 业务处理时间； @Transactional(timeout = 3) 单位秒  事务超时的报错信息: org.springframe...
Spring事务超时时间可能存在的错误认识
jinnianshilongnian的专栏
12-06 1198
1、先看代码 1.1、spring-config.xml &lt;bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource"&gt; &lt;property name="driverClassName" value="com.mysql.jdbc...
weblogic.transaction.TimedOutException
xjt2316229的博客
10-13 517
WebLogic Server 版本: 10.3.3.0 异常描述：weblogic.transaction.TimedOutException: Transaction timed out after 40 seconds 有可能不会直接报这个错误，但是会提示Caused by: weblogic.transaction.TimedOutException: 解决方法： ...
事务超时时间的错误理解
Nero的博客
10-29 2312
java开发,无非数据库,spring等一些技术,在公司码代码,一直有用到事务这个东西,按说对这个也很熟悉了,今天突然发现一个"奇怪"的现象. 首先pom文件是这样的,用的spring-boot1.5.20,spring版本为<spring.version>4.3.23.RELEASE</spring.version> <parent> <group...
spring事务超时时间测试
heroking
08-03 4094
1、如下代码会导致事务超时异常（org.springframework.transaction.TransactionTimedOutException: Transaction timed out） @Override @Transactional(timeout = 2) public int insert(User user) { try { ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值