精华内容
下载资源
问答
  • 声明式事务

    2014-03-25 19:16:33
    声明式事务编辑以方法为单位,进行事物控制;抛出异常,事物回滚。 最小的执行单位为方法。 决定执行成败是通过是否抛出异常来判断的,抛出异常即执行失败    声明式事务(declarative transaction management)...

     

    百度百科

     

    声明式事务编辑以方法为单位,进行事物控制;抛出异常,事物回滚。

    最小的执行单位为方法。

    决定执行成败是通过是否抛出异常来判断的,抛出异常即执行失败

     

     声明式事务(declarative transaction management)是Spring提供的对程序事务管理的方式之一。

    Spring的声明式事务顾名思义就是采用声明的方式来处理事务。这里所说的声明,就是指在配置文件中申明

    用在Spring配置文件中声明式的处理事务来代替代码式的处理事务。

    这样的好处是,事务管理不侵入开发的组件,具体来说,业务逻辑对象就不会意识到正在事务管理之中,事实上也应该如此,因为事务管理是属于系统层面的服务,而不是业务逻辑的一部分,如果想要改变事务管理策划的话,也只需要在定义文件中重新配置即可;在不需要事务管理的时候,只要在设定文件上修改一下,即可移去事务管理服务,无需改变代码重新编译,这样维护起来极其方便。

    Spring使用AOP来完成声明式的事务管理,因而声明式事务是以方法为单位,Spring的事务属性自然就在于描述事务应用至方法上的策略,在Spring中事务属性有以下四个参数:

    1.传播行为

    2.隔离级别

    3.只读提示

    4.事务超时期间

    展开全文
  • 目录事务的概念搭建事务操作的环境创建数据库表,添加记录代码演示事务场景引入事务管理介绍注解声明式事务管理声明式事务管理参数配置propagation:事务传播行为ioslation:事务隔离级别timeout:超时时间readOnly...

    事务的概念

    事务的概念(通俗理解):事务是数据库操作最基本单元,逻辑上一组操作,要么都成功,如果有一个失败所有操作都失败。

    典型场景:银行转账(这两件事必须都成功或都不成功)
    lucy 转账 100 元 给 mary
    lucy 少 100,mary 多 100

    事务四个特性(ACID)
    (1)原子性:这个过程不可分割。
    (2)一致性:操作之前和操作之后的总量不变。
    (3)隔离性:多事务操作时不会相互参生影响。
    (4)持久性:事务提交后数据库数据会发生变化。

    搭建事务操作的环境

    在这里插入图片描述

    创建数据库表,添加记录

    在这里插入图片描述

    代码演示

    (1)创建 service,搭建 dao,完成对象创建和注入关系。
    (2)service 注入 dao,在 dao 注入 JdbcTemplate,在 配置文件中在JdbcTemplate 中注入 DataSource。
    (3)在 dao 创建两个方法:多钱和少钱的方法,在 service 创建方法(转账的方法)。

    jdbc.properties:

    jdbc.driverClass=com.mysql.jdbc.Driver
    jdbc.url=jdbc:mysql://127.0.0.1:3306/user_db?characterEncoding=utf8&useUnicode=true&useSSL=false
    jdbc.username=root
    jdbc.password=18044229
    

    bean1.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:p="http://www.springframework.org/schema/p"
           xmlns:util="http://www.springframework.org/schema/util"
           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/util http://www.springframework.org/schema/util/spring-util.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.Keafmd"></context:component-scan>
    
        <!--引入外部的属性文件-->
        <context:property-placeholder location="classpath:jdbc.properties"/>
    
        <!--配置连接池-->
        <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
    
            <property name="driverClassName" value="${jdbc.driverClass}"></property>
            <property name="url" value="${jdbc.url}" ></property>
            <property name="username" value="${jdbc.username}" ></property>
            <property name ="password" value="${jdbc.password}" ></property>
    
        </bean>
    
        <!--创建jdbcTemplate对象-->
        <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
            <!--注入DataSource-->
            <property name="dataSource" ref="dataSource"></property>
    
        </bean>
    
    </beans>
    

    UserDao 接口:

    package com.Keafmd.spring5.dao;
    
    /**
     * Keafmd
     *
     * @ClassName: UserDao
     * @Description:
     * @author: 牛哄哄的柯南
     * @date: 2021-01-20 10:09
     */
    
    public interface UserDao {
    
        //多钱
        public void addMoney();
    
        //少钱
        public void reduceMoney();
    }
    

    实现类UserDaoImpl :

    package com.Keafmd.spring5.dao;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.jdbc.core.JdbcTemplate;
    import org.springframework.stereotype.Repository;
    
    import javax.sql.rowset.JdbcRowSet;
    
    /**
     * Keafmd
     *
     * @ClassName: UserDaoImpl
     * @Description:
     * @author: 牛哄哄的柯南
     * @date: 2021-01-20 10:09
     */
    @Repository
    public class UserDaoImpl implements UserDao{
    
        @Autowired
        private JdbcTemplate jdbcTemplate;
    
    
        //少钱
        @Override
        public void reduceMoney() {
            String sql = "update t_account set money =money-? where username =?";
            jdbcTemplate.update(sql,100,"Lucy");
        }
    
    
        //多钱
        @Override
        public void addMoney() {
            String sql = "update t_account set money =money+? where username =?";
            jdbcTemplate.update(sql,100,"Mary");
        }
    
    
    }
    

    UserService 类:

    package com.Keafmd.spring5.service;
    
    import com.Keafmd.spring5.dao.UserDao;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    import org.springframework.transaction.annotation.Transactional;
    
    /**
     * Keafmd
     *
     * @ClassName: UserService
     * @Description:
     * @author: 牛哄哄的柯南
     * @date: 2021-01-20 10:08
     */
    @Service
    public class UserService {
    
        //注入dao
        @Autowired
        private UserDao userDao;
    
        //转账的方法
        public void accountMoney(){
            
            // Lucy 少100
            userDao.reduceMoney();
    
            //Mary多100
            userDao.addMoney();
    
        }
    
    }
    

    测试类:

    package com.Keafmd.spring5.test;
    
    import com.Keafmd.spring5.config.TxConfig;
    import com.Keafmd.spring5.service.UserService;
    import org.junit.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.annotation.AnnotationConfigApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    /**
     * Keafmd
     *
     * @ClassName: TestAccount
     * @Description:
     * @author: 牛哄哄的柯南
     * @date: 2021-01-20 10:40
     */
    public class TestAccount {
    
        @Test
        public void test1(){
            ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
            UserService userService = context.getBean("userService",UserService.class);
            userService.accountMoney();
        }
    }
    
    

    测试前的数据:
    在这里插入图片描述
    测试后的数据:
    在这里插入图片描述

    这样正常执行,没有问题,但是如果中途出错了呢?接着往下看。

    事务场景引入

    上面代码,如果正常执行没有问题的,但是如果代码执行过程中出现异常,就会有问题,假如在Lucy少100后代码发生了错误,那么会怎样?
    我们手动添加个错误:

    //转账的方法
        public void accountMoney(){
    
            // Lucy 少100
            userDao.reduceMoney();
    
            //手动添加异常
            int i =100/0;
    
            //Mary多100
            userDao.addMoney();
    
        }
    

    这样数据的变化就会出现问题。
    测试前的数据:
    在这里插入图片描述
    测试后的数据:
    在这里插入图片描述

    这样就发生了问题,Lucy少了100但是Mary却没有多。这就需要利用事务来解决,让其在发生错误的时候进行回滚。

    事务管理介绍

    1、事务添加到 JavaEE 三层结构里面 Service 层(业务逻辑层)
    2、在 Spring 进行事务管理操作
    有两种方式:
    (1)编程式事务管理(不方便)
    (2)声明式事务管理(使用)
    3、声明式事务管理
    (1)基于注解方式(简单方便)
    (2)基于 xml 配置文件方式
    4、在 Spring 进行声明式事务管理,底层使用 AOP 原理
    5、Spring 事务管理 API
    提供一个接口,代表事务管理器,这个接口针对不同的框架提供不同的实现类:

    Spring中使用的是DataSourceTransactionManager
    在这里插入图片描述

    注解声明式事务管理

    (1)在 spring 配置文件配置事务管理器
    (2)在 spring 配置文件,开启事务注解
    (3)在 spring 配置文件引入名称空间 tx
    (4)开启事务注解

    bean1.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:p="http://www.springframework.org/schema/p"
           xmlns:util="http://www.springframework.org/schema/util"
           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/util http://www.springframework.org/schema/util/spring-util.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.Keafmd"></context:component-scan>
    
        <!--引入外部的属性文件-->
        <context:property-placeholder location="classpath:jdbc.properties"/>
    
        <!--配置连接池-->
        <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
    
            <property name="driverClassName" value="${jdbc.driverClass}"></property>
            <property name="url" value="${jdbc.url}" ></property>
            <property name="username" value="${jdbc.username}" ></property>
            <property name ="password" value="${jdbc.password}" ></property>
    
        </bean>
    
        <!--创建jdbcTemplate对象-->
        <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
            <!--注入DataSource-->
            <property name="dataSource" ref="dataSource"></property>
    
        </bean>
    
        <!--创建事务管理器-->
        <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
            <!--注入数据源-->
            <property name="dataSource" ref="dataSource"></property>
    
        </bean>
    
    
        <!--开启事务注解-->
        <tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>
    
    </beans>
    

    在 service 类上面(或者 service 类里面方法上面)添加事务注解:
    (1)@Transactional,这个注解添加到类上面,也可以添加方法上面
    (2)如果把这个注解添加类上面,这个类里面所有的方法都添加事务
    (3)如果把这个注解添加方法上面,为这个方法添加事务

    UserService 类:

    package com.Keafmd.spring5.service;
    
    import com.Keafmd.spring5.dao.UserDao;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    import org.springframework.transaction.annotation.Transactional;
    
    /**
     * Keafmd
     *
     * @ClassName: UserService
     * @Description:
     * @author: 牛哄哄的柯南
     * @date: 2021-01-20 10:08
     */
    @Service
    @Transactional  // @Transactional,这个注解添加到类上面
    public class UserService {
    
        //注入dao
        @Autowired
        private UserDao userDao;
    
        //转账的方法
        public void accountMoney(){
    
            // Lucy 少100
            userDao.reduceMoney();
    
            //手动添加异常,事务回滚
            int i =100/0;
    
            //Mary多100
            userDao.addMoney();
    
        }
    
    }
    

    现在我们添加事务后带着异常运行测试类:

    测试前的数据:
    在这里插入图片描述
    测试后的数据:
    在这里插入图片描述

    很明显的看到测试后的数据没有变化,是因为发生了异常,进行了事务回滚,所以数据库中的数据都没有改变。

    声明式事务管理参数配置

    在 service 类上面添加注解@Transactional,在这个注解里面可以配置事务相关参数:
    在这里插入图片描述

    propagation:事务传播行为

    事务传播行为:多事务方法直接进行调用,这个过程中事务 是如何进行管理的。

    在这里插入图片描述
    我们在add方法加了事务,update没有加,当我们的add调用update的时候,事务会怎么处理,这个过程就叫做事务的传播行为。有事务的方法调用没事务的,还有就是都有事务并且调用这些情况发生的时候事务会怎么处理,这些过程就叫做事务的传播行为。
    事务的传播行为可以由传播属性指定。Spring 定义了7种类传播行为。
    在这里插入图片描述
    结合我们的例子介绍两种最常见的:
    在这里插入图片描述

    默认的是REQUIRED:@Transactional(propagation = Propagation.REQUIRED)相当于:@Transactional

    ioslation:事务隔离级别

    (1)事务有特性成为隔离性,多事务操作之间不会产生影响。不考虑隔离性产生很多问题
    (2)有三个读问题:脏读、不可重复读、虚(幻)读

    脏读(致命问题):一个未提交事务读取到另一个未提交事务的数据
    在这里插入图片描述

    不可重复读(现象):一个未提交事务读取到另一提交事务修改数据
    在这里插入图片描述

    虚读(现象):一个未提交事务读取到另一提交事务添加数据
    不可重复读的重点是修改了数据,同样的条件 , 你读取过的数据 , 再次读取出来发现值不一样了。
    幻读的重点是新增或者删除了数据 , 第 1 次和第 2 次读出来的记录数不一样。

    解决:通过设置事务隔离级别,解决读问题。
    在这里插入图片描述

    设置隔离级别方式:@Transactional(isolation = Isolation.REPEATABLE_READ),这种可重复读是mysql默认的设置方式。

    timeout:超时时间

    (1)事务需要在一定时间内进行提交,如果不提交进行回滚
    (2)默认值是 -1 ,设置时间以秒单位进行计算

    设置方式:@Transactional(timeout = 5)

    readOnly:是否只读

    (1)读:查询操作,写:添加修改删除操作
    (2)readOnly 默认值 false,表示可以查询,可以添加修改删除操作
    (3)设置 readOnly 值是 true,设置成 true 之后,只能查询

    设置方式:@Transactional(readOnly = true)

    rollbackFor:回滚

    设置出现哪些异常进行事务回滚

    设置方式:@Transactional(rollbackFor=Exception.class)

    noRollbackFor:不回滚

    设置出现哪些异常不进行事务回滚

    设置方式:@Transactional(notRollbackFor=RunTimeException.class)

    XML声明式事务管理(不常用)

    在 spring 配置文件中进行配置:
    第一步:配置事务管理器
    第二步:配置通知
    第三步:配置切入点和切面

    bean2.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:p="http://www.springframework.org/schema/p"
           xmlns:aop="http://www.springframework.org/schema/aop"
           xmlns:util="http://www.springframework.org/schema/util"
           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/util http://www.springframework.org/schema/util/spring-util.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.Keafmd"></context:component-scan>
    
        <!--引入外部的属性文件-->
        <context:property-placeholder location="classpath:jdbc.properties"/>
    
        <!--配置连接池-->
        <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
    
            <property name="driverClassName" value="${jdbc.driverClass}"></property>
            <property name="url" value="${jdbc.url}" ></property>
            <property name="username" value="${jdbc.username}" ></property>
            <property name ="password" value="${jdbc.password}" ></property>
    
        </bean>
    
        <!--创建jdbcTemplate对象-->
        <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
            <!--注入DataSource-->
            <property name="dataSource" ref="dataSource"></property>
    
        </bean>
    
        <!--创建事务管理器-->
        <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
            <!--注入数据源-->
            <property name="dataSource" ref="dataSource"></property>
    
        </bean>
    
    
        <!--2 配置通知-->
        <tx:advice id="txadvice">
            <!--配置事务参数-->
            <tx:attributes>
                <!--指定哪种规则的方法上面添加事务-->
                <tx:method name="accountMoney" propagation="REQUIRED"/>
                <!--<tx:method name="account*"/>-->
            </tx:attributes>
        </tx:advice>
        <!--3 配置切入点和切面-->
        <aop:config>
            <!--配置切入点-->
            <aop:pointcut id="pt" expression="execution(* com.Keafmd.spring5.service.UserService.*(..))"/>
            <!--配置切面-->
            <aop:advisor advice-ref="txadvice" pointcut-ref="pt"/>
        </aop:config>
    
    </beans>
    

    把UserService的@Transactional注解注释掉,其它不变,新建个测试类:

    package com.Keafmd.spring5.test;
    
    import com.Keafmd.spring5.config.TxConfig;
    import com.Keafmd.spring5.service.UserService;
    import org.junit.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.annotation.AnnotationConfigApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    /**
     * Keafmd
     *
     * @ClassName: TestAccount
     * @Description:
     * @author: 牛哄哄的柯南
     * @date: 2021-01-20 10:40
     */
    public class TestAccount {
    
        @Test
        public void test2(){
            ApplicationContext context = new ClassPathXmlApplicationContext("bean2.xml");
            UserService userService = context.getBean("userService",UserService.class);
            userService.accountMoney();
        }
    
    }
    

    这样我们使用的是bean2.xml配置文件,那我们这就是XML声明式事务管理。

    完全注解声明式事务管理

    在注解声明式事务管理我们也是需要使用bean1.xml配置文件,我们也可以不使用配置文件,创建个配置类,和注解声明式事务管理相比其它类都不变。

    TxConfig类:

    package com.Keafmd.spring5.config;
    
    import com.alibaba.druid.pool.DruidDataSource;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.ComponentScan;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.jdbc.core.JdbcTemplate;
    import org.springframework.jdbc.datasource.DataSourceTransactionManager;
    import org.springframework.transaction.annotation.EnableTransactionManagement;
    
    import javax.sql.DataSource;
    
    
    /**
     * Keafmd
     *
     * @ClassName: TxConfig
     * @Description: 完全注解开发
     * @author: 牛哄哄的柯南
     * @date: 2021-01-20 21:16
     */
    @Configuration //配置类
    @ComponentScan(basePackages = "com.Keafmd")  //组件扫描
    @EnableTransactionManagement  // 开启事务
    public class TxConfig {
    
        //创建数据库连接池
        @Bean
        public DruidDataSource getDruidDataSource(){
            DruidDataSource dataSource = new DruidDataSource();
            dataSource.setDriverClassName("com.mysql.jdbc.Driver");
            dataSource.setUrl("jdbc:mysql://127.0.0.1:3306/user_db?characterEncoding=utf8&useUnicode=true&useSSL=false");
            dataSource.setUsername("root");
            dataSource.setPassword("18044229");
            return dataSource;
        }
    
        //创建jdbcTemplate对象
        @Bean
        public JdbcTemplate getJdbcTemplate(DataSource dataSource){
            JdbcTemplate jdbcTemplate = new JdbcTemplate();
            jdbcTemplate.setDataSource(dataSource);
            return jdbcTemplate;
        }
    
        //创建事务管理器
        @Bean
        public DataSourceTransactionManager getDataSourceTransactionManager(DataSource dataSource){
            DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();
            transactionManager.setDataSource(dataSource);
            return transactionManager;
        }
    
    }
    

    测试类:

    package com.Keafmd.spring5.test;
    
    import com.Keafmd.spring5.config.TxConfig;
    import com.Keafmd.spring5.service.UserService;
    import org.junit.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.annotation.AnnotationConfigApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    /**
     * Keafmd
     *
     * @ClassName: TestAccount
     * @Description:
     * @author: 牛哄哄的柯南
     * @date: 2021-01-20 10:40
     */
    public class TestAccount {
    
    	//使用配置类
        @Test
        public void test3(){
            ApplicationContext context = new AnnotationConfigApplicationContext(TxConfig.class);
            UserService userService = context.getBean("userService",UserService.class);
            userService.accountMoney();
        }
    
    }
    

    这样我们就实现了完全注解声明式事务管理。

    展开全文
  • 声明式事务和编程式事务的区别

    万次阅读 2020-02-02 14:26:12
    声明式事务:通过AOP(面向切面)方式在方法前使用编程式事务的方法开启事务,在方法后提交或回滚。用配置文件的方法或注解方法(如:@Transactional)控制事务。 编程式事务:手动开启、提交、回滚事务。 通俗地...
    • 区别

    声明式事务:通过AOP(面向切面)方式在方法前使用编程式事务的方法开启事务,在方法后提交或回滚。用配置文件的方法或注解方法(如:@Transactional)控制事务。

    编程式事务:手动开启、提交、回滚事务。

    通俗地去理解两者的区别,即声明式事务只需要“声明”就可以达到事务的效果;编程式事务需要“编程”才可以达到事务效果。

    • 声明式事务案例

    业务层代码

    @Override
    @Transactional
    public Map<String, Object> fun() {
    
    }
    • 编程式事务案例

    工具类代码

    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.jdbc.datasource.DataSourceTransactionManager;
    import org.springframework.stereotype.Component;
    import org.springframework.transaction.TransactionStatus;
    import org.springframework.transaction.interceptor.DefaultTransactionAttribute;
    @Component
    public class Utils {
    	@Autowired
    	private DataSourceTransactionManager dataSourceTransactionManager;
    
    	// 开启事务
    	public TransactionStatus openTx() {
    		return dataSourceTransactionManager.getTransaction(new DefaultTransactionAttribute());
    	}
    	// 提交事务
    	public void commitTx(TransactionStatus ts) {
    		dataSourceTransactionManager.commit(ts);
    	}
    	// 回滚事务
    	public void rollbackTx(TransactionStatus ts) {
    		dataSourceTransactionManager.rollback(ts);
    	}
    }
    

    业务层代码

    
    @Service
    public class RegisterServiceImpl implements RegisterService {
    	@Autowired
    	private Utils utils;
    	@Override
    	public void programming(String name,String age,String studentId) {
    		TransactionStatus ts = null;
    		try {
    			// 开启事务
    			ts = utils.openTx();
    			registerMapper.programming( name, age, studentId);
    			int a=1/0;
    			registerMapper.programming( name, age, studentId);
    			if (ts != null) {
    				// 提交事务
    				utils.commitTx(ts);
    			}
    		} catch (Exception e) {
    			if (ts != null) {
    				// 回滚事务
    				utils.rollbackTx(ts);
    			}
    		}
    	}
    }

     

    展开全文
  • Spring事务管理之开启声明式事务

    万次阅读 2021-01-31 17:23:27
    声明式事务:AOP 编程式事务:需要在代码中进行事务管理 如果不配置事务, 可能存在数据提交不一致的情况 如果不在Spring中去配置声明式事务, 我们就需要在代码中手动配置事务 事务在项目开发中十分重要, 涉及到数据...

    Spring 中的事务管理

    官方文档:http://mybatis.org/spring/zh/transactions.html

    • 声明式事务:AOP
    • 编程式事务:需要在代码中进行事务管理

    如果不配置事务, 可能存在数据提交不一致的情况

    如果不在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"
           xsi:schemaLocation="http://www.springframework.org/schema/beans
            https://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/aop
            https://www.springframework.org/schema/aop/spring-aop.xsd
            http://www.springframework.org/schema/tx
            https://www.springframework.org/schema/tx/spring-tx.xsd">
    
        <!--dataSource: 使用Spring的数据源替换Mybatis的配置 c3p0 dbcp druid
            我们这里使用Spring提供的JDBC: org.springframework.jdbc.datasource.DriverManagerDataSource
        -->
        <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
            <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
            <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&amp;useUnicode=true&amp;characterEncoding=utf8"/>
            <property name="username" value="root"/>
            <property name="password" value="123456"/>
        </bean>
    
        <!--sqlSessionFactory-->
        <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
            <property name="dataSource" ref="dataSource"/>
            <!--关联/绑定 mybatis 配置文件-->
            <property name="configLocation" value="classpath:mybatis-config.xml"/>
            <!--绑定 Mapper.xml-->
            <property name="mapperLocations" value="classpath:com/pro/mapper/*.xml"/>
        </bean>
    
        <!--SqlSessionTemplate: 就是我们使用的 sqlSession-->
        <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
            <!--只能使用构造器注入, 因为它没有set方法-->
            <constructor-arg index="0" ref="sqlSessionFactory"/>
        </bean>
    
        
        <!--################# 开启事务管理 #################-->
        <!--开启 Spring 声明式事务-->
        <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
            <constructor-arg ref="dataSource" />
        </bean>
    
        <!--结合AOP实现事务织入-->
        <!--配置事务通知-->
        <tx:advice id="txAdvice" transaction-manager="transactionManager">
            <!--1. 给那些方法配置事务-->
            <!--2. 配置事务的传播特性: propagation-->
            <tx:attributes>
                <tx:method name="add" propagation="REQUIRED"/>
                <tx:method name="delete" propagation="REQUIRED"/>
                <tx:method name="update" propagation="REQUIRED"/>
                <tx:method name="query" read-only="true"/>
                <tx:method name="*" propagation="REQUIRED"/>
            </tx:attributes>
        </tx:advice>
    
        <!--配置事务切入-->
        <aop:config>
            <!--mapper包下的所有类的所有方法-->
            <aop:pointcut id="txPointCut" expression="execution(* com.pro.mapper.*.*(..))"/>
            <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/>
        </aop:config>
    </beans>
    
    展开全文
  • color=red size=72 face=" 事务声明声明式事务和编程式事务区别" 我是黑体字 我是微软雅黑 我是华文彩云 color=red size=72 face=“黑体” color=blue color=gray
  • 详解 Spring 声明式事务

    千次阅读 2019-06-13 23:48:25
    Spring的事务机制包括声明式事务和编程式事务。 编程式事务管理:Spring推荐使用 TransactionTemplate,实际开发中使用声明式事务较多。 声明式事务管理:将我们从复杂的事务处理中解脱出来,获取连接,关闭连接...
  • Spring 声明式事务

    万次阅读 2019-06-22 22:04:27
    声明式事务: 环境搭建: 1、导入相关依赖 数据源、数据库驱动、Spring-jdbc模块 2、配置数据源、JdbcTemplate(Spring提供的简化数据库操作的工具)操作数据 3、给方法上标注@Transactional标识当前方法是一个...
  • 这篇文章主要介绍了使用XML 的声明式事务控制的配置方式,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧。 什么是声明式是事务? 声明式事务就是不需要在业务逻辑代码中...
  • Spring AOP声明式事务

    千次阅读 2018-09-19 23:43:08
    Spring AOP声明式事务Spring AOP声明式事务传统spring配置SpringBoot配置总结 Spring AOP声明式事务 Spring AOP声明式事务可以帮我们自动管理事务,在业务操作前后加入事务开始和提交,根据约定的命名规则,进行...
  •  Spring提供了丰富的事务管理功能,Spring的事务管理分为编程式事务管理和声明式事务管理两种方式。编程式事务管理指通过编码的方式实现事务管理,声明式事务基于AOP,将业务逻辑与事务处理解耦。声明式事务对代码...
  • Spring的声明式事务底层原理

    千次阅读 2018-11-17 19:54:16
    文章目录声明式事务的概述声明式事务的初探声明式事务的源码分析 声明式事务的概述 Spring 的声明式事务管理在底层是建立在 AOP 的基础之上的。其本质是对方法前后进行拦截,然后在目标方法开始之前创建或者加入一...
  • SpringBoot声明式事务的简单运用

    万次阅读 多人点赞 2018-06-27 14:01:56
    Spring声明式事物的实现,有两种方式;第一种是配置xml,第二种是使用相关注解(这两种方式可详见《程序员成长笔记(一)》的相关章节)。SpringBoot中默认配置了第二种方式,所以,SpringBoot直接使用注解即可。下面...
  • 事务声明声明式事务和编程式事务介绍

    万次阅读 多人点赞 2016-06-24 17:41:42
    编程式事务:所谓编程式事务指的是通过编码方式实现事务,即类似于JDBC编程实现事务管理。...声明式事务 :管理建立在AOP之上的。其本质是对方法前后进行拦截,然后在目标方法开始之前创建或者加入一个事务
  • 编程式事务和声明式事务的区别

    千次阅读 2021-03-05 15:33:05
    声明式事务:就是在aop的基础上,受aop管理的。其本质是对方法前后进行拦截,然后在目标方法开始之前创建或者加入一个事务,在执行完目标方法之后根据执行情况提交或者回滚事务。声明式事务最大的优点就是不需要通过...
  • 事务管理在系统开发中是不可缺少的一部分,Spring提供了很好事务管理机制,主要分为编程式事务和声明式事务两种。 关于事务的基础知识,如什么是事务,数据库事务以及Spring事务的ACID、隔离级别、传播机制、行为等...
  • Springboot2(47)注解事务声明式事务

    万次阅读 多人点赞 2019-06-03 13:58:55
    springboot的事务也主要分为两大类,一是xml声明式事务,二是注解事务,注解事务也可以实现类似声明式事务的方法,关于注解声明式事务,目前网上搜索不到合适的资料,所以在这里,我将自己查找和总结的几个方法写到...
  • 2、事务管理使用spring的声明式事务 当二者同事存在时,事务管理器失效;当注释业务aop拦截时,事务管理生效。 声明式事务是基于动态代理的,如果方法不通过代理的形式调用,事务就会时效。现在如何保证...
  • Spring 声明式事务管理

    万次阅读 多人点赞 2018-06-21 20:41:12
    大多数Spring Framework的用户选择声明式事务管理. 这种方式对应用代码的影响最小, 并且最符合一个非 侵入型轻量级容器的理想.1 理解Spring Framework的声明式事务实现 告诉你简单的为你的类注释上@Transactional的...
  • spring两种事物,编程式事务和声明式事务 编程式事务管理使用TransactionTemplate或者直接使用底层的PlatformTransactionManager。对于编程式事务管理,spring推荐使用TransactionTemplate。 声明式事务管理建立在...
  • spring为我们提供了两种的事务管理,编程式事务管理和声明式事务管理,因为spring提倡使用声明式事务管理,所以笔者本身也具体学习研究和应用声明式事务,这里只详细谈谈声明式事务,而编程式事务就一句概括;...
  • 编程式事务:所谓编程式事务指的是通过编码方式实现事务,即类似于JDBC编程实现事务管理。...声明式事务:管理建立在AOP之上的。其本质是对方法前后进行拦截,然后在目标方法开始之前创建或者加入一个事务,在
  • Spring框架提供编程式事务处理和声明式事务处理。 编程式事务处理就是指在业务代码中利用Spring框架提供的一些类进行事务处理。 声明式事务处理就是指在xml配置文件或注解的方式声明对某个类方法进行事务处理。 通过...
  • 1.编程式事务:编码方式实现事务管理...2.声明式事务:可知编程式事务每次实现都要单独实现,但业务量大功能复杂时,使用编程式事务无疑是痛苦的,而声明式事务不同,声明式事务属于无侵入式,不会影响业务逻辑的实现。
  • Spring声明式事务的实现

    千次阅读 多人点赞 2020-08-15 14:14:08
    目录1. 导入相关jar包2.... 修改,增加声明式事务支持1. 开启Spring的事务处理功能2. 配置事务通知3. 结合AOP实现事务织入10. 再次测试 首先新建一个Spring-MyBatis程序 项目结构: 1. 导入相关jar包 <depe
  • Spring声明式事务

    千次阅读 2015-08-12 20:34:20
    Spring框架对事务管理提供了两种...2> 声明式事务:基于AOP实现(动态代理方式织入事务、提交/回滚事务),只需要要配置文件中配置好事务规则(tx及aop配置或使用@Transactional注解),注解方式开发简洁推荐使用。
  • 什么是声明式事务

    千次阅读 2019-11-04 12:47:37
    声明式事务(declarative transaction management)是Spring提供的对程序事务管理的方式之一。 Spring的声明式事务顾名思义就是采用声明的方式来处理事务。这里所说的声明,就是指在配置文件中申明。用在Spring配置...
  • 本文主要讲述事务模板与声明式事务的优缺点,以及为什么我极力建议大家使用事务模板的原因。
  • Spring JDBC-使用XML配置声明式事务

    千次阅读 2017-09-23 05:49:14
    txmethod元素属性系列Spring对事务管理的支持概述以及 编程式的事务管理Spring JDBC-使用XML配置声明式事务Spring JDBC-使用注解配置声明式事务概述大多数开发者选择声明式事务管理的功能,这种方式对代码的侵入性...
  • spring支持编程式事务管理和声明式事务管理两种方式。 编程式事务管理使用TransactionTemplate或者直接使用底层的PlatformTransactionManager。对于编程式事务管理,spring推荐使用TransactionTemplate。 声明式...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 94,059
精华内容 37,623
关键字:

声明式事务