spring事务管理

最新推荐文章于 2022-06-29 21:47:23 发布
最新推荐文章于 2022-06-29 21:47:23 发布
阅读量90 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40699540/article/details/109482102
版权

Spring 事务管理

1.事务问题

什么是事务:

事务逻辑上的一组操作,组成这组操作的各个逻辑单元,要么一起成功,要么一起失败.

事务特性（4种）:

原子性 （atomicity）:强调事务的不可分割.
一致性 （consistency）:事务的执行的前后数据的完整性保持一致.
隔离性 （isolation）:一个事务执行的过程中,不应该受到其他事务的干扰
持久性（durability） :事务一旦结束,数据就持久到数据库

如果不考虑隔离性引发安全性问题:

脏读 :一个事务读到了另一个事务的未提交的数据
不可重复读 :一个事务读到了另一个事务已经提交的 update 的数据导致多次查询结果不一致.
脏读：所谓的脏读，其实就是读到了别的事务回滚前的脏数据。比如事务B执行过程中修改了数据X，在未提交前，事务A读取了X，而事务B却回滚了，这样事务A就形成了脏读。

也就是说，当前事务读到的数据是别的事务想要修改成为的但是没有修改成功的数据。

不可重复读：事务A首先读取了一条数据，然后执行逻辑的时候，事务B将这条数据改变了，然后事务A再次读取的时候，发现数据不匹配了，就是所谓的不可重复读了。

也就是说，当前事务先进行了一次数据读取，然后再次读取到的数据是别的事务修改成功的数据，导致两次读取到的数据不匹配，也就照应了不可重复读的语义。

幻读：事务A首先根据条件索引得到N条数据，然后事务B改变了这N条数据之外的M条或者增添了M条符合事务A搜索条件的数据，导致事务A再次搜索发现有N+M条数据了，就产生了幻读。

解决读问题: 设置事务隔离级别（5种）

DEFAULT 这是一个PlatfromTransactionManager默认的隔离级别，使用数据库默认的事务隔离级别.
未提交读（read uncommited） :脏读，不可重复读，虚读都有可能发生
已提交读 （read commited）:避免脏读。但是不可重复读和虚读有可能发生
可重复读 （repeatable read） :避免脏读和不可重复读.但是虚读有可能发生.
串行化的 （serializable） :避免以上所有读问题.

read uncommited：是最低的事务隔离级别，它允许另外一个事务可以看到这个事务未提交的数据。
read commited：保证一个事物提交后才能被另外一个事务读取。另外一个事务不能读取该事物未提交的数据。
repeatable read：这种事务隔离级别可以防止脏读，不可重复读。但是可能会出现幻象读。它除了保证一个事务不能被另外一个事务读取未提交的数据之外还避免了以下情况产生（不可重复读）。
serializable：这是花费最高代价但最可靠的事务隔离级别。事务被处理为顺序执行。除了防止脏读，不可重复读之外，还避免了幻象读（避免三种）。

PROPAGION_XXX :事务的传播行为

  • 保证同一个事务中
    PROPAGATION_REQUIRED 支持当前事务，如果不存在 就新建一个(默认)
    PROPAGATION_SUPPORTS 支持当前事务，如果不存在，就不使用事务
    PROPAGATION_MANDATORY 支持当前事务，如果不存在，抛出异常
  • 保证没有在同一个事务中
    PROPAGATION_REQUIRES_NEW 如果有事务存在，挂起当前事务，创建一个新的事务
    PROPAGATION_NOT_SUPPORTED 以非事务方式运行，如果有事务存在，挂起当前事务
    PROPAGATION_NEVER 以非事务方式运行，如果有事务存在，抛出异常
    PROPAGATION_NESTED 如果当前事务存在，则嵌套事务执行

1.导入JAR包

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

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

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.6</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.7</version>
        </dependency>

        <!--数据库连接 -->
        <dependency>
            <groupId>commons-dbutils</groupId>
            <artifactId>commons-dbutils</artifactId>
            <version>1.4</version>
        </dependency>

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

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

    </dependencies>

2.Dao层

2.1接口层
public interface AccountDao {

    /**
     * 加钱方法
     * @param id
     * @param money
     */
    void increaseMoney(Integer id , Double money);

    /**
     * 减钱方法
     * @param id
     * @param money
     */
    void decreaseMoney(Integer id , Double money);
}
2.2实现层
@Component("accountDao")
public class AccountDaoImpl implements AccountDao {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    public void increaseMoney(Integer id, Double money) {
        jdbcTemplate.update("update ar_account set money = money + ? where id = ?",money,id);
    }

