多数据源原理

最新推荐文章于 2024-03-31 22:40:53 发布

Good LA

最新推荐文章于 2024-03-31 22:40:53 发布

阅读量208

点赞数

分类专栏： Spring 文章标签： mysql spring 数据库

本文链接：https://blog.csdn.net/qq_36180997/article/details/120459755

版权

Spring 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

背景

项目中看到多数据源配置，好奇之下看下下实现原理，比较简单

使用

数据源定义

spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.driverClassName=com.mysql.cj.jdbc.Driver
spring.datasource.druid.master.url=jdbc:mysql://ip/databaseName?serverTimezone=Hongkong
spring.datasource.druid.master.username=username
spring.datasource.druid.master.password=password
spring.datasource.druid.zaqmain.enabled=true
spring.datasource.druid.zaqmain.url=jdbc:mysql://ip/databaseName?serverTimezone=Hongkong
spring.datasource.druid.zaqmain.username=username
spring.datasource.druid.zaqmain.password=password

数据源配置类

@Configuration
public class DruidProperties
{
    @Value("${spring.datasource.druid.initialSize:1}")
    private int initialSize;

    @Value("${spring.datasource.druid.minIdle:1}")
    private int minIdle;

    @Value("${spring.datasource.druid.maxActive:20}")
    private int maxActive;

    @Value("${spring.datasource.druid.maxWait:60000}")
    private int maxWait;

    @Value("${spring.datasource.druid.timeBetweenEvictionRunsMillis:60000}")
    private int timeBetweenEvictionRunsMillis;

    @Value("${spring.datasource.druid.minEvictableIdleTimeMillis:300000}")
    private int minEvictableIdleTimeMillis;

    @Value("${spring.datasource.druid.maxEvictableIdleTimeMillis:600000}")
    private int maxEvictableIdleTimeMillis;

    @Value("${spring.datasource.druid.validationQuery:select 'x'}")
    private String validationQuery;

    @Value("${spring.datasource.druid.testWhileIdle:true}")
    private boolean testWhileIdle;

    @Value("${spring.datasource.druid.testOnBorrow:false}")
    private boolean testOnBorrow;

    @Value("${spring.datasource.druid.testOnReturn:false}")
    private boolean testOnReturn;

    public DruidDataSource dataSource(DruidDataSource datasource)
    {
        /** 配置初始化大小、最小、最大 */
        datasource.setInitialSize(initialSize);
        datasource.setMaxActive(maxActive);
        datasource.setMinIdle(minIdle);

        /** 配置获取连接等待超时的时间 */
        datasource.setMaxWait(maxWait);

        /** 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 */
        datasource.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);

        /** 配置一个连接在池中最小、最大生存的时间，单位是毫秒 */
        datasource.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
        datasource.setMaxEvictableIdleTimeMillis(maxEvictableIdleTimeMillis);

        /**
         * 用来检测连接是否有效的sql，要求是一个查询语句，常用select 'x'。如果validationQuery为null，testOnBorrow、testOnReturn、testWhileIdle都不会起作用。
         */
        datasource.setValidationQuery(validationQuery);
        /** 建议配置为true，不影响性能，并且保证安全性。申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效。 */
        datasource.setTestWhileIdle(testWhileIdle);
        /** 申请连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能。 */
        datasource.setTestOnBorrow(testOnBorrow);
        /** 归还连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能。 */
        datasource.setTestOnReturn(testOnReturn);
        return datasource;
    }
}

数据源加入到IOC

@Configuration
public class DruidConfig
{
    @Bean
    @ConfigurationProperties("spring.datasource.druid.master")
    public DataSource masterDataSource(DruidProperties druidProperties)
    {
        DruidDataSource dataSource = DruidDataSourceBuilder.create().build();
        return druidProperties.dataSource(dataSource);
    }

    @Bean
    @ConfigurationProperties("spring.datasource.druid.slave")
    @ConditionalOnProperty(prefix = "spring.datasource.druid.slave", name = "enabled", havingValue = "true")
    public DataSource slaveDataSource(DruidProperties druidProperties)
    {
        DruidDataSource dataSource = DruidDataSourceBuilder.create().build();
        return druidProperties.dataSource(dataSource);
    }
    
	@Bean(name = "dynamicDataSource")
    @Primary
    public DynamicDataSource dataSource(DataSource masterDataSource)
    {
        Map<Object, Object> targetDataSources = new HashMap<>();
        targetDataSources.put(DataSourceType.MASTER.name(), masterDataSource);
        setDataSource(targetDataSources, DataSourceType.SLAVE.name(), "slaveDataSource");
        // 将配置信息放到jdbc包下的AbstractRoutingDataSource类里的一个map中
        return new DynamicDataSource(masterDataSource, targetDataSources);
    }
}

项目中使用

@Service
@DataSource(value= DataSourceType.ZAQMAIN)
public class AdminOrderPayServiceImpl {
}

@DataSource(DataSourceType.MASTER)
public SysConfig selectConfigById(Long configId) {
}

原理

@DataSource这个注解切面做了啥

@Aspect
@Order(1)
@Component
public class DataSourceAspect
{
    protected Logger logger = LoggerFactory.getLogger(getClass());

    @Pointcut("@annotation(com.za.framework.aspectj.lang.annotation.DataSource)"
            + "|| @within(com.za.framework.aspectj.lang.annotation.DataSource)")
    public void dsPointCut()
    {

    }

