3、什么时候想到使用事务？

4、通常使用JDBC访问数据库，还是mybatis访问数据库，怎么处理事务？

5、问题中事务处理的方式有什么不足？

6、怎么解决不足？

spring boot中配置事务以及使用：

前言：

目前大多数的项目都是通过spring或者springboot来开发的，并且项目里面操作数据库常用的有mybatis\mybatis-plus等，在操作数据库的时候，经常会使用事务的处理，因为在操作数据库的时候，如果出现异常的话，所有的数据库操作都能够回滚操作，避免造成一些异常数据的问题。目前网络上搜索的都是原始的配置方式，比如说使用xml进行bean的配置，或者说直接在方法头上面进行添加注解的方式进行调用的，本文主要介绍通过配置类进行管理实务的方式，统一的管理、统一的处理方式。

事务的相关问题

1、什么是事务？

事务是指一组SQL语句的集合，集合中有多条SQL语句，可以是insert、update、select、delete，希望这些SQL语句执行是一致的，作为一个整体执行。要么都成功，要么都失败。

2、事务的特点（ACID）

原子性（Atomicity）：事务是一个原子操作，由一系列动作组成。事务的原子性确保动作要么全部完成，要么完全不起作用。

一致性（Consistency）：一旦事务完成（不管成功还是失败），系统必须确保它所建模的业务处于一致的状态，而不会是部分完成部分失败。在现实中的数据不应该被破坏。

隔离性（Isolation）：可能有许多事务会同时处理相同的数据，因此每个事务都应该与其他事务隔离开来，防止数据损坏。

持久性（Durability）：一旦事务完成，无论发生什么系统错误，它的结果都不应该受到影响，这样就能从任何系统崩溃中恢复过来。通常情况下，事务的结果被写到持久化存储器中。

3、什么时候想到使用事务？

（1）当操作设计多个表，或者是多个SQL语句的insert、update、delete。需要保证这些语句都是成功才能完成功能，或者都失败是符合要求的。（要么都成功，要么都失败）

（2）事务在java开发中如何运用？

1、事务放在service类的业务方法中，因为业务方法会调用多个dao，执行多条SQL语句

4、通常使用JDBC访问数据库，还是mybatis访问数据库，怎么处理事务？

（1）jdbc访问数据，处理事务。Connection conn；conn.commit();conn.rollback();

（2）mybatis访问数据库，处理事务。SqlSession.commit() ;SqlSession.rollback();

（3）hibernate访问数据库，处理事务，Session.commit(); Session.rollback();

5、问题中事务处理的方式有什么不足？

（1）不同数据库访问技术，处理事务的对象、方法不同。需要了解不同数据库使用事务的原理。

（2）需要掌握多种数据库事务的处理逻辑，什么时候提交事务，什么时候回滚事务。

（3）处理事务的方法种类多。

总结：就是多种数据库访问技术，不同的事务处理的机制、对象、方法。较难掌握。

6、怎么解决不足？

spring提供了处理事务的统一模型，能够使用统一的步骤、方式完成多种不同数据库访问技术的事务处理。使用spring的事务处理机制可以完成mybatis、hibernate访问数据库的事务处理。

7、处理事务，需要怎么做，做什么？

spring处理事务的模型，使用的步骤都是固定的。把事务要使用的信息都提供给spring就可以了。

（1）事务内部提交、回滚事务使用的是事务管理器对象，代替手动commit、rollback。事务管理器是一个接口和其众多的实现类。

接口：PlatformTransactionManager，定义了事务的重要方法 commit、rollback

实现类：spring把每一种数据库访问技术对应的事务处理累都创建好了。

a、mybatis访问数据库—spring创建好的是DataSourceTransactionManager

b、hibernate访问数据库—spring创建好的是HibernateTransactionManager

怎么使用？

只需告诉spring使用哪种数据库的访问技术（框架），声明数据库访问技术对应的事务管理器的实现类，在spring的配置文件中使用<bean>声明就可以了。例如使用mybatis访问数据库：

