Springboot + mybatis + druid 整合 (Mysql多数据源)

已于 2022-02-07 11:43:04 修改
阅读量1.8k 收藏 10
点赞数 2
文章标签： spring boot java
于 2022-01-14 16:06:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/czc_292/article/details/122486961
版权

Druid单数据源整合

前言

为什么要使用Druid连接池？

通常我们是直接通过mybatis与数据库建立连接，而创建连接的过程是在发起请求和接受请求之间进行的，这样请求就会消耗更多的时间。并且在大型的web项目中，当有成百上千个请求发给数据库时，数据库就会为每个请求都分配一个数据库连接，这样就会导致请求的性能会很差。


而对于druid连接池而言，在tomcat启动时，就会自动创建多个连接对象，并且保存在连接池中。当接收到请求时，直接从连接池中取出，用完后再放回连接池中即可。同时Druid连接池还提供了监控功能可以实时对数据进行分析。

1. 依赖注入

<!--SpringBoot-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <version>2.5.3</version>
</dependency>
<!--druid连接池-->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid-spring-boot-starter</artifactId>
    <version>1.1.21</version>
</dependency>
<!--mybatis-plus  其中mybatis的功能也能用-->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.4.3</version>
</dependency>
<!--添加mysql-->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.26</version>
</dependency>

2. application.yml文件配置

spring:
  datasource:
    druid:
      #开启监控的配置
      stat-view-servlet:
        login-username: admin    #druid登录时的账号密码
        login-password: 123456
        reset-enable: false      #是否开启重置监控数据
        url-pattern: /druid/*    #登录druid网页后缀
        enabled: true            #开启监控
        allow:                   #添加IP白名单,不写就是所有都允许
        #deny:                   #添加IP黑名单
      #监控配置中的 web监控
      web-stat-filter:
        enabled: true           #表示开启
        url-pattern: /*         #url
        #忽略过滤格式
        exclusions: "*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*"
    #数据源1(名字自己定),以下数据对应自己数据库
    jt:
      #以下内容根据自己数据库而定
      username: root
      password: root
      driver-class-name: com.mysql.cj.jdbc.Driver
      url: jdbc:mysql://127.0.0.1:3306/jt?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf8&autoReconnect=true&allowMultiQueries=true
      type: com.alibaba.druid.pool.DruidDataSource
      #druid数据源配置
      initial-size: 5  #初始化大小
      min-idle: 5      #最小连接数
      max-active: 20   #最大连接数
      max-wait: 10000  #最大等待时间(毫秒)
      #监控sql统计时,拦截stat(监控统计的sql),wall(防御sql注入),slf4j(日志用的sql)
      filters: stat,wall
      #druid用来测试连接是否可用的SQL语句,默认值每种数据库都不相同,oracle: select 1 from dual
      validation-query: select 1
      #申请连接时检测validation-query是否有效,降低性能,关闭
      test-on-borrow: false
      #归还连接时检测validation-query是否有效,降低性能,关闭
      test-on-return: false
      #申请连接时检测validation-query是否有效,提高安全性,不影响性能
      test-while-idle: true
      #配置隔多久进行一次检测(检测可以关闭的空闲连接),单位毫秒
      time-between-eviction-runs-millis: 60000
    #数据源2(名字自己定),以下数据对应自己数据库
    mybatisdb:
      #以下内容根据自己数据库而定
      username: root
      password: root
      driver-class-name: com.mysql.cj.jdbc.Driver
      url: jdbc:mysql://127.0.0.1:3306/mybatisdb?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf8&autoReconnect=true&allowMultiQueries=true
      type: com.alibaba.druid.pool.DruidDataSource
      #druid数据源配置
      initial-size: 5  #初始化大小
      min-idle: 5      #最小连接数
      max-active: 20   #最大连接数
      max-wait: 10000  #最大等待时间(毫秒)
      #监控sql统计时,拦截stat(监控统计的sql),wall(防御sql注入),slf4j(日志用的sql)
      filters: stat,wall
      #druid用来测试连接是否可用的SQL语句,默认值每种数据库都不相同,oracle: select 1 from dual
      validation-query: select 1
      #申请连接时检测validation-query是否有效,降低性能,关闭
      test-on-borrow: false
      #归还连接时检测validation-query是否有效,降低性能,关闭
      test-on-return: false
      #申请连接时检测validation-query是否有效,提高安全性,不影响性能
      test-while-idle: true
      #配置隔多久进行一次检测(检测可以关闭的空闲连接),单位毫秒
      time-between-eviction-runs-millis: 60000

3. 对数据源指定对应mapper

当存在多个数据源时，需要进行数据源指定。否则无法识别数据源。

从已经配置的application.yml中可以看出目前有两个数据源 jt 和 mybatisdb。

3.1 配置 jt 数据源

package com.jt.config;

import com.alibaba.druid.pool.DruidDataSource;
import com.baomidou.mybatisplus.core.MybatisConfiguration;
import com.baomidou.mybatisplus.core.MybatisXMLLanguageDriver;
import com.baomidou.mybatisplus.core.config.GlobalConfig;
import com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.type.JdbcType;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import javax.sql.DataSource;

/**
 * @author: czc
 * @date: 2022/1/14 9:24
 * @description:
 */
