Spring6 中的事务

最新推荐文章于 2024-04-26 09:36:55 发布
最新推荐文章于 2024-04-26 09:36:55 发布
阅读量158 收藏
点赞数
分类专栏： Spring6的学习实践 文章标签： spring java
文章均为博主原创，转载请标明出处。未经允许不得用于商业目的。欢迎大佬批评指正。
本文链接：https://blog.csdn.net/Clanhaoren/article/details/130379661
版权

目录

一. JdbcTemplate

1.1 JdbcTemplate简介

1.2 环境准备

1.3 基础CRUD

二. 事务概述

2.1 事务基本概念

2.1.1 什么是事务

2.1.2 事务的特性

2.2 编程式事务和声明式事务

三. 基于注解的声明式事务

3.1 环境准备

3.2 测试无事务情况

3.3 添加事务配置

3.4 @Transactional注解标识的位置

3.5 事务属性

3.5.1 事务属性：只读

3.5.2 事务属性：超时

3.5.3 事务属性：回滚策略

3.5.4 事务属性：隔离级别

3.5.5 事务属性：传播行为

3.6 全注解配置事务

四. 基于XML的声明式事务

4.1 引入依赖

4.2 修改配置文件

一. JdbcTemplate

1.1 JdbcTemplate简介

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

1.2 环境准备

①搭建子模块

搭建子模块：spring6-jdbc-tx

②加入依赖

<dependencies>
    <!--spring jdbc  Spring 持久化层支持jar包-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>6.0.2</version>
    </dependency>
    <!-- MySQL驱动 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.30</version>
    </dependency>
    <!-- 数据源 -->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>1.2.15</version>
    </dependency>
</dependencies>

③创建jdbc.properties

jdbc.user=root
jdbc.password=root
jdbc.url=jdbc:mysql://localhost:3306/spring?characterEncoding=utf8&useSSL=false
jdbc.driver=com.mysql.cj.jdbc.Driver

④配置Spring的配置文件

<?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
       http://www.springframework.org/schema/context/spring-context.xsd">

    <!-- 导入外部属性文件 -->
    <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.user}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>

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

</beans>

⑤数据库表创建

CREATE DATABASE `spring`;

use `spring`;

CREATE TABLE `t_emp` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(20) DEFAULT NULL COMMENT '姓名',
  `age` int(11) DEFAULT NULL COMMENT '年龄',
  `sex` varchar(2) DEFAULT NULL COMMENT '性别',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

1.3 基础CRUD

①装配 JdbcTemplate

创建测试类，整合JUnit，注入JdbcTemplate

package com.demo.spring6;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.test.context.junit.jupiter.SpringJUnitConfig;

@SpringJUnitConfig(locations = "classpath:beans.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, "男");
    
    //修改功能
	//String sql = "update t_emp set name=? where id=?";
    //int result = jdbcTemplate.update(sql, "李四", 1);

    //删除功能
	//String sql = "delete from t_emp where id=?";
	//int result = jdbcTemplate.update(sql, 1);
}

③查询数据返回对象

创建实体类对象，生成get、set、toString方法

//查询：返回对象
@Test
public void testSelectObject() {

    String sql = "select * from t_emp where id=?";
    Emp emp = jdbcTemplate.queryForObject(sql,
                  new BeanPropertyRowMapper<>(Emp.class),1);
    System.out.println(emp);
}

④查询数据返回list集合

@Test
//查询多条数据为一个list集合
public void testSelectList(){
    String sql = "select * from t_emp";
    List<Emp> list = jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(Emp.class));
    System.out.println(list);
}

⑤查询返回单个的值

@Test
//查询单行单列的值
public void selectCount(){
    String sql = "select count(id) from t_emp";
    Integer count = jdbcTemplate.queryForObject(sql, Integer.class);
    System.out.println(count);
}

二. 事务概述

2.1 事务基本概念

2.1.1 什么是事务

