八、Spring事务（注解方案）

已于 2022-09-11 14:44:31 修改
阅读量2.3k 收藏 1
点赞数 1
分类专栏： Spring 简单回顾 文章标签： spring java
于 2022-06-02 22:24:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_30769437/article/details/125107782
版权

八、Spring事务（注解方案）

声明式事务：AOP
编程式事务：需要在代码中进行事务管理

1、Spring事务处理模型

*使用步骤是固定的，只要把事务的使用信息提供给Spring就完事了。

  1. 事务内部提交、回滚事务，使用事务管理器对象，代替你完成commit、rolback
    1. 事务管理器是一个接口和它众多的实现类
    2. 事务管理器接口：PlatformTransactionManager，定义了事务重要的方法commit、rolback
    3. 事务管理器接口实现类：Spring把每一种数据库访问技术对应的事务处理类都创建好了
      1. mybatis访问数据库：DataSourceTransactionManager
      2. hibernate访问数据库：HibernateTransactionManager
      3. … …
    4. 使用方法：告诉Spring要使用哪种数据库访问技术
      1. 在spring配置文件使用声明需要使用的数据库访问技术对应的事务管理器实现类
        1. eq：<bean id="xxx" class="...DataSourceTransactionManager"/>
  2. 说明需要事务的类型（TransactionDefinition）
    1. 事务的隔离级别（对应TransactionDefinition下定义的5个以**ISOLATION_**开头的常量）
      1. DEFAULT：采用DB默认事务隔离级别，Mysql为REPEATABLE_READ，Oracle为READ_COMMITTED
      2. **READ_UNCOMMITTED：**读未提交。未解决任何并发问题
      3. **READ_COMMITTED：**读已提交。解决脏读，存在不可重复读和幻读
      4. **REPEATABLE_READ：**可重复读。解决脏读、不可重复读，存在幻读
      5. **SERIALIZABLE：**串行化。不存在并发问题
    2. 事务的超时时间（TIMEOUT_DEFAULT）：表示一个事务最长的执行时间，如果超时就回滚，单位：秒(整数值)，默认-1不限时
    3. 事务的传播行为（有7个）：控制业务方法是否有事务，有什么样的事务（对应TransactionDefinition下定义的7个以**PROPAGATION_**开头的常量）
      1. **PROPAGATION_REQUIRED：**指定的方法必须在事务内执行，若存在当前事务则加入，不存在则创建一个新事务（最常见的选择，也是Spring默认的事务传播行为）
      2. **PROPAGATION_REQUIRES_NEW：**总是新建一个事务，若当前存在事务，就将当前事务挂起，直到新事物执行完毕
      3. **PROPAGATION_SUPPORTS：**若存在当前事务就加入，不存在就以非事务方式执行
      4. PROPAGATION_MANDATORY
      5. PROPAGATION_NESTED
      6. PROPAGATION_NEVER
      7. PROPAGATION_NOT_SUPPORTED
  3. 事务提交、回滚时机
    1. 业务方法正确执行完毕，没有抛出异常，spring自动提交事务
    2. 业务方法执行过程中抛出了运行时异常（RuntimeException及其子类）或ERROR，spring自动回滚事务
    3. 业务方法执行过程中抛出了非运行时异常（主要是受查异常），也会提交事务
      1. 受查异常：写代码时必须要捕获的异常（IOException、SQLException…）

2、Spring事务处理方案

1、注解方案（适合中小型项目使用，本文重点介绍）

  1. Spring框架自己用AOP实现业务方法增加事务的功能，使用**@Transactional**注解添加事务
  2. @Transactional注解是Spring框架提供的注解，放在public方法上面，表示当前方法开启了事务
  3. 可以给@Transactional注解的属性赋值，表示具体的隔离级别、传播行为、异常信息等

2、使用aspectJ框架（适合大型项目）

​ 在Spring配置文件中声明类、方法需要的事务，达到业务方法和事务配置完全分离。一键跳转~

