springBoot-mybatis+druid多数据源

最新推荐文章于 2024-05-30 15:38:25 发布
最新推荐文章于 2024-05-30 15:38:25 发布
阅读量1.3k 收藏 2
点赞数
分类专栏： java后端 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46188681/article/details/123311866
版权

springBoot多数据源

配置多数据源有多种方式，这里使用的是AOP动态代理的方式进行动态切换的。所谓的动态数据源就是，多个数据源，可以进行切换，比如读写分离，读是一个数据源，写又是一个数据源。不过使用这种方式配置的动态数据源不适合动态扩展，当需要新增数据源的时候，只能重启服务进行重新配置，当然也可以使用nacos配置中新做动态刷新，我只是想到可以怎么做，但是具体没有做过。

AbstractRoutingDataSource

动态数据源最核心的就是AbstractRoutingDataSource 这个抽象类，我们只需要继承这个抽象类，然后重写 determineCurrentLookupKey()方法给他返回一个数据源名称就可以了，到时候他会根据你返回的数据源名称去resolvedDataSources这个map集合中找，resolvedDataSources这个map集合的key就是数据源名称，value对应的就是具体的数据库连接。

    @Nullable
    protected abstract Object determineCurrentLookupKey();

这个是父类的方法，我们在子类进行重写。到时候父类会调用determineTargetDataSource()方法确定目标数据源，然后就调用到子类的实现，这也是人家留给我们的一个扩展，让我能动态的确定数据源。

    protected DataSource determineTargetDataSource() {
        Assert.notNull(this.resolvedDataSources, "DataSource router not initialized");
        Object lookupKey = this.determineCurrentLookupKey();
        DataSource dataSource = (DataSource)this.resolvedDataSources.get(lookupKey);
        if (dataSource == null && (this.lenientFallback || lookupKey == null)) {
            dataSource = this.resolvedDefaultDataSource;
        }

        if (dataSource == null) {
            throw new IllegalStateException("Cannot determine target DataSource for lookup key [" + lookupKey + "]");
        } else {
            return dataSource;
        }
    }

引入依赖

<dependencies>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>

        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.1</version>
        </dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-aop</artifactId>
		</dependency>

		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
            <version>8.0.18</version>
		</dependency>
        
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.2.8</version>
        </dependency>
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper</artifactId>
            <version>5.3.0</version>
        </dependency>

    </dependencies>

配置文件

spring:
  datasource:
      master:
            driver-class-name: com.mysql.cj.jdbc.Driver
            type: com.alibaba.druid.pool.DruidDataSource
            url: jdbc:mysql://127.0.0.1:3306/db1?characterEncoding=utf8&connectTimeout=1000&socketTimeout=3000&autoReconnect=true&serverTimezone=UTC
            username: root
            password: root
      slave:
            driver-class-name: com.mysql.cj.jdbc.Driver
            type: com.alibaba.druid.pool.DruidDataSource
            url: jdbc:mysql://122.132.222.110:3306/db2?characterEncoding=utf8&connectTimeout=1000&socketTimeout=3000&autoReconnect=true&serverTimezone=GMT%2B8
            username: root
            password: root