数据库事务( transaction)是访问并可能操作各种数据项的一个数据库操作序列，这些操作要么全部执行，要么全部不执行，是一个不可分割的工作单位。事务由事务开始与事务结束之间执行的全部数据库操作组成。

2.1.2 事务的特性

①A：原子性(Atomicity)：一个事务(transaction)中的所有操作，要么全部完成，要么全部不完成，不会结束在中间某个环节。事务在执行过程中发生错误，会被回滚（Rollback）到事务开始前的状态，就像这个事务从来没有执行过一样。

②C：一致性(Consistency)：事务的一致性指的是在一个事务执行之前和执行之后数据库都必须处于一致性状态。如果事务成功地完成，那么系统中所有变化将正确地应用，系统处于有效状态。如果在事务中出现错误，那么系统中的所有变化将自动地回滚，系统返回到原始状态。

③I：隔离性(Isolation)：指的是在并发环境中，当不同的事务同时操纵相同的数据时，每个事务都有各自的完整数据空间。由并发事务所做的修改必须与任何其他并发事务所做的修改隔离。事务查看数据更新时，数据所处的状态要么是另一事务修改它之前的状态，要么是另一事务修改它之后的状态，事务不会查看到中间状态的数据。

④D：持久性(Durability)：指的是只要事务成功结束，它对数据库所做的更新就必须保存下来。即使发生系统崩溃，重新启动数据库系统后，数据库还能恢复到事务成功结束时的状态。

2.2 编程式事务和声明式事务

编程式事务：事务功能的相关操作全部通过自己编写代码来实现，代码复用性差。

声明式事务：将固定代码进行封装，然后在配置文件中进行配置，通过配置让框架实现功能 。 

三. 基于注解的声明式事务

3.1 环境准备

①添加配置

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

②创建表和相关组件

3.2 测试无事务情况

①编写测试类

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.test.context.junit.jupiter.SpringJUnitConfig;

@SpringJUnitConfig(locations = "classpath:beans.xml")
public class TxByAnnotationTest {

    @Autowired
    private BookController bookController;

    @Test
    public void testBuyBook(){
        bookController.buyBook(1, 1);
    }

}

②模拟场景

用户购买图书，先查询图书的价格，再更新图书的库存和用户的余额

假设用户id为1的用户，购买id为1的图书

用户余额为50，而图书价格为80

购买图书之后，用户的余额为-30，数据库中余额字段设置了无符号，因此无法将-30插入到余额字段

此时执行sql语句会抛出SQLException

③测试分析

测试结果可查：图书的库存更新100→99，但是用户的余额没有更新

所以可以看出没有事务的结果是错误的

3.3 添加事务配置

①添加事务配置

在spring配置文件中引入tx命名空间

<?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
       http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/tx
       http://www.springframework.org/schema/tx/spring-tx.xsd">

</bean>

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

<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" />

②添加事务注解

在业务层对应方法，添加注解@Transactional

③测试分析

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

3.4 @Transactional注解标识的位置

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

3.5 事务属性

3.5.1 事务属性：只读

①概述

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

②使用方式

@Transactional(readOnly = true)
public void buyBook(Integer bookId, Integer userId) {
    //查询图书的价格
    Integer price = bookDao.getPriceByBookId(bookId);

    //更新图书的库存
    bookDao.updateStock(bookId);

    //更新用户的余额
    bookDao.updateBalance(userId, price);
}

③测试分析

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

Caused by: java.sql.SQLException

3.5.2 事务属性：超时

①概述

事务在执行过程中，有可能因为遇到某些问题，导致程序卡住，从而长时间占用数据库资源。而长时间占用资源，大概率是因为程序运行出现了问题（可能是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);
   
}

③测试分析

执行过程中抛出异常：

org.springframework.transaction.TransactionTimedOutException

3.5.3 事务属性：回滚策略

①概述

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

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

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

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

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

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

②使用方式

