Spring Boot多数据源配置

最新推荐文章于 2024-08-22 11:13:11 发布
最新推荐文章于 2024-08-22 11:13:11 发布
阅读量236 收藏 1
点赞数
分类专栏： springboot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/csdn_cai/article/details/117958547
版权

这里的案例使用的 mysql数据源以及clickHouse数据源

创建Spring Boot项目引入依赖

<?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.4.7</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.mn</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>demo</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-webflux</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>ru.yandex.clickhouse</groupId>
            <artifactId>clickhouse-jdbc</artifactId>
            <version>0.3.1</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.2.5</version>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.4.0</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>io.projectreactor</groupId>
            <artifactId>reactor-test</artifactId>
            <scope>test</scope>
        </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>

书写application.yml

#配置多数据源
spring:
  firstdatasource:
    primary:
      username: test
      password: test
      url: jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=UTF-8&autoReconnect=true&useSSL=false&zeroDateTimeBehavior=convertToNull&serverTimezone=Asia/Shanghai
      driver-class-name: com.mysql.cj.jdbc.Driver
  seconddatasouce:
    secondary:
      username: test
      password: test
      url: jdbc:clickhouse://localhost:8123/test
      driver-class-name: ru.yandex.clickhouse.ClickHouseDriver

书写与配置文件对应的实体类

@Data
public class MysqlDataSource {
    private String url;
    private String username;
    private String password;
    private String driverClassName;
}

数据源配置

多数据源配置的时候注意，必须要有⼀个主数据源
必须建立指定的目录 classpath:mapper//*Mapper.xml 写一个空的xml即可
classpath:cmapper//*Mapper.xml 写一个空的xml即可
@NestedConfigurationProperty
private MysqlDataSource primary; 这个primary就是我们在配置文件中除去spring.firstdatasource后边的那个对象

@Configuration
@MapperScan(basePackages = MySqlDataSourceConfig.PACKAGE, sqlSessionFactoryRef = "mysqlSqlSessionFactory")
@ConfigurationProperties(value = "spring.firstdatasource",ignoreUnknownFields = false,ignoreInvalidFields = true)
public class MySqlDataSourceConfig {


    /**
     * 精确到 ck ⽬录，以便跟其他数据源隔离
     */
    static final String PACKAGE = "com.mn.**.mapper";
    static final String MAPPER_LOCATION = "classpath:mapper/**/*Mapper.xml";


    @NestedConfigurationProperty
    private MysqlDataSource primary;

    public MysqlDataSource getPrimary() {
        return primary;
    }

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

    /**
     * 设置主数据源
     *
     * @return
     */
    @Bean(name = "mysqlDataSource")
    @Primary
    public DataSource mysqlDataSource() {
        DruidDataSource source = new DruidDataSource();
        source.setUsername(primary.getUsername());
        source.setPassword(primary.getPassword());
        source.setUrl(primary.getUrl());
        source.setDriverClassName(primary.getDriverClassName());
        return source;
    }

    /**
     * 为这个数据源设置事务管理
     */
    @Bean(name = "mysqlDataSourceTransactionManager")
    @Primary
    public DataSourceTransactionManager mysqlDataSourceTransactionManager() {
        return new DataSourceTransactionManager(mysqlDataSource());
    }
    /**
     * 设置mybatis的模版
     */
    @Bean(name = "mysqlSqlSessionFactory")
    @Primary
    public SqlSessionFactory mysqlSqlSessionFactory(@Qualifier("mysqlDataSource") DataSource mysqlDataSource) throws Exception {
        MybatisSqlSessionFactoryBean bean = new MybatisSqlSessionFactoryBean();
        MybatisConfiguration mybatisConfiguration = new MybatisConfiguration();
        mybatisConfiguration.setCallSettersOnNulls(true);
        mybatisConfiguration.setJdbcTypeForNull(JdbcType.NULL);
        mybatisConfiguration.addInterceptor(new PaginationInterceptor());
        bean.setConfiguration(mybatisConfiguration);
        bean.setDataSource(mysqlDataSource);
        bean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources(MySqlDataSourceConfig.MAPPER_LOCATION));
        return bean.getObject();
    }

}

@Configuration
@MapperScan(basePackages = CkDataSourceConfig.PACKAGE, sqlSessionFactoryRef= "ckSqlSessionFactory")
@ConfigurationProperties(value = "spring.seconddatasouce",ignoreUnknownFields = false,ignoreInvalidFields = true)
public class CkDataSourceConfig {