// @Configuration表示此类为配置类
@Configuration
// @MapperScan表示对此"com.jt.mapper"路径的文件配置 jtSqlSessionTemplate
@MapperScan(basePackages = {"com.jt.mapper"} , sqlSessionTemplateRef = "jtSqlSessionTemplate")
public class JtMybatisConfig {

    @Bean("jtDataSource")
    // @ConfigurationProperties把"spring.datasource.jt"配置路径下的配置用于druid
    @ConfigurationProperties(prefix = "spring.datasource.jt")
    public DataSource jtDataSource(){
        DruidDataSource druid = new DruidDataSource();
        return druid;
    }

    @Bean("jtSqlSessionFactory")
    public SqlSessionFactory jtSqlSessionFactory(
            // @Qualifier用于指定某个bean对象
            @Qualifier("jtDataSource") DataSource dataSource) throws Exception {
        MybatisSqlSessionFactoryBean SqlSessionFactory = new MybatisSqlSessionFactoryBean();
        SqlSessionFactory.setDataSource(dataSource);

        MybatisConfiguration Configuration = new MybatisConfiguration();
        Configuration.setDefaultScriptingLanguage(MybatisXMLLanguageDriver.class);
        Configuration.setJdbcTypeForNull(JdbcType.NULL);
        SqlSessionFactory.setConfiguration(Configuration);
        
        // getResources方法表示resources路径
        // *表示所有
        SqlSessionFactory.setMapperLocations(new PathMatchingResourcePatternResolver().
                getResources("classpath:mappers/*.xml"));
        SqlSessionFactory.setGlobalConfig(new GlobalConfig().setBanner(false));

        return SqlSessionFactory.getObject();
    }

    @Bean("jtSqlSessionTemplate")
    public SqlSessionTemplate jtSqlSessionTemplate(@Qualifier("jtSqlSessionFactory") SqlSessionFactory sqlSessionFactory){
        return new SqlSessionTemplate(sqlSessionFactory);
    }

    // 数据源的事务管理
    @Bean("jtTransactionManager")
    public DataSourceTransactionManager jtTransactionManager(@Qualifier("jtDataSource") DataSource dataSource){
        return new DataSourceTransactionManager(dataSource);
    }

}

3.2 配置 mybatisdb 数据源

package com.jt.config;

import com.alibaba.druid.pool.DruidDataSource;
import com.baomidou.mybatisplus.core.MybatisConfiguration;
import com.baomidou.mybatisplus.core.MybatisXMLLanguageDriver;
import com.baomidou.mybatisplus.core.config.GlobalConfig;
import com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.type.JdbcType;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import javax.sql.DataSource;

/**
 * @author: czc
 * @date: 2022/1/14 9:26
 * @description:
 */
//注释同上的含义
@Configuration
@MapperScan(basePackages = {"com.jt.mapper1"} , sqlSessionTemplateRef = "mybatisdbSqlSessionTemplate")
public class MybatisdbMybatisConfig {

    @Bean("mybatisdbDataSource")
    @ConfigurationProperties("spring.datasource.mybatisdb")
    public DataSource mybatisdbDataSource(){
        DruidDataSource druid = new DruidDataSource();
        return druid;
    }

    @Bean("mybatisdbSqlSessionFactory")
    public SqlSessionFactory mybatisdbSqlSessionFactory(
            @Qualifier("mybatisdbDataSource") DataSource dataSource) throws Exception {
        MybatisSqlSessionFactoryBean SqlSessionFactory = new MybatisSqlSessionFactoryBean();
        SqlSessionFactory.setDataSource(dataSource);

        MybatisConfiguration Configuration = new MybatisConfiguration();
        Configuration.setDefaultScriptingLanguage(MybatisXMLLanguageDriver.class);
        Configuration.setJdbcTypeForNull(JdbcType.NULL);
        SqlSessionFactory.setConfiguration(Configuration);

        SqlSessionFactory.setMapperLocations(new PathMatchingResourcePatternResolver().
                getResources("classpath:mappers1/*.xml"));
        SqlSessionFactory.setGlobalConfig(new GlobalConfig().setBanner(false));

        return SqlSessionFactory.getObject();
    }


