Spring - Spring事务控制详解与案例总结

于 2022-04-26 21:26:25 发布
阅读量290 收藏
点赞数 1
分类专栏： 笔记 成长阶段 文章标签： java spring java-ee
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39123467/article/details/124437587
版权

文章目录

Spring的事务控制

编程式事务控制相关对象

PlatformTransactionManager

就是一个接口

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Kn2aorFd-1650979333138)(spring.assets/image-20220426160508206.png)]

TransactionDefinition

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-K7ORNYeJ-1650979333140)(spring.assets/image-20220426160827936.png)]

事务隔离级别

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eV2DO8nh-1650979333140)(spring.assets/image-20220426163804750.png)]

事务传播行为

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TzxEKjSu-1650979333141)(spring.assets/image-20220426164042649.png)]

TransactionStatus

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-chc4EL9r-1650979333142)(spring.assets/image-20220426164712770.png)]

基于XML的声明式事务控制

什么是声明式事务控制

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cQCylPJd-1650979333142)(spring.assets/image-20220426165401112.png)]

转账业务环境搭建

新建项目、导入相关依赖

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.5.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.4</version>
        </dependency>

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

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>5.0.5.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.0.5.RELEASE</version>
        </dependency>

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

        <dependency>
            <groupId>c3p0</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.1.2</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

编写Dao层

package com.taotao.dao;

import org.springframework.jdbc.core.JdbcTemplate;

/**
 * create by 刘鸿涛
 * 2022/4/26 17:29
 */
@SuppressWarnings({"all"})
public interface AccountDao {
    void setJdbcTemplate(JdbcTemplate jdbcTemplate);
    
    void out(String outMan,double money);
    
    void in(String inMan,double money);
}


package com.taotao.dao.impl;

import com.taotao.dao.AccountDao;
import org.springframework.jdbc.core.JdbcTemplate;

/**
 * create by 刘鸿涛
 * 2022/4/26 17:28
 */
@SuppressWarnings({"all"})
public class AccountDaoImpl implements AccountDao {

    private JdbcTemplate jdbcTemplate;
    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    public void out(String outMan, double money) {
        jdbcTemplate.update("update account set money = money-? where name=?",money,outMan);
    }

    public void in(String inMan, double money) {
        jdbcTemplate.update("update account set money=money+? where name=?",money,inMan);
    }
}

实体类

package com.taotao.domain;

/**
 * create by 刘鸿涛
 * 2022/4/26 17:34
 */
@SuppressWarnings({"all"})
public class Account {
    private String name;
    private double money;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }

    @Override
    public String toString() {
        return "Account{" +
                "name='" + name + '\'' +
                ", money=" + money +
                '}';
    }
}

service层

package com.taotao.service;

import com.taotao.dao.AccountDao;

/**
 * create by 刘鸿涛
 * 2022/4/26 17:37
 */
@SuppressWarnings({"all"})
public interface AccountService {
    void setAccountDao(AccountDao accountDao);

    void transfer(String outMan,String inMan,double money);
}


package com.taotao.service.impl;

import com.taotao.dao.AccountDao;
import com.taotao.service.AccountService;

/**
 * create by 刘鸿涛
 * 2022/4/26 17:36
 */
@SuppressWarnings({"all"})
public class AccountServiceImpl implements AccountService {
    private AccountDao accountDao;

    public void setAccountDao(AccountDao accountDao) {
        this.accountDao = accountDao;
    }

    public void transfer(String outMan, String inMan, double money) {
        accountDao.out(outMan,money);
        accountDao.in(inMan,money);
    }
}

操作类

package com.taotao.controller;

import com.taotao.service.AccountService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * create by 刘鸿涛
 * 2022/4/26 17:53
 */
@SuppressWarnings({"all"})
public class AccountController {
    public static void main(String[] args) {
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        AccountService accountService = app.getBean(AccountService.class);
        accountService.transfer("ano","lucy",500);
    }
}

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

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

    <!--    数据源对象-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driver}"/>
        <property name="jdbcUrl" value="${jdbc.url}"/>
        <property name="user" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>

    </bean>
    <!--    jdbc模板对象-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"/>
    </bean>
    
    <bean id="accountDao" class="com.taotao.dao.impl.AccountDaoImpl">
        <property name="jdbcTemplate" ref="jdbcTemplate"/>
    </bean>
    
    <bean id="accountService" class="com.taotao.service.impl.AccountServiceImpl">
        <property name="accountDao" ref="accountDao"/>
    </bean>
