SpringBoot多数据源配置超快捷方式

首先pom.xml文件 这里SpringBoot版本使用的是

2.2.5.RELEASE

 <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
    <!-- https://mvnrepository.com/artifact/com.baomidou/mybatis-plus-boot-starter -->
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
        <version>3.2.0</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/com.baomidou/dynamic-datasource-spring-boot-starter -->
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>dynamic-datasource-spring-boot-starter</artifactId>
        <version>2.5.4</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.10</version>
        <scope>provided</scope>
    </dependency>
    <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>

 

使用的是操作数据库用的是MyBatisPlus，可以切换成 jdbcTemplate

重中之重引入这个文件，上面已经引入过了，在这在提下

 <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>dynamic-datasource-spring-boot-starter</artifactId>
        <version>2.5.4</version>
    </dependency>

application.yml文件

spring:
  datasource:
#    url: jdbc:mysql://127.0.0.1:3306/demo1
#    username: root
#    password: 123456
#    driver-class-name: com.mysql.cj.jdbc.Driver
    dynamic:
      primary: master #设置默认的数据源或者数据源组,默认值即为master
      strict: false #设置严格模式,默认false不启动. 启动后在未匹配到指定数据源时候回抛出异常,不启动会使用默认数据源.
      datasource:
        master:
          url: jdbc:mysql://127.0.0.1:3306/demo1
          username: root
          password: 123456
          driver-class-name: com.mysql.cj.jdbc.Driver
        slave_1:
          url: jdbc:mysql://127.0.0.1:3306/demo1
          username: root
          password: 123456
          driver-class-name: com.mysql.cj.jdbc.Driver
        slave_2:
          url: jdbc:mysql://127.0.0.1:3306/demo2
          username: root
          password: 123456
          driver-class-name: com.mysql.cj.jdbc.Driver

 

Controller层，我就全部放在启动类了，方便快速测试。

package com.mgk.springboot.mybatisplus.springmybatis;

import com.baomidou.dynamic.datasource.annotation.DS;
import com.mgk.springboot.mybatisplus.springmybatis.entity.User;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@MapperScan("com.mgk.springboot.mybatisplus.springmybatis.dao")
@SpringBootApplication
@RestController
public class SpringmybatisApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringmybatisApplication.class, args);
    }
    @DS("slave_2")
    @RequestMapping("/")
    public String secondary(){
        User user = new User();
        user.setStatus((byte)2);
        user.setName("从库");
        user.setPassword("123456");
        user.insert();
        return "success";
    }
    @DS("slave_1")
    @RequestMapping("/hello")
    public String primary(){
        User user = new User();
        user.setStatus((byte)2);
        user.setName("主库");
        user.setPassword("123456");
        user.insert();
        return "success";
    }
}

 

@DS介绍下

注解	结果
没有@DS	默认数据源
@DS("dsName")	dsName可以为组名也可以为具体某个库的名称

再使用jdbcTemplate查询下之前添加的数据

查询下主库数据

使用jdbcTemplate代码

  @Autowired
    private JdbcTemplate jdbcTemplate;
    @DS("slave_2")//从库
    @RequestMapping("/jdbcv1")
    public String jdbcSecondary(){
        List<Map<String, Object>> maps = jdbcTemplate.queryForList("select * from user");
        maps.forEach(System.out::println);
        return "success";
    }
    @DS("slave_1")//主库
    @RequestMapping("/jdbcv2")
    public String jdbcSprimary(){
        List<Map<String, Object>> maps = jdbcTemplate.queryForList("select * from user");
        maps.forEach(System.out::println);
        return "success";
    }

查看下 dynamic-datasource-spring-boot-starter自动装配读取全局配置文件的源码

@EnableAutoConfiguration注解里面有@Import({AutoConfigurationImportSelector.class})进入该类，加载

getCandidateConfigurations方法

这个方法SpringFactoriesLoader.loadFactoryNames内部就定义了要去哪里读取自动配置类

接下来查看下这个文件，是一个KeyValue类型的，用,\可以配置多个自动配置类

接下来继续进来自动配置类里面查看是如何读取的配置文件 类头是这样的

@Configuration
@EnableConfigurationProperties({DynamicDataSourceProperties.class})//主要负责装配属性的是这个类
@AutoConfigureBefore({DataSourceAutoConfiguration.class})//
@Import({DruidDynamicDataSourceConfiguration.class})
public class DynamicDataSourceAutoConfiguration {

DynamicDataSourceProperties.class类的内部咱们继续下面看

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package com.baomidou.dynamic.datasource.spring.boot.autoconfigure;

import com.baomidou.dynamic.datasource.spring.boot.autoconfigure.druid.DruidConfig;
import com.baomidou.dynamic.datasource.spring.boot.autoconfigure.hikari.HikariCpConfig;
import com.baomidou.dynamic.datasource.strategy.DynamicDataSourceStrategy;
import com.baomidou.dynamic.datasource.strategy.LoadBalanceDynamicDataSourceStrategy;
import java.util.LinkedHashMap;
import java.util.Map;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.context.properties.NestedConfigurationProperty;

@ConfigurationProperties(
    prefix = "spring.datasource.dynamic"
)
public class DynamicDataSourceProperties {
    private String primary = "master";
    private Boolean strict = false;
    private Boolean p6spy = false;
    private Map<String, DataSourceProperty> datasource = new LinkedHashMap();
    private Class<? extends DynamicDataSourceStrategy> strategy = LoadBalanceDynamicDataSourceStrategy.class;
    private Integer order = -2147483648;
    @NestedConfigurationProperty
    private DruidConfig druid = new DruidConfig();
    @NestedConfigurationProperty
    private HikariCpConfig hikari = new HikariCpConfig();

    public DynamicDataSourceProperties() {
    }

    public String getPrimary() {
        return this.primary;
    }

    public Boolean getStrict() {
        return this.strict;
    }

    public Boolean getP6spy() {
        return this.p6spy;
    }

    public Map<String, DataSourceProperty> getDatasource() {
        return this.datasource;
    }

    public Class<? extends DynamicDataSourceStrategy> getStrategy() {
        return this.strategy;
    }

    public Integer getOrder() {
        return this.order;
    }

    public DruidConfig getDruid() {
        return this.druid;
    }

    public HikariCpConfig getHikari() {
        return this.hikari;
    }

    public void setPrimary(String primary) {
        this.primary = primary;
    }

    public void setStrict(Boolean strict) {
        this.strict = strict;
    }

    public void setP6spy(Boolean p6spy) {
        this.p6spy = p6spy;
    }

    public void setDatasource(Map<String, DataSourceProperty> datasource) {
        this.datasource = datasource;
    }

    public void setStrategy(Class<? extends DynamicDataSourceStrategy> strategy) {
        this.strategy = strategy;
    }

    public void setOrder(Integer order) {
        this.order = order;
    }

    public void setDruid(DruidConfig druid) {
        this.druid = druid;
    }

    public void setHikari(HikariCpConfig hikari) {
        this.hikari = hikari;
    }
}

@ConfigurationProperties//这个注解配置了，application.yml前缀自己可以去对应下

下面是他的属性

primary

strict

datasource 存放数据库连接属性的