spring中如何切换数据源

fiy 1年前其他 32

共3条回复我来回复

不及物动词
这个人很懒，什么都没有留下～
评论

在Spring中切换数据源，可以通过以下几种方式实现：

方式一：使用Spring Boot的自动配置功能。Spring Boot在启动时会自动加载数据库连接池等相关配置信息，并根据配置文件中的设置来自动切换数据源。只需要在配置文件中设置多个数据源的相关信息，然后通过@Primary注解标注默认数据源，通过@Qualifier注解标注其他数据源，即可实现数据源的切换。

方式二：使用Spring的AbstractRoutingDataSource类。AbstractRoutingDataSource是Spring提供的动态数据源切换的抽象类，通过继承该类并重写determineCurrentLookupKey()方法，可以实现根据不同的条件来动态切换数据源。在该方法中，可以根据不同的请求参数、登录用户等条件，返回不同的数据源标识，从而实现数据源的切换。

方式三：使用AOP切面功能。通过在方法或类上添加切面注解，可以实现对方法的拦截和增强操作。通过切面技术，可以在方法执行前根据条件切换数据源，从而实现数据源的切换。可以使用Spring的@Around注解来标注切面方法，并在切面方法中通过手动切换数据源来实现切换。

方式四：手动切换数据源。可以通过使用DataSourceTransactionManager来手动切换数据源。在使用不同的数据源执行数据库操作之前，先通过TransactionStatus的getConnectionHolder()方法获取当前线程的连接持有者，然后再通过ConnectionHolder的setTargetConnection()方法切换数据源，从而实现数据源的切换。在切换完成后，再通过setTargetConnection()方法将连接设置回原来的数据源，以保证连接的正确性。

总结：以上是四种在Spring中切换数据源的常用方式，根据实际需求选择合适的方式来实现数据源的切换。无论选择哪种方式，都需要配置多个数据源的相关信息，并且在切换数据源时需要进行相应的操作，以确保数据源的正确切换和使用。

1年前 0条评论

fiy

Worktile&PingCode市场小伙伴

在Spring中切换数据源有多种方式。以下是一些常用的切换数据源的方法：

使用注解方式切换数据源：Spring提供了@Primary和@Qualifier注解来切换数据源。我们可以在多个配置数据源的Bean上使用@Primary注解标注默认的数据源，当需要切换数据源时，可以通过@Qualifier指定要使用的数据源。

@Configuration
public class DataSourceConfig {
    @Bean
    @Primary
    @ConfigurationProperties(prefix="spring.datasource.first")
    public DataSource firstDataSource() {
        return DataSourceBuilder.create().build();
    }
 
    @Bean
    @ConfigurationProperties(prefix="spring.datasource.second")
    public DataSource secondDataSource() {
        return DataSourceBuilder.create().build();
    }
}

使用配置文件方式切换数据源：通过在Spring的配置文件中配置多个数据源，然后在需要切换数据源的时候，通过修改配置文件中的数据源配置来切换。可以使用@ConfigurationProperties注解将配置文件中的属性映射到Java Bean中，然后通过修改属性的值来切换数据源。

@Configuration
@PropertySource(value = {"classpath:datasource.properties"})
public class DataSourceConfig {
    @Autowired
    private Environment env;
 
    @Bean
    public DataSource dataSource() {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setUrl(env.getProperty("spring.datasource.url"));
        dataSource.setUsername(env.getProperty("spring.datasource.username"));
        dataSource.setPassword(env.getProperty("spring.datasource.password"));
        dataSource.setDriverClassName(env.getProperty("spring.datasource.driver-class-name"));
 
        return dataSource;
    }
}

使用AOP方式切换数据源：可以使用Spring的AOP功能来切换数据源。通过在切面中根据条件来选择不同的数据源，在切面中，可以使用@Around注解将切面织入到具体的方法中，在方法执行前动态切换数据源。

@Aspect
@Component
public class DataSourceAspect {
    @Pointcut("@annotation(com.example.annotation.DataSource)")
    public void dataSourcePointCut() {
    }
 
    @Around("dataSourcePointCut()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();
        DataSource dataSource = method.getAnnotation(DataSource.class);
        if (dataSource != null) {
            String dataSourceName = dataSource.value();
            DynamicDataSource.setDataSource(dataSourceName);
        }
 
        try {
            return joinPoint.proceed();
        } finally {
            DynamicDataSource.clearDataSource();
        }
    }
}

使用动态数据源切换：通过继承AbstractRoutingDataSource类，重写determineCurrentLookupKey()方法来动态切换数据源。在determineCurrentLookupKey()方法中根据一定的条件来选择当前要使用的数据源。

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

使用Spring Boot自动配置多数据源：Spring Boot提供了自动配置的功能，可以根据配置文件中的属性自动创建多个数据源。只需要在配置文件中指定多个数据源的相关配置即可。

spring.datasource.primary.url=jdbc:mysql://localhost:3306/primary_db
spring.datasource.primary.username=root
spring.datasource.primary.password=123456
 
spring.datasource.secondary.url=jdbc:mysql://localhost:3306/secondary_db
spring.datasource.secondary.username=root
spring.datasource.secondary.password=123456

