SpringBoot 配置多数据源

1. Maven配置

<?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 http://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.6.3</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <groupId>com.mutiple.datasource.demo</groupId>
    <artifactId>mutiple-datasource-demo</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>com.taosdata.jdbc</groupId>
            <artifactId>taos-jdbcdriver</artifactId>
            <version>2.0.38</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>com.zaxxer</groupId>
            <artifactId>HikariCP</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </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-starter-aop</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.1</version>
        </dependency>
    </dependencies>
</project>

• 第一数据源连接mysql，并且使用JPA，所以引入了spring-boot-starter-data-jpa
• 第二数据源连接tdengine，由于tdengine不能使用JPA操作，所以配置了mybatis操作tdengine，这里引入了mybatis-spring-boot-starter
• 由于同时操作mysql和tdengine，所以引入mysql驱动和tdengine驱动配置 mysql-connector-java 和 taos-jdbcdriver
• 数据库连接池使用默认的连接池 Hikari
• 同时引入springboot相关依赖

2. application.yml文件中的配置

spring:
  datasource:
    primary:
      type: com.zaxxer.hikari.HikariDataSource
      driverClassName: com.mysql.cj.jdbc.Driver
      jdbcUrl: jdbc:mysql://mysql-server:3306/test?useUnicode=true&characterEncoding=utf8&useSSL=false&useLegacyDatetimeCode=false&serverTimezone=UTC&createDatabaseIfNotExist=true
      username: root
      password: root
      poolName: HikariPool-1
      minimumIdle: 5
      maximumPoolSize: 10
      idleTimeout: 600000
      maxLifetime: 1800000
      connectionTimeout: 30000
    secondary:
      type: com.zaxxer.hikari.HikariDataSource
      driverClassName: com.taosdata.jdbc.TSDBDriver
      jdbcUrl: jdbc:TAOS://h1.taosdata.com:6030?timezone=UTC-8&charset=UTF-8&locale=en_US.UTF-8
      username: root
      password: taosdata
      poolName: HikariPool-2
      minimumIdle: 5
      maximumPoolSize: 10
      idleTimeout: 600000
      maxLifetime: 1800000
      connectionTimeout: 30000
  #日志打印执行的SQL
  jpa:
    show-sql: true
    #Hibernate的DDL策略
    hibernate:
      ddl-auto: none

• 这里需要注意：jpa.hibernate.ddl-auto的配置，如果使用某个现成库中的表做测试，要配置none，其中可以配置的值有：
  • create （危险等级：**）
    应用启动的时候，如果数据库中没有对应的表，就会自动根据实体类的结构创建一个表结构。如果表已经存在了就会将表中的数据清空。
  • create-drop（危险等级 ***）
    应用启动的时候，如果数据库中没有对应的表，就会自动根据实体类的结构创建一个表结构。如果表已经存在了就会将表中的数据清空。
    程序停止的时候会将数据库中所有表删除掉。
  • update（危险等级 *）
    应用启动的时候，如果数据库中没有对应的表，就会自动根据实体类的结构创建一个表结构。如果表已经存在了就会判断有没有新增字段或者修改长度之类的，如果有则会更新表结构，不会影响数据。
  • validate 不会更新和删除表或者数据，只会做验证逻辑。
  • none 禁用ddl操作

3. 配置数据源

DatasourceConfig.java文件

/**
 * 创建数据源：如果是一个数据源,springboot在启动时候，自动创建。
 * 如果多个数据源，需要自己手动自动配置，创建数据源，放入容器中
 */
@Slf4j
@Configuration
public class DatasourceConfig {

    @Primary
    @Bean(name = "primaryDatasource")
    @ConfigurationProperties(prefix = "spring.datasource.primary")
    public DataSource primaryDatasource() {
        return DataSourceBuilder.create().build();
    }

    @Bean(name = "secondaryDatasource")
    @ConfigurationProperties(prefix = "spring.datasource.secondary")
    public DataSource secondaryDatasource() {
        return DataSourceBuilder.create().build();
    }

