SpringBoot+Mybatis+Atomikos实现分布式事务多数据源

最新推荐文章于 2024-06-11 15:51:42 发布
最新推荐文章于 2024-06-11 15:51:42 发布
阅读量377 收藏 3
点赞数 2
分类专栏： 分布式事务 文章标签： spring boot java 分布式事务
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45243783/article/details/120765960
版权

1在数据库中建立两个数据库连接，一个叫做logs,一个叫做order
建表脚本如下：

#logs数据库中
CREATE TABLE `log_info` (
  `id` int(11) NOT NULL,
  `create_time` datetime DEFAULT NULL,
  `content` longtext,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
 
 
#order数据库中
CREATE TABLE `order_info` (
  `id` int(11) NOT NULL,
  `money` double NOT NULL,
  `user_id` varchar(20) DEFAULT NULL,
  `address` varchar(200) DEFAULT NULL,
  `create_time` datetime DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

最终效果如下:
在这里插入图片描述

2.新建一个springboot项目，导入如下依赖
1.导入如下pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.1.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.cd</groupId>
    <artifactId>jta</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>jta</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>

        <!--lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

        <!-- mysql  -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.0</version>
        </dependency>
        
        <!-- 引入atomikos -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jta-atomikos</artifactId>
        </dependency>


        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.20</version>
        </dependency>

    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

2.编写实体类

LogInfo.java

package com.cd.pojo;
import lombok.Data;
import java.util.Date;
@Data
public class LogInfo {
    private Integer id;
    private Date createTime;
    private String content;
}

OrderInfo

package com.cd.pojo;
import lombok.Data;
import java.util.Date;
@Data
public class OrderInfo {
    private Integer id;
    private Double money;
    private String userId;
    private String address;
    private Date createTime;
}

3.编写mapper层接口
LogMapper

 package com.cd.log.mapper;

import com.cd.pojo.LogInfo;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.springframework.stereotype.Component;

import java.util.List;

@Mapper
@Component
public interface LogMapper {

    /**
     * 新增
     * @param logInfo
     * @return
     */
    int insertLogInfo(LogInfo logInfo);

    /**
     * 批量新增
     * @param logInfoList
     * @return
     */
    int insertBatchLogs(@Param("logInfoList") List<LogInfo> logInfoList);

}

对应LogMapper.如下

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.cd.log.mapper.LogMapper">

    <insert id="insertLogInfo">
        insert into log_info(id,create_time,content) values(#{id},#{createTime},#{content})
    </insert>
    <insert id="insertBatchLogs">
        insert into log_info
        (id,create_time,content)
        values
        <foreach collection="logInfoList" item="log" index="index" separator=",">
            (#{log.id},#{log.createTime},#{log.content})
        </foreach>
    </insert>

</mapper>

OrderMapper.java

package com.cd.order.mapper;
import com.cd.pojo.OrderInfo;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.springframework.stereotype.Component;
import java.util.List;
@Mapper
@Component
public interface OrderMapper {

    /**
     * 新增
     *
     * @param orderInfo
     * @return
     */
    int insertOrderInfo(OrderInfo orderInfo);

    /**
     * 批量新增
     *
     * @param orderInfos
     * @return
     */
    int insertBatchOrder(@Param("orderInfos") List<OrderInfo> orderInfos);
}

对应OrderMapper.xml如下

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.cd.order.mapper.OrderMapper">

    <insert id="insertOrderInfo">
        insert into order_info(id,money,user_id,address,create_time)
        values(#{id},#{money},#{userId},#{address},#{createTime})
    </insert>
    <insert id="insertBatchOrder">
        insert into order_info
        (id,money,user_id,address,create_time)
        values
        <foreach collection="orderInfos" item="order" index="index" separator=",">
            (#{order.id},#{order.money},#{order.userId},#{order.address},#{order.createTime})
        </foreach>

    </insert>


</mapper>

4.编写service层接口

OrderService.java

package com.cd.service;

import com.cd.pojo.OrderInfo;

public interface OrderService {

    /**
     * 新增
     * @param orderInfo
     */
    void addOrder(OrderInfo orderInfo);


}

对应实现类

package com.cd.service.impl;
import com.cd.log.mapper.LogMapper;
import com.cd.order.mapper.OrderMapper;
import com.cd.pojo.LogInfo;
import com.cd.pojo.OrderInfo;
import com.cd.service.OrderService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import javax.transaction.Transactional;
import java.util.Date;
import java.util.Random;

@Slf4j
@Service
@Transactional(rollbackOn = Exception.class)
public class OrderServiceImpl implements OrderService {

    @Autowired
    private OrderMapper orderMapper;

    @Autowired
    private LogMapper logMapper;


    @Override
    public void addOrder(OrderInfo orderInfo) {
        int insert = orderMapper.insertOrderInfo(orderInfo);
        log.info("order库新增sql执行条数:{}",insert);

        //测试1 异常回滚
        int i=1/0;

        LogInfo logInfo=new LogInfo();
        logInfo.setId((new Random().nextInt()));
        logInfo.setCreateTime(new Date());
        logInfo.setContent(orderInfo.toString());
        int insert1 = logMapper.insertLogInfo(logInfo);
        log.info("logs库新增sql执行条数:{}",insert1);

        //测试2 异常回滚
//        int i=1/0;
    }

}

配置类（由于只用了两个数据源，这里就有两个读取springboot主配置类的两个类：）

package com.cd.config;

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

/**
 * 数据源1配置类
 * 用于读取配置文件自定义配置
 *
 * 
 */
@Component
@Data
@ConfigurationProperties(prefix = "spring.datasource.druid.master")
public class DBConfig {

    private String url;
    private String username;
    private String password;


}

package com.cd.config;

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

/**
 * 数据源2配置类
 * 用于读取配置文件自定义配置
 */
@Component
@Data
@ConfigurationProperties(prefix = "spring.datasource.druid.slave")
public class DBConfig2 {

    private String url;
    private String username;
    private String password;

}

使用xa数据源统一管理配置信息，每一个数据源对应一个SqlSessionFactoryBean;并且管理各自的mapper，然后配置全局的事务管理器，并将事务管理器纳入到spring容器当中；

package com.cd.config;
import com.mysql.cj.jdbc.MysqlXADataSource;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jta.atomikos.AtomikosDataSourceBean;
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 javax.sql.DataSource;
import java.sql.SQLException;


@Configuration
@MapperScan(basePackages = "com.cd.order.mapper",
        sqlSessionFactoryRef = "firstSqlSessionFactory"
)
public class MybatisDatasourceConfig {

    @Primary
    @Bean(name = "firstDataSource")
    public DataSource firstDataSource(DBConfig config) throws SQLException {
        //获取mysqlXaDataSource
        MysqlXADataSource mysqlXaDataSource = new MysqlXADataSource();
        //数据源配置
        mysqlXaDataSource.setUrl(config.getUrl());
        mysqlXaDataSource.setPinGlobalTxToPhysicalConnection(true);
        mysqlXaDataSource.setPassword(config.getPassword());
        mysqlXaDataSource.setUser(config.getUsername());
        mysqlXaDataSource.setPinGlobalTxToPhysicalConnection(true);
        //将mysql数据源交由Atomikos统一管理
        AtomikosDataSourceBean xaDataSource = new AtomikosDataSourceBean();
        xaDataSource.setXaDataSource(mysqlXaDataSource);
        xaDataSource.setUniqueResourceName("firstDataSource1");
        return xaDataSource;
    }


    /**
     * 设置SqlSessionFactory，每一个数据源一个SqlSessionFactoryBean
     *
     * @param dataSource
     * @return
     * @throws Exception
     */
    @Bean(name = "firstSqlSessionFactory")
    public SqlSessionFactory firstSqlSessionFactory(@Qualifier("firstDataSource") DataSource dataSource) throws Exception {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(dataSource);
        bean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:/mapper/order/*.xml"));
        return bean.getObject();
    }

    @Bean(name = "firstSqlSessionTemplate")
    public SqlSessionTemplate testSqlSessionTemplate(
            @Qualifier("firstSqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception {
        return new SqlSessionTemplate(sqlSessionFactory);
    }
}

package com.cd.config;
import com.mysql.cj.jdbc.MysqlXADataSource;
import lombok.Data;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jta.atomikos.AtomikosDataSourceBean;
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 javax.sql.DataSource;
import java.sql.SQLException;

/**
 * @author Lucifer
 */
@Configuration
@MapperScan(basePackages = "com.cd.log.mapper",
        sqlSessionFactoryRef = "secondSqlSessionFactory"
)
public class MybatisDatasourceConfig2 {


    @Bean(name = "secondDataSource")
    public DataSource secondDataSource(DBConfig2 config2) throws SQLException {
        //获取mysqlXaDataSource
        MysqlXADataSource mysqlXaDataSource = new MysqlXADataSource();
        //配置数据源
        mysqlXaDataSource.setUrl(config2.getUrl());
        mysqlXaDataSource.setPinGlobalTxToPhysicalConnection(true);
        mysqlXaDataSource.setPassword(config2.getPassword());
        mysqlXaDataSource.setUser(config2.getUsername());
        mysqlXaDataSource.setPinGlobalTxToPhysicalConnection(true);
        //将mysql数据源交由Atomikos统一管理
        AtomikosDataSourceBean xaDataSource = new AtomikosDataSourceBean();
        xaDataSource.setXaDataSource(mysqlXaDataSource);
        xaDataSource.setUniqueResourceName("secondDataSource");
        return xaDataSource;
    }


    /**
     * 设置SqlSessionFactory，每一个数据源一个SqlSessionFactoryBean
     *
     * @param dataSource
     * @return
     * @throws Exception
     */
    @Bean(name = "secondSqlSessionFactory")
    public SqlSessionFactory secondSqlSessionFactory(@Qualifier("secondDataSource") DataSource dataSource) throws Exception {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(dataSource);
        bean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:/mapper/log/*.xml"));
        return bean.getObject();
    }

    @Bean(name = "secondSqlSessionTemplate")
    public SqlSessionTemplate testSqlSessionTemplate(
            @Qualifier("secondSqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception {
        return new SqlSessionTemplate(sqlSessionFactory);
    }

}

5.编写application.yaml配置文件如下

spring:
  datasource:
    type: com.alibaba.druid.pool.xa.DruidXADataSource
    druid:
      master:
        driver-class-name: com.mysql.jdbc.Driver
        url: jdbc:mysql://192.168.84.129:3306/order?autoReconnect=true&useSSL=false&characterEncoding=utf-8&zeroDateTimeBehavior=convertToNull
        username: root
        password: 123456
        maxPoolSize: 5
      slave:
        driver-class-name: com.mysql.jdbc.Driver
        url: jdbc:mysql://192.168.84.129:3306/logs?autoReconnect=true&useSSL=false&characterEncoding=utf-8&zeroDateTimeBehavior=convertToNull
        username: root
        password: 123456
        maxPoolSize: 5
server:
  port: 8080
#mybatis:
#  mapper-locations: classpath:/mapper/*.xml
#  type-aliases-package: com.cd.pojo

最后，编写controller层代码进行测试

package com.cd.controller;

import com.cd.pojo.OrderInfo;
import com.cd.service.OrderService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.Date;

@RestController
public class BeController {

    @Autowired
    private OrderService orderService;

    @PostMapping("/insert")
    public void insert(){

        OrderInfo orderInfo = new OrderInfo();
        orderInfo.setAddress("456");
        orderInfo.setCreateTime(new Date());
        orderInfo.setMoney(1.00);
        orderInfo.setId(3);
        orderService.addOrder(orderInfo);
    }

}

进入主启动类，启动代码

package com.cd;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class JtaApplication {

    public static void main(String[] args) {
        SpringApplication.run(JtaApplication.class, args);
    }
}

至此，大功告成，效果如下:
在这里插入图片描述
当往库中插入一条数据的时候，另外一条库也成功，当出现异常时，事务进行回滚，实现了分布式事务管理。

最后，附上该案例的整体结构图，可根据图创建对应文件结构
在这里插入图片描述

我哪会这个啊
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多数据源解决分布式事务问题【SpringBoot+JTA+Atomikos】
a917922724的博客
02-18 884
1：引入依赖 <!--java 事务api 阶段 是xa协议的java实现--> <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-jta-atomikos --> <dependency> <groupId>org.s...
SpringBoot 分布式事务的解决方案（JTA+Atomic+多数据源）
m0_69305074的博客
04-19 871
首先，到底啥是分布式事务呢，比如我们在执行一个业务逻辑的时候有两步分别操作A数据源和B数据源，当我们在A数据源执行数据更改后，在B数据源执行时出现运行时异常，那么我们必须要让B数据源的操作回滚，并回滚对A数据源的操作；这种情况在支付业务时常常出现；比如买票业务在最后支付失败，那之前的操作必须全部回滚，如果之前的操作分布在多个数据源中，那么这就是典型的分布式事务回滚； 了解了什么是分布式事务，那分布式事务在java的解决方案就是JTA(即Java Transaction API)；springboot官..
SpringBoot+Mybatis+atomikos实现分布式事务
酷爱编程的小猿同学
12-23 1028
背景：随着业务的不断发展，数据量的倍增，单个数据库的性能产生瓶颈，我们可能会对数据库进行分区（也就是我们常说的分库分表），这里所说的分区指的是物理分区，分区之后可能不同的库就处于不同的服务器上了，这个时候单个数据库的ACID已经不能适应这种情况了，而在这种ACID的集群环境下，再想保证集群的ACID几乎是很难达到，或者即使能达到那么效率和性能会大幅下降，这个时候我们就会用到分布式事务 Atomikos 是干嘛用的？ Atomikos 是一个为Java平台提供增值服务的并且开源类事务管理器，主要用于处理.
ruoyi诺依框架集成mybatisplus+atomikos分布式事务，解决pagehelper失效
java_xy_的博客
03-23 1762
本项目是ruoyi的分离版，官网只有mybatis+atomikos，本文用于集成mybatisplus+atomikos，已用于实际项目中，不同环境依赖包版本不一致可能需要自行修改。
springboot连接多个库
最新发布
sunyingboaini的博客
06-11 419
一个SpringBoot项目，同时连接两个数据库：比如一个是Mysql数据库，一个是oracle数据库（啥数据库都一样，连接两个同为oracle的数据库，或两个不同的数据库，只需要更改对应的driver-class-name和jdbc-url等即可）注意：连接什么数据库，要引入对应数据库的包。
SpringBoot使用MyBatis 集成Atomikos 实现分布式事务 管理多数据源
路西法Lucifer
11-22 695
1.项目结构： 2.配置：（最重要） 由于只用了两个数据源，这里就有两个读取springboot主配置类的两个类： package com.lucifer.config; import lombok.Data; import org.springframework.boot.context.properties.ConfigurationProperties; /** * 数...
【分布式】springboot + mybatis + JTA + Atomikos 实现多数据源的分布式事务管理
王如霜
05-24 3090
文章目录1. 添加依赖(pom.xml)2. 配置数据库连接信息 （application.yml）3. 读取配置文件信息4. 创建多数据源5. 启动项添加@EnableConfigurationProperties6. 测试使用事务注解 spring boot默认继承事务，只要在方法上添加@Transaction注解即可， 但是这种只适用与单数据源，在多数据源下就不再适用，比如在一个servic...
Spring Boot+Atomikos进行多数据源的分布式事务管理详解和实例
日拱一卒无有尽，功不唐捐终入海
08-24 3517
背景： 一直零散的使用着Spring Boot 的各种组件和特性，从未系统性的学习和总结，本次借着这个机会搞一波。共同学习，一起进步。哈哈Atomikos是一个易用、可靠、开放源码的事务管理器，它可以用于管理分布式事务，尤其在微服务架构中非常实用。它支持JTA（Java Transaction API）规范，能够与各种JTA兼容的资源管理器（如数据库和消息队列）配合使用。
Spring使用MyBatis 集成Atomikos 实现分布式事务 管理多数据源
路西法Lucifer
11-22 326
项目结构： 2.实体类（order类;logInfo类） package com.lucifer.pojo; import lombok.Data; import java.util.Date; /** * @author Lucifer */ @Data public class LogInfo { private Integer id; private...
SpringBoot+mybatisPlus+atomikos+druid.zip
09-07
Spring Boot：mybatis-plus + atomikos + druid 实现不同实例数据库的多数据源配置和分布式事务管理（demo项目），想到工作上可能会用到多数据源，但是自己在这方面并不是很熟悉，于是在网上查阅了很多文章，结果...
Spring Boot + Druid + Mybatis + Atomikos 配置多数据源 并支持分布式事务
01-23
本教程将探讨如何利用Spring Boot、Druid、Mybatis以及Atomikos来配置多数据源并实现分布式事务。 首先，Spring Boot是Java生态系统中的一个流行框架，它简化了设置和配置过程，使得开发人员可以快速启动新项目。在...
springboot + mybatis + atomikos 多数据源分布式事物管理
05-18
springboot + mybatis + atomikos 多数据源分布式事物管理;springboot + mybatis + atomikos 多数据源分布式事物管理
SpringBoot+Atomikos分布式事务及多数据源动态切换，两种demo
08-29
SpringBoot+Atomikos分布式事务及多数据源动态切换，两种demo，两条数据源，是满足事务唯一性的，看清楚是demo
springboot+mybatis+jta+atomikos解决多数据源事务问题.pdf
05-21
springboot+mybatis+jta+atomikos解决多数据源事务问题
springboot+mybatis+druid+atomikos 多数据源，分布式事务，集成websocket，redis，swagger2
11-12
在本项目中，我们主要探讨的是如何利用Spring Boot、MyBatis、Druid、Atomikos、WebSocket、Redis以及Swagger2构建一个具有多数据源、分布式事务管理，并且集成了实时通信与API文档管理功能的高级应用。下面将对这些...
Spring boot+Atomikos+JTA+Hibernate+mybatis+MySQL实现分布式事务+多数据源
10-08
本案例主要探讨如何利用Spring Boot、Atomikos、JTA（Java Transaction API）、Hibernate以及MyBatis，结合MySQL数据库，实现一个跨数据源的分布式事务解决方案。 首先，Spring Boot是一个基于Spring框架的快速开发...
超简单 springboot+ mybatisplus+atomikos实现多数据源分布式事务
峰子哥哥的博客
09-30 4790
jdk环境：1.8 springboot：2.1.3.RELEASE mybatisplus：3.2.0 本文主要用atomikos的AtomikosNonXADataSourceBean配置连接池，另一个是AtomikosDataSourceBean，是支持第三方如druid配置管理连接池，具体实现请参考我的另一篇文章：超简单 springboot+ mybatisplus+druid ...
Atomikos + MybatisPlus解决多数据源事务一致性问题
who_I_am__的博客
10-15 583
Atomikos + MybatisPlus解决多数据源事务一致性问题
spring jta 分布式事物配置
weixin_38836909的博客
06-30 536
在项目中需要操作多个数据库，同时，需要保证操作的原子性，保证对多个数据库的操作一致性，而传统的JDBC事务被限定在一个单一的数据库连接中，故引用JTA，即Java Transaction API。JTA事务比JDBC事务更强大，一个JTA事务可以有多个数据源参与者。 现在，我们用spring+jta+mybatis来完成基本的测试框架。 1 配置多数据源 application.xml
3分钟搞定SpringBoot+Mybatis+druid多数据源和分布式事务
08-10
### 回答1： 首先，为了使用多数据源和分布式事务，我们需要添加以下依赖： ```xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-jdbc</artifactId> </dependency> <dependency> <groupId>com.alibaba</groupId> <artifactId>druid-spring-boot-starter</artifactId> <version>1.1.6</version> </dependency> <dependency> <groupId>org.mybatis.spring.boot</groupId> <artifactId>mybatis-spring-boot-starter</artifactId> <version>2.2.0</version> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-jta-atomikos</artifactId> </dependency> ``` 接下来，我们需要在application.properties文件中配置数据源和事务管理器： ```properties # 配置主数据源 spring.datasource.url=jdbc:mysql://localhost:3306/main_db?characterEncoding=utf8&useSSL=false spring.datasource.username=root spring.datasource.password=root spring.datasource.driver-class-name=com.mysql.jdbc.Driver # 配置从数据源 spring.datasource.slave.url=jdbc:mysql://localhost:3306/slave_db?characterEncoding=utf8&useSSL=false spring.datasource.slave.username=root spring.datasource.slave.password=root spring.datasource.slave.driver-class-name=com.mysql.jdbc.Driver # 配置Mybatis mybatis.mapper-locations=classpath:mapper/*.xml mybatis.type-aliases-package=com.example.entity # 配置Druid数据源 spring.datasource.type=com.alibaba.druid.pool.DruidDataSource spring.datasource.druid.initial-size=1 spring.datasource.druid.max-active=10 spring.datasource.druid.min-idle=1 spring.datasource.druid.max-wait=60000 spring.datasource.druid.time-between-eviction-runs-millis=60000 spring.datasource.druid.min-evictable-idle-time-millis=300000 spring.datasource.druid.test-while-idle=true spring.datasource.druid.test-on-borrow=false spring.datasource.druid.test-on-return=false spring.datasource.druid.filters=stat,wall,log4j spring.datasource.druid.connection-properties=druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000 # 配置事务管理器 spring.transaction.default-timeout=600 spring.transaction.rollback-on-commit-failure=true spring.transaction.allow-bean-definition-overriding=true spring.transaction.jta.registry-name=atomikos spring.jta.enabled=true spring.jta.atomikos.connectionfactory.min-pool-size=5 spring.jta.atomikos.connectionfactory.max-pool-size=10 spring.jta.atomikos.connectionfactory.borrow-connection-timeout=30 spring.jta.atomikos.connectionfactory.max-idle-time=60 spring.jta.atomikos.connectionfactory.concurrency-level=100 ``` 然后，我们需要创建两个数据源的配置类，分别为主数据源和从数据源： ```java @Configuration @MapperScan(basePackages = "com.example.mapper.main", sqlSessionTemplateRef = "mainSqlSessionTemplate") public class MainDataSourceConfig { @Bean(name = "mainDataSource") @ConfigurationProperties(prefix = "spring.datasource") public DataSource mainDataSource() { return DruidDataSourceBuilder.create().build(); } @Bean(name = "mainSqlSessionFactory") public SqlSessionFactory mainSqlSessionFactory(@Qualifier("mainDataSource") DataSource dataSource) throws Exception { SqlSessionFactoryBean bean = new SqlSessionFactoryBean(); bean.setDataSource(dataSource); bean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mapper/main/*.xml")); return bean.getObject(); } @Bean(name = "mainTransactionManager") public DataSourceTransactionManager mainTransactionManager(@Qualifier("mainDataSource") DataSource dataSource) { return new DataSourceTransactionManager(dataSource); } @Bean(name = "mainSqlSessionTemplate") public SqlSessionTemplate mainSqlSessionTemplate(@Qualifier("mainSqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception { return new SqlSessionTemplate(sqlSessionFactory); } } ``` ```java @Configuration @MapperScan(basePackages = "com.example.mapper.slave", sqlSessionTemplateRef = "slaveSqlSessionTemplate") public class SlaveDataSourceConfig { @Bean(name = "slaveDataSource") @ConfigurationProperties(prefix = "spring.datasource.slave") public DataSource slaveDataSource() { return DruidDataSourceBuilder.create().build(); } @Bean(name = "slaveSqlSessionFactory") public SqlSessionFactory slaveSqlSessionFactory(@Qualifier("slaveDataSource") DataSource dataSource) throws Exception { SqlSessionFactoryBean bean = new SqlSessionFactoryBean(); bean.setDataSource(dataSource); bean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mapper/slave/*.xml")); return bean.getObject(); } @Bean(name = "slaveTransactionManager") public DataSourceTransactionManager slaveTransactionManager(@Qualifier("slaveDataSource") DataSource dataSource) { return new DataSourceTransactionManager(dataSource); } @Bean(name = "slaveSqlSessionTemplate") public SqlSessionTemplate slaveSqlSessionTemplate(@Qualifier("slaveSqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception { return new SqlSessionTemplate(sqlSessionFactory); } } ``` 最后，我们需要在事务管理器上添加注解@EnableTransactionManagement，并在需要使用事务的方法上添加注解@Transactional： ```java @Service public class UserServiceImpl implements UserService { @Autowired private UserMapper userMapper; @Transactional(rollbackFor = Exception.class, transactionManager = "mainTransactionManager") @Override public void save(User user) { userMapper.insert(user); } @Transactional(rollbackFor = Exception.class, transactionManager = "slaveTransactionManager") @Override public User findById(int id) { return userMapper.selectByPrimaryKey(id); } } ``` 以上就是使用SpringBoot+Mybatis+druid多数据源和分布式事务的基本步骤。 ### 回答2： Spring Boot是一个用于构建独立的、生产级的应用程序的框架。它简化了应用程序的开发过程，并通过自动配置来减少了繁琐的配置。MyBatis是一个ORM（对象关系映射）框架，它提供了将数据库操作映射到Java对象的功能。Druid是一种高性能的数据库连接池。 要在Spring Boot中使用MyBatis和Druid进行多数据源配置和分布式事务管理，可以按照以下步骤进行操作： 1. 添加依赖：在项目的pom.xml文件中，添加Spring Boot、MyBatis和Druid的依赖。 2. 配置数据源：在application.properties文件中，配置并命名多个数据源，设置数据库连接等信息。 3. 创建数据源配置类：创建一个配置类，使用@Configuration注解将其标记为配置类，并使用@ConfigurationProperties注解将数据源属性注入。 4. 创建数据源：根据配置类中的属性，创建多个数据源，并将其加入到数据源路由器中。 5. 配置MyBatis：创建一个配置类，使用@MapperScan注解设置MyBatis的mapper接口路径，并将数据源注入到SqlSessionFactory中。 6. 配置分布式事务：使用@EnableTransactionManagement注解启用事务管理，并配置事务管理器。 7. 编写数据库操作代码：在mapper接口中定义数据库操作方法，并在Service层中调用这些方法进行数据库操作。 通过以上步骤，你就可以在Spring Boot项目中完成MyBatis和Druid的多数据源配置和分布式事务管理。不过需要注意的是，使用多数据源和分布式事务会增加项目的复杂性和性能开销，所以在使用之前需要仔细考虑是否真正需要这些功能。 ### 回答3： Spring Boot是一种快速构建Java应用程序的框架，MyBatis是一种流行的Java持久化框架，Druid是一种高性能的数据库连接池。本文将介绍如何在Spring Boot中使用MyBatis和Druid来实现多数据源和分布式事务。 要使用多个数据源，我们首先需要配置多个数据源。在Spring Boot中，我们可以通过在application.properties或者application.yml文件中配置多个数据源的连接信息。我们需要为每个数据源指定不同的URL、用户名和密码。然后，我们可以使用@Primary和@Qualifier来指定主数据源和其他数据源。 在配置数据源后，我们需要配置MyBatis来使用这些数据源。我们可以通过创建多个SqlSessionFactory来实现多数据源，然后在每个SqlSessionFactory中设置相应的数据源。我们还可以使用@MapperScan注解来自动扫描和注册Mapper接口。 在使用MyBatis和多个数据源时，我们可能会遇到事务管理的问题。为了解决这个问题，我们可以使用Spring Boot提供的@Transactional注解来标记需要进行事务管理的方法，然后Spring Boot会自动为我们处理事务。对于需要跨多个数据源进行事务管理的情况，我们可以使用JTA（Java Transaction API）实现分布式事务。在Spring Boot中，我们可以使用Atomikos或Bitronix等JTA提供商来实现分布式事务。 总结起来，使用Spring Boot、MyBatis和Druid，我们可以很容易地实现多数据源和分布式事务。通过正确配置数据源和使用相关注解，我们可以在几分钟内完成这些任务。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值