spring动态数据源怎么用

使用Spring动态数据源可以实现在运行时动态切换数据源，方便在多数据源的场景下灵活的切换数据库。下面是使用Spring动态数据源的步骤：

1、添加依赖
首先，在项目的pom.xml文件中添加spring-boot-starter-jdbc依赖，以及对应数据库的驱动依赖。例如，使用MySQL数据库，则添加mysql-connector-java的依赖。

2、配置数据源
在Spring Boot的配置文件中，配置多个数据源的相关信息。通常，可以在application.properties或application.yml文件中配置数据源的参数，包括数据库的URL、用户名、密码等。

3、创建动态数据源配置类
创建一个DynamicDataSourceConfig类来配置动态数据源。在该类中，需要实现接口InitializingBean，并重写afterPropertiesSet方法。在该方法中，可以通过读取配置文件的方式，动态创建多个数据源，并将这些数据源保存在一个Map中。

4、自定义切换数据源注解
创建一个自定义注解，用于在方法或类上标识使用的数据源。可以使用@Target和@Retention注解来确定注解的使用范围和生命周期。

5、创建切面
使用切面技术，在方法执行前切换数据源。可以通过@Around注解在方法前后织入代码，在方法执行前判断注解是否存在，并根据注解的值切换数据源。

6、使用动态数据源
在需要切换数据源的方法或类上添加自定义注解，就可以在运行时动态切换数据源了。当调用这些方法时，切面会根据注解的值自动切换数据源。

通过以上步骤，就可以成功使用Spring动态数据源了。在多数据源的场景下，可以根据需要灵活切换数据库，实现更高效、灵活的数据访问。

使用Spring动态数据源，可以在运行时动态切换数据库连接。下面是使用Spring动态数据源的步骤：

1. 导入相关依赖：在项目的pom.xml文件中，添加Spring动态数据源的依赖。可以使用类似以下的代码：

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

2. 配置数据源：在Spring的配置文件中(application.properties或application.yml)，配置主数据源和从数据源的相关信息。可以使用类似以下的配置代码：

spring.datasource.master.url=jdbc:mysql://localhost:3306/db_master
spring.datasource.master.username=root
spring.datasource.master.password=123456

spring.datasource.slave.url=jdbc:mysql://localhost:3306/db_slave
spring.datasource.slave.username=root
spring.datasource.slave.password=123456

3. 配置数据源路由：创建一个数据源路由器，用于根据需要动态切换数据源。可以使用以下的示例代码：

@Configuration
@EnableTransactionManagement
public class DataSourceConfig {

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

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

    @Bean
    public DynamicDataSource dynamicDataSource(@Qualifier("masterDataSource") DataSource masterDataSource,
                                               @Qualifier("slaveDataSource") DataSource slaveDataSource) {
        Map<Object, Object> targetDataSources = new HashMap<>();
        targetDataSources.put("masterDataSource", masterDataSource);
        targetDataSources.put("slaveDataSource", slaveDataSource);

        DynamicDataSource dynamicDataSource = new DynamicDataSource();
        dynamicDataSource.setTargetDataSources(targetDataSources);
        dynamicDataSource.setDefaultTargetDataSource(masterDataSource);

        return dynamicDataSource;
    }

    @Bean
    public SqlSessionFactory sqlSessionFactory(DynamicDataSource dynamicDataSource) throws Exception {
        SqlSessionFactoryBean sessionFactoryBean = new SqlSessionFactoryBean();
        sessionFactoryBean.setDataSource(dynamicDataSource);
        return sessionFactoryBean.getObject();
    }

    @Bean
    public PlatformTransactionManager transactionManager(DynamicDataSource dynamicDataSource) {
        return new DataSourceTransactionManager(dynamicDataSource);
    }
}

4. 配置AOP切面：使用AOP切面，拦截需要切换数据源的方法。可以使用以下的示例代码：

@Aspect
@Component
public class DataSourceAspect {

    @Around("@annotation(com.baomidou.dynamic.datasource.annotation.DS) || @within(com.baomidou.dynamic.datasource.annotation.DS)")
    public Object around(ProceedingJoinPoint point) throws Throwable {
        MethodSignature signature = (MethodSignature) point.getSignature();
        Method method = signature.getMethod();

        DS ds = method.getAnnotation(DS.class);
        if (ds == null) {
            Class<?> targetClass = point.getTarget().getClass();
            ds = targetClass.getAnnotation(DS.class);
        }

        if (ds != null) {
            String dataSourceName = ds.value();
            DynamicDataSourceContextHolder.setDataSource(dataSourceName);
        }

        try {
            return point.proceed();
        } finally {
            DynamicDataSourceContextHolder.clearDataSource();
        }
    }
}

