public abstract class AbstractRoutingDataSource extends AbstractDataSource implements InitializingBean {
        //目标数据源map集合，存储将要切换的多数据源bean信息
        @Nullable
        private Map<Object, Object> targetDataSources;
        //未指定数据源时的默认数据源对象
        @Nullable
        private Object defaultTargetDataSource;
        private boolean lenientFallback = true;
        //数据源查找接口，通过该接口的getDataSource(String dataSourceName)获取数据源信息
        private DataSourceLookup dataSourceLookup = new JndiDataSourceLookup();
        //解析targetDataSources之后的DataSource的map集合
        @Nullable
        private Map<Object, DataSource> resolvedDataSources;
        @Nullable
        private DataSource resolvedDefaultDataSource;
    
        //将targetDataSources的内容转化一下放到resolvedDataSources中，将defaultTargetDataSource转为DataSource赋值给resolvedDefaultDataSource
        public void afterPropertiesSet() {
            //如果目标数据源为空，会抛出异常，在系统配置时应至少传入一个数据源
            if (this.targetDataSources == null) {
                throw new IllegalArgumentException("Property 'targetDataSources' is required");
            } else {
                //初始化resolvedDataSources的大小
                this.resolvedDataSources = CollectionUtils.newHashMap(this.targetDataSources.size());
                //遍历目标数据源信息map集合，对其中的key，value进行解析
                this.targetDataSources.forEach((key, value) -> {
                    //resolveSpecifiedLookupKey方法没有做任何处理，只是将key继续返回
                    Object lookupKey = this.resolveSpecifiedLookupKey(key);
                    //将目标数据源map集合中的value值（德鲁伊数据源信息）转为DataSource类型
                    DataSource dataSource = this.resolveSpecifiedDataSource(value);
                    //将解析之后的key，value放入resolvedDataSources集合中
                    this.resolvedDataSources.put(lookupKey, dataSource);
                });
                if (this.defaultTargetDataSource != null) {
                    //将默认目标数据源信息解析并赋值给resolvedDefaultDataSource
                    this.resolvedDefaultDataSource = this.resolveSpecifiedDataSource(this.defaultTargetDataSource);
                }
    
            }
        }
    
        protected Object resolveSpecifiedLookupKey(Object lookupKey) {
            return lookupKey;
        }
    
        protected DataSource resolveSpecifiedDataSource(Object dataSource) throws IllegalArgumentException {
            if (dataSource instanceof DataSource) {
                return (DataSource)dataSource;
            } else if (dataSource instanceof String) {
                return this.dataSourceLookup.getDataSource((String)dataSource);
            } else {
                throw new IllegalArgumentException("Illegal data source value - only [javax.sql.DataSource] and String supported: " + dataSource);
            }
        }
        
        //因为AbstractRoutingDataSource继承AbstractDataSource，而AbstractDataSource实现了DataSource接口，所有存在获取数据源连接的方法
        public Connection getConnection() throws SQLException {
            return this.determineTargetDataSource().getConnection();
        }
    
        public Connection getConnection(String username, String password) throws SQLException {
            return this.determineTargetDataSource().getConnection(username, password);
        }
    
        protected DataSource determineTargetDataSource() {
            Assert.notNull(this.resolvedDataSources, "DataSource router not initialized");
            //调用实现类中重写的determineCurrentLookupKey方法拿到当前线程要使用的数据源的名称
            Object lookupKey = this.determineCurrentLookupKey();
            //去解析之后的数据源信息集合中查询该数据源是否存在，如果没有拿到则使用默认数据源resolvedDefaultDataSource
            DataSource 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 + "]");
            } else {
                return dataSource;
            }
        }
    
        @Nullable
        protected abstract Object determineCurrentLookupKey();
}

public class DynamicDataSource extends AbstractRoutingDataSource {

    // 可选：保存所有定义好的数据源（备用）
    private Map<Object, Object> defineTargetDataSources;

    /**
     * 决定当前线程使用哪个数据源
     */
    @Override
    protected Object determineCurrentLookupKey() {
        return DynamicDataSourceHolder.getDynamicDataSourceKey();
    }

    public Map<Object, Object> getDefineTargetDataSources() {
        return defineTargetDataSources;
    }

    public void setDefineTargetDataSources(Map<Object, Object> defineTargetDataSources) {
        this.defineTargetDataSources = defineTargetDataSources;
    }
}

public class CommonConstant {
    public static final String ARCHIVE = "archive";

    public static final String BUSINESS = "business";

    public static final String USER = "user";

    public static final String BSAP = "bsap";

    public static final String CN6 = "cn6";

    public static final String SIM = "sim";

    public static final String ETC = "etc";

    public static final String FUELMANAGE = "fuelmanage";

    public static final String CLOUD = "cloud";

    public static final String LOG = "log";

    public static final String TSP = "tsp";

    public static final String OTA = "ota";
}

public class DynamicDataSourceHolder {
    private static final Logger logger = LoggerFactory.getLogger(DynamicDataSourceHolder.class);
    private static final ThreadLocal<String> DYNAMIC_DATASOURCE_KEY = new ThreadLocal<>();