@Transactional(noRollbackFor = ArithmeticException.class)
public void buyBook(Integer bookId, Integer userId) {
    //查询图书的价格
    Integer price = bookDao.getPriceByBookId(bookId);

    //更新图书的库存
    bookDao.updateStock(bookId);

    //更新用户的余额
    bookDao.updateBalance(userId, price);
}

③测试分析

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

3.5.4 事务属性：隔离级别

①概述

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

隔离级别一共有四种：

  • 读未提交（READ UNCOMMITTED）：允许Transaction01读取Transaction02未提交的修改。

  • 读已提交（READ COMMITTED）：要求Transaction01只能读取Transaction02已提交的修改。

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

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

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

隔离级别脏读不可重复读幻读
READ UNCOMMITTED有有有
READ COMMITTED无有有
REPEATABLE READ无无有
SERIALIZABLE无无无

②使用方式

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

3.5.5 事务属性：传播行为

①概述

事务的传播行为：在service类中有a()方法和b()方法，a()方法上有事务，b()方法上也有事务，当a()方法执行过程中调用了b()方法，事务是如何传递的？合并到一个事务里？还是开启一个新的事务？这就是事务传播行为。

一共有七种传播行为：

  • REQUIRED：支持当前事务，如果不存在就新建一个(默认)【没有就新建，有就加入】

  • SUPPORTS：支持当前事务，如果当前没有事务，就以非事务方式执行【有就加入，没有就不管了】

  • MANDATORY：必须运行在一个事务中，如果当前没有事务正在发生，将抛出一个异常【有就加入，没有就抛异常】

  • REQUIRES_NEW：开启一个新的事务，如果一个事务已经存在，则将这个存在的事务挂起【不管有没有，直接开启一个新事务，开启的新事务和之前的事务不存在嵌套关系，之前事务被挂起】

  • NOT_SUPPORTED：以非事务方式运行，如果有事务存在，挂起当前事务【不支持事务，存在就挂起】

  • NEVER：以非事务方式运行，如果有事务存在，抛出异常【不支持事务，存在就抛异常】

  • NESTED：如果当前正有一个事务在进行中，则该方法应当运行在一个嵌套式事务中。被嵌套的事务可以独立于外层事务进行提交或回滚。如果外层事务不存在，行为就像REQUIRED一样。【有事务的话，就在这个事务里再嵌套一个完全独立的事务，嵌套的事务可以独立的提交和回滚。没有事务就和REQUIRED一样。】

3.6 全注解配置事务

①添加配置类

package com.demo.spring6.config;

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import javax.sql.DataSource;

@Configuration
@ComponentScan("com.demo.spring6")
@EnableTransactionManagement
public class SpringConfig {

    @Bean
    public DataSource getDataSource(){
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/spring?characterEncoding=utf8&useSSL=false");
        dataSource.setUsername("root");
        dataSource.setPassword("root");
        return dataSource;
    }

    @Bean(name = "jdbcTemplate")
    public JdbcTemplate getJdbcTemplate(DataSource dataSource){
        JdbcTemplate jdbcTemplate = new JdbcTemplate();
        jdbcTemplate.setDataSource(dataSource);
        return jdbcTemplate;
    }

    @Bean
    public DataSourceTransactionManager getDataSourceTransactionManager(DataSource dataSource){
        DataSourceTransactionManager dataSourceTransactionManager = new DataSourceTransactionManager();
        dataSourceTransactionManager.setDataSource(dataSource);
        return dataSourceTransactionManager;
    }
}

②测试分析

import com.demo.spring6.config.SpringConfig;
import com.demo.spring6.controller.BookController;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.test.context.junit.jupiter.SpringJUnitConfig;

public class TxByAllAnnotationTest {

    @Test
    public void testTxAllAnnotation(){
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringConfig.class);
        BookController accountService = applicationContext.getBean("bookController", BookController.class);
        accountService.buyBook(1, 1);
    }
}

四. 基于XML的声明式事务

4.1 引入依赖

基于xml实现的声明式事务，必须引入aspectJ的依赖

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

4.2 修改配置文件