mybatis:
    type-aliases-package: com.compass.mapper
    mapper-locations: classpath:mapper/*.xml
server:
  port: 8080

动态数据源配置

1.定义标识使用那个数据源的注解

@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface TargetDataSource {
    String value();
}

2.数据源配置类

import com.github.pagehelper.PageInterceptor;
import org.apache.ibatis.plugin.Interceptor;
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.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
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.PlatformTransactionManager;

import javax.sql.DataSource;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;


@Configuration
@MapperScan(basePackages = {"com.compass.mapper"})
public class DataSourceConfigurer {

    /**
     * master DataSource
     *
     * @return data source
     * @Primary 注解用于标识默认使用的 DataSource Bean，因为有多个 DataSource Bean，该注解可用于 master
     * 或 slave DataSource Bean, 但不能用于 dynamicDataSource Bean, 否则会产生循环调用
     * @ConfigurationProperties 注解用于从 application.properties 或 application.yml 文件中读取配置，为 Bean 设置属性
     */
    @Bean("master")
    @Primary
    @ConfigurationProperties(prefix = "spring.datasource.master")
    public DataSource master() {
         return new DruidDataSource();
    }

    /**
     * slave DataSource * * @return data source
     */
    @Bean("slave")
    @ConfigurationProperties(prefix = "spring.datasource.slave")
    public DataSource slave() {
      return new DruidDataSource();
    }

    /**
     * Dynamic data source. * * @return the data source
     */
    @Bean("dynamicDataSource")
    public DataSource dynamicDataSource() {
        DynamicRoutingDataSource dynamicRoutingDataSource = new DynamicRoutingDataSource();
        Map<Object, Object> dataSourceMap = new HashMap<>(2);
        dataSourceMap.put("master", master());
        dataSourceMap.put("slave", slave());
        // 将 master 数据源作为默认指定的数据源
        dynamicRoutingDataSource.setDefaultTargetDataSource(master());
        // 将 master 和 slave 数据源作为指定的数据源
        dynamicRoutingDataSource.setTargetDataSources(dataSourceMap);

        // 将数据源的 key 放到数据源上下文的 key 集合中，用于切换时判断数据源是否有效
        DynamicDataSourceContextHolder.dataSourceKeys.addAll(dataSourceMap.keySet());
        return dynamicRoutingDataSource;
    }

    /**
     * 配置 SqlSessionFactoryBean
     *
     * @return the sql session factory bean
     * @ConfigurationProperties 在这里是为了将 MyBatis 的 mapper 位置和持久层接口的别名设置到
     * Bean 的属性中，如果没有使用 *.xml 则可以不用该配置，否则将会产生 invalid bond statement 异常
     *
     * @ConfigurationProperties(prefix = "mybatis") 不写，Reason: No converter found capable of converting from type [java.lang.String] to type [@org.springframework.boot.context.properties.ConfigurationProperties org.mybatis.spring.SqlSessionFactoryBean]
     * Github 资料表明与 SpringBoot 2.0 有关
     */

    /**
     * 方式1：
     * @return
     * @throws Exception
     */
