精华内容
下载资源
问答
  • 面试中,spring的事务问得比较多,特别是spring事务的传播级别和隔离级别,下面就让我们一起来复习下,首先我们要清楚事务的四大特征(ACID): 原子性(atomicity) 一致性(consistency) 隔离性(isolation) 持久...

    前言

    面试中,Spring的事务问得比较多,特别是Spring事务的传播行为和隔离级别,下面就让我们一起来复习下,首先我们要清楚事务的四大特征(ACID):

    • 原子性(atomicity)
    • 一致性(consistency)
    • 隔离性(isolation)
    • 持久性(durability)

    1、概念

    Spring有两种事务处理方式,一种是声明式事务,另外一种是编程式事务。

    • 声明式事务:底层建立在IoC和AOP的基础上,在方法的前后进行拦截,在方法执行前创建或者加入一个事务,方法执行后提交或者回滚事务。
    • 编程式事务:在方法的前后手动的开启和关闭事务,控制的粒度比声明式事务要小,可以达到代码块级别,但代码会很臃肿和复杂,项目中一般不会用。

    2、声明式事务

    在配置声明式事务管理的时候,我们用到最多的是注解方式,我们看下@Transactional这个注解的源码:

    @Target({ElementType.METHOD, ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Inherited
    @Documented
    public @interface Transactional {
    	//定义事务管理器,这里的value是IoC容器中的Bean id
        @AliasFor("transactionManager")
        String value() default "";
        @AliasFor("value")
        String transactionManager() default "";
        //传播行为
        Propagation propagation() default Propagation.REQUIRED;
        //隔离级别
        Isolation isolation() default Isolation.DEFAULT;
        //超时时间
        int timeout() default -1;
        //是否开启只读事务
        boolean readOnly() default false;
        //回滚事务的异常类定义
        Class<? extends Throwable>[] rollbackFor() default {};
        //回滚事务的异常类名称定义
        String[] rollbackForClassName() default {};
        //当产生哪些异常不回滚
        Class<? extends Throwable>[] noRollbackFor() default {};
        //当产生哪些异常不回滚类名称定义
        String[] noRollbackForClassName() default {};
    }
    

    上面的属性中,这里重点解释传播行为和隔离级别

    3、传播行为

    下面是定义传播行为Propagation枚举类的源码:

    public enum Propagation {
    	//支持当前事务(如果当前存在事务,则加入到当前事务,总共一个事务),如果不存在 就新建一个(默认)
        REQUIRED(0),
        //支持当前事务,如果不存在,就不使用事务
        SUPPORTS(1),
        //支持当前事务,如果不存在,抛出异常
        MANDATORY(2),
        //如果有事务存在,挂起当前事务,新建一个新的事务(新建的事务是独立,与当前事务无关)
        REQUIRES_NEW(3),
        //以非事务方式运行,如果有事务存在,挂起当前事务
        NOT_SUPPORTED(4),
        //以非事务方式运行,如果有事务存在,抛出异常
        NEVER(5),
        //如果当前事务存在,则嵌套事务执行,作为当前事务中的一个子事务(依赖外层的事务,外层事务失败,子事务也要回滚)
        NESTED(6);
        private final int value;
        private Propagation(int value) {
            this.value = value;
        }
        public int value() {
            return this.value;
        }
    }
    

    4、隔离级别

    先看下几个基本的概念:

    1. 脏读:一个事务读取到另一事务未提交的更新数据。
    2. 不可重复读:在同一事务中, 第一次读取和第二次读取过程中,有另外一个事务更新提交了数据,导致多次读取同一数据返回的结果不同。
    3. 幻读 : 第一个事务正在查询符合某一条件的数据,这时,另一个事务又插入了一条符合条件的数据,第一个事务在第二次查询符合同一条件的数据时,发现多了一条前一次查询时没有的数据,仿佛幻觉一样,这就是幻像读。

    【提示】:不可重复读针对的是更新和删除操作导致数据不一致,幻读针对的是插入操作导致的数据不一致。

    下面是定义隔离级别Isolation枚举类的源码:

    public enum Isolation {
    	//Spring默认的隔离级别,使用数据库默认的事务隔离级别
    	//MYSQL: 默认为REPEATABLE_READ级别
    	//SQLSERVER: 默认为READ_COMMITTED
        DEFAULT(-1),
        //读取未提交数据(会出现脏读, 不可重复读) 基本不使用
        READ_UNCOMMITTED(1),
        //读取已提交数据(会出现不可重复读和幻读)
        READ_COMMITTED(2),
        //可重复读(会出现幻读)
        REPEATABLE_READ(4),
        //串行化(防止脏读,不可重复读外,还避免了幻像读,但花费代价很大)
        SERIALIZABLE(8);
        private final int value;
        private Isolation(int value) {
            this.value = value;
        }
        public int value() {
            return this.value;
        }
    }
    

    结束语

    本文较为详细的介绍了Spring事务的相关知识点,大家可以自己在本地亲自实践下,加深自己的理解。

    展开全文
  • spring事务理解

    千次阅读 2014-03-31 21:31:18
    搜集了一些网上的介绍,这是我对spring事务理解: spring是在service中事务管理,是当他调用service中的一个方法的时候 就会开启一个事务,直到你执行完这个方法,才会commit。所以只要其中有一个方法失败都会...

    搜集了一些网上的介绍,这是我对spring事务的理解:

    spring是在service中事务管理,是当他调用service中的一个方法的时候 就会开启一个事务,直到你执行完这个方法,才会commit。所以只要其中有一个方法失败都会回滚。

    就是说配置到方法上,但管理事务在service中

    <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.*.service.*.*(..))"/>
    		<aop:advisor advice-ref="txAdvice" 
    			pointcut-ref="interceptorPointCuts"/>
    	</aop:config>
    <tx:method name="*" propagation="REQUIRED"/>这句是将所有的方法都走事务,当然也可以自己定义些,可使用通配符。

    <aop:pointcut id="interceptorPointCuts" expression="execution(* com.*.service.*.*(..))"/> 这句是将事务管理应用到service上,具体表达式根据自己建的包使用通配符来创建,最后的*.*是到某个类下的某个方法,括号是匹配任意参数。

    展开全文
  • 深入理解 Spring 事务原理

    千次阅读 2017-02-21 10:58:24
    Spring事务的本质其实就是数据库事务的支持,没有数据库的事务支持,spring是无法提供事务功能的。对于纯JDBC操作数据库,想要用到事务,可以按照以下步骤进行: 获取连接 Connection con = DriverManager.get...

    Spring事务的基本原理

    Spring事务的本质其实就是数据库对事务的支持,没有数据库的事务支持,spring是无法提供事务功能的。对于纯JDBC操作数据库,想要用到事务,可以按照以下步骤进行:

    1. 获取连接 Connection con = DriverManager.getConnection()
    2. 开启事务con.setAutoCommit(true/false);
    3. 执行CRUD
    4. 提交事务/回滚事务 con.commit() / con.rollback();
    5. 关闭连接 conn.close();

    使用Spring的事务管理功能后,我们可以不再写步骤 2 和 4 的代码,而是由Spirng 自动完成。那么Spring是如何在我们书写的 CRUD 之前和之后开启事务和关闭事务的呢?解决这个问题,也就可以从整体上理解Spring的事务管理实现原理了。下面简单地介绍下,注解方式为例子

    1. 配置文件开启注解驱动,在相关的类和方法上通过注解@Transactional标识。
    2. spring 在启动的时候会去解析生成相关的bean,这时候会查看拥有相关注解的类和方法,并且为这些类和方法生成代理,并根据@Transaction的相关参数进行相关配置注入,这样就在代理中为我们把相关的事务处理掉了(开启正常提交事务,异常回滚事务)。
    3. 真正的数据库层的事务提交和回滚是通过binlog或者redo log实现的。

    Spring的事务机制

    所有的数据访问技术都有事务处理机制,这些技术提供了API用来开启事务、提交事务来完成数据操作,或者在发生错误的时候回滚数据。

    而Spring的事务机制是用统一的机制来处理不同数据访问技术的事务处理。Spring的事务机制提供了一个PlatformTransactionManager接口,不同的数据访问技术的事务使用不同的接口实现,如表所示。

    数据访问技术及实现

    数据访问技术 实现
    JDBC DataSourceTransactionManager
    JPA JapTransactionManager
    Hibernate HibernateTransactionManager
    JDO JdoTransactionManager
    分布式事务 JtaTransactionManager

    在程序中定义事务管理器的代码如下:

    @Bean 
    public PlatformTransactionManager transactionManager() { 
    
        JpaTransactionManager transactionManager = new JpaTransactionManager(); 
        transactionManager.setDataSource(dataSource()); 
        return transactionManager; 
    }
    

    声名式事务

    Spring支持声名式事务,即使用注解来选择需要使用事务的方法,它使用@Transactional注解在方法上表明该方法需要事务支持。这是一个基于AOP的实现操作。

    @Transactional 
    public void saveSomething(Long  id, String name) { 
        //数据库操作 
    }
    

    在此处需要特别注意的是,此@Transactional注解来自org.springframework.transaction.annotation包,而不是javax.transaction。

    AOP 代理的两种实现:

    • jdk是代理接口,私有方法必然不会存在在接口里,所以就不会被拦截到;
    • cglib是子类,private的方法照样不会出现在子类里,也不能被拦截。

    Java 动态代理。

    具体有如下四步骤:

    1. 通过实现 InvocationHandler 接口创建自己的调用处理器;
    2. 通过为 Proxy 类指定 ClassLoader 对象和一组 interface 来创建动态代理类;
    3. 通过反射机制获得动态代理类的构造函数,其唯一参数类型是调用处理器接口类型;
    4. 通过构造函数创建动态代理类实例,构造时调用处理器对象作为参数被传入。

    GCLIB代理

    cglib(Code Generation Library)是一个强大的,高性能,高质量的Code生成类库。它可以在运行期扩展Java类与实现Java接口。

    • cglib封装了asm,可以在运行期动态生成新的class(子类)。
    • cglib用于AOP,jdk中的proxy必须基于接口,cglib却没有这个限制。

    原理区别:

    java动态代理是利用反射机制生成一个实现代理接口的匿名类,在调用具体方法前调用InvokeHandler来处理。而cglib动态代理是利用asm开源包,对代理对象类的class文件加载进来,通过修改其字节码生成子类来处理。

    1. 如果目标对象实现了接口,默认情况下会采用JDK的动态代理实现AOP
    2. 如果目标对象实现了接口,可以强制使用CGLIB实现AOP
    3. 如果目标对象没有实现了接口,必须采用CGLIB库,spring会自动在JDK动态代理和CGLIB之间转换

    如果是类内部方法直接不是走代理,这个时候可以通过维护一个自身实例的代理。

    @Service
    public class PersonServiceImpl implements PersonService {
        @Autowired
        PersonRepository personRepository;
    
        // 注入自身代理对象,在本类内部方法调用事务的传递性才会生效
        @Autowired
        PersonService selfProxyPersonService;
    
        /**
         * 测试事务的传递性
         *
         * @param person
         * @return
         */
        @Transactional
        public Person save(Person person) {
            Person p = personRepository.save(person);
            try {
                // 新开事务 独立回滚
                selfProxyPersonService.delete();
            } catch (Exception e) {
                e.printStackTrace();
            }
            try {
                // 使用当前事务 全部回滚
                selfProxyPersonService.save2(person);
            } catch (Exception e) {
                e.printStackTrace();
            }
            personRepository.save(person);
    
            return p;
        }
    
        @Transactional
        public void save2(Person person) {
            personRepository.save(person);
            throw new RuntimeException();
        }
    
        @Transactional(propagation = Propagation.REQUIRES_NEW)
        public void delete() {
            personRepository.delete(1L);
            throw new RuntimeException();
        }
    }
    

    Spring 事务的传播属性

    所谓spring事务的传播属性,就是定义在存在多个事务同时存在的时候,spring应该如何处理这些事务的行为。这些属性在TransactionDefinition中定义,具体常量的解释见下表:

    常量名称 常量解释
    PROPAGATION_REQUIRED 支持当前事务,如果当前没有事务,就新建一个事务。这是最常见的选择,也是 Spring 默认的事务的传播。
    PROPAGATION_REQUIRES_NEW 新建事务,如果当前存在事务,把当前事务挂起。新建的事务将和被挂起的事务没有任何关系,是两个独立的事务,外层事务失败回滚之后,不能回滚内层事务执行的结果,内层事务失败抛出异常,外层事务捕获,也可以不处理回滚操作
    PROPAGATION_SUPPORTS 支持当前事务,如果当前没有事务,就以非事务方式执行。
    PROPAGATION_MANDATORY 支持当前事务,如果当前没有事务,就抛出异常。
    PROPAGATION_NOT_SUPPORTED 以非事务方式执行操作,如果当前存在事务,就把当前事务挂起。
    PROPAGATION_NEVER 以非事务方式执行,如果当前存在事务,则抛出异常。
    PROPAGATION_NESTED 如果一个活动的事务存在,则运行在一个嵌套的事务中。如果没有活动事务,则按REQUIRED属性执行。它使用了一个单独的事务,这个事务拥有多个可以回滚的保存点。内部事务的回滚不会对外部事务造成影响。它只对DataSourceTransactionManager事务管理器起效。

    数据库隔离级别

    隔离级别 隔离级别的值 导致的问题
    Read-Uncommitted 0 导致脏读
    Read-Committed 1 避免脏读,允许不可重复读和幻读
    Repeatable-Read 2 避免脏读,不可重复读,允许幻读
    Serializable 3 串行化读,事务只能一个一个执行,避免了脏读、不可重复读、幻读。执行效率慢,使用时慎重

    脏读:一事务对数据进行了增删改,但未提交,另一事务可以读取到未提交的数据。如果第一个事务这时候回滚了,那么第二个事务就读到了脏数据。

    不可重复读:一个事务中发生了两次读操作,第一次读操作和第二次操作之间,另外一个事务对数据进行了修改,这时候两次读取的数据是不一致的。

    幻读:第一个事务对一定范围的数据进行批量修改,第二个事务在这个范围增加一条数据,这时候第一个事务就会丢失对新增数据的修改。

    总结:

    隔离级别越高,越能保证数据的完整性和一致性,但是对并发性能的影响也越大。

    大多数的数据库默认隔离级别为 Read Commited,比如 SqlServer、Oracle

    少数数据库默认隔离级别为:Repeatable Read 比如: MySQL InnoDB

    Spring中的隔离级别

    常量 解释
    ISOLATION_DEFAULT 这是个 PlatfromTransactionManager 默认的隔离级别,使用数据库默认的事务隔离级别。另外四个与 JDBC 的隔离级别相对应。
    ISOLATION_READ_UNCOMMITTED 这是事务最低的隔离级别,它充许另外一个事务可以看到这个事务未提交的数据。这种隔离级别会产生脏读,不可重复读和幻像读。
    ISOLATION_READ_COMMITTED 保证一个事务修改的数据提交后才能被另外一个事务读取。另外一个事务不能读取该事务未提交的数据。
    ISOLATION_REPEATABLE_READ 这种事务隔离级别可以防止脏读,不可重复读。但是可能出现幻像读。
    ISOLATION_SERIALIZABLE 这是花费最高代价但是最可靠的事务隔离级别。事务被处理为顺序执行。

    事务的嵌套

    通过上面的理论知识的铺垫,我们大致知道了数据库事务和spring事务的一些属性和特点,接下来我们通过分析一些嵌套事务的场景,来深入理解spring事务传播的机制。

    假设外层事务 Service A 的 Method A() 调用 内层Service B 的 Method B()

    PROPAGATION_REQUIRED(spring 默认)

    如果ServiceB.methodB() 的事务级别定义为 PROPAGATION_REQUIRED,那么执行 ServiceA.methodA() 的时候spring已经起了事务,这时调用 ServiceB.methodB(),ServiceB.methodB() 看到自己已经运行在 ServiceA.methodA() 的事务内部,就不再起新的事务。

    假如 ServiceB.methodB() 运行的时候发现自己没有在事务中,他就会为自己分配一个事务。

    这样,在 ServiceA.methodA() 或者在 ServiceB.methodB() 内的任何地方出现异常,事务都会被回滚。

    PROPAGATION_REQUIRES_NEW

    比如我们设计 ServiceA.methodA() 的事务级别为 PROPAGATION_REQUIRED,ServiceB.methodB() 的事务级别为 PROPAGATION_REQUIRES_NEW。

    那么当执行到 ServiceB.methodB() 的时候,ServiceA.methodA() 所在的事务就会挂起,ServiceB.methodB() 会起一个新的事务,等待 ServiceB.methodB() 的事务完成以后,它才继续执行。

    他与 PROPAGATION_REQUIRED 的事务区别在于事务的回滚程度了。因为 ServiceB.methodB() 是新起一个事务,那么就是存在两个不同的事务。如果 ServiceB.methodB() 已经提交,那么 ServiceA.methodA() 失败回滚,ServiceB.methodB() 是不会回滚的。如果 ServiceB.methodB() 失败回滚,如果他抛出的异常被 ServiceA.methodA() 捕获,ServiceA.methodA() 事务仍然可能提交(主要看B抛出的异常是不是A会回滚的异常)。

    PROPAGATION_SUPPORTS

    假设ServiceB.methodB() 的事务级别为 PROPAGATION_SUPPORTS,那么当执行到ServiceB.methodB()时,如果发现ServiceA.methodA()已经开启了一个事务,则加入当前的事务,如果发现ServiceA.methodA()没有开启事务,则自己也不开启事务。这种时候,内部方法的事务性完全依赖于最外层的事务。

    PROPAGATION_NESTED

    现在的情况就变得比较复杂了, ServiceB.methodB() 的事务属性被配置为 PROPAGATION_NESTED, 此时两者之间又将如何协作呢? ServiceB#methodB 如果 rollback, 那么内部事务(即 ServiceB#methodB) 将回滚到它执行前的 SavePoint 而外部事务(即 ServiceA#methodA) 可以有以下两种处理方式:

    a、捕获异常,执行异常分支逻辑

    void methodA() { 
    
            try { 
    
                ServiceB.methodB(); 
    
            } catch (SomeException) { 
    
                // 执行其他业务, 如 ServiceC.methodC(); 
    
            } 
    
        }
    

    这种方式也是嵌套事务最有价值的地方, 它起到了分支执行的效果, 如果 ServiceB.methodB 失败, 那么执行 ServiceC.methodC(), 而 ServiceB.methodB 已经回滚到它执行之前的 SavePoint, 所以不会产生脏数据(相当于此方法从未执行过), 这种特性可以用在某些特殊的业务中, 而 PROPAGATION_REQUIRED 和 PROPAGATION_REQUIRES_NEW 都没有办法做到这一点。

    b、 外部事务回滚/提交 代码不做任何修改, 那么如果内部事务(ServiceB#methodB) rollback, 那么首先 ServiceB.methodB 回滚到它执行之前的 SavePoint(在任何情况下都会如此), 外部事务(即 ServiceA#methodA) 将根据具体的配置决定自己是 commit 还是 rollback

    另外三种事务传播属性基本用不到,在此不做分析。

    总结

    对于项目中需要使用到事务的地方,我建议开发者还是使用spring的TransactionCallback接口来实现事务,不要盲目使用spring事务注解,如果一定要使用注解,那么一定要对spring事务的传播机制和隔离级别有个详细的了解,否则很可能发生意想不到的效果。

    Spring Boot 对事务的支持

    通过org.springframework.boot.autoconfigure.transaction.TransactionAutoConfiguration类。我们可以看出Spring Boot自动开启了对注解事务的支持
    Spring

    只读事务(@Transactional(readOnly = true))的一些概念

    • 概念:

    从这一点设置的时间点开始(时间点a)到这个事务结束的过程中,其他事务所提交的数据,该事务将看不见!(查询中不会出现别人在时间点a之后提交的数据)。

    @Transcational(readOnly=true) 这个注解一般会写在业务类上,或者其方法上,用来对其添加事务控制。当括号中添加readOnly=true, 则会告诉底层数据源,这个是一个只读事务,对于JDBC而言,只读事务会有一定的速度优化。而这样写的话,事务控制的其他配置则采用默认值,事务的隔离级别(isolation) 为DEFAULT,也就是跟随底层数据源的隔离级别,事务的传播行为(propagation)则是REQUIRED,所以还是会有事务存在,一代在代码中抛出RuntimeException,依然会导致事务回滚。

    • 应用场合:
    1. 如果你一次执行单条查询语句,则没有必要启用事务支持,数据库默认支持SQL执行期间的读一致性;
    2. 如果你一次执行多条查询语句,例如统计查询,报表查询,在这种场景下,多条查询SQL必须保证整体的读一致性,否则,在前条SQL查询之后,后条SQL查询之前,数据被其他用户改变,则该次整体的统计查询将会出现读数据不一致的状态,此时,应该启用事务支持。

    【注意是一次执行多次查询来统计某些信息,这时为了保证数据整体的一致性,要用只读事务】

    参考:
    http://www.codeceo.com/article/spring-transactions.html
    http://www.cnblogs.com/fenglie/articles/4097759.html
    https://www.zhihu.com/question/39074428/answer/88581202
    http://blog.csdn.net/andyzhaojianhui/article/details/51984157

    展开全文
  • Spring事务理解

    2019-08-05 15:58:35
    理解为:事务其实就是一件事情,要做就做完,中途出问题了就要恢复成原状态(等于没有做). 二、事务的四大特性 (1)、原子性: 事务必须是一个不可分割的整体 (2)、一致性: 执行完数据库操作后,数据不会被...

    一、什么是事务:

    我理解为:事务其实就是一件事情,要做就做完,中途出问题了就要恢复成原状态(等于没有做).
    

    二、事务的四大特性

    (1)、原子性:

    	事务必须是一个不可分割的整体
    

    (2)、一致性:

    执行完数据库操作后,数据不会被破坏。打个比方,如果从 A 账户转账到 B 账户,不可能因为 A 账户扣了钱,而 B 账户没有加钱吧
    

    (3)、隔离性:

    对同一条数据的操作,不同的事务之间应该隔离(提交之前,数据变化仅仅在事务内部,与外部隔离),要不然会产生脏读、幻读等情况情况。
    为了让事务之间没有干扰,
    制定了以下几种事务隔离级别:
    
    <1>、READ_UNCOMMITTED
    <2>、READ_COMMITTED
    <3>、REPEATABLE_READ
    <4>、SERIALIZABLE
    
    从上往下,级别越来越高,并发性越来越差,安全性越来越高
    

    (4)、持久性:

    当我们执行一条 insert 语句后,数据库必须要保证有一条数据永久地存放在磁盘中,这个也算事务的一条特性
    

    (5)、总结:

    原子性是基础,隔离性是手段,持久性是目的,真正的老大就是一致性。数据不一致了就要乱套了。
    

    三、JDBC不同事务隔离级别要解决的问题:

    (1) :脏读:就是当前事务中访问到了其它事务还没有提交的数据,并且在此基础上做了其它的数据操作。
    

    在这里插入图片描述

    (2):不可重复读:我理解为当前事务中读取到了其它事务已经提交修改的数据(其它事务修改前读取了一次
    	,修改后又读取了一次,导致同一事务中两次读取的数据不一样)
    

    在这里插入图片描述

    (3):幻读:我理解为当前事务中读取到了其它事务提交新增的数据集(其它事务新增前读取了一次,
    	新增后又读取了一次,导致同一事务中读取到的结果集行数不同)
    

    在这里插入图片描述

    	以上3种情况脏读是一定要避免的。	
    	MySQL 数据库的默认事务隔离级别就是 READ_COMMITTED(只禁止脏读,也就是隔离其它事务没有提交的数据),READ_COMMITTED已经可以解决大部分的问题。
    

    在这里插入图片描述

    四、完善事务管理功能

    (1)、事务传播行为

    Spring 解决的只是方法之间的事务传播,比如A方法是一个事务,B方法是一个事务,A方法里面包含B方法。那么事务是怎么传播的?
    

    (2)、PROPAGATION_REQUIRED:

    最常用也是spring默认是事务传播级别,A方法执行的时候已经有事务了,所以B方法的事务会注入到A方法事务里面来(合成一个事务)。
    

    (3)、Spring关于事务的附加功能

    1、事务超时(Transaction Timeout):为了解决事务时间太长,消耗太多的资源,所以故意给事务设置一个最大时常,
       如果超过了,就回滚事务。   
       ------  timeout="1"
       
    2、只读事务(Readonly Transaction):为了忽略那些不需要事务的方法,比如读取数据,这样可以有效地提高一些性能 
      	------  propagation="REQUIRED"
    

    事务最重要的两个特性,是事务的传播级别和数据隔离级别。传播级别定义的是事务的控制范围,事务隔离级别定义的是事务在数据库读写方面的控制范围。

    五、如何配置Spring的事务管理:

    (1)、在Spring配置文件中使用AOP的方式实现事务的配置:
    
    <!-- 定义事务管理器 -->
    <bean id="transactionManager"
    	class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    	<property name="dataSource" ref="dataSource" />
    </bean>
    
    <!-- 定义通知 -->
    <tx:advice id="TestAdvice" transaction-manager="transactionManager">
    	<!--配置事务传播性,隔离级别以及超时回滚等问题 -->
    	<tx:attributes>
    		<tx:method name="save*" propagation="REQUIRED" isolation="DEFAULT"   timeout="1"/>
    		<tx:method name="del*" propagation="REQUIRED" />
    		<tx:method name="update*" propagation="REQUIRED" />
    		<tx:method name="add*" propagation="REQUIRED" />
    		<tx:method name="*" rollback-for="Exception" />
    	</tx:attributes>
    </tx:advice>
    
    <aop:config>
    		<!--配置事务切点,将TestAdvice通知切入到com.website.service子目录下的所有方法 -->
    		<aop:pointcut id="services"
    			expression="execution(* com.website.service.*.*(..))" />
    		<aop:advisor pointcut-ref="services" advice-ref="TestAdvice" />
    </aop:config>
    

    (2)、注解式事务:

    <1>、首先在Spring配置文件中设置事务管理器,定义通知tx:annotation-driven

    <!-- 定义事务管理器 -->
    <bean id="transactionManager"
    	class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    	<property name="dataSource" ref="dataSource" />
    </bean>
    <!--使用事务注解, 注解方式配置事务-->
    <tx:annotation-driven  transaction-manager="transactionManager" />
    

    <2>、代码中的具体的注解以及事务的传播性、隔离级别一般在service 层中配置下面

    @Transactional(propagation=Propagation.REQUIRED,rollbackFor=Exception.class,timeout=1,isolation=Isolation.DEFAULT)
    	public void saveUser(Map<String, String> map) throws Exception {
             System.out.println("方法开始");
    		for (int i = 0; i < 500000; i++) {
    	            System.out.println("*");
    	        }
    		 System.out.println("进入保存");
    		 userDao.saveUser(map);
    		 System.out.println("退出保存");
    	}
    
    @Transactional 一般是放在public方法上面,也可以放在类上面,方法和类同时有@Transactional 注解时,方法上面的注解优先级高。
    

    六、以上面的笔记来理解,Spring AOP是怎样来管理事务的.

     1、配置文件里面用aop的方式切入事务到service的指定方法,每个service方法都被事务管理。事务的隔离级别是READ_COMMITTED(只禁止脏数据),事务的传播级别是PROPAGATION_REQUIRED(遇到新的事务,会将其加入到当前事务,合并成一个事务)
     2、这个时候需要实现一个功能,先插入数据,再查询数据,有三种写法:
         <1>、action层里面调用两个server方法:
    		@Action(value="getList")
    		public void getList(){
    		    this.Service.add();  //添加方法
    			this.Service.getList(); //查询方法
    		}
    	分析:因为每个server是一个独立的事务,这里的action里面调用方法是按顺序执行的,
    	所以是先执行添加事务并且提交事务后再执行查询事务,结果是可以查到刚添加的数据
    
    
    <2>、action层里面调用一个server方法,这个server方法里面调用添加和查询server方法
    	@Action(value="getList")
    	public void getList(){
    	    this.Service.serviceFun(); 
    	}
    	
    	server方法层:
    	public void serviceFun(){
    		this.add();
    		this.getList();
    	}
    
    分析:因为事务的传播级别是PROPAGATION_REQUIRED(遇到新的事务,会将其加入到当前事务,合并成一个事务),所以this.add()和this.getList();是在一个事务内执行的,不存在什么添加事务提交不提交,都在一个隔离墙内,所以结果是可以查到刚添加的数据。
    
    <3>、如果添加删除操作都在一个servier里面之间调用dao层方法,本来就是一个事务,那就更加可以查到刚添加的数据了。
    
    以上是我对于spring Aop切入事务后,为什么我们不用考虑事务管理是原因的理解,因为spring都帮我们搞定了。
    
    展开全文
  • Spring事务如何理解

    千次阅读 2018-07-22 10:10:46
    事务:是指一组数据库操作,这组操作数据库所做的修改, 要么全部成功,提交到数据库生效; 要么全部失败,数据库回滚到这组操作之前的状态。 事务保证了数据库中数据的一致性,防止了脏数据的出现。所以,为了...
  • 理解spring事务传播机制

    万次阅读 2017-08-13 13:49:04
    http://www.codeceo.com/article/spring-transactions.html1.spring实现对事务的控制,使用的是代理的技术。通过生成的代理类来捕捉被代理类(也就是我们编写的类)的异常,决定事务的提交或回滚。从某一角度来说
  • 我所理解spring 事务

    千次阅读 2017-11-30 22:38:23
    spring事务实现原理,自己动手实现spring事务管理
  • Spring事务 的本质其实就是数据库事务的支持,没有数据库的事务支持,spring是无法提供事务功能的。对于纯JDBC操作数据库,想要用到事务,可以按照以下步骤进行: 获取连接 Connection con = DriverManager.get...
  • Spring事务管理理解

    2017-05-22 20:58:58
     标签: 写这篇博客之前我首先读了《Spring in ...Spring事务机制详解Spring事务配置的五种方式Spring中的事务管理实例详解 1 初步理解 理解事务之前,先讲一个你日常生活中最常干的事:取钱。 比如你去A
  • ”关注我哟 好看记得加个“星标”哈! 前言 ...Spring事务应用大纲 在看这篇文章,以及下篇源码分析的文章我希望你Spring AOP以及有充分的了解,不然一些细节问题你可能看不明白,关于Spring AOP如果
  • 在谈Spring事务管理之前我们想一下在我们不用Spring的时候,在Hibernate中我们是怎么进行数据操作的。在Hibernate中我们每次进行一个操作的的时候我们都是要先开启事务,然后进行数据操作,然后提交事务,关闭事务,...
  • spring事务理解与测试

    千次阅读 2016-07-18 11:08:52
    经常使用到spring事务的会知道,一般处理到spring的事务,有三种处理方式: 1、编程式事务 较繁琐,适用于处理复杂的业务场景 业务层使用事务模板对象TransactionTemplate完成将多个操作制成同一事务,使用...
  • 对Spring声明式事务理解

    千次阅读 2011-08-10 21:14:45
    1:当我们采用Annotation的形式声明事务时,我们会遇到Propagation的设置,期中Propagation的取值可以为:   2:REQUIRED的理解    When the propagation setting is PROPAGA
  • 深入理解事务--Spring事务的传播机制

    万次阅读 多人点赞 2015-05-17 19:56:18
    spring事务开启 ,或者是基于接口的或者是基于类的代理被创建(注意一定要是代理,不能手动new 一个对象,并且此类(有无接口都行)一定要被代理——spring中的bean只要纳入了IOC管理都是被代理的)。所以在同一个...
  • 深入理解Spring事务的传播行为

    千次阅读 2019-06-13 20:32:14
    本文主要介绍下Spring事务中的传播行为。 事务传播行为介绍 Spring中的7个事务传播行为: 事务行为 说明 PROPAGATION_REQUIRED 支持当前事务,假设当前没有事务。就新建一个事务 PROPAGATION_SUPPORTS 支持...
  • 一文带你深入理解 Spring 事务原理

    千次阅读 2020-04-02 10:36:42
    Spring事务的本质其实就是数据库事务的支持,没有数据库的事务支持,spring是无法提供事务功能的。对于纯JDBC操作数据库,想要用到事务,可以按照以下步骤进行: 获取连接 Connection con = DriverManager.get...
  • 环境: Springboot:2.2.3.RELEASE Spring:5.2.3.RELEASE 事务传播行为枚举参见Spring源码:org.spring...先来了解一下Spring事务的传播机制(由于英语不好,直接google翻译了) 简单终结一下: 枚举 ...
  • @[TOC] 目录 NO1.框架自动提交事务与异常回滚 NO2.控制框架的提交和事务回滚 NO3.AOP+注解实现事务的提交和回滚 NO4.spring事务源码解读
  • Spring Boot事务理解事务的传播

    千次阅读 2019-08-21 08:59:40
    在我之前的教程中,Spring Boot事务管理例子中,我们了解了事务的声明式实现和管理。在这片文章中,我们会 来看事务的传播性以及不同的传播类型。下一篇文章中,我们将会学习Spring Boot 事务回滚和Spring Boot事务...
  • Spring中@Transactional事务回滚 http://www.importnew.com/19489.html Mysql中“select ... for update”排他锁分析 http://blog.csdn.net/claram/article/details/54023216 MySQL事务...
  • spring事务,我的理解

    千次阅读 2007-04-25 15:46:00
    Spring事务:spring 将事务管理进行抽象,具有一致的事务管理,有点如下:一 spring 事务管理带给我们什么好处1 为不同的事务API提供一致的编程模型:我的理解是,无论是jdbc,hibernate,jta,均可以按照一定的模型—...
  • Spring学习笔记-加深对Spring理解

    千次阅读 2017-03-16 17:29:10
    在之前对Spring的学习和开发中,一直处于会用的状态,对Spring以及它的核心IOC、DI和AOP一直处于非常浅的认识...不过,这次的课堂作业就是对Spring理解,所以正好可以借这个机会查找相关资料来加深下对Spring理解

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 82,259
精华内容 32,903
关键字:

对spring事物的理解

spring 订阅