将Spring配置文件中去掉tx:annotation-driven 标签，并添加配置：

<aop:config>
    <!-- 配置事务通知和切入点表达式 -->
    <aop:advisor advice-ref="txAdvice" pointcut="execution(* com.demo.spring.tx.xml.service.impl.*.*(..))"></aop:advisor>
</aop:config>
<!-- tx:advice标签：配置事务通知 -->
<!-- id属性：给事务通知标签设置唯一标识，便于引用 -->
<!-- transaction-manager属性：关联事务管理器 -->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
    <tx:attributes>
        <!-- tx:method标签：配置具体的事务方法 -->
        <!-- name属性：指定方法名，可以使用星号代表多个字符 -->
        <tx:method name="get*" read-only="true"/>
        <tx:method name="query*" read-only="true"/>
        <tx:method name="find*" read-only="true"/>
    
        <!-- read-only属性：设置只读属性 -->
        <!-- rollback-for属性：设置回滚的异常 -->
        <!-- no-rollback-for属性：设置不回滚的异常 -->
        <!-- isolation属性：设置事务的隔离级别 -->
        <!-- timeout属性：设置事务的超时属性 -->
        <!-- propagation属性：设置事务的传播行为 -->
        <tx:method name="save*" read-only="false" rollback-for="java.lang.Exception" propagation="REQUIRES_NEW"/>
        <tx:method name="update*" read-only="false" rollback-for="java.lang.Exception" propagation="REQUIRES_NEW"/>
        <tx:method name="delete*" read-only="false" rollback-for="java.lang.Exception" propagation="REQUIRES_NEW"/>
    </tx:attributes>
</tx:advice>

窗外有风景，笔下有前途。不读书的人，只能永远被选择。请让自己优秀，然后骄傲的生活。

2013-4-27 于北京

