spring动态数据源怎么使用

使用Spring动态数据源需要以下步骤：

1. 添加依赖：在项目的pom.xml文件中添加以下依赖:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>dynamic-datasource-spring-boot-starter</artifactId>
    <version>3.4.2</version>
</dependency>

2. 配置数据源：在Spring Boot的配置文件application.properties或application.yml中配置数据源，例如：

spring:
  datasource:
    url: jdbc:mysql://127.0.0.1:3306/mydb?useUnicode=true&characterEncoding=utf-8&serverTimezone=GMT%2B8
    username: root
    password: 123456
    driver-class-name: com.mysql.cj.jdbc.Driver

3. 创建动态数据源配置类：创建一个类来配置动态数据源，例如：

@Configuration
@MapperScan("com.example.mapper")
public class DynamicDataSourceConfig {
    
    @Bean
    @ConfigurationProperties(prefix = "spring.datasource")
    public DataSource dataSource() {
        return DataSourceBuilder.create().build();
    }
    
    @Bean
    public DataSource dynamicDataSource(DataSource dataSource) {
        DynamicDataSource dynamicDataSource = new DynamicDataSource();
        Map<Object, Object> dataSourceMap = new HashMap<>();
        dataSourceMap.put("master", dataSource);
        dynamicDataSource.setDefaultTargetDataSource(dataSource);
        dynamicDataSource.setTargetDataSources(dataSourceMap);
        return dynamicDataSource;
    }
    
    @Bean
    public SqlSessionFactory sqlSessionFactory(DataSource dynamicDataSource) throws Exception {
        SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
        factoryBean.setDataSource(dynamicDataSource);
        return factoryBean.getObject();
    }
}

4. 使用注解选择数据源：在需要使用不同数据源的方法上使用@DataSource注解，例如：

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserMapper userMapper;

    @Override
    @DataSource("slave") // 选择从数据源
    public User getUserById(Long id) {
        return userMapper.selectById(id);
    }

    @Override
    @DataSource("master") // 选择主数据源
    public void saveUser(User user) {
        userMapper.insert(user);
    }
}

5. 启动应用程序：运行Spring Boot应用程序，动态数据源将会根据注解选择相应的数据源。

以上就是使用Spring动态数据源的基本步骤，可以根据实际需求进行配置和使用。

Spring动态数据源是指在应用程序运行时可以动态切换数据源的功能。使用动态数据源可以方便地在不同的环境或者不同的场景下切换不同的数据库连接。

下面是使用Spring动态数据源的步骤：

1. 引入依赖：在项目的pom.xml文件中引入Spring JDBC和数据库连接池的相关依赖，例如：

<dependencies>
    ...
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-jdbc</artifactId>
    </dependency>

    <dependency>
        <groupId>com.zaxxer</groupId>
        <artifactId>HikariCP</artifactId>
    </dependency>
    ...
</dependencies>

2. 配置数据源：在application.properties或者application.yml文件中配置主数据源的连接参数，例如：

spring.datasource.url=jdbc:mysql://localhost:3306/db1
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.driver-class-name=com.mysql.jdbc.Driver

3. 创建动态数据源：创建一个类来实现javax.sql.DataSource接口，通过继承AbstractRoutingDataSource类来实现动态切换数据源的功能。例如：

public class DynamicDataSource extends AbstractRoutingDataSource {
    @Override
    protected Object determineCurrentLookupKey() {
        return DataSourceContextHolder.getDataSource();
    }
}

其中，DataSourceContextHolder是一个线程安全的类，用于存储当前线程使用的数据源。

4. 配置动态数据源：在Spring配置文件中配置动态数据源，例如：

<bean id="dataSource" class="com.example.DynamicDataSource">
    <property name="targetDataSources">
        <map>
            <entry key="db1" value-ref="db1DataSource"/>
            <entry key="db2" value-ref="db2DataSource"/>
        </map>
    </property>
    <property name="defaultTargetDataSource" ref="db1DataSource"/>
</bean>

<bean id="db1DataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    <property name="url" value="jdbc:mysql://localhost:3306/db1"/>
    <property name="username" value="root"/>
    <property name="password" value="123456"/>
    <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
