Spring实现注解（编程式事务管理、通过XML或注解的声明式事务管理）

已于 2023-03-04 20:19:49 修改
阅读量540 收藏 1
点赞数 1
分类专栏： # SSM 文章标签： spring xml 事务 java
于 2022-09-14 15:20:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yuandfeng/article/details/126853062
版权

Java知识点总结：想看的可以从这里进入

目录

15.3、实现事务

事务管理方式有两种：一种是传统的编程式事务管理（编写代码实现事务，能精确地定义事务的边界），一种是声明式事务管理（以AOP技术实现，无须通过编程的方式管理事务）。

声明式事务管理的优点就是不需要通过编程的方式实现，只需要在配置文件中进行事务的规则声明，就可以将事务应用得到业务逻辑当中，实际上就是将事务切入到业务目标中，它对业务代码没有侵入性，耦合度低，易于维护，所以现在开发基本都使用声明式事务管理。

声明式事事务管理也分为两种：XML文件配置和注解，其中XML文件配置已经很少使用，现在的事务管理都是通过注解：@Transactional来实现的。

15.3.1、编程式事务

实际上就是通过我们自己写程序来实现的，Spring提供的最原始的事务管理方式是基于TransactionDefinition、PlatformTransactionManager、TransactionStatus 编程式事务。而TransactionTemplate的编程式事务管理是使用模板方法设计模式对原始事务管理方式的封装。

我们使用过spring的JdbcTemplate访问数据库，但是他不支持事务，所以spring设置了一个 org.springframework.transaction.support.TransactionTemplate模板，它是提供事务管理器的模板。它的核心方法是 execute，传入的参数有两种选择：TransactionCallback、TransactionCallbackWithoutResult

//简化程序化事务划分和事务异常处理的模板类。
public class TransactionTemplate extends DefaultTransactionDefinition implements TransactionOperations, InitializingBean {
	.....构造方法等省略.....
    /** 设置要使用的事务管理策略 */
    public void setTransactionManager(@Nullable PlatformTransactionManager transactionManager) {
        this.transactionManager = transactionManager;
    }
    /**返回要使用的事务管理策略。*/
    @Nullable
    public PlatformTransactionManager getTransactionManager() {
        return this.transactionManager;
    }
    /**中心方法 ，支持实现TransactionCallback接口的事务代码。 */
    @Override
    @Nullable
    public <T> T execute(TransactionCallback<T> action) throws TransactionException {
        Assert.state(this.transactionManager != null, "No PlatformTransactionManager set");
		//使用自定义的事务管理器
        if (this.transactionManager instanceof CallbackPreferringPlatformTransactionManager) {
            return ((CallbackPreferringPlatformTransactionManager) this.transactionManager).execute(this, action);
        }
        //系统默认的管理器
        else {
            //获取事务的状态
            TransactionStatus status = this.transactionManager.getTransaction(this);
            T result;
            try {
                //回调接口方法
                result = action.doInTransaction(status);
            }
            catch (RuntimeException | Error ex) {
                // 事务代码抛出应用程序异常 -> 回滚
                rollbackOnException(status, ex);
                throw ex;
            }
            catch (Throwable ex) {
                // 事务代码抛出异常 ->回滚
                rollbackOnException(status, ex);
                throw new UndeclaredThrowableException(ex, "TransactionCallback threw undeclared checked exception");
            }
            //提交事务
            this.transactionManager.commit(status);
            return result;
        }
    }
    /**执行回滚，正确处理回滚异常。 */
    private void rollbackOnException(TransactionStatus status, Throwable ex) throws TransactionException {
        Assert.state(this.transactionManager != null, "No PlatformTransactionManager set");

        logger.debug("Initiating transaction rollback on application exception", ex);
        try {
            this.transactionManager.rollback(status);
        }
        catch (TransactionSystemException ex2) {
            logger.error("Application exception overridden by rollback exception", ex);
            ex2.initApplicationException(ex);
            throw ex2;
        }
        catch (RuntimeException | Error ex2) {
            logger.error("Application exception overridden by rollback exception", ex);
            throw ex2;
        }
    }
}

下面测试一下：

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

    <!-- 导入database文件       -->
    <!-- 配置数据库连接池       -->
    <!--配置事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!-- 将配置好的数据库连接池加入-->
        <property name="dataSource" ref="dataSource"/>
    </bean>
    <!--事务模板-->
    <bean id="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate">
        <property name="transactionManager" ref="transactionManager"/>
    </bean>
</beans>