码云说
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java：Spring6--事务
islunatic的博客
03-16 258
在一个业务流程当中，通常需要多条DML（insert delete update）语句共同联合才能完成，这多条DML语句必须同时成功，或者同时失败，这样才能保证数据的安全。
Spring-6-事务管理
andy的博客
12-29 436
事务是构建可靠企业级应用程序的最关键部分之一。最常见的事务类型是数据库操作。在典型的数据库更新操作中，首先数据库事务开始，然后数据被更新，最后提交或回滚事务(根据数据库操作的结果而定)。但是，在很多情况下，由于应用程序需求以及应用程序需要与之交互的后端资源(如RDBMS、面向消息的中间件、ERP系统等)的不同，事务管理可能更加复杂。Spring支持声明式和编程式事务管理。Spring声明性事务提供极好的支持，这意味着不需要将事务管理代码和业务逻辑混淆起来。
@SpringJUnitConfig爆红（仅个人记录）
最新发布
2201_75495430的博客
04-26 124
是 Spring 框架提供的一个模块，它包含了用于测试 Spring 组件的类和注解。下面是一个示例，展示了如何在 Maven 项目的。要在 Maven 项目中导入。依赖，你需要在项目的。
spring（六）：事务（概念介绍、基于注解使用、事务属性介绍）
Kaiser__的博客
02-26 964
事务（概念介绍、基于注解使用、事务属性介绍）
Spring（六、配置事务，事务角色，事务传播行为
weixin_48841931的博客
08-19 271
注解事务可以添加到业务方法上表示当前方法开启事务，也可以直接添加到接口上表示该接口所有方法都开启事务。在Spring中常指代数据层方法，也可以是业务层方法。在Spring中常指代业务层开启事务的方法。
浅谈Spring6之事务(XML方式实现)
weixin_47268883的博客
03-27 431
浅谈Spring6之事务(XML方式实现)
Spring框架+Spring中的事务
03-22
Spring事务传播机制可以通过Propagation枚举类中的不同值来指定，共包括七种不同的传播行为。具体来说，Spring事务传播机制包括以下七种： REQUIRED：如果当前没有事务，则创建一个新的事务；如果当前已经存在事务，...
在SPRING中实现事务暂停
02-04
Spring的声明性事务分离可以应用到任何POJO目标对象，并且包含所有EJB基于容器管理事务中的已声明事务。后台的事务管理器支持简单的基于JDBC的事务和全功能的基于JTA的J2EE事务。这篇文章详细的讨论了Spring的事务...
Spring中的事务管理如何配置
08-25
主要介绍了spring中的事务管理如何配置,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Spring中的事务管理实例详解
09-04
主要介绍了Spring中的事务管理,以实例形式详细分析了事务的概念与特性以及事物管理的具体用法,需要的朋友可以参考下
在Spring中集成Hibernate事务
02-04
本文试图解释如何使用Spring来集成组件（包括组件的事务关系）。在J2EE应用程序中，连接到单个存储数据没有什么困难。但是一旦要求集成企业级组件的时候，情况就复杂了。一个组件一般会受到一个或多个存储数据的支持...
【深入浅出Spring6】第九期——Spring对事务的支持
欢迎来到我的世界
11-22 326
介绍了Spring事务的一些属性，以及Spring对事务的支持，如何采用全注解方式对事务进行处理，已经通过XML的方式声明事务
spring的@SpringJUnitConfig注解
听海边涛声
01-29 578
spring的@SpringJUnitConfig注解
Spring 常用注解(IOC/AOP/MVC)
书启鸿蒙知秋枫
02-06 1051
和 XML 配置文件一样，注解本身并不能执行，注解本身仅仅只是做一个标记，具体的功能是框架检测到注解标记的位置，然后针对这个位置按照注解标记的功能来执行具体操作。本质上：所有一切的操作都是Java代码来完成的，XML和注解只是告诉框架中的Java代码如何执行。Spring 为了知道程序员在哪些地方标记了什么注解，就需要通过扫描的方式，来进行检测。然后根据注解进行后续操作。对于Spring使用IOC容器管理这些组件来说没有区别。
spring注解
heima201907的博客
01-16 215
@Component 使用在类上用于实例化Bean @Controller 使用在web层类上用于实例化Bean @Service 使用在service层类上用于实例化Bean @Repository 使用在dao层类上用于实例化Bean @Autowired 使用在字...
spring Junit 测试使用
weirdo_world的博客
08-21 274
1、加入pom.xml 所需依赖 <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.12</version> <scope>test</scope>...
Spring-boot junit类读取config配置文件的注解
热门推荐
飞奔的小土豆@1024
07-03 1万+
@SpringBootApplication @RunWith(SpringJUnit4ClassRunner.class) @SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT) /*@ContextConfiguration(locations = {"classpath:spring.x
各框架下的常用注解
L12131415L的博客
04-19 1270
Spring、Spring MVC、Mybatis、Spring Boot等框架常用注解
Spring 使用详解
weixin_57176230的博客
03-18 3438
引入spring及测试的依赖 <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>5.3.16</version> </dependency> <!--
Spring中事务注解
03-28
Spring中事务注解是一种简便的方式来管理事务。它可以用来标注需要事务管理的方法或类，Spring框架会在方法执行时自动开启事务、提交或回滚事务，从而保证数据的一致性。 常用的Spring事务注解包括： - @Transactional：标注在方法或类上，表示该方法或类需要使用事务管理。 - @Transactional(propagation)：指定事务的传播行为。 - @Transactional(isolation)：指定事务的隔离级别。 - @Transactional(readOnly)：指定事务是否只读。 - @Transactional(timeout)：指定事务超时时间。 - @Transactional(rollbackFor)：指定需要回滚的异常类型。 - @Transactional(noRollbackFor)：指定不需要回滚的异常类型。 使用事务注解可以简化代码的编写和维护，同时也可以提高代码的可读性和可维护性。但需要注意的是，事务注解只适用于Spring管理的bean，对于非Spring管理的bean不起作用。同时，需要确保注解的作用范围正确，避免不必要的事务开销。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

码云说

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值