事务的简介与基本应用

最新推荐文章于 2023-12-13 17:39:54 发布
最新推荐文章于 2023-12-13 17:39:54 发布
阅读量132 收藏
点赞数
文章标签： 数据库 mybatis mysql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SW_qxwh/article/details/129092989
版权

事务的简介

        Spring事务的本质其实就是数据库对事务的支持，使用JDBC的事务管理机制,就是利用java.sql.Connection对象完成对事务的提交

  定义： 事物就是数据库执行过程中的一个逻辑单位，由一个有限的数据库操作序列构成。
  本质： 由一个或多个sql语句组成。这些sql语句在执行过程中被当作一个整体，要么全部的sql语句执行成功，要么全部失败。不存在一部分执行成功，一部分执行失败。

事务的四大特性

1. 原子性（Atomicity）
  原子性是将事物进行的操作捆绑成一个不可分割的单元，事物中进行的数据操作要么全部成功，要么全部失败。

2. 一致性（Consistency）
  一致性是指事物使数据库从一个一致性状态转换到另一个一致性状态。也就是数据库前后必须处于一致性状态。

3. 独立性（Isolation）
  多个用户并发访问数据库，数据库为每个用户开启一个事物，每个事物相互独立，互不干扰。
  事务的隔离性主要规定了各个事务之间相互影响的程度。隔离性概念主要面向对数据资源的并发访问(Concurrency)，并兼顾影响事务的一致性。

4. 持久性(Durability)
  持久性是指一个事务一旦被提交了，那么对数据库中的数据的改变就是永久性的，即便是在数据库系统遇到故障的情况下也不会丢失提交事务的操作。
 

事务的隔离级别

多个线程开启各自事务操作数据库中数据时，数据库系统要负责隔离操作，以保证各个线程在获取数据时的准确性，在数据库内部定义了四种隔离级别，用于解决三种隔离问题

事务的隔离级别按照从弱到强分别为“Read Uncommitted (未提交读)”，“Read Committed（提交读）”，“Repeatable Read（可重复读）”和“Serializable（序列化）”。三种问题  脏读  不可重复读 虚度（幻读）

1.Serializable 可避免脏读，不可重复读，虚度（幻读）等情况

2.Repeatable Read 可避免脏读、不可重复读情况的发生。（可重复读）不可以避免虚读（幻读）

3.Read committed：可避免脏读情况发生

4.Read Uncommitted 最低级别，以上问题均无法保证

设置隔离级别的设置

在mysql中设置

        查看当前隔离级别： select @@tx_isolation

        设置隔离级别： set session transaction isolation level

注：mysql中默认的事务隔离级别是 Repeatable read.

        oracle 中默认的事务隔离级别是 Read committed

在jdbc中设置        

        Controller接口定义事务隔离级别的四个常量：

                static int TRANSACTION_READ_COMMITTED

                指示不可以发生脏读的常量；不可重复读和虚读可以发生。

                static int TRANSACTION_READ_UNCOMMITTED

                指示可以发生脏读 (dirty read)、不可重复读和虚读 (phantom read) 的常量。

                static int TRANSACTION_REPEATABLE_READ

                指示不可以发生脏读和不可重复读的常量；虚读可以发生。

                static int TRANSACTION_SERIALIZABLE

                指示不可以发生脏读、不可重复读和虚读的常量。

通过 void setTransactionIsolation(int level) 设置数据库隔离级别

        安全性：serializable > repeatable read > read committed > read uncommitted

        性能：serializable < repeatable read < read committed < read uncommitted

结论： 实际开发中，通常不会选择 serializable 和 read uncommitted ，

mysql默认隔离级别 repeatable read ，oracle默认隔离级别 read committed

Spring中事务的传播行为

        Spring在TransactionDefinition接口中规定了7种类型的事务传播行为。事务传播行为是Spring框架独有的事务增强特性，他不属于的事务实际提供方数据库行为。这是Spring为我们提供的强大的工具箱，使用事务传播行可以为我们的开发工作提供许多便利

        Spring事务针对的是代理对象，如果调用同一个类中直接调用方法，事务不生效（可以自己注入自己调用）

        事务传播行为用来描述由某一个事务传播行为修饰的方法被嵌套进另一个方法的时事务如何传播