public class ClassesTest {
    @Autowired
    private TransactionTemplate transactionTemplate;
    @Autowired
    private JdbcTemplate jdbcTemplate;
    public List<Classes> getClasses(Integer ... id){
		//使用execute方法 操作事务
        return transactionTemplate.execute(status -> {
            String sql = "SELECT * FROM `user` WHERE user_id = ?";
            try {
                List<User> userList = jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(User.class), id);
                System.out.println("事务操作成功");
                return userList;
            } catch (DataAccessException e) {
                //出现异常设置事务的回滚，必须要有回滚
                System.out.println("操作失败事务回滚");
                status.setRollbackOnly();
            }
            return null;
        });
    }
}
image-20230228143005133

image-20230228145615424

15.3.2、声明式事务

声明式事务是一种约定性的事务管理，使用事务时，大部分情况是发生异常后，需要回滚，不发生异常时提交事务。基于这点，spring声明式事务规定，业务方法不发生异常时，spring就让事务管理器提交事务，发生异常时，事务管理器回滚事务。

Spring 声明式事务管理是通过 AOP 实现的，其本质是对方法前后进行拦截，然后在目标方法开始之前创建（加入）一个事务，在执行完目标方法后，根据执行情况提交或者回滚事务。声明式事务最大的优点就是对业务代码的侵入性低，可以将业务代码和事务管理代码很好地进行解耦。

1、基于XML

在Spring2.0后，提供了 tx 命名空间来配置事务，通过 tx:advice 元素配置事务的通知，它有两个属性 id(唯一标识)、transaction-manager（指定事务管理器）。有一个子元素 tx:attributes ，通过配置多个 tx:method 来配置事务的细节

tx:method 的属性描述
name指定那些方法执行事务(支持通配符)
propagation指定事务的传播行为
isolation指定事务的隔离级别
read-only指定事务是否只读
timeout指定事务的超时时间
rollback-for指定触发回滚的异常
no-rollback-for指定不触发回滚的异常
使用XML配置
<!--1、配置事务管理器-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
</bean>
<!--2、配置通知-->
<tx:advice id="interceptor" transaction-manager="transactionManager">
    <!--配置事务参数-->
    <tx:attributes>
        <!--指定哪种规则-->
         <tx:method name="select*" propagation="REQUIRED" isolation="DEFAULT" read-only="false" timeout="-1" 		no-rollback-for="" rollback-for=""/>
    </tx:attributes>
</tx:advice>

<!--3 配置切入点和切面-->
<aop:config>
    <!--配置切入点-->
    <aop:pointcut id="pt" expression="execution()"/>
    <!--配置切面-->
    <aop:advisor advice-ref="interceptor" pointcut-ref="pt"/>
</aop:config>

测试一下：有四个用户，让其中一个人赠送积分给另一个人

image-20220914142436824

  • dao操作数据库

    public class IntegralTestTransactionalDao {
    @Autowired
    private JdbcTemplate jdbcTemplate;
	/** 获取所有信息*/
    public List<Integral> servletIntegral() {
        String sql = "SELECT id,`name`,integral_num FROM integral";
        return jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(Integral.class));
    }
	/** 赠送积分*/
    public void givingIntegral(int integralNum,int id){
        String sql = "update integral set integral_num = integral_num-? where id=?";
        jdbcTemplate.update(sql,integralNum,id);
    }
    /** 得到积分*/
    public void getIntegral(int integralNum,int id){
        String sql = "update integral set integral_num = integral_num+? where id=?";
        jdbcTemplate.update(sql,integralNum,id);
    }
 	/** 根据id获取*/
    public Integral servletById(int id) {
        String sql = "select id,`name`,integral_num FROM integral where id =?";
        try {
            return jdbcTemplate.queryForObject(sql,new BeanPropertyRowMapper<>(Integral.class),id);
        }catch (EmptyResultDataAccessException e){
            return null;
        }
    }
}

  • service

    public class IntegralTransactionalServiceImpl implements IntegralTestTransactionalService {
    @Autowired
    private IntegralTestTransactionalDao dao;
    @Override
    public List<Integral> servletIntegral() {
        return dao.servletIntegral();
    }
    @Override
    public Integral servletById(int id) {
        return dao.servletById(id);
    }

    @Override
    public void changeIntegral(int integralNum,Integral integral1,Integral integral2) throws Exception {
        System.out.println(integral1.getName()+"赠送积分："+integralNum);
        dao.givingIntegral(integralNum,integral1.getId());

        try {
            int i = 5/0;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }

        System.out.println(integral2.getName()+"获得积分："+integralNum);
        dao.getIntegral(integralNum,integral2.getId());
    }
}

  • 不配置注解，测试一下效果

    image-20220914150127429

