[SSM] spring事务

最新推荐文章于 2022-03-20 00:13:06 发布

qianye_97

最新推荐文章于 2022-03-20 00:13:06 发布

阅读量173

点赞数

分类专栏： spring 文章标签： spring

本文链接：https://blog.csdn.net/qq_37574623/article/details/109839791

版权

spring 专栏收录该内容

14 篇文章 0 订阅

订阅专栏

Spring中的事务管理

Spring在不同的事务管理API之上定义了一个抽象层，使得开发人员不必了解底层的事务管理API就可以使用Spring的事务管理机制。Spring支持编程式事务管理和声明式的事务管理。

编程式事务管理

将事务管理代码嵌到业务方法中来控制事务的提交和回滚
缺点：必须在每个事务操作业务逻辑中包含额外的事务管理代码

声明式事务管理

一般情况下比编程式事务好用。
将事务管理代码从业务方法中分离出来，以声明的方式来实现事务管理。
将事务管理作为横切关注点，通过aop方法模块化。Spring中通过Spring AOP框架支持声明式事务管理。

事务管理器

无论使用Spring的哪种事务管理策略（编程式或者声明式）事务管理器都是必须的。
就是 Spring的核心事务管理抽象，管理封装了一组独立于技术的方法。

Public interface PlatformTransactionManager()...{  
    // 由TransactionDefinition得到TransactionStatus对象
    TransactionStatus getTransaction(TransactionDefinition definition) throws TransactionException; 
    // 提交
    Void commit(TransactionStatus status) throws TransactionException;  
    // 回滚
    Void rollback(TransactionStatus status) throws TransactionException;  
    }

JDBC事务

<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
       <property name="dataSource" ref="dataSource" />
</bean>

Hibernate事务

<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
    <property name="sessionFactory" ref="sessionFactory" />
</bean>

Java持久化API事务（JPA）

<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
    <property name="sessionFactory" ref="sessionFactory" />
</bean>

spring事务传播特性：

事务传播行为就是多个事务方法相互调用时，事务如何在这些方法间传播。spring支持7种事务传播行为：

propagation_requierd：如果当前没有事务，就新建一个事务，如果已存在一个事务中，加入到这个事务中，这是最常见的选择，也是Spring的默认选择。
propagation_supports：支持当前事务，如果没有当前事务，就以非事务方法执行。
propagation_mandatory：使用当前事务，如果没有当前事务，就抛出异常。
propagation_required_new：新建事务，如果当前存在事务，把当前事务挂起。
propagation_not_supported：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
propagation_never：以非事务方式执行操作，如果当前事务存在则抛出异常。
propagation_nested：如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与propagation_required类似的操作

编程式事务

1、使用PlatformTransactionManager

//定义一个某个框架平台的TransactionManager，如JDBC、Hibernate
DataSourceTransactionManager dataSourceTransactionManager = new DataSourceTransactionManager(); 
// 设置数据源
dataSourceTransactionManager.setDataSource(this.getJdbcTemplate().getDataSource()); 
// 定义事务属性
DefaultTransactionDefinition transDef = new DefaultTransactionDefinition(); 
// 设置传播行为属性
transDef.setPropagationBehavior(DefaultTransactionDefinition.PROPAGATION_REQUIRED); 
// 获得事务状态
TransactionStatus status = dataSourceTransactionManager.getTransaction(transDef); 
try {
    /*
    ***此处写数据库操作***
    */
    dataSourceTransactionManager.commit(status);// 提交
} catch (Exception e) {
    dataSourceTransactionManager.rollback(status);// 回滚
}

2、使用TransactionTemplate

采用TransactionTemplate和采用其他Spring模板，如JdbcTempalte和HibernateTemplate是一样的方法。它使用回调方法，把应用程序从处理取得和释放资源中解脱出来。如同其他模板，TransactionTemplate是线程安全的。使用TransactionCallback()可以返回一个值。如果使用TransactionCallbackWithoutResult则没有返回值。

