Spring 事务管理

最新推荐文章于 2025-08-06 14:52:08 发布
最新推荐文章于 2025-08-06 14:52:08 发布
阅读量478 收藏
点赞数
分类专栏： spring 文章标签： spring 事务
本文深入探讨了Spring框架下利用JDBC实现的编程式事务管理及声明式事务管理，包括事务的基本概念、JDBC事务管理的具体实现、Spring提供的事务管理接口及其封装、以及声明式事务管理的配置与应用。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

.3  JDBC事务管理

Spring提供编程式的事务管理（Programmatic transaction manage- ment）与声明式的事务管理（Declarative transaction management），为不同的事务实现提供了一致的编程模型，这节以JDBC事务为例，介绍Spring的事务管理。

5.3.1  Spring对事务的支持

事务是一组原子（Atomic）操作的工作单元，以数据库存取的实例来说，就是一组SQL指令，这一组SQL指令必须全部执行成功，若因为某个原因未全部执行成功（例如其中一行SQL有错误），则先前所有执行过的SQL指令都会被撤消。

举个简单的例子，一个客户从A银行转账至B银行，要作的动作为从A银行的账户扣款、在B银行的账户加上转账的金额，两个动作必须成功，如果有一个动作失败，则此次转账失败。

事务还必须保持所参与资源的一致性（Consistent），例如在银行账户的例子中，两个账户的转账金额，B账户取款的金额不能大于A账户的存款金额。每个事务彼此之间必须是隔离的（Isolated），例如在A账户中可能有两笔事务，同时进行存款与提款的动作，两个事务基本上不需意识到彼此的存在。事务还必须是可持续的（Durable），在某一笔事务之后，这笔事务必须是被记录下来的。

在这里将介绍JDBC如何使用事务管理。首先来看看事务的原子性实现，在JDBC中，可以操作 Connection的setAutoCommit() 方法，给定false参数，在下达一连串的SQL语句后，自行执行Connection的commit()来送出变更，如果中间发生错误，则执行 rollback() 来撤消所有的执行，例如：

try {

    .....

    connection.setAutoCommit(false);

    .....

    // 一连串SQL操作

    connection.commit();

} catch(SQLException) {

    // 发生错误，撤消所有变更

    connection.rollback();

}

在Spring中对JDBC的事务管理加以封装，Spring事务管理的抽象关键在于org.springframework.transaction.PlatformTransactionManager接口的实现：

...

public interface PlatformTransactionManager {

    TransactionStatus getTransaction(TransactionDefinition

                    definition)  throws TransactionException;

    void commit(TransactionStatus status)

                                   throws TransactionException;

    void rollback(TransactionStatus status)

                                   throws TransactionException;

}

PlatformTransactionManager接口有许多具体的事务实现类，例如 DataSourceTransactionManager、HibernateTransactionManager、JdoTransaction- Manager、JtaTransactionManager等，通过依赖于PlatformTransactionManager接口及各种的技术实现，Spring在事务管理上可以让开发人员使用一致的编程模型，即使所使用的是不同的事务管理技术。


5.3.2  JDBC编程事务管理

Spring提供两种方式实现编程式的事务管理，一是直接使用PlatformTransactionManager实现，二是使用org.springframework.transaction.support.TransactionTemplate。

1、先来看看如何使用PlatformTransactionManager，在这里使用它的实现类 DataSourceTransactionManager，

public class UserDAO implements IUserDAO {

    private DataSourceTransactionManager transactionManager;

    private DefaultTransactionDefinition def;

    private JdbcTemplate jdbcTemplate;

   

    public void setDataSource(DataSource dataSource) {

        jdbcTemplate = new JdbcTemplate(dataSource);

        transactionManager =

            new DataSourceTransactionManager(dataSource);

        // 建立事务的定义

        def = new DefaultTransactionDefinition();

        def.setPropagationBehavior(

                TransactionDefinition.PROPAGATION_REQUIRED);

    }

   