在不配置事务的情况下，张三积分减少，但是王五的并没有获得积分，现在通过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" 
       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/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 
            http://www.springframework.org/schema/aop 
            https://www.springframework.org/schema/aop/spring-aop.xsd">

    <!-- 导入database文件       -->
	<!-- 配置 dataSource      -->
    <!--配置事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!-- 将配置好的数据库连接池加入-->
        <property name="dataSource" ref="dataSource"/>
    </bean>
    
    <!--    XML声明事务-->
    <tx:advice id="interceptor" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="change*" read-only="false"/>
        </tx:attributes>
    </tx:advice>
    
    <!-- 配置切点、切面   -->
    <aop:config>
        <aop:pointcut id="point" expression="execution(* com.yu.XmlTransactional.IntegralTransactionalServiceImpl.changeIntegral(..))"/>
        <aop:advisor advice-ref="interceptor" pointcut-ref="point"/>
    </aop:config>
</beans>

在数据库将数据改成初始状态，再进行测试：我们发现事务回滚了，所有人的积分都没有变化

image-20220914150331592

2、基于注解

想要使用注解实现事务，必须开启事务注解的支持，也是有两种方法进行开启

  • 在XML文件中开启：tx 命名空间提供了一个 tx:annotation-driven 的元素，用来开启注解事务，简化 Spring 声明式事务的 XML 配置。

    <!--配置事务管理器... -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <!-- 将配置好的数据库连接池加入-->
    <property name="dataSource" ref="dataSource1"/>
</bean>
<!--开启事务注解驱动-->
<tx:annotation-driven transaction-manager="transactionManager"/>

  • 也可以在 @Configuration 的类上添加注解 @EnableTransactionManagement 开启注解支持

    使用注解
@Configuration
@ComponentScan
@EnableTransactionManagement			//开启事务
public class TransactionConfig {
	............
}

Spring 声明式事务编程的核心注解是 @Transactional ，该注解既可以在类上使用，也可以在方法上使用。在类上使用，则表示类中的所有方法都支持事务。在方法上使用，则表示当前方法支持事务。

Spring 容器会查找所有使用了 @Transactional 注解的 Bean，并自动为它们添加事务通知，通知的事务属性则是通过 @Transactional 注解的属性来定义的。

事务属性说明
propagation指定事务的传播行为。
isolation指定事务的隔离级别。
read-only指定是否为只读事务。
timeout表示超时时间，单位为“秒”；声明的事务在指定的超时时间后，自动回滚，避免事务长时间不提交会回滚导致的数据库资源的占用。
rollback-for指定事务对于那些类型的异常应当回滚，而不提交。
no-rollback-for指定事务对于那些异常应当继续运行，而不回滚。

测试，还是使用上面XML的例子：

  • 先在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">
    <!-- 导入database文件       -->
    <!-- 使用德鲁伊连接池设置database       -->
    <!-- 创建 jdbcTemplate1操作数据库      -->
  
    <!--配置事务管理器-->
    <bean id="transactionManager1" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!-- 将配置好的数据库连接池加入-->
        <property name="dataSource" ref="dataSource1"/>
    </bean>
    <!--开启事务注解驱动-->
    <tx:annotation-driven transaction-manager="transactionManager1"/>
</beans>

  • dao操作数据

    @Repository
public class IntegralTestTransactionalDao {
    ................
}

  • 编写service(先不加事务注解)

    @Service
public class IntegralTransactionalServiceImpl implements IntegralTestTransactionalService{
  ..............................
    @Override
    public void changeIntegral(int integralNum,Integral integral1,Integral integral2) throws Exception {
        System.out.println(integral1.getName()+"赠送积分："+integralNum);
        dao.givingIntegral(integralNum,integral1.getId());
		//出错误
        try {
            int i = 5/0;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        System.out.println(integral2.getName()+"获得积分："+integralNum);
        dao.getIntegral(integralNum,integral2.getId());
    }
}

  • 测试

