//根据配置选择原生加载还是groupBy加载
public SchemaMetaData load(final DatabaseType databaseType) throws SQLException {
        SchemaMetaData result = useGroupMetaLoad?loadShardingSchemaMetaDataGroupByActualDataNodes(databaseType):loadShardingSchemaMetaData(databaseType);
        result.merge(loadDefaultSchemaMetaData(databaseType));
        return result;
    }

//原有逻辑
    private SchemaMetaData loadShardingSchemaMetaData(final DatabaseType databaseType) throws SQLException {
        LOGGER.info("Loading {} logic tables' meta data.", shardingRule.getTableRules().size());
        Map<String, TableMetaData> tableMetaDataMap = new HashMap<>(shardingRule.getTableRules().size(), 1);
        for (TableRule each : shardingRule.getTableRules()) {
            tableMetaDataMap.put(each.getLogicTable(), load(each.getLogicTable(), databaseType));
        }
        return new SchemaMetaData(tableMetaDataMap);
    }
//新逻辑
    private SchemaMetaData loadShardingSchemaMetaDataGroupByActualDataNodes(final DatabaseType databaseType) throws SQLException {
        LOGGER.info("Loading {} logic tables' meta data.", shardingRule.getTableRules().size());
//根据actualDataNodes分组，key为要查询的逻辑表名，value为同个acutalDataNodes的表名
        Map<String, Set<String>> sameNodeMap = groupByActualDataNodes(shardingRule.getShardingDataSourceNames().getShardingRuleConfig().getTableRuleConfigs());
        int maxQuery=Math.min(CORES*2,maxConnectionsSizePerQuery);
        List<List<String>> tableGroups = Lists.partition(new ArrayList<>(sameNodeMap.keySet()), Math.max(sameNodeMap.size() / maxQuery, 1));
        Map<String, TableMetaData> tableMetaDataMap = new HashMap<>(shardingRule.getTableRules().size(), 1);
        if (tableGroups.size() == 1 || isCheckingMetaData) {
            for (String sameLogicTable : tableGroups.get(0)) {
                TableMetaData load = load(sameLogicTable, databaseType);
                Set<String> value = sameNodeMap.get(sameLogicTable);
                for (String s : value) {
                    tableMetaDataMap.put(s, load);
                }
            }
        } else {
            //async，模仿已有写法
            ExecutorService executorService = Executors.newFixedThreadPool(Math.min(tableGroups.size(), maxQuery));
            try {
                Collection<Future<Map<String, TableMetaData>>> futures = new LinkedList<>();
                for (List<String> each : tableGroups) {
                    futures.add(executorService.submit(() -> {
                        Map<String, TableMetaData> tableMetaData = new HashMap<>();
                        for (String s : each) {
                            tableMetaData.put(s, load(s, databaseType));
                        }
                        return tableMetaData;
                    }));
                }
                for (Future<Map<String, TableMetaData>> each : futures) {
                    try {
                        Map<String, TableMetaData> m = each.get();
                        for (String s : m.keySet()) {
                            Set<String> sameTable = sameNodeMap.get(s);
                            for (String string : sameTable) {
                                tableMetaDataMap.put(string, m.get(s));
                            }
                        }
                    } catch (final InterruptedException | ExecutionException ex) {
                        if (ex.getCause() instanceof SQLException) {
                            throw (SQLException) ex.getCause();
                        }
                        Thread.currentThread().interrupt();
                    }
                }
            } finally {
                executorService.shutdown();
            }
        }
        LOGGER.info("Actual {} logic tables' meta data loaded.", sameNodeMap.size());
        return new SchemaMetaData(tableMetaDataMap);
    }

private Map<String, Set<String>> groupByActualDataNodes(Collection<TableRuleConfiguration> configurations) {
        Map<String, List<TableRuleConfiguration>> collect = configurations.stream().collect(Collectors.groupingBy(TableRuleConfiguration::getActualDataNodes));
        Map<String, Set<String>> containSet = new HashMap<>();
        for (Entry<String, List<TableRuleConfiguration>> entry : collect.entrySet()) {
            //同一个datasource分为一组
            Map<String,Set<String>> sameDatabaseMap=new HashMap<>();
            entry.getValue().stream().map(TableRuleConfiguration::getLogicTable).forEach(e->{
                String currentDatabase = getFirstDataSourceNameByLogicTableName(e);
                Set<String> tableNames = sameDatabaseMap.getOrDefault(currentDatabase, new HashSet<>());
                tableNames.add(e);
                sameDatabaseMap.put(currentDatabase,tableNames);
            });
            for (Entry<String, Set<String>> sameDatabaseSet : sameDatabaseMap.entrySet()) {
                Set<String> value = sameDatabaseSet.getValue();
                containSet.put(value.iterator().next(),value);
            }
        }
        return containSet;
    }
    private String getFirstDataSourceNameByLogicTableName(String logicTableName){
        TableRule tableRule = shardingRule.getTableRule(logicTableName);
        DataNode dataNode = tableRule.getActualDataNodes().iterator().next();
        return dataNode.getDataSourceName();
    }

spring.shardingsphere.props.max.connections.size.per.query=10
spring.shardingsphere.props.group.metadata.load.enabled=true