1、@Transactional属性

  1. **propagation：**事务传播行为。类型为Propagation枚举，默认值为Propagation.REQUIRED
  2. **isolation：**事务隔离级别。类型为Isolation枚举，默认值为Isolation.DEFAULT
  3. **readOnly：**设置该方法对数据库的操作是否是只读的。类型为boolean，默认值为false
  4. **timeout：**设置本操作与数据库连接的超时时限。单位为秒，类型为int，默认值为-1(无时限)
  5. **rollbackFor：**设置需要回滚的异常类。类型为Class[]，默认值为空数组（只有一个异常类时可不用数组）
  6. **rollbackForClassName：**设置需要回滚的异常类名字。类型为String[]，默认值为空数组（只有一个异常类名字时可不用数组）
  7. **notRollbackFor：**设置不需要回滚的异常类。类型为Class[]，默认值为空数组（只有一个异常类时可不用数组）
  8. **notRollbackForClassName：**设置不需要回滚的异常类名字。类型为String[]，默认值为空数组（只有一个异常类名字时可不用数组）

2、@Transactional的使用步骤

  1. 声明事务管理器对象

    1. <bean id="xxx" class="...DataSourceTransactionManager" />

  2. 开启事务注解驱动

    1. 告诉spring框架爹要用注解的方式管理事务

    2. spring使用AOP机制，创建@Transactional所标注类的代理对象，给方法加入事务功能

    3. spring给业务方法加入事务：使用AOP环绕通知，运行方法前开启事务，运行方法后提交或回滚事务

      1. @Around(value = "execution(..)")
Object myAround(){
    // TODO: Spring开启事务
    try{
        // TODO: 执行业务方法
        // TODO: Spring提交事务
    } catch(Exception e){
        // TODO: Spring回滚事务
    }
}

  3. 在业务方法上加@Transactional注解

3、实现步骤

  1. 创建maven项目
  2. 加入maven依赖
    1. spring依赖
    2. mybatis依赖
    3. mysql驱动
    4. spring的事务依赖
    5. mybatis和spring集成依赖（mybatis官方提供的，用来在spring项目中创建mybatis的SqlSessionFactory、dao对象的）
  3. 创建实体类
  4. 创建dao接口及mapper文件
  5. 创建mybatis主配置文件
  6. 创建Service接口及实现类，属性包含dao
  7. 创建spring配置文件（声明mybatis对象交给spring创建）
    1. 数据源（dataSource）
    2. SqlSessionFactory
    3. Dao对象
    4. 声明自定义的service
  8. 创建测试类，获取service对象，通过service对象完成对数据库的访问

4、项目结构

在这里插入图片描述

*MySql-Table-goods

在这里插入图片描述

*MySql-Table-sale

在这里插入图片描述

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>hom.wang</groupId>
  <artifactId>st-07-spring-trans</artifactId>
  <version>1.0-SNAPSHOT</version>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
  </properties>

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

    <!-- spring事务 -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
      <version>5.3.18</version>
    </dependency>
    <!--  jdbc  -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>5.3.18</version>
    </dependency>
    <!--  mybatis依赖  -->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.5.7</version>
    </dependency>
    <!--  mybatis和spring集成  -->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>2.0.6</version>
    </dependency>
    <!--  mysql驱动  -->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>8.0.29</version>
    </dependency>
    <!--  ali的数据库连接池  -->
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.2.6</version>
    </dependency>
  </dependencies>

  <build>
    <!--目的是把src/main/java目录下的.xml文件包含到输出结果中（输出到classes目录下）
	[※※※ 个人配置此项并未生效...完全扫描不到... ※※※]-->
    <resources>
      <resource>
        <!--所在目录-->
        <directory>src/main/java</directory>
        <!--包括目录下的.properties/.xml文件都会扫描到-->
        <includes>
          <include>**/*.xml</include>
          <!--<include>**/*.properties</include>-->
        </includes>
        <filtering>false</filtering>
      </resource>
    </resources>
    <!--指定jdk版本-->
    <plugins>
      <plugin>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.8.1</version>
        <configuration>
          <source>1.8</source>
          <target>1.8</target>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

data.Goods.java

package hom.wang.data;
import java.math.BigDecimal;
public class Goods {
    private String goodsId;
    private String goodsName;
    private Integer goodsAmount;
    private BigDecimal goodsPrice;
}

data.Sale.java

package hom.wang.data;
public class Sale {
    private Integer saleId;
    private String goodsId;
    private Integer saleNum;
}

dao.Goods.java

package hom.wang.dao;
import hom.wang.data.Goods;
public interface GoodsDao {
    int updateGoods(Goods goods);

    Goods selectGoodsById(Goods goods);
}