    public static void logDS(DataSource dataSource) {
        HikariDataSource hds = (HikariDataSource) dataSource;
        String info = "\n\n\tHikariCP连接池配置\n\t连接池名称：" +
                hds.getPoolName() +
                "\n\t最小空虚连接数：" +
                hds.getMinimumIdle() +
                "\n\t最大连接数：" +
                hds.getMaximumPoolSize() +
                "\n\t连接超时时间：" +
                hds.getConnectionTimeout() +
                "ms\n\t空虚连接超时时间：" +
                hds.getIdleTimeout() +
                "ms\n\t连接最长生命周期：" +
                hds.getMaxLifetime() +
                "ms\n";
        log.info(info);
    }
}

PrimaryConfig.java 文件

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.orm.jpa.HibernateProperties;
import org.springframework.boot.autoconfigure.orm.jpa.HibernateSettings;
import org.springframework.boot.autoconfigure.orm.jpa.JpaProperties;
import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import javax.annotation.Resource;
import javax.persistence.EntityManager;
import javax.sql.DataSource;
import java.util.Map;


/**
 * 第一数据源msql，用于jpa
 */
@Slf4j
@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(
        entityManagerFactoryRef = "entityManagerFactoryPrimary",
        transactionManagerRef = "transactionManagerPrimary",
        basePackages = {"mutiple.datasource.primary.repository"}) //设置Repository所在位置
public class PrimaryConfig {

    @Autowired
    @Qualifier("primaryDatasource")
    private DataSource primaryDataSource;

    @Resource
    private JpaProperties jpaProperties;

    @Resource
    private HibernateProperties hibernateProperties;

    private Map<String, Object> getVendorProperties() {
        return hibernateProperties.determineHibernateProperties(jpaProperties.getProperties(), new HibernateSettings());
    }

    @Primary
    @Bean(name = "entityManagerPrimary")
    public EntityManager entityManager(EntityManagerFactoryBuilder builder) {
        return entityManagerFactoryPrimary(builder).getObject().createEntityManager();
    }

    @Primary
    @Bean(name = "entityManagerFactoryPrimary")
    public LocalContainerEntityManagerFactoryBean entityManagerFactoryPrimary (EntityManagerFactoryBuilder builder) {
        return builder
                .dataSource(primaryDataSource)
                .packages("mutiple.datasource.primary") //设置实体类所在位置
                .persistenceUnit("primaryPersistenceUnit")
                .properties(getVendorProperties())
                .build();
    }

    @Primary
    @Bean(name = "transactionManagerPrimary")
    public PlatformTransactionManager transactionManagerPrimary(EntityManagerFactoryBuilder builder) {
        return new JpaTransactionManager(entityManagerFactoryPrimary(builder).getObject());
    }
}

SecondaryConfig.java文件

import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Qualifier;
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;

/**
 * 第二数据源dengine，用于mybatis
 */
@Configuration
@MapperScan(basePackages = { SecondaryConfig.PACKAGE }, sqlSessionFactoryRef = "secondSqlSessionFactory")
public class SecondaryConfig {

    static final String PACKAGE = "mutiple.datasource.secondary.dao";
    static final String MAPPER_LOCATION = "classpath:mapper/*.xml";


    @Bean(name = "secondTransactionManager")
    public DataSourceTransactionManager clusterTransactionManager(@Qualifier("secondaryDatasource") DataSource clusterDataSource) {
        return new DataSourceTransactionManager(clusterDataSource);
    }

    @Bean(name = "secondSqlSessionFactory")
    public SqlSessionFactory clusterSqlSessionFactory(@Qualifier("secondaryDatasource") DataSource clusterDataSource)
            throws Exception {
        final SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
        sessionFactory.setDataSource(clusterDataSource);
        sessionFactory.setMapperLocations(new PathMatchingResourcePatternResolver()
                .getResources(SecondaryConfig.MAPPER_LOCATION));
        return sessionFactory.getObject();
    }
}

项目地址
注：运行项目需要tdengine数据库 和 mysql数据库