TransactionTemplate tt = new TransactionTemplate(); // 新建一个TransactionTemplate
// 执行execute方法进行事务管理
Object result = tt.execute(
    new TransactionCallback(){  
        public Object doTransaction(TransactionStatus status){  
            /*
			    ***此处写数据库操作并返回一个值，例如：***
			    Object result=update();  
            	return result;  
			*/
        }  
});

声明式事务

1、使用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.dbf" />

    <!-- 定义事务管理器（声明式的事务） --> 
    <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织入事务-->
	<aop:config>
		<!--横切到dao包下面的全部文件-->
	   <aop:pointcut id="txPointcut" expression="execution(* com.dbf.dao.*.*(..))"/>
	   <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointcut"/>
	</aop:config>
</beans>

2、全注解

<?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="transactionManager"
        class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory" />
    </bean>

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

上面两种方法配置完了之后，要在DAO上或者某些函数上加上@Transactional注解，如下：

@Transactional(propagation=Propagation.REQUIRES_NEW,
            isolation=Isolation.READ_COMMITTED,
            noRollbackFor={UserAccountException.class},
            readOnly=true, timeout=3)
@Component("userDao")
public class UserDaoImpl  implements UserDao {

    public User getUser() {
        return ***;
    }  
}

全注解声明式事务的执行流程

⾸先对于使⽤了@Transactional注解的Bean，Spring会创建⼀个代理对象作为Bean
当调⽤代理对象的⽅法时，会先判断该⽅法上是否加了@Transactional注解
如果加了，那么则利⽤事务管理器创建⼀个数据库连接
并且修改数据库连接的autocommit属性为false，禁⽌此连接的⾃动提交，这是实现Spring事务⾮常重
要的⼀步
然后执⾏当前⽅法，⽅法中会执⾏sql
执⾏完当前⽅法后，如果没有出现异常就直接提交事务
如果出现了异常，并且这个异常是需要回滚的就会回滚事务，否则仍然提交事务
Spring事务的隔离级别对应的就是数据库的隔离级别
Spring事务的传播机制是Spring事务⾃⼰实现的，也是Spring事务中最复杂的
Spring事务的传播机制是基于数据库连接来做的，⼀个数据库连接⼀个事务，如果传播机制配置为需要新开⼀个事务，那么实际上就是先建⽴⼀个数据库连接，在此新数据库连接上执⾏sql

什么时候@Transactional失效

发生自调用，类里面使用this来调用本类的方法，这个时候并不是代理类调用的，也就是AOP压根没起作用。
@Transactional只能用于public的方法上，因为你的方法本身是提供给外部调用的
数据库不支持事务
没有被spring管理，即没有成功进入bean容器
异常被吃掉了，并没有抛出来，导致事务没有出错也就没有回滚

在同一个service中使用传播行为

通过this调用同一个service中的方法，this是指service实现类对象本身，不是代理对象，就相当于方法中的代码粘到了大方法里面，相当于还是一个方法。

只需要把this.方法名()替换成this代理对象.方法名()即可。

问题是怎么在service中获取当前类的代理对象？

在类中获取代理对象分三个步骤：

导入aop的场景依赖：spring-boot-starter-aop
开启AspectJ的自动代理，同时要暴露代理对象：@EnableAspectJAutoProxy(exposeProxy=true)
获取代理对象：SpuInfoService proxy = (SpuInfoService) AopContext.currentProxy();

qianye_97

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
[SSM] spring事务

1、事务概念事务在项目开发过程非常重要，涉及到数据的一致性的问题，不容马虎！事务管理是企业级应用程序开发中必备技术，用来确保数据的完整性和一致性。事务就是把一系列的动作当成一个独立的工作单元，这些动作要么全部完成，要么全部不起作用。四个属性ACID原子性（atomicity）事务是原子性操作，由一系列动作组成，事务的原子性确保动作要么全部完成，要么完全不起作用一致性（consistency）一旦所有事务动作完成，事务就要被提交。数据和资源处于一种满足业务规则的一致性状态中
复制链接

扫一扫