dao.GoodsMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="hom.wang.dao.GoodsDao">

    <update id="updateGoods">
        update goods
        set goods_amount = #{goodsAmount}
        where goods_id = #{goodsId}
    </update>

    <resultMap id="goodsMap" type="hom.wang.data.Goods">
        <id property="goodsId" column="goods_id" />
        <result property="goodsName" column="goods_name" />
        <result property="goodsAmount" column="goods_amount" />
        <result property="goodsPrice" column="goods_price" />
    </resultMap>

    <select id="selectGoodsById" resultMap="goodsMap">
        select
               goods_id,
               goods_name,
               goods_amount,
               goods_price
        from goods
        where goods_id = #{goodsId}
    </select>

</mapper>

dao.SaleDao.java

package hom.wang.dao;
import hom.wang.data.Sale;
public interface SaleDao {
    int insertSale(Sale sale);
}

dao.SaleMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="hom.wang.dao.SaleDao">

    <insert id="insertSale">
        insert into sale(goods_id, sale_num) values(#{goodsId}, #{saleNum})
    </insert>

</mapper>

exce.NotEnoughException.java

package hom.wang.exce;
/* 库存不足异常 */
public class NotEnoughException extends RuntimeException {
    public NotEnoughException() {
    }
    public NotEnoughException(String message) {
        super(message);
    }
}

service.impl.BuyServiceImpl.java

package hom.wang.service.impl;

import hom.wang.dao.GoodsDao;
import hom.wang.dao.SaleDao;
import hom.wang.data.Goods;
import hom.wang.data.Sale;
import hom.wang.exce.NotEnoughException;
import hom.wang.service.BuyService;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
public class BuyServiceImpl implements BuyService {
    GoodsDao goodsDao;
    SaleDao saleDao;

    /**
     * rollbackFor：发生指定异常一定回滚
     *  spring处理逻辑：
     *      1、首先判断抛出异常是否是rollbackFor包含的，是就回滚
     *      2、不在rollbackFor数组中则判断是否是RuntimeException，是就回滚
     */
    /* @Transactional(
                propagation = Propagation.REQUIRED,
                isolation = Isolation.DEFAULT,
                readOnly = false,
                rollbackFor = {
                        NullPointerException.class,
                        NotEnoughException.class
                }
        )*/
    // 上面配置的都是默认值，故而直接使用@Transactional就可以
    @Transactional
    @Override
    public void buy(Sale sale) {
        System.out.println("============ buy start =============");

        // 1、判断库存是否充足
        Goods goods = new Goods();
        goods.setGoodsId(sale.getGoodsId());
        goods = goodsDao.selectGoodsById(goods);

        if(null == goods){
            throw new NullPointerException("编号[" + sale.getGoodsId() + "]商品不存在！");
        }

        if(goods.getGoodsAmount() < sale.getSaleNum()){
            throw new NotEnoughException("库存不足！");
        }

        // 2、减少库存
        goods.setGoodsAmount(goods.getGoodsAmount() - sale.getSaleNum());
        goodsDao.updateGoods(goods);

        // 3、增加销售记录
        saleDao.insertSale(sale);

        System.out.println("============ buy end =============");
    }

    public void setGoodsDao(GoodsDao goodsDao) {
        this.goodsDao = goodsDao;
    }

    public void setSaleDao(SaleDao saleDao) {
        this.saleDao = saleDao;
    }
}

mybatis.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

    <!--设置别名-->
    <typeAliases>
        <!--name：实体类所在包名-->
        <package name="hom.wang.data"/>
    </typeAliases>

    <mappers>
        <!-- 配置文件导入全部写在这里 -->
        <mapper resource="hom/wang/dao/GoodsMapper.xml"/>
        <mapper resource="hom/wang/dao/SaleMapper.xml"/>

        <!--name：包名（这个包所有.xml文件一次性全部加载）-->
        <!--<package name="hom.wang.dao"/>-->
    </mappers>
</configuration>

jdbc.properties

jdbc.url=jdbc:mysql://127.0.0.1:3306/ms_user
jdbc.username=root
jdbc.password=root
jdbc.maxActive=20

applicationContext.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"
       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">

    <context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder>

    <!--声明数据源DataSource，用于连接数据库-->
    <bean id="myDataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
        <!--使用属性配置文件中的数据，语法：${key}-->
        <property name="url" value="${jdbc.url}"></property>
        <property name="username" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
        <property name="maxActive" value="${jdbc.maxActive}"></property>
    </bean>

    <!--声明mybatis提供的SqlSessionFactoryBean，用于创建SqlSessionFactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="myDataSource"></property>
        <property name="configLocation" value="classpath:mybatis.xml"></property><!--在spring配置文件中指定其他配置文件路径需要使用 classpath:-->
    </bean>

    <!--创建dao对象，使用SqlSession的getMapper(UserDao.class)
        MapperScannerConfigurer：在内部调用getMapper()生成每个dao接口的代理对象
    -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!--指定SqlSessionFactory的id-->
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"></property>
        <!--指定包名（dao所在的包名）
            MapperScannerConfigurer会扫描这个包中的所有接口，
			把每个接口都执行一次 getMapper()方法，得到每个接口的dao对象。
			创建好的dao对象放入到 spring容器中
        -->
        <property name="basePackage" value="hom.wang.dao"></property>
    </bean>

    <bean id="buyService" class="hom.wang.service.impl.BuyServiceImpl">
        <property name="goodsDao" ref="goodsDao"></property>
        <property name="saleDao" ref="saleDao"></property>
    </bean>

    <!--使用Spring事务管理-->
    <!--1、声明事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!--连接的数据库，指定数据源-->
        <property name="dataSource" ref="myDataSource" />
    </bean>

    <!--2、开启事务注解驱动，告诉Spring使用注解管理事务，创建代理对象-->
    <!--springframework.org/schema/tx/spring-tx
        transaction-manager：配置事务管理器对象
    -->
    <tx:annotation-driven transaction-manager="transactionManager" />
</beans>

MyTest.java

package hom.wang;
import hom.wang.data.Sale;
import hom.wang.service.BuyService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MyTest {
    @Test
    public void test(){
        ApplicationContext ac = 
            new ClassPathXmlApplicationContext("applicationContext.xml");
        BuyService buyService = (BuyService) ac.getBean("buyService");
        //buyService的代理对象是：com.sun.proxy.$Proxy17，jdk动态代理对象
        System.out.println("buyService的代理对象是：" + buyService.getClass().getName());

        Sale sale = new Sale();
        sale.setGoodsId("p_yz_00002");
        sale.setSaleNum(1);

        buyService.buy(sale);
    }
}

*没错，最终结果正如你所预料的！

纯纯的小白
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
spring 的事务注解
范文聪
05-23 1750
知识点： 1.同一个类的（没有@Transactional注解）A方法调用B方法，（有@Transactional注解）B方法的事务无效。 2.A类的B方法调用C类的D方法,那么D方法的事务是有效的。（这里的B方法没有注解，D方法有注解） 解决注解失效的方法： @Transactional注解可以作用于哪些地方？ @Transactional 可以作用在接口、类、类方法。 作用于类：当把@Transactional 注解放在类上时，表示所有该类的public方法都配置相同的事务属性信息。 作用
【Spring全家桶系列】Spring中的事务管理（基于注解完成实现）
未见花闻的博客
05-16 1647
前面我们已经介绍了如何在Spring环境中整合mybatis完成数据库的增删查改操作，在正常情况下，操作数据库是没有问题的，但是一个业务需要多次操作数据库，并且需要完成修改，插入，删除操作可能会有问题，如转账，其实是有两个步骤，第一步从A账户扣钱，第二步在B账户中加钱。
Spring 事务管理
473687880
09-13 663
特此提醒：在使用事务时，千万不要不假思索地将事务内部抛出异常的地方默默地捕获，一旦将异常捕获掉，会造成事务不会回滚。 使用步骤： 步骤一、在spring配置文件中引入&lt;tx:&gt;命名空间 &lt;beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/...
Spring中的事务详解
最新发布
努力分享一些干货内容，纯干货，没有一点水
07-19 1094
但是随着事务越来越大，执行时间也会变长，就需要将这个大事务拆分成多个事务，如果确保这个事务能够拆分成多个事务，就需要指定Spring的事务传播行为。比如，在用户注册时候，需要记录注册日志，这时候可以将记录日志的操作单独划分为一个事务，而注册是另一个单独的事务，可以将保存日志的方法指定。事务隔离级别，即数据库中事务隔离级别，指的是一个事务对数据的修改与另一个并行的事务的隔离程度。事务传播行为指，当一个事务方法被另一个事务方法调用时，这个事务方法应该如何进行，是应该加入现有事务，还是应该启动一个新事务。
Spring注解(事务)
art_code的博客
04-10 747
Spring注解(事务) spring操作数据库 jdbc <!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc --> <dependency> <groupId>org.springframework</groupId> <art...
Spring事务注解
严文文 Chris
08-26 7606
spring注解事务特性介绍，失效场景总结
spring 事务注解
weixin_30418341的博客
11-14 91
在spring中使用事务需要遵守一些规范和了解一些坑点，别想当然。列举一下一些注意点。 在需要事务管理的地方加@Transactional 注解。@Transactional 注解可以被应用于接口定义和接口方法、类定义和类的public 方法上。 @Transactional 注解只能应用到 public 可见度的方法上。如果你在 protected、private 或者packag...
Spring事务失效问题分析及解决方案
08-25
Spring事务失效问题分析及解决方案 在本文中，我们将详细介绍 Spring 中的事务失效问题分析及解决方案。Spring 事务机制是基于 AOP 实现的，通过使用 @Transaction 注解来标注事务方法。然而，在实际开发中，可能会...
Spring中注解式事务管理在项目中应用
06-14
涉及到目前互联网项目中最常用的高并发解决方案技术, 如 dubbo,redis,solr,freemarker,activeMQ,springBoot框架,微信支付,nginx负载均衡,电商活动秒杀,springSecurity安全框架,FastDFS分布式文件服务器,还会涉及到...
关于SpringMyBatis纯注解事务不能提交的问题分析与解决
07-31
然而，在实际开发过程中，可能会遇到使用Spring MyBatis纯注解方式配置的事务无法正常提交的情况，尤其是在使用Oracle数据库时更为常见。 ### 问题描述 本文主要针对在Spring + MyBatis环境下，或使用Spring JDBC...
redisson分布式锁与spring注解事务共用产生的一系列问题，及对应解决方案
阿啄debugIT
03-10 1188
前言 有锁才有自由，生活中不存在绝对的自由，绝对的自由通常对应的无序和混沌，只有在道德、法律、伦理的约束下的相对自由，才能使人感受到自由。 而在多线程编程中，锁是至关重要的，锁就是道德，就是法律约束，没有锁的多线程环境将会是混乱的，所有线程都在争夺资源，最后的结果就是导致系统崩溃，而有了锁之后，多线程环境才能稳定高效的工作。 事故现场 某些原因，获取锁失败-------没有在至少N/2+1个Redis实例取到锁，或者取锁时间已经超过了有效时间），客户端应该在所有的Redis实例上进行解锁（即便某
spring事务注解
先相信你自己，然后别人才会相信你。
08-06 6201
注意的几点:1  @Transactional 只能被应用到public方法上, 对于其它非public的方法,如果标记了@Transactional也不会报错,但方法没有事务功能.2 默认情况下,一个有事务方法, 遇到RuntiomeException 时会回滚 .  遇到 受检查的异常 是不会回滚 的. 要想所有异常都回滚,要加上 @Transactional( rollbackFor={Exception.class,其它异常}) .@Transactional  的所有可选属性如下: 属性类型默认值
spring 注解事务
剑平的专栏
06-16 1309
spring 注解事务使用，及注解事务使用误区
spring注解实现事务
weixin_30344995的博客
07-28 104
码云： https://gitee.com/MarkPolaris/spring-transcation 转载于:https://www.cnblogs.com/MC-Curry/p/11257951.html
Spring 事务详解（注解方式）
shine的博客
08-05 3274
事务指逻辑上的一组操作，组成这组操作的各个单元，要么全部成功，要么全部不成功，只有这两种情况。@Transactional注解 可以作用于接口、接口方法、类以及类方法上。当作用于类上时，该类的所有 public 方法将都具有该类型的事务属性，同时，我们也可以在方法级别使用该标注来覆盖类级别的定义。虽然@Transactional 注解可以作用于接口、接口方法、类以及类方法上，但是 Spring 建议不要在接口或者接口方法上使用该注解，因为这只有在使用基于接口的代理时它才会生效。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

纯纯的小白

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

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

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

打赏作者

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

抵扣说明：

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

余额充值