    /**
     * 设置/切换当前线程使用的数据源
     */
    public static void setDynamicDataSourceKey(String key) {
		//logger.info("切换数据源至：{}", key);
        DYNAMIC_DATASOURCE_KEY.set(key);
    }

    /**
     * 获取当前线程使用的数据源，如果没有设置则返回默认的archive数据源
     */
    public static String getDynamicDataSourceKey() {
        String key = DYNAMIC_DATASOURCE_KEY.get();
        return (key == null) ? CommonConstant.ARCHIVE : key;
    }

    /**
     * 清除当前线程中的数据源标识
     */
    public static void removeDynamicDataSourceKey() {
        logger.info("移除数据源：{}", DYNAMIC_DATASOURCE_KEY.get());
        DYNAMIC_DATASOURCE_KEY.remove();
    }
}

@Configuration
@MapperScan("com.xxxx.archive.mapper")
public class DruidConfig {

    @Bean(name = CommonConstant.ARCHIVE)
    @ConfigurationProperties("spring.datasource.druid.archive")
    public DataSource archiveDataSource() {
        return DruidDataSourceBuilder.create().build();
    }

    @Bean(name = CommonConstant.BUSINESS)
    @ConfigurationProperties("spring.datasource.druid.business")
    public DataSource businessDataSource() {
        return DruidDataSourceBuilder.create().build();
    }

    @Bean(name = CommonConstant.USER)
    @ConfigurationProperties("spring.datasource.druid.user")
    public DataSource userDataSource() {
        return DruidDataSourceBuilder.create().build();
    }

    @Bean(name = CommonConstant.BSAP)
    @ConfigurationProperties("spring.datasource.druid.bsap")
    public DataSource bsapDataSource() {
        return DruidDataSourceBuilder.create().build();
    }

    @Bean(name = CommonConstant.CN6)
    @ConfigurationProperties("spring.datasource.druid.cn6")
    public DataSource cn6DataSource() {
        return DruidDataSourceBuilder.create().build();
    }

    @Bean(name = CommonConstant.SIM)
    @ConfigurationProperties("spring.datasource.druid.sim")
    public DataSource simDataSource() {
        return DruidDataSourceBuilder.create().build();
    }

    @Bean(name = CommonConstant.ETC)
    @ConfigurationProperties("spring.datasource.druid.etc")
    public DataSource etcDataSource() {
        return DruidDataSourceBuilder.create().build();
    }

    @Bean(name = CommonConstant.FUELMANAGE)
    @ConfigurationProperties("spring.datasource.druid.fuelmanage")
    public DataSource fuelmanageDataSource() {
        return DruidDataSourceBuilder.create().build();
    }

    @Bean(name = CommonConstant.CLOUD)
    @ConfigurationProperties("spring.datasource.druid.cloud")
    public DataSource cloudDataSource() {
        return DruidDataSourceBuilder.create().build();
    }

    @Bean(name = CommonConstant.LOG)
    @ConfigurationProperties("spring.datasource.druid.log")
    public DataSource logDataSource() {
        return DruidDataSourceBuilder.create().build();
    }

    @Bean(name = CommonConstant.TSP)
    @ConfigurationProperties("spring.datasource.druid.tsp")
    public DataSource tspDataSource() {
        return DruidDataSourceBuilder.create().build();
    }

    @Bean(name = CommonConstant.OTA)
    @ConfigurationProperties("spring.datasource.druid.ota")
    public DataSource otaDataSource() {
        return DruidDataSourceBuilder.create().build();
    }

    @Bean
    @Primary
    public DynamicDataSource dynamicDataSource() {
        Map<Object, Object> targetDataSources = new HashMap<>(12);
        targetDataSources.put(CommonConstant.ARCHIVE, archiveDataSource());
        targetDataSources.put(CommonConstant.BUSINESS, businessDataSource());
        targetDataSources.put(CommonConstant.USER, userDataSource());
        targetDataSources.put(CommonConstant.BSAP, bsapDataSource());
        targetDataSources.put(CommonConstant.CN6, cn6DataSource());
        targetDataSources.put(CommonConstant.SIM, simDataSource());
        targetDataSources.put(CommonConstant.ETC, etcDataSource());
        targetDataSources.put(CommonConstant.FUELMANAGE, fuelmanageDataSource());
        targetDataSources.put(CommonConstant.CLOUD, cloudDataSource());
        targetDataSources.put(CommonConstant.LOG, logDataSource());
        targetDataSources.put(CommonConstant.TSP, tspDataSource());
        targetDataSources.put(CommonConstant.OTA, otaDataSource());


        DynamicDataSource dynamicDataSource = new DynamicDataSource();
        // 设置默认数据源（此处默认使用 archive 数据源）
        dynamicDataSource.setDefaultTargetDataSource(archiveDataSource());
        // 设置所有目标数据源
        dynamicDataSource.setTargetDataSources(targetDataSources);

        // 保存原始数据源信息
        dynamicDataSource.setDefineTargetDataSources(targetDataSources);
        // 初始化 resolvedDataSources
        dynamicDataSource.afterPropertiesSet();

        return dynamicDataSource;
    }
}

DynamicDataSourceHolder.setDynamicDataSourceKey(config.getTargetDatasource());