    @Around("dsPointCut()")
    public Object around(ProceedingJoinPoint point) throws Throwable
    {
        DataSource dataSource = getDataSource(point);

        if (StringUtils.isNotNull(dataSource))
        {
        	// 将数据源名称放到ThreadLocal中，那什么时候去拿了呢？
            DynamicDataSourceContextHolder.setDataSourceType(dataSource.value().name());
        }

        try
        {
            return point.proceed();
        }
        finally
        {
            // 销毁数据源 在执行方法之后
            DynamicDataSourceContextHolder.clearDataSourceType();
        }
    }

    /**
     * 获取需要切换的数据源
     */
    public DataSource getDataSource(ProceedingJoinPoint point)
    {
        MethodSignature signature = (MethodSignature) point.getSignature();
        Class<? extends Object> targetClass = point.getTarget().getClass();
        DataSource targetDataSource = targetClass.getAnnotation(DataSource.class);
        if (StringUtils.isNotNull(targetDataSource))
        {
            return targetDataSource;
        }
        else
        {
            Method method = signature.getMethod();
            DataSource dataSource = method.getAnnotation(DataSource.class);
            return dataSource;
        }
    }
}

进入DynamicDataSourceContextHolder类，查看哪里用了数据源


public class DynamicDataSourceContextHolder
{
    public static final Logger log = LoggerFactory.getLogger(DynamicDataSourceContextHolder.class);

    /**
     * 使用ThreadLocal维护变量，ThreadLocal为每个使用该变量的线程提供独立的变量副本，
     *  所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。
     */
    private static final ThreadLocal<String> CONTEXT_HOLDER = new ThreadLocal<>();

    /**
     * 设置数据源的变量
     */
    public static void setDataSourceType(String dsType)
    {
        log.info("切换到{}数据源", dsType);
        CONTEXT_HOLDER.set(dsType);
    }

    /**
     * 获得数据源的变量，这里进去可以看到哪里用了这个数据源
     */
    public static String getDataSourceType()
    {
        return CONTEXT_HOLDER.get();
    }

    /**
     * 清空数据源变量
     */
    public static void clearDataSourceType()
    {
        CONTEXT_HOLDER.remove();
    }
}

进入DynamicDataSource 发现继承了AbstractRoutingDataSource

public class DynamicDataSource extends AbstractRoutingDataSource
{
    public DynamicDataSource(DataSource defaultTargetDataSource, Map<Object, Object> targetDataSources)
    {
        super.setDefaultTargetDataSource(defaultTargetDataSource);
        super.setTargetDataSources(targetDataSources);
        super.afterPropertiesSet();
    }

	// 该方法获取数据源名称，并根据名称到map中获取对应的数据源实例。数据源实例在将数据源加入到IOC时，放进到这个map中了
    @Override
    protected Object determineCurrentLookupKey()
    {
        return DynamicDataSourceContextHolder.getDataSourceType();
    }
}

看看AbstractRoutingDataSource是啥

public abstract class AbstractRoutingDataSource extends AbstractDataSource implements InitializingBean {
	protected DataSource determineTargetDataSource() {
		Assert.notNull(this.resolvedDataSources, "DataSource router not initialized");
		Object lookupKey = determineCurrentLookupKey();
		// 不配置的情况下，会获取默认的数据源对象
		DataSource dataSource = this.resolvedDataSources.get(lookupKey);
		if (dataSource == null && (this.lenientFallback || lookupKey == null)) {
			dataSource = this.resolvedDefaultDataSource;
		}
		if (dataSource == null) {
			throw new IllegalStateException("Cannot determine target DataSource for lookup key [" + lookupKey + "]");
		}
		return dataSource;
	}

	/**
	 * Determine the current lookup key. This will typically be
	 * implemented to check a thread-bound transaction context.
	 * <p>Allows for arbitrary keys. The returned key needs
	 * to match the stored lookup key type, as resolved by the
	 * {@link #resolveSpecifiedLookupKey} method.
	 */
	 // 这个方法是获取name，然后去ioc拿实例对象。DynamicDataSource 重写了这个方法，从threadlocal中拿到name
	@Nullable
	protected abstract Object determineCurrentLookupKey();
}

总结

将多数据源配置加入到ioc中，用不同的name区分。同时将数据源实例设置到AbstractRoutingDataSource的map中。
需要用到不同数据源的时候，通过AOP将数据源名称设置到threadlocal中，查询数据库前，会通过AbstractRoutingDataSource的子类的determineCurrentLookupKey方法获取数据源名称，然后根据名称从AbstractRoutingDataSource的map中获取数据源实例。

思想

之所以能够实现多数据源，是因为jdbc的设计支持了。jdbc将数据源维护在map中，连接数据库前会根据name获取数据源实例。并且提供一个抽象方法让研发去拓展获取数据源的逻辑。

这种思想在项目中写公共模块或者其它小框架的时候是可以借鉴的。提供一个默认的策略和通过抽象方法来支持策略可拓展。

Good LA

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
多数据源原理

背景项目中看到多数据源配置，好奇之下看下下实现原理，比较简单使用数据源定义spring.datasource.type=com.alibaba.druid.pool.DruidDataSourcespring.datasource.driverClassName=com.mysql.cj.jdbc.Driverspring.datasource.druid.master.url=jdbc:mysql://ip/databaseName?serverTimezone=Hongkongspring
复制链接

扫一扫

专栏目录