首页 > 软件编程 > java > springboot mybatis事务配置

springboot结合mybatis操作事务配置的处理

2024-07-04 11:21:19 作者：喜欢猪猪

在操作数据库的时候,经常会使用事务的处理,本文主要介绍了springboot结合mybatis操作事务配置的处理,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧

前言：

目前大多数的项目都是通过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访问数据库：

<bean id = "xxx" class = "...DataSourceTransactionManager"/>

（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操作事务配置的处理的文章就介绍到这了,更多相关springboot mybatis事务配置内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！