（2）业务方法需要什么样的事务？说明需要事务的类型。

8、事务的隔离级别

有 5 个值，其中一个是默认。这些常量均是以ISOLATION_开头，即形如：ISOLATION_XXX。

1、DEFAULT：采用DB默认的事务隔离级别。MySQL的默认隔离级别：REPEATABLE_READ（可重复读）；Oracle默认的隔离级别：READ_COMMITTED（读已提交）

2、READ_UNCOMMITTED：读未提交，未解决任何并发问题。

3、READ_COMMITTED：读已提交。解决度脏数据，存在不可重复读与幻读。

4、REPEATABLE_READ：可重复度。解决脏读、不可重复读，存在幻读。

5、SERIALIZABLE：串行化。不存在并发问题。

9、事务的超时时间

表示一个方法最长的执行时间，如果方法执行时超过了这个时间，事务就回滚。单位是秒，整数值，默认是：-1（表示没有限制最长时间）。

10、事务的传播行为

控制业务方法是不是有事务的，是什么样的事务的。共有 7 个传播行为。（标红常用需掌握）

（1）PROPAGATION_REQUIRED：指定的方法必须在事务内执行。若当前存在事务，就加入当前事务中；若当前没有事务，则创建一个新事务。这种创博行为时最常见的选择，也是spring默认的事务传播行为。

（2）PROPAGATION_REQUIRES_NEW：总是新建一个事务，若当前存在事务，就将当前事务挂起，知道新事物执行完毕。

（3）PROPAGATION_SUPPORTS：指定方法支持当前事务，但若当前没有事务，也可以以非事务的方式执行。

（4）PROPAGATION_MANDATORY

（5）PROPAGATION_NESTED

（6）PROPAGATION_NEVER

（7）PROPAGATION_NOT_SUPPORTED

spring boot中配置事务以及使用：

1、进行配置类的处理

#transaction setting###############################################
spring.transaction.aop.aop-pointcut-expression=execution(* com...*ServiceImpl.*(..))
spring.transaction.aop.tx-method-timeout=3600
spring.transaction.aop.require-rule=insert*,update*,delete*,do*
spring.transaction.aop.read-only-rule=query*
spring.transaction.aop.indep-transaction-rule=indep*

第一个配置：该方法主要是为了在操作的时候，扫描包的路径，不是所有的方法都是走事务处理的。

第二个配置：配置处理的时间大小36秒

第三个配置：为了限制规则，比如说方法的名称必须是什么开头的，只有这些方法名称开头的才会走事务的处理

第四个配置：读取的规则的方法名称开头的命名

第五个配置：事务的处理规则

2、创建数据资源配置类：

import java.sql.Connection;
import java.sql.SQLException;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import javax.sql.DataSource;
import org.apache.ibatis.plugin.Interceptor;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.SqlSessionTemplate;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.aop.Advisor;
import org.springframework.aop.aspectj.AspectJExpressionPointcut;
import org.springframework.aop.support.DefaultPointcutAdvisor;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.jdbc.DataSourceProperties;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.interceptor.NameMatchTransactionAttributeSource;
import org.springframework.transaction.interceptor.RollbackRuleAttribute;
import org.springframework.transaction.interceptor.RuleBasedTransactionAttribute;
import org.springframework.transaction.interceptor.TransactionAttribute;
import org.springframework.transaction.interceptor.TransactionInterceptor;