    public void insert(User user) {

       String name = user.getName();

       int age = user.getAge().intValue();

      

       TransactionStatus status =

           transactionManager.getTransaction(def);

       try {

           jdbcTemplate.update("INSERT INTO user (name,age) "

                   + "VALUES('" + name + "'," + age + ")");

           // 下面的SQL有错误，用以测试事务

           jdbcTemplate.update("INSER INTO user (name,age) "

                   + "VALUES('" + name + "'," + age + ")");

       }

       catch(DataAccessException e) {

           transactionManager.rollback(status);

           throw e;

       }

       transactionManager.commit(status);

    }

2、另一个实现编程式事务管理的方法是使用TransactionTemplate，它需要一个TransactionManager实例，如下所示：

...

TransactionTemplate transactionTemplate =

        new TransactionTemplate(transactionManager);

...

transactionTemplate.execute(new TransactionCallback() {

    public Object doInTransaction(TransactionStatus status) {

         return jdbcTemplate.update("INSERT INTO user (name,age) "

               + "VALUES('" + name + "'," + age + ")");

    }

});

如果发生了异常，则会进行Rollback，否则提交事务，如果没有回传值，则也可以使用TransactionCallbackWithoutResult：

...

transactionTemplate.execute(

        new TransactionCallbackWithoutResult() {

                public void doInTransactionWithoutResult(

                                TransactionStatus status) {

            .        ...

                }

            });

5.3.3  JDBC声明事务管理

Spring声明式的事务管理依赖它的AOP框架来完成。使用声明事务管理的好处是，事务管理不能侵入您所开发的组件，具体来说，DAO对象不会意识到正在事务管理之中，事实上也应当如此，因为事务管理是属于系统层面的服务，而不是业务逻辑的一部分，如果想要改变事务管理策略的话，也只需要在定义文件中重新配置。

1、一个简单的方法是使用TransactionProxyFactoryBean，指定要介入的事务管理对象及其方法。

第一种方式：每个Bean都有一个代理

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

    <bean id="sessionFactory"  
            class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">  
        <property name="configLocation" value="classpath:hibernate.cfg.xml" />  
        <property name="configurationClass" value="org.hibernate.cfg.AnnotationConfiguration" />
    </bean>  

    <!-- 定义事务管理器（声明式的事务） -->  
    <bean id="transactionManager"
        class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory" />
    </bean>
    
    <!-- 配置DAO -->
    <bean id="userDaoTarget" class="com.bluesky.spring.dao.UserDaoImpl">
        <property name="sessionFactory" ref="sessionFactory" />
    </bean>
    
    <bean id="userDao"  
        class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">  
           <!-- 配置事务管理器 -->  
           <property name="transactionManager" ref="transactionManager" />     
        <property name="target" ref="userDaoTarget" />  
         <property name="proxyInterfaces" value="com.bluesky.spring.dao.GeneratorDao" />
        <!-- 配置事务属性 -->  
        <property name="transactionAttributes">  
            <props>  
                <prop key="*">PROPAGATION_REQUIRED</prop>
            </props>  
        </property>  
    </bean>  
</beans>

    第二种方式：所有Bean共享一个代理基类

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

    <bean id="sessionFactory"  
            class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">  
        <property name="configLocation" value="classpath:hibernate.cfg.xml" />  
        <property name="configurationClass" value="org.hibernate.cfg.AnnotationConfiguration" />
    </bean>  

    <!-- 定义事务管理器（声明式的事务） -->  
    <bean id="transactionManager"
        class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory" />
    </bean>
    
    <bean id="transactionBase"  
            class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"  
            lazy-init="true" abstract="true">  
        <!-- 配置事务管理器 -->  
        <property name="transactionManager" ref="transactionManager" />  
        <!-- 配置事务属性 -->  
        <property name="transactionAttributes">  
            <props>  
                <prop key="*">PROPAGATION_REQUIRED</prop>  
            </props>  
        </property>  
    </bean>    
   
    <!-- 配置DAO -->
    <bean id="userDaoTarget" class="com.bluesky.spring.dao.UserDaoImpl">
        <property name="sessionFactory" ref="sessionFactory" />
    </bean>
    