    public void decreaseMoney(Integer id, Double money) {
        jdbcTemplate.update("update ar_account set money = money - ? where id = ?",money,id);
    }
}

3.Service层

3.1 service接口层

public interface AccountService {
	//转账的方法
    void Transfer(Integer from,Integer to ,Double money);
}
3.2 service实现层
@Service
public class AccountServiceImpl implements AccountService {

    @Autowired
    private AccountDao accountDao;

    public void Transfer(final Integer from, final Integer to,final Double money) {
                accountDao.decreaseMoney(from,money);
                int i =1/0;
                accountDao.increaseMoney(to,money);
    }
}

4.配置xml

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

   <context:component-scan base-package="com.qf"></context:component-scan>

    <!-- 配置数据源 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <!--连接数据库的必备信息-->
        <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/test"></property>
        <property name="user" value="root"></property>
        <property name="password" value="59852369"></property>
    </bean>
    <bean id="jdbcTemplate"  class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"/>
    </bean>
    </beans>

5.调用

@RunWith(SpringJUnit4ClassRunner.class)
//指定创建容器时使用哪个配置文件
@ContextConfiguration("classpath:applicationContext.xml")
public class TestJdbc02 {

    @Autowired
    private AccountService accountService;

    @Test
    public void test(){
        accountService.Transfer(3,2,1000.0);
    }
}

2.使用AOP配置事务的方式

2.1 更改xml配置，配置事务，开启AOP的注解模式
  <!-- 平台事务管理器 -->
 <bean id="transactionManager" 		class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
2.2配置通知类
@Component
@Aspect
public class MyAdvice {

    @Autowired
    private DataSourceTransactionManager transactional;

    @Pointcut("execution( * com.qf.service.*.*.*(..))")
    public void pt1(){

    }

    @Around("pt1()")
    public Object around(ProceedingJoinPoint point) throws Throwable {
        DefaultTransactionDefinition def = new DefaultTransactionDefinition();
        def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
        TransactionStatus status = transactional.getTransaction(def);
        Object proceed=null;
        try {
            System.out.println("这是环绕通知之前的部分");
            proceed = point.proceed();
            System.out.println("这是环绕通知之后的部分");
            transactional.commit(status);
        }catch (Exception e){
            transactional.rollback(status);
            System.out.println(e.getMessage());
            System.out.println("这是环绕通知异常的部分");
        }finally {
            System.out.println("这是最终通知");
        }
        return proceed;
    }
}

3.使用TransactionTemplate配置事务的方式

3.1 增加xml配置
<bean id="template" class="org.springframework.transaction.support.TransactionTemplate">
        <property name="transactionManager" ref="transactionManager" />
  </bean>
     <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <!-- 传播行为 -->
            <!-- REQUIRED：如果有事务，则在事务中执行；如果没有事务，则开启一个新的事物
            <!—->l          <!—->DEFAULT 使用数据库设置的隔离级别 ( 默认 ) ，由 DBA 默认的设置来决定隔离级别 .

<!—->l          <!—->READ_UNCOMMITTED 会出现脏读、不可重复读、幻读 ( 隔离级别最低，并发性能高 )

<!—->l          <!—->READ_COMMITTED  会出现不可重复读、幻读问题（锁定正在读取的行）

<!—->l          <!—->REPEATABLE_READ 会出幻读（锁定所读取的所有行）

<!—->l          <!—->SERIALIZABLE 保证所有的情况不会发生（锁表）
                    mysql的默认隔离界别 Repeatable Read :可重复读(会出现幻读) 
            -->
            <tx:method name="save*" propagation="REQUIRED" />
            <tx:method name="insert*" propagation="REQUIRED" />
            <tx:method name="add*" propagation="REQUIRED" />
            <tx:method name="create*" propagation="REQUIRED" />
            <tx:method name="delete*" propagation="REQUIRED" />
            <tx:method name="update*" propagation="REQUIRED" />
            <tx:method name="transfer" propagation="REQUIRED" />
            <!-- SUPPORTS：如果有事务，则在事务中执行；如果没有事务，则不会开启事物 -->
            <tx:method name="find*" propagation="SUPPORTS" read-only="true" />
            <tx:method name="select*" propagation="SUPPORTS" read-only="true" />
            <tx:method name="get*" propagation="SUPPORTS" read-only="true" />
        </tx:attributes>
    </tx:advice>

    <aop:config>
        <aop:pointcut id="txPointCut" expression="execution(* com.qf.service.*.*(..))" />
        <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/>
    </aop:config>