//    @Bean("sqlSessionFactoryBean")
    public SqlSessionFactoryBean sqlSessionFactoryBean() throws Exception {
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        // 配置数据源，此处配置为关键配置，如果没有将 dynamicDataSource 作为数据源则不能实现切换
        sqlSessionFactoryBean.setDataSource(dynamicDataSource());

        // 配置分页插件
        setPagePlugins(sqlSessionFactoryBean);

        // 配置mapper映射路径
        sqlSessionFactoryBean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mapper/*Mapper.xml"));
        return sqlSessionFactoryBean;
    }


    /**
     * 方式2:
     * @return
     * @throws Exception
     */
    @Bean("sqlSessionFactory")
    public SqlSessionFactory sqlSessionFactory() throws Exception {
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();

        sqlSessionFactoryBean.setDataSource(dynamicDataSource());

        // 配置分页插件
        setPagePlugins(sqlSessionFactoryBean);

        // 配置mapper映射路径
        org.apache.ibatis.session.Configuration configuration = new org.apache.ibatis.session.Configuration();
        configuration.setMapUnderscoreToCamelCase(true);
        sqlSessionFactoryBean.setConfiguration(configuration);
        sqlSessionFactoryBean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mapper/*Mapper.xml"));
        return sqlSessionFactoryBean.getObject();
    }

    @Bean
    public SqlSessionTemplate sqlSessionTemplate() throws Exception {
        return new SqlSessionTemplate(sqlSessionFactory());
    }

    /**
     * 分页插件
     * @param sqlSessionFactoryBean
     */
    public void  setPagePlugins(SqlSessionFactoryBean sqlSessionFactoryBean){
        Properties properties = new Properties();
        properties.setProperty("reasonable", "true");
        properties.setProperty("supportMethodsArguments", "true");
        properties.setProperty("pageSizeZero", "true");

        PageInterceptor interceptor = new PageInterceptor();
        interceptor.setProperties(properties);

        sqlSessionFactoryBean.setPlugins(new Interceptor[]{interceptor});
    }


    /**
     * 配置事务管理，如果使用到事务需要注入该 Bean，否则事务不会生效
     * 在需要的地方加上 @Transactional 注解即可
     *
     * @return the platform transaction manager
     */
    @Bean
    public PlatformTransactionManager transactionManager() {
        return new DataSourceTransactionManager(dynamicDataSource());
    }
}

3.控制动态数据源的AOP切面

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;


@Aspect
// 该切面应当先于 @Transactional 执行
@Order(-1)
@Component
public class DynamicDataSourceAspect {
    /** * Switch DataSource * * @param point * @param targetDataSource */
    // @annotation:用来拦截所有被某个注解修饰的方法
    @Before("@annotation(targetDataSource))")
    public void switchDataSource(JoinPoint point, TargetDataSource targetDataSource) {
        if (!DynamicDataSourceContextHolder.containDataSourceKey(targetDataSource.value())) {
            System.out.println("DataSource [{}] doesn't exist, use default DataSource [{}] " + targetDataSource.value());
        } else {
            // 切换数据源
            DynamicDataSourceContextHolder.setDataSourceKey(targetDataSource.value());
            System.out.println("Switch DataSource to [{}] in Method [{}] " +
                    DynamicDataSourceContextHolder.getDataSourceKey() + point.getSignature());
        }
    }

    /** * Restore DataSource * * @param point * @param targetDataSource */
    @After("@annotation(targetDataSource))")
    public void restoreDataSource(JoinPoint point, TargetDataSource targetDataSource) {
        // 将数据源置为默认数据源
        DynamicDataSourceContextHolder.clearDataSourceKey();
        System.out.println("Restore DataSource to [{}] in Method [{}] " +
                DynamicDataSourceContextHolder.getDataSourceKey() + point.getSignature());
    }
}

4.动态数据源的封装

import java.util.ArrayList;
import java.util.List;


public class DynamicDataSourceContextHolder {

    /** 为每个线程维护变量，以避免影响其他线程 */
    private static final ThreadLocal<String> contextHolder = new ThreadLocal<String>() {

        /** 将 master 数据源的 key 作为默认数据源的 key */
        @Override
        protected String initialValue() {
            return "master";
        }
    };


    /** * 数据源的 key 集合，用于切换时判断数据源是否存在 */
    public static List<Object> dataSourceKeys = new ArrayList<>();

    /** *要切换 DataSource @param key 键 */
    public static void setDataSourceKey(String key) {
        contextHolder.set(key);
    }

    /** * 获取当前DataSource @return 数据源key */
    public static String getDataSourceKey() {
        return contextHolder.get();
    }

    /** * To set DataSource as default */
    public static void clearDataSourceKey() {
        contextHolder.remove();
    }

    /** * 检查给定数据源是否在当前数据源列表中 @param  key @return boolean */
    public static boolean containDataSourceKey(String key) {
        return dataSourceKeys.contains(key);
    }
}

5.继承AbstractRoutingDataSource返回确定的数据源

public class DynamicRoutingDataSource extends AbstractRoutingDataSource {
    @Override
    protected Object determineCurrentLookupKey() {
        return DynamicDataSourceContextHolder.getDataSourceKey();
    }
}

基本上配置就完毕了。

大致思路，不是很详细，大家可以自行debug

  1. 在 this.finishBeanFactoryInitialization(beanFactory);刷新工厂初始化单实例bean的时候就会初始化SqlSessionFactoryBean，在初始化SqlSessionFactoryBean的途中去初始化DataSource，给AbstractRoutingDataSource的targetDataSources属性赋值，将我们配置的数据源全部都给他。给AbstractRoutingDataSource的defaultTargetDataSource属性也赋值，指定我们默认的数据源。
  2. 在AbstractRoutingDataSource的afterPropertiesSet()方法中将targetDataSources中的数据源赋值给resolvedDataSources，最后将defaultTargetDataSource的值赋值给resolvedDefaultDataSource
  3. SqlSessionFactoryBean初始化完毕后将SqlSessionFactory传递进去初始化SqlSessionTemplate
  4. 当我们执行service层中业务方法的时候，就会进入到我们的AOP切面的前置通知，将注解上标注的数据源名称赋值给contextHolder
  5. 然后StatementHandler对象执行query（）方法，在执行query（）方法的过程中会去获取数据库连接，然后就来到了我们重写的 determineCurrentLookupKey()方法，我们之前早就在contextHolder中给设置好，所以我们直接从里面取就好了。
  6. 在AbstractRoutingDataSource的determineTargetDataSource（）方法中得到我们返回的数据源名称，然后去resolvedDataSources中去，resolvedDataSources是一个map集合，key就是我们的数据源名称，value就是真实的数据源
  7. 最终我们的StatementHandler获取到数据源连接，就可以去执行具体的SQL了。

以上准备工作做好，我们就可以进行测试业务代码了。

实体类

public class User implements Serializable {

    private int id;
    private String name;
    private int age;
    private String email;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }
    public User() {

    }
    public User(int id, String name, int age, String email) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.email = email;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", email='" + email + '\'' +
                '}';
    }
}

mapper层

mapper接口


@Repository
@Mapper
public interface UserMapper {
    User findById(@Param("id") String id);
    Integer addUser(User user);
}