第一种：PROPAGATION_REQUIRED: 支持当前事务，如果不存在 就新建一个

  • A,B 如果A有事务，B使用A的事务，如果A没有事务，B就开启一个新的事务.(A,B是在一个事务中。)

第二种：PROPAGATION_SUPPORTS: 支持当前事务，如果不存在，就不使用事务

  • A,B 如果A有事务，B使用A的事务，如果A没有事务，B就不使用事务.

第三种：PROPAGATION_MANDATORY: 支持当前事务，如果不存在，抛出异常

  • A,B 如果A有事务，B使用A的事务，如果A没有事务，抛出异常.

第四种：PROPAGATION_REQUIRES_NEW: 如果有事务存在，挂起当前事务，创建一个新的事务

  • A,B 如果A有事务，B将A的事务挂起，重新创建一个新的事务.(A,B不在一个事务中.事务互不影响.)

第五种：PROPAGATION_NOT_SUPPORTED: 以非事务方式运行，如果有事务存在，挂起当前事务

  • A,B 非事务的方式运行，A有事务，就会挂起当前的事务.

第六种：PROPAGATION_NEVER: 以非事务方式运行，如果有事务存在，抛出异常

第七种：PROPAGATION_NESTED: 如果当前事务存在，则嵌套事务执行

  • 基于SavePoint技术.

  • A,B   A有事务，A执行之后，将A事务执行之后的内容保存到SavePoint.B事务有异常的话，用户需要自己设置事务提交还是回滚.

常用:(重点)

        PROPAGATION_REQUIRED

        PROPAGATION_REQUIRES_NEW

        PROPAGATION_NESTED

  

Spring配置XML方式进行事务管理（简单小案例）

支持声明式事务管理: 不需要手动编写代码，只需要配置即可

1.创建表