3.2修改service转账方法
    //将事务管理类注入到service中
    @Autowired
    private TransactionTemplate template;

    public void Transfer(final Integer from, final Integer to,final Double money) {
    template.execute(new TransactionCallbackWithoutResult() {
            @Override
            protected void doInTransactionWithoutResult(TransactionStatus transactionStatus) {
                accountDao.decreaseMoney(from,money);
                int i =1/0;
                accountDao.increaseMoney(to,money);
            }
        });

    }

4.使用注解配置事务方式

4.1修改xml

需要在Spring的配置中通过一行配置’通知’Spring容器对标注@Transactional注解的Bean进行加工处理!

在默认情况, <tx:annotation-driven /> 中transaction-manager属性会自动使用名为 “transactionManager” 的事务管理器.所以,如果用户将事务管理器的id定义为 transactionManager , 则可以进一步将①处的配置简化为 <tx:annotation-driven />.

使用以上测试用例即可

    <!--开启spring对注解AOP的支持-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
     <!--①配置注解事务开启 对标注@Transactional注解的Bean进行加工处理,以织入事物管理切面 -->
      <tx:annotation-driven transaction-manager="transactionManager" />
4.2修改service代码，配置事务管理

因为注解本身具有一组默认的事务属性,所以往往只要在需要事务的业务类中添加一个@Transactional注解,就完成了业务类事务属性的配置!

@Service
@Transactional
public class AccountServiceImpl implements AccountService {

    @Autowired
    private AccountDao accountDao;

    public void Transfer(final Integer from, final Integer to,final Double money) {
                accountDao.decreaseMoney(from,money);
                int i =1/0;
                accountDao.increaseMoney(to,money);
    }
}
4.3在何处标注@Transactional注解

@Transactional注解可以直接用于接口定义和接口方法,类定义和类的public方法上.

但Spring建议在业务实现类上使用@Transactional注解,当然也可以添加到业务接口上,但是这样会留下一些容易被忽视的隐患,因为注解不能被继承,所以业务接口中标注的@Transactional注解不会被业务类实现继承.

方法出添加注解会覆盖类定义处的注解,如果有写方法需要使用特殊的事务属性,则可以在类注解的基础上提供方法注解,如下:

@Transactional
@Service("accountService")
public class AccountServiceImpl implements AccountService {
    @Autowired
    private AccountDao accountDao;