</bean>

<bean id="db2DataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    <property name="url" value="jdbc:mysql://localhost:3306/db2"/>
    <property name="username" value="root"/>
    <property name="password" value="123456"/>
    <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
</bean>

5. 切换数据源：在需要切换数据源的地方，可以通过DataSourceContextHolder.setDataSource("db1")来切换到对应的数据源。例如：

// 切换到db1数据源
DataSourceContextHolder.setDataSource("db1");
// 执行需要使用db1数据源的操作

// 切换到db2数据源
DataSourceContextHolder.setDataSource("db2");
// 执行需要使用db2数据源的操作

通过以上步骤，就可以在Spring应用中使用动态数据源来动态切换不同的数据库连接了。这样可以方便地在不同的环境或者不同的场景下使用不同的数据源。

Spring动态数据源是一种在运行时能够动态切换数据源的技术。这种技术可以使我们在同一个应用程序中使用多个数据源。

下面是使用Spring动态数据源的步骤：

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.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
</dependency>

2.配置数据源
在Spring Boot的配置文件application.properties（或application.yml）中添加数据源的配置信息：

# 主数据源
spring.datasource.url=jdbc:mysql://localhost:3306/maindb
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.driver-class-name=com.mysql.jdbc.Driver

# 从数据源
slave.datasource.url=jdbc:mysql://localhost:3306/slatedb
slave.datasource.username=root
slave.datasource.password=123456
slave.datasource.driver-class-name=com.mysql.jdbc.Driver

3.创建数据源切换策略
创建一个类，实现Spring的AbstractRoutingDataSource接口，并重写determineCurrentLookupKey()方法，该方法用于确定当前线程使用哪个数据源。例如：

public class DynamicDataSource extends AbstractRoutingDataSource {

    @Override
    protected Object determineCurrentLookupKey() {
        return DynamicDataSourceContextHolder.getDataSourceKey();
    }
}

4.创建数据源上下文
创建一个类，用于切换数据源的上下文。例如：

public class DynamicDataSourceContextHolder {

    private static final ThreadLocal<String> contextHolder = new ThreadLocal<>();

    public static void setDataSourceKey(String dataSourceKey) {
        contextHolder.set(dataSourceKey);
    }

    public static String getDataSourceKey() {
        return contextHolder.get();
    }

    public static void clearDataSourceKey() {
        contextHolder.remove();
    }
}

5.配置数据源切换逻辑
在Spring的配置文件中，配置数据源切换逻辑，将主数据源和从数据源添加到DynamicDataSource中，并设置默认数据源为主数据源。例如：

@Configuration
public class DataSourceConfig {

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

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

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

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

        return dynamicDataSource;
    }

    @Bean
    public SqlSessionFactory sqlSessionFactory(@Qualifier("dynamicDataSource") DataSource dynamicDataSource)
            throws Exception {
        SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
        sessionFactory.setDataSource(dynamicDataSource);
        return sessionFactory.getObject();
    }

    @Bean
    public SqlSessionTemplate sqlSessionTemplate(SqlSessionFactory sqlSessionFactory) {
        return new SqlSessionTemplate(sqlSessionFactory);
    }
}

6.在业务代码中切换数据源
在需要切换数据源的地方，调用DynamicDataSourceContextHolder的setDataSourceKey()方法切换数据源。例如：

DynamicDataSourceContextHolder.setDataSourceKey("slaveDataSource"); // 切换到从数据源

7.使用注解切换数据源
如果希望通过注解的方式来切换数据源，可以使用@DataSource注解。首先，创建一个自定义注解：

@Target({ ElementType.METHOD, ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface DataSource {

    // 数据源名称
    String value() default "mainDataSource";
}

然后，在需要切换数据源的方法上添加@DataSource注解，指定要切换到的数据源。例如：

@DataSource("slaveDataSource") // 切换到从数据源
public User getUserById(Long id) {
    // ...
}

以上就是使用Spring动态数据源的步骤。通过以上配置，就可以实现运行时动态切换数据源的功能。