</beans>
jdbc.properties
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/Test
jdbc.username=root
jdbc.password=12345

测试转账成功

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SOnLAyJd-1650979333143)(spring.assets/image-20220426182923333.png)]

声明式事务控制的表现

当数据异常时，终止提交事务

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dCqRUAn9-1650979333144)(spring.assets/image-20220426182322592.png)]

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

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

    <!--    数据源对象-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driver}"/>
        <property name="jdbcUrl" value="${jdbc.url}"/>
        <property name="user" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>

    </bean>
    <!--    jdbc模板对象-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <bean id="accountDao" class="com.taotao.dao.impl.AccountDaoImpl">
        <property name="jdbcTemplate" ref="jdbcTemplate"/>
    </bean>

    <!--    目标对象 内部的方法时切点-->
    <bean id="accountService" class="com.taotao.service.impl.AccountServiceImpl">
        <property name="accountDao" ref="accountDao"/>
    </bean>

    <!--    配置平台事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!--    通知 事务的增强-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="*"/>
        </tx:attributes>
    </tx:advice>

    <!--    配置事务的aop织入-->
    <aop:config>
        <aop:advisor advice-ref="txAdvice" pointcut="execution(* com.taotao.service.impl.*.*(..))"></aop:advisor>
    </aop:config>

</beans>

在业务成加个异常切入点

当异常时，不提交数据

package com.taotao.service.impl;

import com.taotao.dao.AccountDao;
import com.taotao.service.AccountService;

/**
 * create by 刘鸿涛
 * 2022/4/26 17:36
 */
@SuppressWarnings({"all"})
public class AccountServiceImpl implements AccountService {
    private AccountDao accountDao;

    public void setAccountDao(AccountDao accountDao) {
        this.accountDao = accountDao;
    }

    public void transfer(String outMan, String inMan, double money) {
        accountDao.out(outMan,money);
        int i = 1 / 0;
        accountDao.in(inMan,money);
    }
}

成功测试

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-47eT0LMc-1650979333144)(spring.assets/image-20220426194311024.png)]

运行

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TbPtjcj4-1650979333145)(spring.assets/image-20220426194424275.png)]

不会滚事务的情况

注销语句
    <!--    配置事务的aop织入-->
<!--    <aop:config>-->
<!--        <aop:advisor advice-ref="txAdvice" pointcut="execution(* com.taotao.service.impl.*.*(..))"></aop:advisor>-->
<!--    </aop:config>-->
测试运行

钱少了500

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KOuxghBJ-1650979333145)(spring.assets/image-20220426194650096.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6cfr7X43-1650979333146)(spring.assets/image-20220426194638473.png)]

切点方法的事务参数的配置

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Kw1mbSLE-1650979333146)(spring.assets/image-20220426203918903.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HXZuxM1h-1650979333147)(spring.assets/image-20220426204127352.png)]

基于注解的声明式事务控制

复制项目

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UpgFDvaP-1650979333147)(spring.assets/image-20220426205907333.png)]

注解修改dao层

package com.taotao.dao.impl;

import com.taotao.dao.AccountDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

/**
 * create by 刘鸿涛
 * 2022/4/26 17:28
 */
@SuppressWarnings({"all"})
@Repository("accountDao")
public class AccountDaoImpl implements AccountDao {

    @Autowired
    private JdbcTemplate jdbcTemplate;
    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    public void out(String outMan, double money) {
        jdbcTemplate.update("update account set money = money-? where name=?",money,outMan);
    }

    public void in(String inMan, double money) {
        jdbcTemplate.update("update account set money=money+? where name=?",money,inMan);
    }
}

注解修改service层

package com.taotao.service.impl;