    /**
     * 精确到 primary ⽬录，以便跟其他数据源隔离
     */
    static final String PACKAGE = "com.mn.**.cmapper";
    static final String MAPPER_LOCATION = "classpath:cmapper/**/*.xml";


    @NestedConfigurationProperty
    private MysqlDataSource secondary;

    public MysqlDataSource getSecondary() {
        return secondary;
    }

    public void setSecondary(MysqlDataSource secondary) {
        this.secondary = secondary;
    }

    /**
     * 设置主数据源
     *
     * @return
     */
    @Bean(name = "ckDataSource")
    public DataSource ckDataSource() {
        DruidDataSource source = new DruidDataSource();
        source.setUsername(secondary.getUsername());
        source.setPassword(secondary.getPassword());
        source.setUrl(secondary.getUrl());
        source.setDriverClassName(secondary.getDriverClassName());
        return source;
    }

    /**
     * 为这个数据源设置事务管理
     */
    @Bean(name = "ckDataSourceTransactionManager")
    public DataSourceTransactionManager ckDataSourceTransactionManager(@Qualifier("ckDataSource") DataSource ckDataSource) {
        return new DataSourceTransactionManager(ckDataSource);
    }


    /**
     * 设置mybatis的模版
     */
    @Bean(name = "ckSqlSessionFactory")
    public SqlSessionFactory ckSqlSessionFactory(@Qualifier("ckDataSource") DataSource ckDataSource) throws Exception {

        MybatisSqlSessionFactoryBean bean = new MybatisSqlSessionFactoryBean();
        MybatisConfiguration mybatisConfiguration = new MybatisConfiguration();
        mybatisConfiguration.setCallSettersOnNulls(true);
        mybatisConfiguration.setJdbcTypeForNull(JdbcType.NULL);
        mybatisConfiguration.addInterceptor(new PaginationInterceptor());
        bean.setConfiguration(mybatisConfiguration);
        bean.setDataSource(ckDataSource);
        bean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources(CkDataSourceConfig.MAPPER_LOCATION));
        return bean.getObject();
    }


}
哀愁
关注
专栏目录
Spring Boot入门(20)：使用Mybatis-plus实现Spring Boot多数据源配置，轻松实现数据库读写分离！
**My Coding Family**
08-22 1万+
如何实现多数据源的配置及项目使用，此文教会你，超级简单，开箱即用。
Spring Boot多数据源配置之Template
JustinNeil的博客
08-10 615
Spring Boot多数据源配置之Template前言代码实现依赖引入配置数据源加载配置文件配置JdbcTemplate实例测试 前言   多数据源配置也算是一个常见的开发需求，在Spring和Spring Boot中，对此都有相应的解决方案，不过一般来说，如果有多数据源的需求，还是建议首选分布式数据库中间件 MyCat 去解决相关问题。当然如果一些简单的需求，还是可以使用多数据源的，Sprin...
springboot多数据源配置
07-28
springboot多数据源配置
spring boot多数据源配置
FMSCOTT
01-08 301
在工作的springboot项目中用到了多数据源，在网上搜索了一通没有找到满意的答案，最后通过查看springboot的源代码找到了解决问题的思路； 项目配置文件 #dataBase spring.datasource.type=com.alibaba.druid.pool.DruidDataSource spring.datasource.driver-class-name=oracle.jd...
Spring Boot 多数据源配置详解
baidu_28705493的博客
08-21 980
在现代企业应用中，可能会涉及到多个数据库的使用，如不同模块或服务使用不同的数据库，或者在同一应用中同时连接多个数据库以处理不同的业务需求。为了应对这种需求，Spring Boot 提供了灵活的多数据源配置机制。本文将详细介绍如何在 Spring Boot 中配置多数据源，并通过代码示例来展示具体的实现步骤。
springboot 多数据源配置
学海无涯,我用JAVA
09-19 698
1 yml中的数据库配置中url 要改为jdbc-url(因为我用的jdbc,其他选择相应的url)经过这些配置后,可以同过上述的自定义注解在查询时,传入数据源name选择不同的数据源查询。我准备用 两个mysql 和 mysql+redis两种作为该多数据源配置的说明。2 springboot启动类上一定要加上去掉默认的数据源的配置。这是个大坑,一直报循环依赖的错误.......经过不断的百度解决。多数据源我认为分两种,一种是同源多库,一种是多元多库。config 是动态数据源切换的核心配置。
Spring Boot+Jpa多数据源配置Demo（支持不同数据库）
04-11
总结来说，Spring Boot + JPA 的多数据源配置需要对Spring的配置机制有深入理解，包括自动配置、bean的创建、数据源的切换等。同时，合理组织实体类和数据库访问层，确保代码的可维护性和扩展性。这个名为`...
Spring Boot多数据源及其事务管理配置方法
08-30
Spring Boot多数据源及其事务管理配置是开发中常见的需求，特别是在大型系统中，可能需要连接多个数据库以实现数据隔离或负载均衡。以下是对这个主题的详细讲解。 **一、准备工作** 在开始配置多数据源之前，我们...
Spring Boot 多数据源配置
最新发布
dream_snow2012的专栏
08-22 3672
通过以上配置，您可以在 Spring Boot 项目中成功实现多数据源的管理，分离不同的数据库操作。这样可以轻松处理不同数据源之间的事务以及数据交互，确保应用的高效性和可扩展性。
Springboot多数据源配置
lizhengyu891231的博客
07-12 254
转载自：https://www.cnblogs.com/carrychan/p/9401471.html 目前，业界流行的数据操作框架是 Mybatis，那 Druid 是什么呢？ Druid 是 Java 的数据库连接池组件。Druid 能够提供强大的监控和扩展功能。比如可以监控 SQL ，在监控业务可以查询慢查询 SQL 列表等。Druid 核心主要包括三部分： 1. DruidDriver...
spring boot 配置 多数据源
constant_rain的博客
08-14 562
spring boot 配置 多数据源
springboot 配置多数据源
热门推荐
ba5189tsl的专栏
08-04 4万+
1.首先在创建应用对象时引入autoConfig @ComponentScan @EnableAutoConfiguration public class Application extends SpringBootServletInitializer { public static void main(String[] args) { SpringApplication ap
spring boot 多数据源配置
06-28
### 回答1： Spring Boot 多数据源配置可以通过以下步骤实现： 1. 在 application.properties 或 application.yml 文件中配置多个数据源的连接信息，例如： ``` spring.datasource.primary.url=jdbc:mysql://localhost:3306/db1 spring.datasource.primary.username=root spring.datasource.primary.password=123456 spring.datasource.secondary.url=jdbc:mysql://localhost:3306/db2 spring.datasource.secondary.username=root spring.datasource.secondary.password=123456 ``` 2. 创建多个数据源的配置类，分别注入不同的数据源连接信息，例如： ``` @Configuration public class PrimaryDataSourceConfig { @Bean(name = "primaryDataSource") @Primary @ConfigurationProperties(prefix = "spring.datasource.primary") public DataSource primaryDataSource() { return DataSourceBuilder.create().build(); } } @Configuration public class SecondaryDataSourceConfig { @Bean(name = "secondaryDataSource") @ConfigurationProperties(prefix = "spring.datasource.secondary") public DataSource secondaryDataSource() { return DataSourceBuilder.create().build(); } } ``` 3. 在需要使用的地方注入对应的数据源，例如： ``` @Service public class UserService { @Autowired @Qualifier("primaryDataSource") private DataSource primaryDataSource; @Autowired @Qualifier("secondaryDataSource") private DataSource secondaryDataSource; // ... } ``` 通过以上步骤，就可以实现 Spring Boot 多数据源配置。 ### 回答2： Spring Boot是一个快速开发框架，其简便的配置方法吸引了越来越多的开发人员。在开发应用过程中，经常需要配置多个数据源以进行不同类型的数据操作。本文将介绍如何在Spring Boot中实现多数据源配置。 1. 添加依赖项 在pom.xml中添加以下依赖项： ``` <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-jdbc</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> ``` 2. 创建数据源配置类 我们可以通过编写一个配置类来声明不同的数据源。Spring Boot已经提供了DataSourceBuilder类来帮助我们创建数据源，它支持多种数据源类型，比如HikariCP，Tomcat JDBC等。以下是一个简单的数据源配置类的示例： ``` @Configuration public class DataSourceConfig { @Bean(name = "dataSource1") @ConfigurationProperties("spring.datasource.dataSource1") public DataSource dataSource1() { return DataSourceBuilder.create().type(HikariDataSource.class).build(); } @Bean(name = "dataSource2") @ConfigurationProperties("spring.datasource.dataSource2") public DataSource dataSource2() { return DataSourceBuilder.create().type(HikariDataSource.class).build(); } } ``` 请注意，我们通过使用@ConfigurationProperties注解将属性文件中的相关配置与Bean进行了绑定。 3. 配置JPA 如果您需要使用JPA来访问数据库，您需要在您的配置文件中配置JPA属性： ``` spring.jpa.show-sql=true spring.jpa.hibernate.ddl-auto=update spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL5Dialect ``` 4. 配置事务管理器 由于我们将使用多个数据源，因此需要一个事务管理器来控制跨多个数据源的事务。我们可以使用Spring Boot的PlatformTransactionManager来实现这一点。以下是一个简单的事务管理器配置： ``` @Configuration @EnableTransactionManagement public class TransactionConfig { @Autowired @Qualifier("dataSource1") private DataSource dataSource1; @Autowired @Qualifier("dataSource2") private DataSource dataSource2; @Bean(name = "transactionManager1") public PlatformTransactionManager transactionManager1() { JpaTransactionManager transactionManager = new JpaTransactionManager(); transactionManager.setEntityManagerFactory(entityManagerFactory1().getObject()); transactionManager.setDataSource(dataSource1); return transactionManager; } @Bean(name = "transactionManager2") public PlatformTransactionManager transactionManager2() { JpaTransactionManager transactionManager = new JpaTransactionManager(); transactionManager.setEntityManagerFactory(entityManagerFactory2().getObject()); transactionManager.setDataSource(dataSource2); return transactionManager; } @Bean(name = "entityManagerFactory1") public LocalContainerEntityManagerFactoryBean entityManagerFactory1() { LocalContainerEntityManagerFactoryBean em = new LocalContainerEntityManagerFactoryBean(); em.setDataSource(dataSource1); em.setPackagesToScan("com.example.entity1"); em.setPersistenceUnitName("dataSource1"); HibernateJpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter(); em.setJpaVendorAdapter(vendorAdapter); HashMap<String, Object> properties = new HashMap<>(); properties.put("hibernate.dialect", "org.hibernate.dialect.MySQL5Dialect"); properties.put("hibernate.show_sql", true); em.setJpaPropertyMap(properties); return em; } @Bean(name = "entityManagerFactory2") public LocalContainerEntityManagerFactoryBean entityManagerFactory2() { LocalContainerEntityManagerFactoryBean em = new LocalContainerEntityManagerFactoryBean(); em.setDataSource(dataSource2); em.setPackagesToScan("com.example.entity2"); em.setPersistenceUnitName("dataSource2"); HibernateJpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter(); em.setJpaVendorAdapter(vendorAdapter); HashMap<String, Object> properties = new HashMap<>(); properties.put("hibernate.dialect", "org.hibernate.dialect.MySQL5Dialect"); properties.put("hibernate.show_sql", true); em.setJpaPropertyMap(properties); return em; } } ``` 请注意，我们在此处使用了两个JpaTransactionManager Bean和两个LocalContainerEntityManagerFactoryBean Bean。我们使用@Qualifier注解明确表示了我们是使用哪个数据源配置的事务管理器或者实体管理器工厂Bean。 5. 配置数据库操作模板 最后一步是创建数据库操作模板，它可以使我们在实现数据库访问时更容易。同样，我们需要声明两个不同的模板，每个模板都使用不同的数据源： ``` @Configuration public class JdbcTemplateConfig { @Autowired @Qualifier("dataSource1") private DataSource dataSource1; @Autowired @Qualifier("dataSource2") private DataSource dataSource2; @Bean(name = "jdbcTemplate1") public JdbcTemplate jdbcTemplate1() { return new JdbcTemplate(dataSource1); } @Bean(name = "jdbcTemplate2") public JdbcTemplate jdbcTemplate2() { return new JdbcTemplate(dataSource2); } } ``` 到这里，我们已经完成了Spring Boot的多数据源配置。我们可以使用这些数据源来访问不同的数据库，并使用声明的模板来执行数据库操作。这种方法可以更好地控制事务和并发，并提高应用的可伸缩性。 ### 回答3： 在实际开发中，我们常常需要使用多个数据源来实现数据的存储和读取。而Spring Boot框架提供了很方便的方式来配置多数据源。 Spring Boot支持使用两种方式来配置多数据源：使用Spring Boot自带的多数据源配置和手动配置多数据源。 使用Spring Boot自带的多数据源配置 Spring Boot已经为我们提供了一种默认的多数据源配置方式，我们只需要在application.properties或application.yml中指定多个数据源的配置信息即可。 以application.properties文件中配置MySQL和Oracle数据库为例： ``` spring.datasource.url=jdbc:mysql://localhost:3306/test1 spring.datasource.username=root spring.datasource.password=123456 spring.datasource.driver-class-name=com.mysql.jdbc.Driver spring.datasource.secondary.url=jdbc:oracle:thin:@localhost:1521:orcl spring.datasource.secondary.username=system spring.datasource.secondary.password=123456 spring.datasource.secondary.driver-class-name=oracle.jdbc.driver.OracleDriver ``` 在该示例中，我们定义了两个数据源：一个为MySQL，一个为Oracle。每个数据源有自己的配置信息，如url、username、password以及驱动等，这里省略了其他的配置项。 使用时我们只需要在代码中使用@Qualifier注解指定使用的数据源即可。 手动配置多数据源 如果我们需要更精细的控制多个数据源，我们可以手动配置多数据源。具体实现过程如下： 1.定义多个数据源配置信息类 我们可以创建多个数据源配置信息类，分别对应不同的数据源。每个类中包括了该数据源的一些配置信息，例如url、用户名、密码等。 示例代码： ``` @Configuration @MapperScan(basePackages = "com.example.demo.mapper.mysql", sqlSessionTemplateRef = "test1SqlSessionTemplate") public class Test1DataSourceConfig { @Bean(name = "test1DataSource") @ConfigurationProperties(prefix = "spring.datasource.test1") public DataSource test1DataSource() { return DataSourceBuilder.create().build(); } @Bean(name = "test1SqlSessionFactory") public SqlSessionFactory test1SqlSessionFactory(@Qualifier("test1DataSource") DataSource dataSource) throws Exception { SqlSessionFactoryBean bean = new SqlSessionFactoryBean(); bean.setDataSource(dataSource); return bean.getObject(); } @Bean(name = "test1TransactionManager") public DataSourceTransactionManager test1TransactionManager(@Qualifier("test1DataSource") DataSource dataSource) { return new DataSourceTransactionManager(dataSource); } @Bean(name = "test1SqlSessionTemplate") public SqlSessionTemplate test1SqlSessionTemplate(@Qualifier("test1SqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception { return new SqlSessionTemplate(sqlSessionFactory); } } ``` 示例代码中，我们使用@Configuration注解声明该类为配置类。同时我们使用@MapperScan注解声明了该数据源对应的Mapper类路径以及使用的SqlSessionTemplate，其中test1对应了我们之前定义的一个数据源。 在该类中，我们分别定义了该数据源对应的DataSource、SqlSessionFactory、DataSourceTransactionManager和SqlSessionTemplate。 2.配置多数据源 在上一步中，我们分别定义了多个数据源，下一步是将它们集成到一起。 Spring Boot提供了一个DynamicDataSource类，可以动态的创建数据源和切换数据源。我们可以在其中定义应用中所使用的所有数据源信息。 示例代码： ``` @Configuration public class DataSourceConfig { @Bean @ConfigurationProperties(prefix = "spring.datasource.master") public DataSource masterDataSource() { return DataSourceBuilder.create().build(); } @Bean @ConfigurationProperties(prefix = "spring.datasource.slave") public DataSource slaveDataSource() { return DataSourceBuilder.create().build(); } @Primary @Bean(name = "dynamicDataSource") public DataSource dynamicDataSource(@Qualifier("masterDataSource") DataSource masterDataSource, @Qualifier("slaveDataSource") DataSource slaveDataSource) { Map<Object, Object> targetDataSources = new HashMap<>(); targetDataSources.put(DatabaseType.MASTER, masterDataSource); targetDataSources.put(DatabaseType.SLAVE, slaveDataSource); MyRoutingDataSource dataSource = new MyRoutingDataSource(); dataSource.setDefaultTargetDataSource(masterDataSource); dataSource.setTargetDataSources(targetDataSources); return dataSource; } } ``` 我们在该类中分别定义了两个数据源masterDataSource和slaveDataSource，并通过注解@ConfigurationProperties(prefix="...")来指定相关的配置信息。 在dynamicDataSource方法中创建了一个MyRoutingDataSource对象，并以masterDataSource作为默认数据源。同时将所有数据源，即masterDataSource和slaveDataSource都添加到了一个HashMap中，并调用setTargetDataSources()方法设置到MyRoutingDataSource对象中。此时，我们就完成了对于多数据源的一个完整配置。 在访问数据库时，我们仍然可以像上一种方式那样，使用@Qualifier注解来指定使用哪个数据源: ``` public interface UserMapper { //使用test1数据源查询 @Select("SELECT * FROM user") @ResultType(User.class) @DataSourceType(MyContextHolder.DatabaseType.MYSQL) List<User> selectAll(); //使用test2数据源查询 @DataSourceType(MyContextHolder.DatabaseType.ORACLE) List<User> selectAll2(); } ``` 总结 Spring Boot实现多数据源的方式有两种，一种是使用Spring Boot自带的多数据源配置，另一种是手动配置多数据源。不管使用哪种方式，记得在使用时需要指定使用哪个具体的数据源。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值