mapper接口的实现（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.compass.mapper.UserMapper">
    <insert id="addUser" >
        insert into t_user(name, age, email) values (#{name},#{age},#{email});
    </insert>

    <select id="findById" resultType="com.compass.pojo.User">
        select * from t_user where id=#{id};
    </select>
</mapper>

service

service接口

public interface UserService {
    User findById(@Param("id") String id);
    Integer addUser(User user);
}

service实现

import com.compass.dds.TargetDataSource;
import com.compass.mapper.UserMapper;
import com.compass.pojo.User;

import com.compass.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;


@Service
public class UserServiceImpl implements UserService {

    @Autowired
    UserMapper userMapper;


    @TargetDataSource(value = "master") 
    @Override
    public User findById(String id) {

        return userMapper.findById(id);
    }

    @TargetDataSource(value = "slave") 
    @Override
    public Integer addUser(User user) {
        return userMapper.addUser(user);
    }
}

controller

import com.compass.pojo.User;

import com.compass.service.UserService;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;


@RestController
public class HelloController {

    @Resource
    UserService userService;


    @GetMapping("/getUserById/{id}")
    public String getUserById(@PathVariable String id){
        return userService.findById(id).toString();
    }

    @GetMapping("/addUser")
    public String addUser(){
        User user = new User(0,"李四", 25, "lisi@qq.com");
        Integer insertCount = userService.addUser(user);
        return "插入的记录数："+insertCount;
    }



}

我为了方便，没有使用post提交参数，直接用2个get请求也是一样的，两个请求都是不同的数据源，一个数据源是查询，一个数据源是读取。

主启动类就跟正常的启动类一样，这里我就不贴出来了

sql文件

CREATE TABLE `t_user` (
                          `id` int(10) unsigned NOT NULL AUTO_INCREMENT,
                          `name` varchar(255) DEFAULT NULL,
                          `age` int(11) DEFAULT NULL,
                          `email` varchar(255) DEFAULT NULL,
                          PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8mb4;
# 可以放在不同的数据库中，一个读库，一个写库

到这儿springBoot的多数据源配置句完毕了，感谢欣赏，可以配合MySQL主从复制也可以配合别的一些数据同步工具，来达到读写分离的目的，在下一篇文章中，我将给大家讲解，如果使用MySQL主从复制+多数据源完成读写分离。

野生java研究僧
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringBoot+Mybatis+Druid+PageHelper实现多数据源并分页方法
08-26
在本文中，我们将深入探讨如何使用SpringBoot、Mybatis、Druid和PageHelper来实现多数据源和分页功能。首先，SpringBoot是基于Spring框架的简化版本，它旨在简化微服务开发，提供了自动配置、内嵌式Web服务器以及...
SpringBoot + mybatis-plus + druid 实现mySql与Orcl双数据源
01-12
总结起来，通过SpringBoot、Mybatis-Plus和Druid，我们可以方便地实现双数据源配置，使得应用能同时处理MySQL和Oracle数据库的数据。在实际开发中，要根据业务场景灵活切换数据源，确保数据操作的正确性和效率。同时...
springboot+mybatis+druid 多数据源整合
s_156的博客
11-02 1452
       前言：在上一篇文章里面我们进行了spring boot 和 mybatis 的整合 《springboot整合mybatis使用druid数据源》, 文中是使用的单数据源，因为项目中有很多需要用到多数据源的场景，比如主从同步（读写分离）, 或者业务库拆分等，这样就需要操作不同的数据库，所以，集成多数据源就很有必要了。          网上关于 spr...
Spring Boot 整合 Mybatis 实现 Druid 多数据源配置
QiuHaoqian的博客
01-27 3056
目录1 多数据源的应⽤场景2 数据库脚本3 项目结构4 代码依赖 pom.xml配置文件数据源配置类实体类sql映射文件daosrvicecontroller启动类5 小节 1 多数据源的应⽤场景 当业务数据量达到了⼀定程 度，DBA 需要合理配置数据库资源。即配置主库的机器⾼配置，把核⼼⾼频的数据放在主库上；把次要的数据放在从库，低配置。开源节流嘛，就这个意思。把数据放在不同的数据库⾥，就需要通过不同的数据源进⾏操作数据。 这⾥我们举个 springboot-mybatis-mutil-datasour
Springboot+druid+多数据源
最新发布
fonjames的专栏
05-30 922
1.在Spring Boot中配置两个不同的Oracle数据源，你需要在配置类中分别定义两个数据源，并使用AbstractRoutingDataSource来路由到不同的数据源。当然，如果你的应用需要配置多个Druid数据源，并且每个数据源的密码都需要通过自定义的解密方法解密，你可以扩展上面的配置方法以适应多数据源的场景。这样，每次调用到数据源的地方，都会根据你的逻辑动态切换到不同的数据源。3. 使用多数据源在业务代码中，你可以通过@DS注解器来指定使用特定的数据源，或者不指定时使用默认的数据源。
正确可用版：SpringBoot+Mybatis-plus+Druid 实现配置多数据源（数据库）
热门推荐
Oxye
01-04 1万+
前言 此文介绍的是在SpringBoot中使用Mybatis配置多数据源（多个数据库），整合Druid 网上有很多文章，翻了翻，但是都有问题啊，有的是没使用Druid，使用了默认的Hirika，有的是配置文件不给或者给的是Hirika能用的配置，层级不对，所以我自己来记一下 代码 pom文件maven依赖 <dependency> <groupId>com.alibaba</groupId> <artifactId>druid
Springboot + mybatis + druid 整合 (Mysql多数据源)
czc_292的博客
01-14 1867
1. 依赖注入 <!--SpringBoot--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> <version>2.5.3</version> </dependency> <!--druid连接池--
Springboot+mybatis+druid多数据源配置（oracle+mybatis）
07-29
总结，Spring Boot结合Mybatis和Druid实现多数据源配置的过程包括：配置数据源、配置Mybatis、创建数据源切换器、以及针对不同数据库的测试。这一过程涉及了Spring Boot的自动配置、依赖注入、配置属性绑定等多个...
Springboot+Mybatis+Druid多数据源配置
01-14
本教程将围绕"Springboot+Mybatis+Druid多数据源配置"这一主题，详细介绍如何实现这一功能。 首先，Spring Boot简化了Spring应用的初始化和配置。在多数据源场景下，我们可以通过Spring Boot的@...
通过springboot+mybatis+druid配置动态数据源
08-25
通过 SpringBoot、MyBatis 和 Druid 配置动态数据源是一种常见的解决方案，它可以帮助开发者轻松地管理多个数据源，并提供了动态切换数据源的能力。在本文中，我们将通过示例代码详细介绍如何使用 SpringBoot、...
详解Spring Boot整合Mybatis实现 Druid多数据源配置
08-31
他有一个小网站 bysocket.com
Spring Boot整合Mybatis使用druid实现多数据源自动切换
08-24
Spring Boot整合Mybatis使用druid实现多数据源自动切换
springboot + mybatis(通用mapper) + druid多数据源
05-08
springboot + mybatis(通用mapper) + druid多数据源
spring-boot整合mybatis和druid连接池（多数据源）
赶路人儿
05-26 1万+
上一篇文章介绍了 spring-boot整合mybatis和druid连接池如何配置和使用，本篇文章是上篇的扩展，如果业务中出现了需要从多个数据源中获取数据，到底该如何实现？本文主要介绍在一种最为简单的实现方案：多数据源 - 多实例。 在上篇文章中不难看出Spring Boot中，通过为该数据源DataSource初始化一个与之对应的SessionFactory，从而实现连接。因此在面对多数据源的...
mybatis-spring-boot-starter中设定多数据源，并实现Durid的监控
contact97的博客
02-16 1106
实现功能：1： 配置两个数据源，根据不同的mapper路径使用不同的数据连接2 ：使用Druid连接池3：Druid 可监控多个数据源的sql执行操作分析：查看mybatis_spring_boot_stater中关于自动装配的类可知【如上图】，需要自定义实现SqlsessionFactory和SqlSessionTemplate的Bean，其中方法依赖于DataSource数据源。所以需要根据不同的数据源配置，自定义配置不同的数据源Bean。
MyBatis初级实战之四：druid多数据源
2401_84152308的博客
05-03 715
分享一套我整理的面试干货，这份文档结合了我多年的面试官经验，站在面试官的角度来告诉你，面试官提的那些问题他最想听到你给他的回答是什么，分享出来帮助那些对前途感到迷茫的朋友。分享一套我整理的面试干货，这份文档结合了我多年的面试官经验，站在面试官的角度来告诉你，面试官提的那些问题他最想听到你给他的回答是什么，分享出来帮助那些对前途感到迷茫的朋友。
springboot mybatis druid配置多数据源
大灰狼的专栏
05-16 3003
1.项目代码结构： 2，导入基本依赖：记得需要导入mysql驱动mysql-connector-java <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <depen
3分钟搞定SpringBoot+Mybatis+druid多数据源和分布式事务
08-10
# 配置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....

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值