    @Test
public void annotationtransactionTest() throws Exception {
    List<Integral> list1 = service.servletIntegral();
    list1.forEach(i -> System.out.println(i.getName()+"有积分："+i.getIntegralNum()));
    Integral user1 = service.servletById(1);
    Integral user2 = service.servletById(3);
    if(user1!=null && user2!=null){
        service.changeIntegral(100,user1,user2);
    }
    List<Integral> list2 = service.servletIntegral();
    list2.forEach(i -> System.out.println(i.getName()+"有积分："+i.getIntegralNum()));
}
    image-20220914142838205

我们发现在没有添加事务的时候，出现错误后，张三的积分减少了，但是王五并没有获得积分。现在对service方法添加 @Transactional

@Override	//开启事务	
@Transactional(isolation = Isolation.DEFAULT,propagation = Propagation.REQUIRED,timeout = 10,readOnly = false)
public void changeIntegral(int integralNum,Integral integral1,Integral integral2) throws Exception {
    System.out.println(integral1.getName()+"赠送积分："+integralNum);
    dao.givingIntegral(integralNum,integral1.getId());

    try {
        int i = 5/0;
    } catch (Exception e) {
        throw new RuntimeException(e);
    }

    System.out.println(integral2.getName()+"获得积分："+integralNum);
    dao.getIntegral(integralNum,integral2.getId());
}

此时进行测试，在出现异常后，事务回滚了，2人的积分都没有发生变化

image-20220914144316534
辰 羽
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
10、Spring事务（基于注解方式）
chf_liu的专栏
05-10 203
Spring事务（基于注解方式）
Spring 利用注解开启事务管理
Code-zyc的博客
11-05 500
第一步： 配置对应的xml 文件 <!--创建事务管理器--> <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> <!-- 注入数据源 --> <property name="dataSource" ref="dataSource"></property> </bean&gt
【Spring学习06】基于xml和注解的事务声明控制
一个正在努力学习的iter
03-26 377
1. 基于xml的事务声明控制 1.1 什么是事务声明控制 Spring 的声明式事务顾名思义就是采用声明的方式来处理事务。这里所说的声明，就是指在配置文件中声明，用在 Spring 配置文件中声明式的处理事务来代替代码式的处理事务。 作用： 事务管理不侵入开发的组件。具体来说，业务逻辑对象就不会意识到正在事务管理之中，事实上也应该如此，因为事务管理是属于系统层面的服务，而不是业务逻辑的一部分，如果想要改变事务管理策划的话，也只需要在定义文件中重新配置即可 在不需要事务管理的时候，只要在设定文件上修改一下
Spring事务机制---XML配置事务和注解方式事务
公子&小白的博客
05-01 1146
文章目录1. Spring事务管理机制1.1 Spring事务管理机制1.2 PlatformTransactionManager事务管理器1.3 TransactionDefinition事务定义信息1.3.1 常用事务隔离级别1.3.2 事务的传播行为PropagationBehavior1.3.1 事务的传播行为1.4 事务状态：TransactionStatus1.5 Spring中要达到事务操作的三个步骤1.6 Spring事务管理两种方式1.6.1 编程式事务管理1.6.2 通过XML或者注解配
第六章：Springmvc事务管理和配置文件xml详解和七大事务和注解@Transactional
beiback的博客
11-21 2363
1.事务配置为事务配置管理即为DataSourceTransactionManager类中dataSource属性赋值2.配置事务通知，通知指的是动作，自定义哪些字符串开头的命名方法添加事务动作。3.将这些事务动作放在哪些位置或者哪个点上？即配置pointcut，像交警一样设卡查哨这里边的expression中execution(public * com.xxx.service..(…))表达式4.配置事务切面即将配置好的事务通知和事务的切点交给事务管理。
Spring实战之使用注解实现声明式事务操作示例
08-25
在本文中，我们将详细介绍如何使用 Spring 框架来实现声明式事务操作，通过对配置文件和接口实现的分析，来描述如何使用注解来实现事务操作。 事务管理 在 Spring 框架中，事务管理是通过实现 ...
Spring 使用注解方式进行事务管理配置方式
08-30
Spring框架的注解式事务管理是一种便捷的方式来控制事务在应用程序中的行为，特别是在JavaEE开发中。这种方式使得开发者可以在不修改大量XML配置的情况下，通过在类或方法上添加注解来实现事务管理。以下是对Spring...
详解Spring学习之声明式事务管理
08-29
声明式事务管理是基于Spring的AOP（面向切面编程）实现的，它会在目标方法执行前后自动插入事务控制逻辑。这意味着，我们只需在配置中声明哪些方法需要事务支持，而无需在代码中编写事务相关的代码。Spring通过创建...
SpringBoot 注解事务声明式事务的方式
08-29
在Spring Boot中，注解事务管理提供了一种更简洁的方式来处理事务，相比于传统的XML配置，它使得代码更加整洁，降低了依赖...通过合理使用`@Transactional`注解及其属性，可以实现与XML配置类似的声明式事务管理功能。
spring声明式事务管理解析
09-01
在Spring中，声明式事务通常通过AOP（面向切面编程）实现，使得事务管理与业务代码分离，提高了代码的可复用性和可维护性。配置文件中的声明能够决定哪些方法应该在事务中执行，而无需在代码中显式调用开始、提交或...
1.11 spring中的声明式事务处理
最新发布
蟑螂恶霸的博客
07-30 136
标识在方法上，则只会影响该方法标识的类上，则会影响类中所有的方法。
Spring声明式事务控制XMl和注解
m0_62317022的博客
05-23 348
Spring的声明式事务顾名思义就是采用声明的方法来处理事务。这里所说的声明，就是指在配置文件中声明，用在Spring配置文件中声明式的处理事务来代替代码式的处理事务。注意：Spring声明式事务控制底层就是AOP。
使用Spring为业务层添加声明式事务
wzy18210825916的博客
09-17 4056
前言 业务层的职能不仅仅是调用DAO层这么简单，它在进行一个业务的时候，还有一件重要的事要兼顾——事务处理。事务处理是任何企业级应用开发中不能回避的一个重要问题，以往我们通过在业务方法中硬编码的方式进行事务控制，比如这样： Connection connection=null; try { connection=DatabaseUtil.getConnection(); co...
【Spring事务】声明式事务 使用详解
ebb29bbe的博客
03-02 1470
个人简介：Java领域新星创作者；阿里云技术博主、星级博主、专家博主；正在Java学习的路上摸爬滚打，记录学习的过程~
Spring的事务管理 xml和注解配置 事务控制用注解配置最方便
qq_35232663的博客
03-20 340
1.spring事务特性spring所有的事务管理策略类都继承自org.springframework.transaction.PlatformTransactionManager接口org.springframework.jdbc.datasource.DataSourceTransactionManager 使用 Spring JDBC 或 iBatis 进行持久化数据时使用org.sprin...
【Spring学习31】Spring事务(1)：概述
程序老兵的博客
04-20 1724
本系列由以下文章组成： Spring事务(1)：概述 Spring事务(2)：事务管理器 Spring事务(3)：事务属性之隔离级别(isolation level) Spring事务(4)：事务属性之7种传播行为 Spring事务(5)：编程式事务 Spring事务(6)：声明式事务
Spring基础（十六）：Spring事务管理注解方式和XML配置方式
Lansonli（蓝深李）的博客
10-13 1189
保证一个事务修改的数据提交后才能被另外一个事务读取，另外一个事务不能读取该事务未提交的数据。这是一个PlatfromTransactionManager默认的隔离级别，使用数据库默认的事务隔离级别。这是事务最低的隔离级别，它允许另外一个事务可以看到这个事务未提交的数据。这种隔离级别会产生脏读，不可重复读和幻像读。无论add是否有事务,都建立一个新的事务,所有的方法都加入到新的事务中,add原来的事务就不用了。如果add方法没有事务,那么就新建一个事务,将addDept和addEmp加入到这个新的事务中。
Spring事务管理-注解方式实现+XML方式实现
风暴计划
12-18 247
目录 1、事务概念与事务的四个特性ACID 2、事务操作（搭建事务操作环境） 3、事务操作（Spring事务管理介绍） 4、事务操作（注解实现-声名式事务） 4.1 事务操作（声名式事务的参数设置） 5、事务操作（XML配置文件实现-声名式事务） 6、事务操作（完全注解式实现-声名式事务） 附录0：Spring事务测试的项目结构 附录1：注解方式实现声名式事务代码 附录1-1：UserDao接口 附录1-2：UserDao接口的实现 附录1-3：事务类：UserServiceTx
Spring——XML配置事务、注解+XML、纯注解的配置方式
m0_37695902的博客
11-12 227
目录 一、基于 xml 配置声明式事务 1、解决银行转账问题2、事务方法 tx:method 属性配置3、CRUD通用事务配置 二、基于 注解 配置声明式事务三、基于 纯注解(JavaConfig) 配置声明式事务四、选择开发方式 Spring系...
深入解析Spring事务管理：编程式与声明式
"本文将全面解析Spring框架中的编程式事务管理和声明式事务管理，帮助读者理解和熟练运用这两种事务管理方式。教程将从基础开始，包括事务管理的基本概念、Spring事务管理的核心机制，以及如何在实际项目中应用。" ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

辰 羽

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

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

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

打赏作者

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

抵扣说明：

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

余额充值