@Configuration
public class SpringBootDatasourceConfig {
    private Logger LOGGER = LoggerFactory.getLogger(SpringBootDatasourceConfig.class);
    @Value("${spring.transaction.aop.tx-method-timeout}")
    private int TX_METHOD_TIMEOUT = 60;
    @Value("${spring.transaction.aop.aop-pointcut-expression}")
    private String AOP_POINTCUT_EXPRESSION;
    @Value("#{'${spring.transaction.aop.require-rule}'.split(',')}")
    private List<String> requireRuleList;
    @Value("#{'${spring.transaction.aop.read-only-rule}'.split(',')}")
    private List<String> readOnlyRuleList;
    @Value("#{'${spring.transaction.aop.indep-transaction-rule}'.split(',')}")
    private List<String> indepTransactionRuleList;
    @Value("${mybatis.mapper-locations}")
    private String MYBATIS_MAPPER_LOCATIONS;
    @Value("${mybatis.config-location}")
    private String MYBATIS_CONFIG_LOCATION;
    @Value("${mybatis.jdbc.dialect.type}")
    private String MYBATIS_JDBC_DIALECT_TYPE;

    public SpringBootDatasourceConfig() {
    }

    @Primary
    @Bean({"db1DataSourceProperties"})
    @ConfigurationProperties(
        prefix = "spring.datasource.db1"
    )
    public DataSourceProperties dataSourceProperties() {
        DataSourceProperties dataSourceProperties = new DataSourceProperties();
        return dataSourceProperties;
    }

    @Primary
    @Bean({"db1DataSource"})
    @ConfigurationProperties(
        prefix = "spring.datasource.db1.tomcat"
    )
    public DataSource db1DataSource(@Qualifier("db1DataSourceProperties") DataSourceProperties dataSourceProperties) {
        DataSource dataSource = dataSourceProperties.initializeDataSourceBuilder().build();
        return dataSource;
    }

    @Primary
    @Bean(
        name = {"db1SqlSessionFactory"}
    )
    public SqlSessionFactory db1SqlSessionFactory(@Qualifier("db1DataSource") DataSource datasource) throws Exception {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(datasource);
        bean.setMapperLocations((new PathMatchingResourcePatternResolver()).getResources(this.MYBATIS_MAPPER_LOCATIONS));
        bean.setConfigLocation((new PathMatchingResourcePatternResolver()).getResource(this.MYBATIS_CONFIG_LOCATION));
        PageInterceptor pageInterceptor = new PageInterceptor();
        Properties properties = new Properties();
        properties.setProperty("dialect", this.MYBATIS_JDBC_DIALECT_TYPE);
        pageInterceptor.setProperties(properties);
        Interceptor[] plugins = new Interceptor[]{pageInterceptor};
        bean.setPlugins(plugins);
        return bean.getObject();
    }

    @Bean({"sqlSessionTemplate"})
    public SqlSessionTemplate db1SqlsessionTemplate(@Qualifier("db1SqlSessionFactory") SqlSessionFactory sessionfactory) {
        SqlSessionTemplate sqlSessionTemplate = new SqlSessionTemplate(sessionfactory);
        if (sqlSessionTemplate != null) {
            Connection connection = null;

            try {
                connection = sqlSessionTemplate.getConnection();
            } catch (Exception var13) {
                this.LOGGER.error("SqlSessionTemplate初始化连接池失败", var13);
            } finally {
                if (connection != null) {
                    try {
                        connection.close();
                    } catch (SQLException var12) {
                        this.LOGGER.error("关闭连接失败", var12);
                    }
                }

            }
        }

        return sqlSessionTemplate;
    }

    @Bean({"txmanager"})
    public DataSourceTransactionManager txManager(@Qualifier("db1DataSource") DataSource dataSource) {
        DataSourceTransactionManager dataSourceTransactionManager = new DataSourceTransactionManager();
        dataSourceTransactionManager.setDataSource(dataSource);
        return dataSourceTransactionManager;
    }

