浅析SpringBoot多数据源实现方案

spring:
  datasource:
    master:
      url: jdbc:mysql://localhost:3306/db_master
      username: root
      password: ******
      driver-class-name: com.mysql.cj.jdbc.Driver
      type: com.alibaba.druid.pool.DruidDataSource
    slave:
      url: jdbc:mysql://localhost:3306/db_slave
      username: root
      password: Hxy@950504
      driver-class-name: com.mysql.cj.jdbc.Driver
      type: com.alibaba.druid.pool.DruidDataSource
mybatis:
  mapper-locations: classpath:mapper/**/*.xml

@Configuration
public class DataSourceConfig {
    @Bean(name = "masterDataSource")
    @ConfigurationProperties("spring.datasource.master")
    public DataSource masterDataSource() {
        return DruidDataSourceBuilder.create().build();
    }
    @Bean(name = "slaveDataSource")
    @ConfigurationProperties("spring.datasource.slave")
    public DataSource slaveDataSource() {
        return DruidDataSourceBuilder.create().build();
    }
}

public abstract class AbstractRoutingDataSource extends AbstractDataSource implements InitializingBean {
    // map结构，用来保存所有的数据源
	@Nullable
	private Map<Object, Object> targetDataSources;
    // 默认的数据源
	@Nullable
	private Object defaultTargetDataSource;
	@Override
	public void afterPropertiesSet() {
		if (this.targetDataSources == null) {
			throw new IllegalArgumentException("Property 'targetDataSources' is required");
		}
		this.resolvedDataSources = CollectionUtils.newHashMap(this.targetDataSources.size());
		this.targetDataSources.forEach((key, value) -> {
			Object lookupKey = resolveSpecifiedLookupKey(key);
			DataSource dataSource = resolveSpecifiedDataSource(value);
			this.resolvedDataSources.put(lookupKey, dataSource);
		});
		if (this.defaultTargetDataSource != null) {
			this.resolvedDefaultDataSource = resolveSpecifiedDataSource(this.defaultTargetDataSource);
		}
	}
	@Override
	public Connection getConnection() throws SQLException {
		return determineTargetDataSource().getConnection();
	}
	/**
	 * getConnection()方法和determineTargetDataSource()方法定义了获取数据库连接，选择数据源的核心逻辑
	 */
	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;
	}
	/**
	 * 根据key选择数据源，但是哪个接口用那个key，由用户自己决定，这就是模板方法模式
	 */
	@Nullable
	protected abstract Object determineCurrentLookupKey();
}

/**
 * 继承spring提供的多数据源路由类，初始化默认数据源和实现选择数据源的方法
 *
 * @author HXY
 */
public class DynamicDataSource extends AbstractRoutingDataSource {
    // 有参构造器，初始化所有的数据源和默认数据源
    public DynamicDataSource(DataSource defaultTargetDataSource, Map<Object, Object> allDataSource) {
        super.setDefaultTargetDataSource(defaultTargetDataSource);
        super.setTargetDataSources(allDataSource);
        super.afterPropertiesSet();
    }
    // 实现抽象方法，定义我们获取K的逻辑
    @Override
    protected Object determineCurrentLookupKey() {
        return DataSourceContextHolder.getDataSource();
    }
}

public class DataSourceContextHolder {
    private static final ThreadLocal<String> CONTEXT_HOLDER = new ThreadLocal<>();
    public static void setDataSource(String dataSourceKey) {
        CONTEXT_HOLDER.set(dataSourceKey);
    }
    public static String getDataSource() {
        return CONTEXT_HOLDER.get();
    }
    public static void release() {
        CONTEXT_HOLDER.remove();
    }
}

@Configuration
public class DataSourceConfig {
    @Bean(name = "masterDataSource")
    @ConfigurationProperties("spring.datasource.master")
    public DataSource masterDataSource() {
        return DruidDataSourceBuilder.create().build();
    }
    @Bean(name = "slaveDataSource")
    @ConfigurationProperties("spring.datasource.slave")
    public DataSource slaveDataSource() {
        return DruidDataSourceBuilder.create().build();
    }
    // DynamicDataSource要交给spring管理
    @Primary  // 一定要写，让DynamicDataSource被容器优先选择
    @Bean
    public DynamicDataSource dynamicDataSource(@Qualifier("masterDataSource") DataSource masterDataSource,
                                        @Qualifier("slaveDataSource") DataSource slaveDataSource) {
        // 所有数据源放到一个map中，交给动态数据源管理
        Map<Object, Object> targetDataSources = new HashMap<>(2);
        targetDataSources.put(DataSourceEnum.MASTER.name(), masterDataSource);
        targetDataSources.put(DataSourceEnum.SLAVE.name(), slaveDataSource);
        // 默认数据源、所有数据源
        return new DynamicDataSource(masterDataSource, targetDataSources);
    }
}

/**
 * 自定义注解用来选择数据源
 *
 * @author HXY
 * @since 1.0.0
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface DataSource {
    DataSourceEnum key() default DataSourceEnum.MASTER;
}

public enum DataSourceEnum {
    MASTER,
    SLAVE,
    ;
}

@Aspect
@Component
public class DynamicDataSourceAspect {
    // 用环绕通知拦截标记了DataSource注解的方法，方法执行前选择数据源，然后执行原来的方法，最后返回结果
    @Around("@annotation(dataSource)")
    public Object selectDataSource(ProceedingJoinPoint joinPoint, DataSource dataSource) throws Throwable {
        try {
            String selectKey = dataSource.key().name();
            DataSourceContextHolder.setDataSource(selectKey);
            return joinPoint.proceed();
        } finally {
            // 请求处理完成后一定要及时释放ThreadLocal数据，否则会引起内存泄漏
            DataSourceContextHolder.release();
        }
    }
}