1年前 0条评论

worktile

Worktile官方账号

在Spring框架中切换数据源可以通过配置多个数据源和使用动态数据源的方式来实现。下面将从这两个方面解答这个问题。

一、配置多个数据源

在配置文件中添加数据源的相关配置，例如在application.properties或application.yml文件中添加如下配置：

spring.datasource.primary.url=jdbc:mysql://localhost:3306/db1
spring.datasource.primary.username=user1
spring.datasource.primary.password=password1

spring.datasource.secondary.url=jdbc:mysql://localhost:3306/db2
spring.datasource.secondary.username=user2
spring.datasource.secondary.password=password2

创建多个DataSource实例，并通过@Configuration注解进行配置，示例如下：

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.datasource.DriverManagerDataSource;

import javax.sql.DataSource;

@Configuration
public class DataSourceConfig {

    @Bean(name = "primaryDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.primary")
    public DataSource primaryDataSource() {
        return new DriverManagerDataSource();
    }

    @Bean(name = "secondaryDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.secondary")
    public DataSource secondaryDataSource() {
        return new DriverManagerDataSource();
    }
}

创建JdbcTemplate的实例，并注入对应的DataSource，示例如下：

import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.core.JdbcTemplate;

import javax.sql.DataSource;

@Configuration
public class JdbcTemplateConfig {

    @Bean(name = "primaryJdbcTemplate")
    public JdbcTemplate primaryJdbcTemplate(
            @Qualifier("primaryDataSource") DataSource dataSource) {
        return new JdbcTemplate(dataSource);
    }

    @Bean(name = "secondaryJdbcTemplate")
    public JdbcTemplate secondaryJdbcTemplate(
            @Qualifier("secondaryDataSource") DataSource dataSource) {
        return new JdbcTemplate(dataSource);
    }
}

在需要切换数据源的地方，通过@Autowired注解注入对应的JdbcTemplate实例，然后使用对应的JdbcTemplate来执行操作，示例如下：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;

@Component
public class UserRepository {

    private final JdbcTemplate primaryJdbcTemplate;
    private final JdbcTemplate secondaryJdbcTemplate;

    @Autowired
    public UserRepository(@Qualifier("primaryJdbcTemplate") JdbcTemplate primaryJdbcTemplate,
                           @Qualifier("secondaryJdbcTemplate") JdbcTemplate secondaryJdbcTemplate) {
        this.primaryJdbcTemplate = primaryJdbcTemplate;
        this.secondaryJdbcTemplate = secondaryJdbcTemplate;
    }

    public void addUser() {
        // 使用primaryJdbcTemplate执行操作
        primaryJdbcTemplate.execute("INSERT INTO user(username, password) VALUES('user1', '123456')");
    }

    public void updateUser() {
        // 使用secondaryJdbcTemplate执行操作
        secondaryJdbcTemplate.execute("UPDATE user SET username='user2' WHERE id=1");
    }
}

二、使用动态数据源

创建DynamicDataSource类，继承AbstractRoutingDataSource，并实现determineCurrentLookupKey方法，用于动态切换数据源，示例如下：

import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;

public class DynamicDataSource extends AbstractRoutingDataSource {

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

创建DataSourceContextHolder类，用于保存当前线程所使用的数据源的上下文信息，示例如下：

public class DataSourceContextHolder {

    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();
    }
}

创建DataSourceRoutingConfig类，用于配置动态数据源，示例如下：

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;

import javax.sql.DataSource;
import java.util.HashMap;
import java.util.Map;

@Configuration
public class DataSourceRoutingConfig {

    @Bean
    public DataSource dynamicDataSource(
            @Qualifier("primaryDataSource") DataSource primaryDataSource,
            @Qualifier("secondaryDataSource") DataSource secondaryDataSource) {
        AbstractRoutingDataSource dataSource = new DynamicDataSource();

        Map<Object, Object> targetDataSources = new HashMap<>();
        targetDataSources.put("primary", primaryDataSource);
        targetDataSources.put("secondary", secondaryDataSource);

        dataSource.setTargetDataSources(targetDataSources);
        dataSource.setDefaultTargetDataSource(primaryDataSource);

        return dataSource;
    }
}

在需要切换数据源的地方，通过调用DataSourceContextHolder类的setDataSourceKey方法来设置当前线程使用的数据源，示例如下：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;

@Component
public class UserRepository {

    private final JdbcTemplate jdbcTemplate;

    @Autowired
    public UserRepository(@Qualifier("primaryJdbcTemplate") JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    public void addUser() {
        DataSourceContextHolder.setDataSourceKey("primary");
        jdbcTemplate.execute("INSERT INTO user(username, password) VALUES('user1', '123456')");
    }

    public void updateUser() {
        DataSourceContextHolder.setDataSourceKey("secondary");
        jdbcTemplate.execute("UPDATE user SET username='user2' WHERE id=1");
    }
}

通过上述方法，即可在Spring中实现数据源的切换。可以根据实际需求选择配置多个数据源或使用动态数据源的方式。

1年前 0条评论