    //不等于默认值!可以覆盖类注解
    @Transactional(readOnly = false , isolation = Isolation.READ_COMMITTED)
    public void transfer(final Integer from, final  Integer to, final  Double money) {

         accountDao.decreaseMoney(from,money);

        // int i = 1/0;

         accountDao.increaseMoney(to,money);

    }
}
只写有用的blog
关注
Spring_事物的写法
09-12
Spring_事物的写法
Spring事务
zxc_jkl的博客
05-25 127
原文：https://blog.csdn.net/weixin_38070406/article/details/78157603 Spring事务： 事务逻辑上的一组操作,组成这组操作的各个逻辑单元,要么一起成功,要么一起失败. 事务特性（4种）: 原子性 （atomicity）:强调事务的不可分割. 一致性 （consistency）:事务的执行的前后数据的完整性保持一致. 隔离性 （iso...
Spring事务编写
ruan_z_x的专栏
09-27 577
提到事务大家可能都比较熟悉了，日常项目中也会经常的用到。在Spring相关的应用中，调用Spring集成的接口，就可以完成事务程序的编写。虽然编写过一些事务应用，但对Spring事务的结构，JDBC以及数据库层面的支撑有些生疏，抽时间整理了一下。          持久层支持          业务事务的实现最终还是需要依赖数据库对事务的支撑。事务具有四大特性:原子性、一致性、隔离性、持久性（
手写spring事务
zhangsuhua0702的博客
09-04 1533
1. 背景： 在spingboot框架搭建的项目中，利用了反射机制调用了service中的方法，导致spring注入的对象全部为null值不可使用，同时spring框架提供的@Transactional注解也失效。为了解决事务回滚失效的问题 ，利用放射类动态代理 以及手写事务的方式来解决反射引起的以上问题。 2.transactionalUtils.java类的编写 import org....
Spring事务管理Demo
05-01
Spring事务管理的目的是确保数据的一致性和完整性，尤其是在多操作、多资源的环境中。本Demo将深入探讨Spring如何实现事务的管理。 首先，Spring提供了两种主要的事务管理方式：编程式事务管理和声明式事务管理。 ...
Spring事务管理开发必备jar包
03-07
本资源包提供了进行Spring事务管理开发所需的所有关键库，包括框架基础、核心组件、AOP（面向切面编程）支持、日志处理、编译工具以及与数据库交互的相关jar包。下面将对这些知识点进行详细解释： 1. **Spring框架*...
Spring事务管理
09-24
Spring事务管理是Java开发中一个至关重要的概念，特别是在企业级应用开发中，它确保了数据的一致性和完整性。Spring框架提供了强大的事务管理机制，能够帮助开发者处理事务的开始、提交、回滚以及隔离级别等事务特性...
java 事务怎么写_Spring声明式事务@Transactional知识点分享
weixin_39673704的博客
02-16 444
@Transactional注解支持9个属性的设置，这里只讲解其中使用较多的三个属性：readOnly、propagation、isolation。其中propagation属性用来枚举事务的传播行为，isolation用来设置事务隔离级别，readOnly进行读写事务控制。@Service@Transactional(readOnly = true)public class AppTradeRe...
spring 事务管理实现
qq_20417529的博客
03-03 77
一、启用事务管理 使用@EnableTransactionManagement注解启用spring事务管理，注入一些必要的配置 /** * {@code @Configuration} class that registers the Spring infrastructure beans * necessary to enable proxy-based annotation-driven transaction management. * * @author Chris Beams *
Spring总结—事务
sx17860543449的博客
03-23 1404
Spring总结—事务 事务操作（Spring事务管理介绍） 事务添加到JavaEE三层结构里面 service层（业务逻辑层）web层（业务） dao层 在spring进行事务管理操作 有两种方式 ：编程式事务管理和声明式事务管理（使用） （一般不会使用编程式，会使代码臃肿） 声明式事务管理 基于注解方式（使用） 基于xml配置文件方式 在spring 进行声明式事务管理，底层使用AOP spring事务管理API 提供了一个接口，代表事务管理器，这个接口针对不同的框架提供不同的实现类，Platfor
Spring的事务操作
weixin_44473463的博客
08-24 189
事务概念简述 事务是数据库操作最基本单元，逻辑上一组操作，要么都成功，如果有一个失败所有操作都失败 事务四个特性（ACID） 原子性 一致性 隔离性 持久性 Spring事务管理介绍 1、事务添加到 JavaEE 三层结构里面 Service 层（业务逻辑层） 2、在 Spring 进行事务管理操作 （1）有两种方式：编程式事务管理(手动开启事务提交和回滚)和声明式事务管理 3、声明式事务管理 （1）基于注解方式（使用） （2）基于 xml 配置文件方式 4、在 Spring 进行声明式事务管理，底层使
Spring事务的实现方式
qq_44266569的博客
10-17 352
什么是事务？ 说到事务，一般指的都是数据库中的事务。 是数据库操作的最小工作单元，是作为单个逻辑工作单元执行的一系列操作。 这些操作作为一个整体一起向系统提交，要么都执行、要么都不执行。 事务是一组不可再分割的操作集合（工作逻辑单元）。 数据具有以下特性（ACID） 原子性（Atomicity） 事务包含的所有操作要么全部成功，要么全部失败回滚，因此事务的操作如果成功就必须要完全应用到数据库，如果操作失败则不能对数据库有任何影响。 一致性（Consistency） 事务必须使数据库从一个一致性状态变换
事务以及Spring中的事务管理一
记忆碎片
04-19 426
首先讲一下事务的概念， 事务就是一系列的动作,它们被当做一个单独的工作单元.这些动作要么全部完成,要么全部不起作用 事务的四个关键属性(ACID) –原子性(atomicity):事务是一个原子操作,由一系列动作组成.事务的原子性确保动作要么全部完成要么完全不起作用. –一致性(consistency):一旦所有事务动作完成,事务就被提交.数据和资源就处于一种满足业务规则的一致
Spring的事务
热门推荐
weixin_44895829的博客
03-14 1万+
1.什么是事务 事务是数据库操作最基本单元，逻辑上一组操作，要么都成功，如果有一个失败所有操 作都失败 （2）典型场景：银行转账 lucy 转账 100 元 给 mary lucy 少 100，mary 多 100 事务四个特性（ACID） （1）原子性 一个事务是一个不可分割的工作单位，事务中包括的诸操作要么都做，要么都不做 （2）一致性 事务必须是使数据库从一个一致性状态变到另一个一致性状态。一致性与原子性是密切相关的。 （3）隔离性 一个事务的执行不能被其他事务干扰...
Spring的事务详解
h295928126的博客
06-29 4万+
Spring的事务详解
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值