5. 使用注解切换数据源：在需要切换数据源的方法上，使用@DS注解指定要切换的数据源。例如：

@DS("masterDataSource")
public void insertUser(User user) {
    userMapper.insert(user);
}

@DS("slaveDataSource")
public void getUser(Long id) {
    return userMapper.selectOne(id);
}

通过以上步骤，就可以使用Spring动态数据源来实现动态切换数据库连接。在方法执行前，根据注解的配置，会自动切换到对应的数据源；方法执行完成后，会自动切换回主数据源。这样就可以实现在运行时动态切换数据源。

Spring动态数据源主要用于在一个应用程序中使用多个数据源。通过动态数据源，可以根据需要动态地选择要使用的数据源，从而实现对数据源的动态切换。

下面是使用Spring动态数据源的方法和操作流程：

1. 引入相关依赖
   首先，在项目的pom.xml文件中引入Spring动态数据源的依赖。如果使用Maven管理项目，可以在pom.xml文件中添加以下依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
    <groupId>com.zaxxer</groupId>
    <artifactId>HikariCP</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-configuration-processor</artifactId>
    <optional>true</optional>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-seata</artifactId>
</dependency>

这些依赖中包含了Spring Boot的JPA、JDBC、HikariCP连接池以及Seata事务管理器。

2. 配置数据库连接信息
   在Spring Boot的配置文件（如application.properties或application.yaml）中配置多个数据源的连接信息。以下是一个示例配置：

spring:
  datasource:
    dynamic:
      datasource-one:
        url: jdbc:mysql://localhost:3306/db1?serverTimezone=UTC
        username: root
        password: root
        driver-class-name: com.mysql.cj.jdbc.Driver
      datasource-two:
        url: jdbc:mysql://localhost:3306/db2?serverTimezone=UTC
        username: root
        password: root
        driver-class-name: com.mysql.cj.jdbc.Driver

在这个配置中，我们定义了两个数据源（datasource-one和datasource-two）分别连接两个不同的数据库。

3. 创建动态数据源
   创建一个DynamicDataSource类，继承自AbstractRoutingDataSource，并重写determineCurrentLookupKey()方法。这个方法用来动态地选择要使用的数据源。

public class DynamicDataSource extends AbstractRoutingDataSource {

    @Override
    protected Object determineCurrentLookupKey() {
        return DataSourceContextHolder.getDataSource();
    }

}

在上面的代码中，DataSourceContextHolder.getDataSource()返回当前线程的数据源标识。

4. 配置动态数据源
   在Spring配置文件中配置动态数据源，并指定多个数据源以及默认的数据源。

@Configuration
public class DataSourceConfiguration {

    @Bean
    @ConfigurationProperties(prefix = "spring.datasource.dynamic.datasource-one")
    public DataSource dataSourceOne() {
        return DataSourceBuilder.create().build();
    }

    @Bean
    @ConfigurationProperties(prefix = "spring.datasource.dynamic.datasource-two")
    public DataSource dataSourceTwo() {
        return DataSourceBuilder.create().build();
    }

    @Bean
    public DynamicDataSource dynamicDataSource(DataSource dataSourceOne, DataSource dataSourceTwo) {
        DynamicDataSource dynamicDataSource = new DynamicDataSource();
        Map<Object, Object> dataSourceMap = new HashMap<>();
        dataSourceMap.put("datasource-one", dataSourceOne);
        dataSourceMap.put("datasource-two", dataSourceTwo);
        dynamicDataSource.setTargetDataSources(dataSourceMap);
        dynamicDataSource.setDefaultTargetDataSource(dataSourceOne);
        return dynamicDataSource;
    }

    @Bean
    public SqlSessionFactoryBean sqlSessionFactory(DynamicDataSource dynamicDataSource) throws Exception {
        SqlSessionFactoryBean sessionFactoryBean = new SqlSessionFactoryBean();
        sessionFactoryBean.setDataSource(dynamicDataSource);
        return sessionFactoryBean;
    }

}

在这个配置类中，我们首先定义了两个数据源（dataSourceOne和dataSourceTwo），然后创建了DynamicDataSource实例，并将两个数据源添加到动态数据源中。最后，将动态数据源作为参数传递给SqlSessionFactoryBean。

5. 使用动态数据源
   在需要使用数据源的地方，可以使用@DataSource注解来指定具体的数据源。

@DataSource("datasource-one")
public List<User> getUsers() {
    // ...
}

在这个示例中，@DataSource("datasource-one")注解指定了具体的数据源为"datasource-one"。

通过以上步骤配置和使用Spring动态数据源，就可以在一个应用程序中使用多个数据源并实现动态切换。