CREATE TABLE `t_account` (
    `id` int(11) NOT NULL AUTO_INCREMENT,
    `name` varchar(20) NOT NULL,
    `money` double DEFAULT NULL,
    PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;

INSERT INTO `t_account` VALUES ('1', 'aaa', '1000');
INSERT INTO `t_account` VALUES ('2', 'bbb', '1000');

2.导入依赖

<dependencies>
    <!-- spring -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.20</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>5.3.20</version>
    </dependency>

    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.9.9.1</version>
    </dependency>
    <!-- tx 事务 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-tx</artifactId>
        <version>5.3.20</version>
    </dependency>

    <!-- mybatis -->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.9</version>
    </dependency>

    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis-spring</artifactId>
        <version>2.0.7</version>
    </dependency>

    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.29</version>
    </dependency>

    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>1.2.9</version>
    </dependency>

    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.17</version>
    </dependency>

    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.13.2</version>
        <scope>test</scope>
    </dependency>

</dependencies>

3.创建AccountController

package com.LSZ.controller;

import com.LSZ.service.AccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

@Controller
public class AccountController {

    @Autowired
    private AccountService accountService;

    /**
     * 转账：accountId1 给 accountId2 转 money
     */
    public void transfer(Integer fromAccountId,Integer toAccountId,Double money){
        accountService.transfer(fromAccountId,toAccountId,money);
    }
}

4.创建AccountService

package com.LSZ.service;

public interface AccountService {
    
    //转账
    void transfer(Integer fromAccountId, Integer toAccountId, Double money);
    
}

5.创建AccountServiceImpl

package com.LSZ.service.impl;

import com.LSZ.mapper.AccountMapper;
import com.LSZ.service.AccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class AccountServiceImpl implements AccountService {

    @Autowired
    private AccountMapper accountMapper;

    /**
     * 转账
     * @param fromAccountId
     * @param toAccountId
     * @param money
     */
    @Override
    public void transfer(Integer fromAccountId, Integer toAccountId, Double money) {

        //从账户转出
        accountMapper.decreaseMoney(fromAccountId,money);

        //手动模拟异常
        //int i = 1/0;

        //转入账户
        accountMapper.increaseMoney(toAccountId,money);
    }
}

6.创建AccountMapper

package com.LSZ.mapper;

import org.apache.ibatis.annotations.Param;
import org.springframework.stereotype.Repository;

@Repository
public interface AccountMapper {
    /**
     * 转出
     *
     * @param fromAccountId
     * @param money
     */
    void decreaseMoney(@Param("fromAccountId") Integer fromAccountId, @Param("money") Double money);

    /**
     * 转入
     *
     * @param toAccountId
     * @param money
     */
    void increaseMoney(@Param("toAccountId") Integer toAccountId, @Param("money") Double money);
}

7.创建AccountMapper.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="com.LSZ.mapper.AccountMapper">

    <!-- 转出方法 -->
    <update id="decreaseMoney">
        update t_account set money = money - #{money} where id = #{fromAccountId}
    </update>

    <!-- 转入方法 -->
    <update id="increaseMoney">
        update t_account set money = money + #{money} where id = #{toAccountId}
    </update>

</mapper>

8.创建db.properties

db.username = root
db.password = root
db.url = jdbc:mysql://localhost:3306/LSZ?serverTimezone=Asia/Shanghai&characterEncoding=UTF8
db.driver = com.mysql.cj.jdbc.Driver

9.创建log4j.properties


log4j.rootLogger=DEBUG, stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n

10.创建mybatis-config.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>

    <!-- 配置日志 -->
    <settings>
        <setting name="logImpl" value="LOG4J"/>
    </settings>

</configuration>

11.创建applicationContext.xml （ 注意导入 tx 约束 ）

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns="http://www.springframework.org/schema/beans" 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-4.2.xsd
                           http://www.springframework.org/schema/context
                           http://www.springframework.org/schema/context/spring-context-4.2.xsd
                           http://www.springframework.org/schema/aop
                           http://www.springframework.org/schema/aop/spring-aop-4.2.xsd
                           http://www.springframework.org/schema/tx
                           http://www.springframework.org/schema/tx/spring-tx-4.2.xsd ">

        <!-- 导入外部配置文件 db.properties -->
        <context:property-placeholder location="classpath:db.properties"></context:property-placeholder>

        <!-- 配置数据源对象 -->
        <bean id="datasource" class="com.alibaba.druid.pool.DruidDataSource">
            <!-- 导入 db.properties 中的值-->
            <property name="username" value="${db.username}"></property>
            <property name="password" value="${db.password}"></property>
            <property name="url" value="${db.url}"></property>
            <property name="driverClassName" value="${db.driver}"></property>
        </bean>

        <!-- 扫描对应包下的注解 -->
        <context:component-scan base-package="com.qf"></context:component-scan>

        <!-- 配置sqlSessionFactory -->
        <bean id="sqlSessionFactoryBean" class="org.mybatis.spring.SqlSessionFactoryBean">
            <!-- 必选配置 -->
            <property name="dataSource" ref="datasource"></property>
            <!-- 非必选属性，根据自己需求去配置 -->
            <!-- 导入 mybatis-config.xml -->
            <property name="configLocation" value="classpath:mybatis-config.xml"></property>
            <!-- 导入 Mapper.xml 文件，classpath后面不能有空格 -->
            <property name="mapperLocations" value="classpath:mapper/*.xml"></property>
        </bean>

        <!-- 扫描 Mapper 接口，生成代理对象 -->
        <bean id="mapperScannerConfigurer" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
            <!-- 指定扫描的具体位置 -->
            <property name="basePackage" value="com.qf.mapper"></property>
        </bean>


    <!-- 事务核心管理器,封装了所有事务操作. 依赖于连接池 -->
    <bean name="transactionManager"
          class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="datasource"></property>
    </bean>

    <!-- 配置事务通知 -->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <!-- 企业中配置CRUD方法一般使用方法名+通配符*的形式配置通知，此时类中的方法名要和配置的方法名一致 -->
            <!-- 以方法为单位,指定方法应用什么事务属性
                    isolation：用于指定事务的隔离级别。默认值是DEFAULT，表示使用数据库的默认隔离级别。
                    propagation：用于指定事务的传播行为。默认值是REQUIRED，表示一定会有事务，增删改的选择。查询方法可以选择SUPPORTS。
                    read-only：用于指定事务是否只读。只有查询方法才能设置为true。默认值是false，表示读写。
                    timeout：用于指定事务的超时时间，默认值是-1，表示永不超时。如果指定了数值，以秒为单位。
                    rollback-for：用于指定一个异常，当产生该异常时，事务回滚，产生其他异常时，事务不回滚。没有默认值。表示任何异常都回滚。
                    no-rollback-for：用于指定一个异常，当产生该异常时，事务不回滚，产生其他异常时事务回滚。没有默认值。表示任何异常都回滚。
                 -->
            <tx:method name="save*" isolation="REPEATABLE_READ"
                       propagation="REQUIRED" read-only="false" />
            <tx:method name="add*" isolation="REPEATABLE_READ"
                       propagation="REQUIRED" read-only="false" />
            <tx:method name="update*" isolation="REPEATABLE_READ"
                       propagation="REQUIRED" read-only="false" />
            <tx:method name="modify*" isolation="REPEATABLE_READ"
                       propagation="REQUIRED" read-only="false" />
            <tx:method name="delete*" isolation="REPEATABLE_READ"
                       propagation="REQUIRED" read-only="false" />
            <tx:method name="remove*" isolation="REPEATABLE_READ"
                       propagation="REQUIRED" read-only="false" />
            <tx:method name="get*" isolation="REPEATABLE_READ"
                       propagation="REQUIRED" read-only="true" />
            <tx:method name="find*" isolation="REPEATABLE_READ"
                       propagation="REQUIRED" read-only="true" />
            
            <tx:method name="transfer" isolation="REPEATABLE_READ"
                       propagation="REQUIRED" read-only="false" />
        </tx:attributes>
    </tx:advice>

    <!-- 配置织入 -->
    <aop:config>
        <!-- 配置切点表达式 -->
        <aop:pointcut expression="execution(* com.qf.service.impl.*ServiceImpl.*(..))" id="txPc" />
        <!-- 配置切面 : 通知+切点 advice-ref:通知的名称 pointcut-ref:切点的名称 -->
        <aop:advisor advice-ref="txAdvice" pointcut-ref="txPc" />
    </aop:config>

</beans>

12.测试文件

package com.LSZ.test;

import com.qf.controller.AccountController;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringTest {

    @Test
    public void test_transfer(){

        ClassPathXmlApplicationContext applicationContext =
                new ClassPathXmlApplicationContext("applicationContext.xml");

        AccountController accountController =
                (AccountController)applicationContext.getBean("accountController");

        accountController.transfer(1,2,100d);

    }
}

Spring的注解方式进行事务管理

1.创建bean.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:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       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
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd"> <!-- bean definitions here -->


        <!-- 导入外部配置文件 db.properties -->
        <context:property-placeholder location="classpath:db.properties"></context:property-placeholder>

        <!-- 配置数据源对象 -->
        <bean id="datasource" class="com.alibaba.druid.pool.DruidDataSource">
            <!-- 导入 db.properties 中的值-->
            <property name="username" value="${db.username}"></property>
            <property name="password" value="${db.password}"></property>
            <property name="url" value="${db.url}"></property>
            <property name="driverClassName" value="${db.driver}"></property>
        </bean>

        <!-- 扫描对应包下的注解 -->
        <context:component-scan base-package="com.LSZ"></context:component-scan>

        <!-- 配置sqlSessionFactory -->
        <bean id="sqlSessionFactoryBean" class="org.mybatis.spring.SqlSessionFactoryBean">
            <!-- 必选配置 -->
            <property name="dataSource" ref="datasource"></property>
            <!-- 非必选属性，根据自己需求去配置 -->
            <!-- 导入 mybatis-config.xml -->
            <property name="configLocation" value="classpath:mybatis-config.xml"></property>
            <!-- 导入 Mapper.xml 文件，classpath后面不能有空格 -->
            <property name="mapperLocations" value="classpath:mapper/*.xml"></property>

        </bean>

        <!-- 扫描 Mapper 接口，生成代理对象 -->
        <bean id="mapperScannerConfigurer" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
            <!-- 指定扫描的具体位置 -->
            <property name="basePackage" value="com.LSZ.mapper"></property>
        </bean>


        <!-- 配置事务 -->
        <!-- 事务平台管理器，封装了所有的事务操作，依赖数据源 -->
        <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
            <property name="dataSource" ref="datasource"></property>
        </bean>

        <!-- 开启注解驱动事务支持 -->
        <tx:annotation-driven></tx:annotation-driven>

</beans>

2.创建AccountServiceImpl

package com.LSZ.service.impl;

import com.LSZ.mapper.AccountMapper;
import com.LSZ.service.AccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

/**
 * @Transactional 配置事务
 * 可以写在类上，也可以写在方法上
 */
//@Transactional(isolation = Isolation.REPEATABLE_READ,propagation = Propagation.REQUIRED,readOnly = false)
@Service
public class AccountServiceImpl implements AccountService {

    @Autowired
    private AccountMapper accountMapper;

    /**
     * 转账
     * @param fromAccountId
     * @param toAccountId
     * @param money
     */
    @Transactional(isolation = Isolation.REPEATABLE_READ,propagation = Propagation.REQUIRED,readOnly = false)
    @Override
    public void transfer(Integer fromAccountId, Integer toAccountId, Double money) {

        //从账户转出
        accountMapper.decreaseMoney(fromAccountId,money);

        //手动模拟异常
        int i = 1/0;

        //转入账户
        accountMapper.increaseMoney(toAccountId,money);
    }
}

3.测试文件

package com.LSZ.test;

import com.LSZ.controller.AccountController;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringTest {


    /**
     * xml测试事务
     */
    @Test
    public void test_transfer(){

        ClassPathXmlApplicationContext applicationContext =
                new ClassPathXmlApplicationContext("applicationContext.xml");

        AccountController accountController =
                (AccountController)applicationContext.getBean("accountController");

        accountController.transfer(1,2,100d);

    }

    /**
     * 注解测试事务
     */
    @Test
    public void test_transfer_annotation_driven(){

        ClassPathXmlApplicationContext applicationContext =
                new ClassPathXmlApplicationContext("bean.xml");

        AccountController accountController =
                (AccountController)applicationContext.getBean("accountController");

        accountController.transfer(1,2,100d);

    }
}

SW_浅笑无痕
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
springboot controller 使用事务
AmbroseLe
04-12 1473
//添加事务第一步 引入platformTransactionManager对象 @Autowired private PlatformTransactionManager platformTransactionManager; /** * 删除信息 */ @DeleteMapping("/{blKeys}") public AjaxResult remove(@PathVariable String[] blKeys) { ...
数据的事务操作及应用场景
xukaiqiang123的博客
10-15 2643
事务是⼀个原⼦操作。是⼀个⼩执⾏单元。可以由⼀个或多个SQL语句组成，在 同⼀个事务当中，所有的SQL语句都成功执⾏时，整 个事务成功，有⼀个SQL语 句执⾏失败，整个事务都执⾏失败。 在某些场景下，一次完整的业务逻辑可能需要多次对数据库数据进行操作，而这些操作中可能在某一环节出错从而导致整个业务出错，这时候就要及时补救，回退到业务的最初。 使用事务的例子 #A 账户转账给 B 账户 1000 元。 #A 账户减1000 元 UPDATE account SET MONEY = MONEY-1000
事务 --- 一般用在哪里
weixin_30916125的博客
07-24 812
例如： 一般是在操作数据库中执行删除操作的时候，尤其是多表删除；比如删除一条记录，但是这条记录分别记录在好几张表中，那么删除的时候就要用事物了，以防出现只删除了一两张表的数据，而其他表的数据没有删除干净；这样在数据查询的时候就容易出现问题；所以经常在删除操作中用事物提交 spring 的事务是通过 声明式事务 的方式对事务进行管理，即在配置文件中进行声明，通过 aop 切面切...
MySQL高级篇——事务的概述与简单应用
★★光亭★★
04-21 6283
MySQL高级篇——事务的概述与简单应用
springboot中的controller层增加事务控制
weixin_42740540的博客
11-27 6423
大多数编程者习惯会在service层加事务控制，当一个controller层调用了多个service的update或者insert方法时，第一个成功了，第二个失败了。那么就会有第一个的事务会回退吗的困惑。其实通过在方法上@Transactional注解就可以控制。但在controller中不要使用try catch被捕捉了就不会回退事务。反正自己动手试试就知道。 controller //可行 @PostMapping("/updateCustTel") @Transactional
sql事务应用积累
10-30
在SQL编程中，事务是数据库操作的基本单位，用于确保一组操作要么全部成功，要么全部失败。这遵循了ACID（原子性、一致性、隔离性和持久性）原则，保证了数据库的稳定性和可靠性。本篇文章将深入探讨SQL事务的应用...
MySQL事务处理与应用简析
01-19
事务处理在各种管理系统中都有着广泛的应用，比如人员管理系统，很多同步数据库操作大都需要用到事务处理。比如说，在人员管理系统中，你删除一个人员，你即需要删除人员的基本资料，也要删除和该人员相关的信息，如...
深入理解Java事务的原理与应用
09-02
首先，我们需要了解事务的基本概念。在数据库管理系统中，事务是一个逻辑工作单元，包含一系列的操作，这些操作必须作为一个整体执行，要么全部成功，要么全部回滚。ACID属性是事务的核心原则，包括原子性...
事务处理概念与技术
07-22
资源名称：事务处理 概念与技术内容简介： 列举了大量成功的商业和研究系统的实例，此外，列出了许多事务处理算法的可编译的C代码片段。本书对于那些对实现分布式系统或客户-服务器结构感兴趣的人来说，是值得一读...
Neo4j系列-简介及应用场景
01-27
【Neo4j简介】 Neo4j是一个高性能的NoSQL图形数据库，它的核心特色在于使用图形数据结构来存储和管理数据。不同于传统的表格形式，Neo4j将数据组织为节点（Nodes）和关系（Relationships），这使得数据之间的关联性...
Springboot中controller使用事务
zhoubing12的博客
08-26 847
如果在Controller里处理事务，最好采用第三种方法使用事物管理类，这种方法好处在于：1》出现异常可以回滚（不出现异常时提交事务）；描述：在springboot的Controller中使用事务。（数据库 表user的 user_name长度为10）使用事务管理类 正常退出 异常会回滚。程序正常退出，增加回滚语句，执行回滚。不处理异常 异常退出 异常会回滚。处理异常 正常退出 异常不回滚。程序异常退出，异常会执行回滚。程序正常退出，异常不执行回滚。程序异常退出，不执行回滚。不使用事务 异常退出。
controller层使用@Transactional事务注解
miracleldf的博客
03-23 2582
controller层使用@Transactional事务注解
控制层Controller使用@Transactional开启事务是否生效问题
最新发布
weixin_43866228的博客
12-13 2322
使用@Transactional注解开启事务是否只能写在Service层？？
看到一遍文章说controller可以加事务，特别测试了下，发现不行
weixin_34296641的博客
07-13 169
文章内容https://blog.csdn.net/mmm333zzz/article/details/45288061附上测试代码@Controller @Transactional public class DemoController2 { @Autowired private CustomerDao customerDao; @R...
Spring事务在controller层中没用的原因以及解决方法
weixin_51929597的博客
11-15 1306
spring事务在controller中没用的原因以及如何解决
controller层到底能不能用@Transactional注解？
打怪升级
08-02 8965
@Transactional使用注意事项
SSM中 实现在Controller中添加事务管理
van的博客
09-19 9295
本人使用： 集成开发环境：idea 项目管理工具：maven 数据库：oracle 框架：Spring+SpringMVC+myBatis 一般而言，事务都是加在Service层的，但也可以加在Controller层。。                         看了不少人的博客，总结出两个方法： 在controller层写编程式事务 将事务配置定义在Spring MVC的应用...
事务使用场景详解
弹指天下
03-11 6738
事务在开发过程大家应该都经常使用，但是事务具体有哪些使用场景？什么时候需要使用事务，什么时候不需要添加事务呢？一个都是查询操作的方法是否需要添加事务？只有一个查询操作需要是否需要添加事务？
Seata分布式事务详解与应用场景
分布式事务是数据库管理中的一项关键技术，它涉及到一次复杂操作如何在多个分布式系统中的协调与一致性保证。在分布式环境中，数据可能存储在不同的服务器上，每个服务器负责一部分业务逻辑。为了确保数据的一致性，...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值