    @Bean("mybatisdbSqlSessionTemplate")
    public SqlSessionTemplate jtSqlSessionTemplate(@Qualifier("mybatisdbSqlSessionFactory") SqlSessionFactory sqlSessionFactory){
        return new SqlSessionTemplate(sqlSessionFactory);
    }

    @Bean("mybatisdbTransactionManager")
    public DataSourceTransactionManager jtTransactionManager(@Qualifier("mybatisdbDataSource") DataSource dataSource){
        return new DataSourceTransactionManager(dataSource);
    }
}

注意！！！

1. @MapperScan 路径

//jt数据源
@MapperScan(basePackages = {"com.jt.mapper"} , 
sqlSessionTemplateRef = "jtSqlSessionTemplate")

//mybatisdb数据源
@MapperScan(basePackages = {"com.jt.mapper1"} , 
sqlSessionTemplateRef = "mybatisdbSqlSessionTemplate")

2. xml文件 路径

// jt数据源
SqlSessionFactory.setMapperLocations(new PathMatchingResourcePatternResolver().
                getResources("classpath:mappers/*.xml"));

// mybatisdb数据源
SqlSessionFactory.setMapperLocations(new PathMatchingResourcePatternResolver().
                getResources("classpath:mappers1/*.xml"));

 

4. 检验配置是否生效

登录网页：http://127.0.0.1:8080/druid

注意：把 ip 和 端口 更改成自己的