    <bean id="userDao" parent="transactionBase" >  
        <property name="target" ref="userDaoTarget" />   
    </bean>
</beans>

2、您也可以设置不同的拦截器（TransactionInterceptor来得到更多的管理细节

第三种方式：使用拦截器

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

    <bean id="sessionFactory"  
            class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">  
        <property name="configLocation" value="classpath:hibernate.cfg.xml" />  
        <property name="configurationClass" value="org.hibernate.cfg.AnnotationConfiguration" />
    </bean>  

    <!-- 定义事务管理器（声明式的事务） -->  
    <bean id="transactionManager"
        class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory" />
    </bean> 
   
    <bean id="transactionInterceptor"  
        class="org.springframework.transaction.interceptor.TransactionInterceptor">  
        <property name="transactionManager" ref="transactionManager" />  
        <!-- 配置事务属性 -->  
        <property name="transactionAttributes">  
            <props>  
                <prop key="*">PROPAGATION_REQUIRED</prop>  
            </props>  
        </property>  
    </bean>
      
    <bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">  
        <property name="beanNames">  
            <list>  
                <value>*Dao</value>
            </list>  
        </property>  
        <property name="interceptorNames">  
            <list>  
                <value>transactionInterceptor</value>  
            </list>  
        </property>  
    </bean>  
  
    <!-- 配置DAO -->
    <bean id="userDao" class="com.bluesky.spring.dao.UserDaoImpl">
        <property name="sessionFactory" ref="sessionFactory" />
    </bean>
</beans>

3、

第四种方式：使用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:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context-2.5.xsd
           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
           http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">

    <context:annotation-config />
    <context:component-scan base-package="com.bluesky" />

    <bean id="sessionFactory"  
            class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">  
        <property name="configLocation" value="classpath:hibernate.cfg.xml" />  
        <property name="configurationClass" value="org.hibernate.cfg.AnnotationConfiguration" />
    </bean>  

    <!-- 定义事务管理器（声明式的事务） -->  
    <bean id="transactionManager"
        class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory" />
    </bean>

    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="*" propagation="REQUIRED" />
        </tx:attributes>
    </tx:advice>
    
    <aop:config>
        <aop:pointcut id="interceptorPointCuts"
            expression="execution(* com.bluesky.spring.dao.*.*(..))" />
        <aop:advisor advice-ref="txAdvice"
            pointcut-ref="interceptorPointCuts" />        
    </aop:config>      
</beans>

第五种方式：全注解

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

    <context:annotation-config />
    <context:component-scan base-package="com.bluesky" />

    <tx:annotation-driven transaction-manager="transactionManager"/>

    <bean id="sessionFactory"  
            class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">  
        <property name="configLocation" value="classpath:hibernate.cfg.xml" />  
        <property name="configurationClass" value="org.hibernate.cfg.AnnotationConfiguration" />
    </bean>  

    <!-- 定义事务管理器（声明式的事务） -->  
    <bean id="transactionManager"
        class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory" />
    </bean>
    
</beans>

此时在DAO上需加上@Transactional注解，如下：

package com.bluesky.spring.dao;

import java.util.List;

import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
import org.springframework.stereotype.Component;

import com.bluesky.spring.domain.User;

@Transactional
@Component("userDao")
public class UserDaoImpl extends HibernateDaoSupport implements UserDao {