import com.taotao.dao.AccountDao;
import com.taotao.service.AccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * create by 刘鸿涛
 * 2022/4/26 17:36
 */
@SuppressWarnings({"all"})
@Service("accountService")
public class AccountServiceImpl implements AccountService {
    private AccountDao accountDao;

    @Autowired
    public void setAccountDao(AccountDao accountDao) {
        this.accountDao = accountDao;
    }

    public void transfer(String outMan, String inMan, double money) {
        accountDao.out(outMan,money);
        int i = 1 / 0;
        accountDao.in(inMan,money);
    }
}

Spring.xml组件扫描

注意context命名空间配置

<!--    组件扫描-->
    <context:component-scan base-package="com.taotao"/>
我们删除一些配置，使用注解完成

下面的都删除

    <!--    通知 事务的增强-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="*"/>
        </tx:attributes>
    </tx:advice>

<!--        配置事务的aop织入-->
    <aop:config>
        <aop:advisor advice-ref="txAdvice" pointcut="execution(* com.taotao.service.impl.*.*(..))"></aop:advisor>
    </aop:config>
我们service层加注解（方式1）
package com.taotao.service.impl;

import com.taotao.dao.AccountDao;
import com.taotao.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;

/**
 * create by 刘鸿涛
 * 2022/4/26 17:36
 */
@SuppressWarnings({"all"})
@Service("accountService")
public class AccountServiceImpl implements AccountService {
    private AccountDao accountDao;

    @Autowired
    public void setAccountDao(AccountDao accountDao) {
        this.accountDao = accountDao;
    }

    @Transactional(isolation = Isolation.READ_COMMITTED,propagation = Propagation.REQUIRED)
    public void transfer(String outMan, String inMan, double money) {
        accountDao.out(outMan,money);
//        int i = 1 / 0;
        accountDao.in(inMan,money);
    }

    @Transactional(isolation = Isolation.DEFAULT)
    public void xxx(){
        
    }
}
我们service层加注解（方式2）
package com.taotao.service.impl;

import com.taotao.dao.AccountDao;
import com.taotao.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;

/**
 * create by 刘鸿涛
 * 2022/4/26 17:36
 */
@SuppressWarnings({"all"})
@Service("accountService")
@Transactional(isolation = Isolation.REPEATABLE_READ)
public class AccountServiceImpl implements AccountService {
    private AccountDao accountDao;

    @Autowired
    public void setAccountDao(AccountDao accountDao) {
        this.accountDao = accountDao;
    }

    public void transfer(String outMan, String inMan, double money) {
        accountDao.out(outMan,money);
//        int i = 1 / 0;
        accountDao.in(inMan,money);
    }

    public void xxx(){

    }
}
我们service层加注解（方式3）

就近原则

package com.taotao.service.impl;

import com.taotao.dao.AccountDao;
import com.taotao.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;

/**
 * create by 刘鸿涛
 * 2022/4/26 17:36
 */
@SuppressWarnings({"all"})
@Service("accountService")
@Transactional(isolation = Isolation.REPEATABLE_READ)
public class AccountServiceImpl implements AccountService {
    private AccountDao accountDao;

    @Autowired
    public void setAccountDao(AccountDao accountDao) {
        this.accountDao = accountDao;
    }

    @Transactional(isolation = Isolation.REPEATABLE_READ,propagation = Propagation.REQUIRED)
    public void transfer(String outMan, String inMan, double money) {
        accountDao.out(outMan,money);
//        int i = 1 / 0;
        accountDao.in(inMan,money);
    }

    public void xxx(){

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

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

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

    <!--    数据源对象-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driver}"/>
        <property name="jdbcUrl" value="${jdbc.url}"/>
        <property name="user" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>

    </bean>
    <!--    jdbc模板对象-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <bean id="accountDao" class="com.taotao.dao.impl.AccountDaoImpl">
        <property name="jdbcTemplate" ref="jdbcTemplate"/>
    </bean>

    <!--    目标对象 内部的方法时切点-->
    <bean id="accountService" class="com.taotao.service.impl.AccountServiceImpl">
        <property name="accountDao" ref="accountDao"/>
    </bean>

