3.spring boot 如何配置多数据源

Spring Boot可以通过配置多个DataSource实现多数据源的管理，具体步骤如下：
1. 在配置文件中定义多个数据源及其相关属性；
2. 创建多个DataSource bean，并指定对应的配置；
3. 创建对应的JdbcTemplate或者MybatisSqlSessionFactory等实例，并指定对应的DataSource bean。

需要注意的是，不同的数据源需要分别指定不同的事务管理器。另外，可以通过使用@Qualifier注解来指定使用哪个数据源。

相关问题

spring boot 动态多数据源配置demo

好的，下面是一个简单的示例代码，演示Spring Boot如何配置动态多数据源：

@Configuration
public class DataSourceConfig {
    
    @Bean
    @Primary
    @ConfigurationProperties("spring.datasource.primary")
    public DataSource primaryDataSource() {
        return DataSourceBuilder.create().build();
    }
    
    @Bean
    @ConfigurationProperties("spring.datasource.secondary")
    public DataSource secondaryDataSource() {
        return DataSourceBuilder.create().build();
    }
    
    @Bean
    @Primary
    public JdbcTemplate primaryJdbcTemplate(DataSource primaryDataSource) {
        return new JdbcTemplate(primaryDataSource);
    }
    
    @Bean
    public JdbcTemplate secondaryJdbcTemplate(DataSource secondaryDataSource) {
        return new JdbcTemplate(secondaryDataSource);
    }
    
    @Bean
    public DataSourceRoutingAspect dataSourceRoutingAspect() {
        return new DataSourceRoutingAspect();
    }

}

这个示例使用了@ConfigurationProperties和@Bean注解来创建两个数据源和两个JdbcTemplate对象。同时，示例代码还使用了一个@Primary注解来指定一个默认的数据源和JdbcTemplate对象。另外，还创建了一个名为"dataSourceRoutingAspect"的切面，用来实现动态数据源的切换。

希望这个示例对你有所帮助！

spring boot 多数据源配置

### 回答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自带的多数据源配置，另一种是手动配置多数据源。不管使用哪种方式，记得在使用时需要指定使用哪个具体的数据源。