    public List<User> listUsers() {
        return this.getSession().createQuery("from User").list();
    }
    
    
}





分析Spring事务管理原理及应用
张彦峰的博客
04-10 5万+
通过配置已经大体知道了spring事务管理实现的原理就是AOP，不难推测，spring会提供实现事务管理相关功能的切面，切点和通知相关的类，来完成对于事务相关功能的支持。我们以配置最简单的注解式配置为例，分析其实现方式。
万字长文深入理解Spring事务管理：配置、实现与最佳实践
学而时习之，不亦说乎？温故而知新，可以为师矣！
08-08 9946
Spring事务管理是企业级应用开发中的关键技术之一，确保数据一致性和完整性。本文将全面介绍Spring事务管理的基本概念、配置方式、实现原理及常见应用。通过详细的示例代码和源码解析，读者将深入理解Spring事务管理的工作机制，掌握如何在实际项目中配置和优化事务管理，实现高效可靠的事务处理。
Spring事务管理详解
java123456111的博客
05-24 1万+
什么是事务 事务是逻辑上的一组操作，要么都执行，要么都不执行。 需要注意的是：事务能否生效数据库引擎是否支持事务是关键。比如常用的 MySQL 数据库默认使用支持事务的 innodb引擎。但是，如果把数据库引擎变为 myisam，那么程序也就不再支持事务了！ 事务的特性（ACID） 原子性：一个事务（transaction）中的所有操作，或者全部完成，或者全部不完成，不会结束在中间某个环节。事务在执行过程中发生错误，会被回滚（Rollback）到事务开始前的状态，就像这个事务从来没有执行过一样。即，事务
Spring 事务管理详解：机制与实现
lssffy的博客
10-04 1848
事务（Transaction）是指一个操作序列，必须被作为一个单元来执行，即该操作序列中的所有操作要么全部执行成功，要么全部回滚。事务的主要特性被称为ACID原子性（Atomicity）：事务中的所有操作要么全部完成，要么全部取消。一致性（Consistency）：事务完成时，数据库从一个一致状态转换到另一个一致状态。隔离性（Isolation）：不同事务之间相互独立，互不干扰。持久性（Durability）：事务完成后，数据的变更是永久性的。
Spring 事务管理简介
qq_65249767的博客
05-04 3041
Spring 事务管理简介
Spring事务管理全面分析
知性人 -- 的博客
06-12 3388
  本次小编将分享 Spring 简单而强大的事务管理功能，包括编程式事务和声明式事务。希望通过对本章的学习，您将能够理解 Spring 事务管理的本质，并灵活运用之。 前提条件 本文章需要您已经掌握了 Java 基础知识，并对 Spring 有一定了解。您还需要具备基本的事务管理的知识，比如：事务的定义，隔离级别的概念，等等。本文将直接使用这些概念而不做详细解释。另外，您最好掌握数据库的基础知识...
Spring事务管理
热门推荐
楠黎倾风的博客
12-14 2万+
Spring事务管理
Spring 事务管理方案和事务管理器及事务控制的API
qq_53317005的博客
06-11 3340
Spring依赖事务管理器进行事务管理，事务管理器即一个通知类，我们为该通知类设置切点为service层方法即可完成事务自动管理。由于不同技术操作数据库，进行事务操作的方法不同。如：JDBC提交事务是 connection.commit() ，MyBatis提交事务是 sqlSession.commit() ，所以Spring提供了多个事务管理器。事务管理器名称作用针对JDBC技术提供的事务管理器。适用于JDBC和MyBatis。针对于Hibernate框架提供的事务管理器。
Spring事务管理机制
yf的博客
10-24 2961
Spring事务管理高层抽象主要包括3个接口，Spring的事务主要是由他们共同完成的： PlatformTransactionManager：事务管理器—主要用于平台相关事务的管理 TransactionDefinition：  事务定义信息(隔离、传播、超时、只读)—通过配置如何进行事务管理。 TransactionStatus：事务具体运行状态—事务管理过程中，每个时间点事务的状态信息...
Spring事务管理的实现原理
weixin_44815852的博客
02-20 4537
Spring事务管理的实现原理 文章目录Spring事务管理的实现原理背景正文第一轮学习总体分析 背景 首先，说明一下，这里指的Spring事务管理指的是spring-tx包下，仅考虑非分布式事务管理的部分。我还没学过分布式事务管理，就是一个比较有耐心肯看源码的小白罢了。 我们使用SSM框架编写自己的项目的时候，对事务管理的处理往往都停留在配置这一层，完全不去考虑它是如何实现的。现在，有了些经验之后，我就想着应该有能力去研究它的实现原理了，事务管理对数据库连接的操作的思想绝对是值得学习的。 还有一点就是，这
spring事务管理
10-27
### Spring事务管理详解 #### 一、Spring事务管理概述 Spring框架提供了强大的事务管理功能，使得开发者能够更方便地管理应用程序中的事务。Spring事务管理主要包括两种类型：编程式事务管理和声明式事务管理。 -...
Spring事务管理Demo
05-01
Spring事务管理的目的是确保数据的一致性和完整性，尤其是在多操作、多资源的环境中。本Demo将深入探讨Spring如何实现事务的管理。 首先，Spring提供了两种主要的事务管理方式：编程式事务管理和声明式事务管理。 ...
Spring事务管理-积分功能实现
03-23
基于tx命名空间的声明式事务管理案例
Spring事务管理开发必备jar包
03-07
本资源包提供了进行Spring事务管理开发所需的所有关键库，包括框架基础、核心组件、AOP（面向切面编程）支持、日志处理、编译工具以及与数据库交互的相关jar包。下面将对这些知识点进行详细解释： 1. **Spring框架*...
MCP协议与Spring AI框架实战
最新发布
沙门空海
08-06 631
摘要 MCP协议（Model Context Protocol）是Anthropic公司推出的标准化AI交互接口协议，旨在解决大模型与外部工具、数据源之间的交互问题。该协议采用客户端-服务器架构，支持STDIO、SSE和Streamable HTTP三种通信模式，核心要素包括Prompts、Resources和Tools，具有统一接口、动态加载和安全访问等优势。 Spring AI是Spring社区推出的Java AI应用框架，简化了AI技术集成。其特点包括：1) 统一API支持多种AI模型；2) 模块化设
【Spring AI快速上手 (三)】Tool实现业务系统对接
2302_79380280的博客
08-05 980
本文介绍了基于SpringAI框架在Java生态中开发智能应用的实践方法，通过@Tool注解和ToolDefinition可以灵活定义AI可调用的工具方法，同时利用@PreAuthorize实现方法级权限控制。该方案为Java开发者提供了完整的AI功能集成参考。
SpringAOP中@annotation与execution的深度对比
bemyrunningdog
08-05 631
Spring AOP中@annotation与execution切点表达式对比： @annotation基于方法注解匹配，适合定制化功能（如权限校验），需显式标记但灵活性高；execution通过方法签名（包/类/方法名）批量拦截，适合全局处理（如性能监控），无侵入但依赖代码结构。 选择原则：需精细控制选@annotation，需批量覆盖选execution，二者可组合使用。核心差异在于匹配维度（注解标记vs方法结构）和代码侵入性。
基于springboot的宠物领养系统的设计与实现(源码+论文+PPT答辩+开题报告)
bronze_s的博客
08-05 784
本文介绍了基于Spring Boot的宠物领养系统开发环境与设计。系统采用Java语言、MySQL数据库和MyEclipse开发工具，利用Spring Boot框架简化开发流程。功能设计分为管理员和用户两大模块：管理员负责用户信息、领养认领、教学视频、感谢信及公告管理；用户可申请领养/认领宠物、查看申请状态、发布感谢信等。数据库采用E-R图设计，包含宠物领养、认领、审核等核心表，通过主外键关联实现数据完整性。系统架构合理，功能完善，能满足宠物领养管理的基本需求。
35.【.NET8 实战--孢子记账--从单体到微服务--转向微服务】--数据缓存
喵叔
08-03 932
摘要 本文探讨了缓存技术在Web应用中的优化作用，重点介绍了孢子记账项目的缓存实现方案。文章首先阐述了传统后端查询模式的局限性，提出了引入缓存的必要性。随后详细讲解了三种缓存类型（内存缓存、磁盘缓存、分布式缓存）及其适用场景，并分析了六种典型的缓存使用场景。针对缓存使用中的常见问题（雪崩/穿透/击穿）给出了解决方案。在技术选型方面，文章对比了五种.NET缓存组件，最终选择Redis作为孢子记账项目的缓存方案。最后以用户配置为例，展示具体的业务代码调用方式。文章为开发者提供了从理论到实践的完整缓存优化指南，特
Spring事务管理配置方式演示
标题所揭示的知识点是Spring事务管理的配置方式。Spring作为Java领域一个极为重要的框架，其事务管理是企业级开发中不可或缺的一部分。事务管理是保证数据库操作的原子性、一致性、隔离性和持久性的关键技术。在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值