czc没有钱
关注
  • 2
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
SpringBoot+Mybatis(Mysql/PostgreSQL)多数据源实战详解
Jason Blog
02-13 3447
前言 由于项目中需要使用到多个数据库进行数据验证，所以一开始在网上找了很多资料，但是大部分都是有关SpringBoot + JPA的多数据源整合。之后找到了微笑大神的一篇blog，在这里感谢微笑大神，参考博客请看这里 预先说明 在整合多数据源时，两个或两个以上，一定得定好一个主数据源，不然会报错，比如：事物方面会报错。 @Primary：SpringBoot自动装配时，当出现多个Bean候选...
Springboot+MybatisPlus+多数据源mysql&oracle（终版）
kai641596729的博客
10-13 2770
Springbootp+MybatisPlus+多数据源mysql&oracle（终版） 步骤如下： 1. 引入相关依赖 因oracle为收费数据库，所以需要手动将jar包打入maven仓库）： 注意，因创建Springbooot项目时选择有Mybatis，而所用MybatisPlus已经包含Mybatis，所以需将Mybatis依赖删除； <!--Mybatis-Plus--> <dependency> <gro
创建SpringBoot + Druid + Mybatis项目
先谢郭嘉的博客
09-28 833
本章将讲述如何创建springboot项目，并配置好mysql数据库、druid连接池，以及mybatis的一些配置文件。
Mybatis整合Druid
08-08
mybatis中整合druid，同时提供了mybatis示例代码以及mybatis的增加以及查询操作
druid数据库连接池配置项说明
最新发布
我有一枚大大大太阳
04-22 976
druid数据库连接池配置项说明
durid多数据源配置不同validation-query
frwcode的博客
06-01 6769
之前在网上也能看到很多关于多数据源的配置方式，但是大多都是同种数据库，针对不同数据库类型的资料较少，最近项目需要一个模块同时连接sqlserver、impala和Oracle，在durid中配置
SpringBoot整合Druid和Mybatis
我这孩子从小记性就不好，什么东西都要写下来才放心
07-25 5335
这里使用IntelliJIDEA2022.1.2演示个人认为IDEA用新不用旧，老有人说新版本bug多，其实呢，正在用的时候我是感知不到，相反他会在新版本修复老版本的bug，我觉得新版更好用更智能。如果你也深有其感，去拥抱新版本吧！.........
MySql优化
weixin_53502170的博客
11-21 1312
mysql优化
druid 参数设置
面朝大海，春暖花开
10-25 8380
11）Remove-abandoned-timeout，指的是强制回收的触发时间阈值。4）Validation-query，指的是连接池探测当前连接是否是健康的SQL语句。9）Time-between-eviction-runs-millis指的是触发空闲连接健康探测阈值，需要跟上面的Test-while结合起来。8）Test-while-idle，指的是控制当连接处于空闲状态时，是否需检测连接的健康状态。2）Min-idle：关掉多余连接，保留有效连接，节省数据库的资源，这个值根据应用实际情况调整。
SpringBoot + mybatis-plus + druid 实现mySql与Orcl双数据源
01-12
总结起来，通过SpringBoot、Mybatis-Plus和Druid，我们可以方便地实现双数据源配置，使得应用能同时处理MySQL和Oracle数据库的数据。在实际开发中，要根据业务场景灵活切换数据源，确保数据操作的正确性和效率。同时...
Springboot+mybatis+druid多数据源配置（oracle+mybatis）
07-29
本篇将详细讲解如何在Spring Boot项目中结合Mybatis和Druid实现多数据源配置，以支持Oracle和MySQL两种数据库，并进行数据库的分离调试。 首先，我们要理解Spring Boot的自动配置机制。Spring Boot通过扫描`@...
通过springboot+mybatis+druid配置动态数据源
08-25
通过 SpringBoot、MyBatis 和 Druid 配置动态数据源是一种常见的解决方案，它可以帮助开发者轻松地管理多个数据源，并提供了动态切换数据源的能力。在本文中，我们将通过示例代码详细介绍如何使用 SpringBoot、...
springboot+mysql+oracle+druid 双数据库进行数据同步
08-13
**双数据源**：在SpringBoot中，通过`Spring Boot Data JPA`和`DataSource`配置，我们可以设置多个数据源。这通常需要使用`@Primary`注解来标记主数据源，同时定义另一个数据源。在本项目中，Oracle作为源数据库，...
SpringBoot+MyBatis+Druid+PageHelper实现多数据源并分页.docx
11-17
总的来说，通过Spring Boot、MyBatis、Druid和PageHelper的整合，我们可以轻松地实现多数据源环境下的高效分页查询。这种方式不仅提高了系统的灵活性，也优化了数据库操作的性能，降低了开发难度。同时，Druid提供的...
springboot整合mybatis+druid（详解）
weixin_38568503的博客
11-18 9047
一、创建一个SpringBoot项目 添加部分依赖： 二、引入相关依赖： 需要的依赖预览： 记忆方式：mysql数据库驱动–>druid数据库连接池–>mybatis进行增删改查 ①连接mysql数据库的驱动：mysql数据库驱动依赖mysql-connector-java ②使用druid和springboot整合的数据库连接池的：druid-spring-boot-starter ③进行数据库的增删改查的mybatis和springboot的整合依赖：mybatis-spring-
什么是validationQuery？
热门推荐
Happy_wu的专栏
03-09 3万+
validationQuery是用来验证数据库连接的查询语句，这个查询语句必须是至少返回一条数据的SELECT语句。每种数据库都有各自的验证语句，下表中收集了几种常见数据库的validationQuery。 DataBase validationQuery hsqldb select 1 from INFORMATION_SCHEMA.SYSTE
springboot整合mybatis & druid
lwj_07的博客
08-04 1359
使用springboot整合mybatis代码演示如下所示：数据库信息：数据层：（springboot整合mybatis的时候，数据层使用纯注解形式写sql语句的时候一定要加上@Mapper注解标明，要不然就会报错）实体类：（属性名要保证和数据库字段名一致，要不然查询出来的数据封装不到对象的属性当中）yml配置文件：（只需要写数据库的信息）...
微服务框架（六）Spring Boot集成Mybatis及Druid
若明天不见
08-07 958
　　此系列文章将会描述Java框架Spring Boot、服务治理框架Dubbo、应用容器引擎Docker，及使用Spring Boot集成Dubbo、Mybatis等开源框架，其中穿插着Spring Boot中日志切面等技术的实现，然后通过gitlab-CI以持续集成为Docker镜像。 　　本文为Spring Boot集成Mybatis，包括mybatis-generator的使用 ...
Spring整合Druid
qq_24324041的专栏
12-10 2163
Druid是Java语言中最好的数据库连接池。Druid能够提供强大的监控和扩展功能。 Druid是阿里巴巴开源平台上的一个项目，整个项目由数据库连接池、插件框架和SQL解析器组成。该项目主要是为了扩展JDBC的一些限制，可以让程序员实现一些特殊的需求，比如向密钥服务请求凭证、统计SQL信息、SQL性能收集、SQL注入检查、SQL翻译等，程序员可以通过定制来实现自己需要的功能。 Druid
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、付费专栏及课程。

余额充值