    @Bean({"txAdvice"})
    public TransactionInterceptor txAdvice(@Qualifier("txmanager") DataSourceTransactionManager dataSourceTransactionManager) {
        RuleBasedTransactionAttribute readOnlyRule = new RuleBasedTransactionAttribute();
        readOnlyRule.setReadOnly(true);
        readOnlyRule.setPropagationBehavior(4);
        RuleBasedTransactionAttribute requireRule = new RuleBasedTransactionAttribute();
        requireRule.setRollbackRules(Collections.singletonList(new RollbackRuleAttribute(RuntimeException.class)));
        requireRule.setPropagationBehavior(0);
        requireRule.setIsolationLevel(2);
        requireRule.setTimeout(this.TX_METHOD_TIMEOUT);
        RuleBasedTransactionAttribute indepTransactionRule = new RuleBasedTransactionAttribute();
        indepTransactionRule.setRollbackRules(Collections.singletonList(new RollbackRuleAttribute(RuntimeException.class)));
        indepTransactionRule.setPropagationBehavior(3);
        indepTransactionRule.setIsolationLevel(2);
        indepTransactionRule.setTimeout(this.TX_METHOD_TIMEOUT);
        Map<String, TransactionAttribute> txMap = new HashMap();

        int i;
        String indepTransacdtionAopRule;
        for(i = 0; i < this.requireRuleList.size(); ++i) {
            indepTransacdtionAopRule = (String)this.requireRuleList.get(i);
            txMap.put(indepTransacdtionAopRule.trim(), requireRule);
        }

        for(i = 0; i < this.readOnlyRuleList.size(); ++i) {
            indepTransacdtionAopRule = (String)this.readOnlyRuleList.get(i);
            txMap.put(indepTransacdtionAopRule.trim(), readOnlyRule);
        }

        for(i = 0; i < this.indepTransactionRuleList.size(); ++i) {
            indepTransacdtionAopRule = (String)this.indepTransactionRuleList.get(i);
            txMap.put(indepTransacdtionAopRule.trim(), indepTransactionRule);
        }

        NameMatchTransactionAttributeSource nameMatchTransactionAttributeSource = new NameMatchTransactionAttributeSource();
        nameMatchTransactionAttributeSource.setNameMap(txMap);
        TransactionInterceptor txAdvice = new TransactionInterceptor(dataSourceTransactionManager, nameMatchTransactionAttributeSource);
        return txAdvice;
    }

    @Bean
    public Advisor txAdviceAdvisor(@Qualifier("txAdvice") TransactionInterceptor transactionInterceptor) {
        AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut();
        pointcut.setExpression(this.AOP_POINTCUT_EXPRESSION);
        return new DefaultPointcutAdvisor(pointcut, transactionInterceptor);
    }
}

3、实际代码里面调用实践：

第一种：添加异常方法，直接调用接口，就可以看到相关的效果，只不过需要在数据库变更的后面，添加相关的异常抛出，让整个方法异常，然后看一下这个数据库的记录没有变化，已经回滚了；

第二种：去除异常方法，让整个方法正常执行下去，通过数据库查询一下记录，看一下数据是更新是成功落库的；

总结：

目前网络上面搜索到的都是直接使用的注解进行事务的处理，而不是根据配置文件进行配置规则、以及事务的统一管理处理，比如说方法名称进行切面的处理，那些方法是会进行mybatis（数据库的更新处理会走事务处理），比如说，目前的很多大型公司，或者说需要保持事务一致性的公司都会用到，整个的调用链比较长，如果中途出现了问题，会进行事务的回滚处理，避免了很多的问题（数据库里面存在垃圾数据的问题）；

springboot---mybatis操作事务配置的处理

前言：

事务的相关问题

1、什么是事务？

2、事务的特点（ACID）

3、什么时候想到使用事务？

4、通常使用JDBC访问数据库，还是mybatis访问数据库，怎么处理事务？

5、问题中事务处理的方式有什么不足？

6、怎么解决不足？

7、处理事务，需要怎么做，做什么？

8、事务的隔离级别

9、事务的超时时间

10、事务的传播行为

spring boot中配置事务以及使用：

1、进行配置类的处理

2、创建数据资源配置类：

3、实际代码里面调用实践：

总结：

猜你喜欢