    <!--    配置平台事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>

<!--    事务的注解驱动-->
    <tx:annotation-driven transaction-manager="transactionManager"/>

</beans>

成功测试

转账成功

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PgeYjJlo-1650979333148)(spring.assets/image-20220426211808295.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PdRfVYt4-1650979333148)(spring.assets/image-20220426211911870.png)]

转账失败

事务中断，不提交

        accountDao.out(outMan,money);
        int i = 1 / 0;
        accountDao.in(inMan,money);

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yE0xH4hX-1650979333148)(spring.assets/image-20220426212046025.png)]

鬼鬼骑士
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
spring-事务案例
abordo的博客
10-14 807
spring-事务案例1.spring事务管理API2.使用spring的事务注解管理事务3.使用Aspectj的AOP配置管理事务 购买商品trans_sale项目 本例要实现购买商品，模拟用户下订单，向订单表添加销售记录，从商品表减少库存。 1.spring事务管理API 1.创建数据库表 创建两个数据库表sale，goods sale 销售表 2.maven依赖 pom.xml 3.创建实体类 4.定义dao接口 5.定义dao接口对应的sql映射文件 6.定义异常类 7.定义Service接口 8
Spring编程式事务管理的例子
fightee的博客
04-30 378
基于底层API的编程式事务管理 涉及到的接口对应的类型： PlatformTransactionManager 事务管理器 TransactionDefinition 事务基础信息 TransactionStatus 事务状态信息 @Service public class OrderServiceImpl implements OrderService { //Autowired自动注...
Spring 事务简单完整例子
06-04
完整的例子,成功运行. 配好mysql数据库后,可以直接main方法测试事务.
Spring事务管理详解+案例
SpringWaterLikeMe
03-11 629
Spring事务管理详解Spring事务事务简介事务原则Java事务Java事务类型事务类型差异Spring事务核心接口 ![在这里插入图片描述](https://img-blog.csdnimg.cn/20200311210812187.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0...
spring处理事务实例
qq_36976201的博客
10-18 483
创建数据库表创建实体类创建接口创建异常类创建servicespring配置文件测试结果 购买商品项目，模拟用户下订单，向订单表添加销售记录，从商品表减少库存 创建数据库表 sale销售表 goods商品表 添加商品数据 创建实体类 分别创建Goods和Sale的实体类，代码略 创建接口 SaleDao public interface SaleDao { //增加销售记录 @Insert("insert into sale(gid,num) values(#{gid},#{num}).
10-Spring-事务管理1
08-04
6. **Spring事务回滚机制** 默认情况下，Spring通过捕获并处理运行时异常（尤其是`RuntimeException`的子类）来决定是否回滚事务。如果抛出了受检查的异常（`Exception`的非运行时子类），事务通常不会自动回滚，...
spring-dubbo整合案例.rar
10-21
《Spring与Dubbo整合实战详解》 在现代企业级应用开发中，Spring框架因其强大的功能和灵活的扩展性，已经成为Java领域内的主流选择。而Dubbo作为阿里巴巴开源的一款高性能、轻量级的服务治理框架，旨在提高服务的可...
spring-and-spring-boot：Spring和Spring Boot课程的实验室解决方案
01-30
《Spring与Spring Boot实战：实验室解决方案深度解析》 在IT领域，Spring框架和Spring Boot是Java开发中的两大重要工具，广泛应用于企业级应用的构建。本篇将详细探讨这两个技术的核心概念、工作原理以及如何在实际...
Spring中的事务传播行为示例详解
08-25
Spring中的事务传播行为示例详解 Spring 框架中事务传播行为是指在多个方法之间的调用关系中，如何处理事务的传播和rollback的机制。事务传播行为是 Spring 框架提供的一种事务管理方式，用于控制事务的传播范围和...
spring-boot-demo.zip
07-30
《Spring Boot Demo实战详解》 在当今的Java开发领域，Spring Boot已经成为构建高效、简洁的Web应用的首选框架。本文将深入探讨一个名为"spring-boot-demo"的项目案例，这是一份已经搭建好的基于Maven的Spring Boot...
spring学习笔记(十五)-编程式事务例子
05-24
NULL 博文链接：https://vzhchv0010.iteye.com/blog/356137
事务控制案例
凉茶铺的博客
02-25 369
本博文使用一个简单案例展示了如何通过spring操作事务
spring事务管理实例
北眼的博客
05-18 411
简介 什么是事务？ 事务是逻辑上的一组操作，要么都执行，要么都不执行. 事物的特性（ACID）： 原子性： 事务是最小的执行单位，不允许分割。事务的原子性确保动作要么全部完成，要么完全不起作用； 一致性： 执行事务前后，数据保持一致； 隔离性： 并发访问数据库时，一个用户的事物不被其他事物所干扰，各并发事务之间数据库是独立的； 持久性: 一个事务被提交之后。它对数据库中数据的改变是持...
实验四 Spring事务管理（案例）
qq_35965559的博客
03-30 1275
目录 实验目的： 实验内容： 实验任务1：创建项目，引入架包 实验任务2：创建一个数据库spring04并创建一个数据表 实验任务3：配置spring框架配置文件 实验任务4：创建UserDao类，并编写添加操作 实验任务5：创建UserService业务逻辑实现添加数据操作 实验任务6：创建test测试类并运行 实验目的： 熟悉Spring事务管理的3个核心接口 了解Spring事务管理的两种方式 掌握基于xml和Annotation的声明方式事务的使用 实验内容： 实验任
spring 事务讲解及案例分析
雾里华的博客
07-06 374
一、首先我们得知道什么是事务？简单的讲、事务就是一系列操作组成的工作单元，工作单元内的操作都是不可分割的。（要么都执行，要么都不执行）例子：银行转账  A账户转出100，B账户转入100  特性 ACID: 原子性，一致性，隔离性，持久性数据库隔离级别？隔离级别是指若干个并发的事务之间的隔离程度。读未提交 （脏读） insert 之后没有提交允许读取未提交数据读已提交 （不可重复读） s...
spring事务管理（有实例）
YondMing的博客
01-24 473
最近在学习spring框架，想将学习心得记录一下，每天进步一点点。 一、什么是事务（transaction）？      事务是指单个的工作单元。说到事务我们一般会联想到和数据有关，拿数据库事务来说，一个数据库事务就是一个单一的工作单元的操作序列，这些操作要么完整的执行，要么完全不执行。事务就是为了保证数据的完整性和一致性。 二、事务的ACID属性  1.原子性（Atomicity） 原
spring事务传播机制实例讲解
kingj126的专栏
09-18 900
  天温习spring的事务处理机制，总结如下   对于SQL事务的概念以及ACID性质，可以参见我的另一篇博文 http://kingj.iteye.com/admin/blogs/1675011 spring的管理的事务可以分为如下2类： 逻辑事务   在spring中定义的事务通常指逻辑事务，提供比物理事务更抽象，方便的事务配置管理，但也基于物理事务 物理事务  特定于数...
Spring事务演示案例
hq.zheng的博客
08-04 1339
一、环境搭建 1）、数据库 新建users表 2)、创建maven项目 pom需要引入的包： <!-- 引入Spring-AOP等相关Jar --> <dependency> <groupId>org.springframework</groupId> <ar...
Spring Mvc那点事---(32)Spring编程式事务的实现
游响云停专栏
07-30 1815
上一节我们介绍了spring 事务中的相关接口，这一节我们看看怎么利用接口通过编程式来使用事务控制。使用TransactionTemplate来实现编程式事务控制。使用TransactionTemplate 不需要显式地开始事务，甚至不需要显式地提交事务。这些步骤都由模板完成。但出现异常时，应通过TransactionStatus 的setRollbackOnly 显式回滚事务。
2024Spring AOP最新HM
最新发布
04-09
本文档主要探讨的是Spring AOP（面向切面编程）在2024年的最新应用，特别是在事务管理和AOP框架下的一个实际示例。首先，回顾了事务的基本概念，强调了事务是一组操作的集合，具有原子性、一致性、隔离性和持久性...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

鬼鬼骑士

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

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

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

打赏作者

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

抵扣说明：

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

余额充值