Sharding-JDBC分库分表-自动配置与分片规则加载原理-3

Sharding JDBC自动配置的原理

与所有starter一样，shardingsphere-jdbc-core-spring-boot-starter也是通过SPI自动配置的原理实现分库分表配置加载，spring.factories文件中的自动配置类shardingsphere-jdbc-core-spring-boot-starter功不可没，他主要是自动创建了模式bean、事务类型bean和数据源bean，配置加载的过程可以归纳如下：

创建模式bean

创建数据源bean

创建事务类型扫描bean

ShardingSphereAutoConfiguration

ModeConfiguration

ShardingSphereDataSource

TransactionTypeScanner

其中，创建数据源bean时会根据不同的模式创建不同的bean，本地模式直接从配置文件中加载，配置中心模式就从配置中心加载。ShardingSphereAutoConfiguration的实现如下：

@Configuration
@ComponentScan("org.apache.shardingsphere.spring.boot.converter")
@EnableConfigurationProperties(SpringBootPropertiesConfiguration.class)
@AutoConfigureBefore(DataSourceAutoConfiguration.class)
@RequiredArgsConstructor
public class ShardingSphereAutoConfiguration implements EnvironmentAware {
    
    private String databaseName;
    
    private final SpringBootPropertiesConfiguration props;
    
    private final Map<String, DataSource> dataSourceMap = new LinkedHashMap<>();
    
    /**
     * 模式配置
     *
     * @return mode configuration
     */
    @Bean
    public ModeConfiguration modeConfiguration() {
        return null == props.getMode() ? null : new YamlModeConfigurationSwapper().swapToObject(props.getMode());
    }
    
    /**
     * 单机模式：从本地配置中加载DataSource
     *
     * @param rules rules configuration
     * @param modeConfig mode configuration
     * @return data source bean
     * @throws SQLException SQL exception
     */
    @Bean
    @Conditional(LocalRulesCondition.class)
    @Autowired(required = false)
    public DataSource shardingSphereDataSource(final ObjectProvider<List<RuleConfiguration>> rules, final ObjectProvider<ModeConfiguration> modeConfig) throws SQLException {
        Collection<RuleConfiguration> ruleConfigs = Optional.ofNullable(rules.getIfAvailable()).orElseGet(Collections::emptyList);
        return ShardingSphereDataSourceFactory.createDataSource(databaseName, modeConfig.getIfAvailable(), dataSourceMap, ruleConfigs, props.getProps());
    }
    
    /**
     * 集群模式：从配置中心中加载DataSource
     *
     * @param modeConfig mode configuration
     * @return data source bean
     * @throws SQLException SQL exception
     */
    @Bean
    @ConditionalOnMissingBean(DataSource.class)
    public DataSource dataSource(final ModeConfiguration modeConfig) throws SQLException {
        return !dataSourceMap.isEmpty() ? ShardingSphereDataSourceFactory.createDataSource(databaseName, modeConfig, dataSourceMap, Collections.emptyList(), props.getProps())
                : ShardingSphereDataSourceFactory.createDataSource(databaseName, modeConfig);
    }
    
    /**
     * 事务类型扫描bean
     *
     * @return transaction type scanner
     */
    @Bean
    public TransactionTypeScanner transactionTypeScanner() {
        return new TransactionTypeScanner();
    }
    
    @Override
    public final void setEnvironment(final Environment environment) {
        dataSourceMap.putAll(DataSourceMapSetter.getDataSourceMap(environment));
        databaseName = DatabaseNameSetter.getDatabaseName(environment);
    }
}

下面以单机模式出发点，理一下加载的过程。

@Bean
@Conditional(LocalRulesCondition.class)
@Autowired(required = false)
public DataSource shardingSphereDataSource(final ObjectProvider<List<RuleConfiguration>> rules, final ObjectProvider<ModeConfiguration> modeConfig) throws SQLException {
    Collection<RuleConfiguration> ruleConfigs = Optional.ofNullable(rules.getIfAvailable()).orElseGet(Collections::emptyList);
    // 通过ShardingSphereDataSourceFactory工厂创建数据源
    return ShardingSphereDataSourceFactory.createDataSource(databaseName, modeConfig.getIfAvailable(), dataSourceMap, ruleConfigs, props.getProps());
}

通过对源码的跟踪，可以发现，ShardingSphereDataSourceFactory.createDataSource创建数据源经历了如下的过程

创建数据源bean

new

创建上下文管理器

创建JDBC上下文

创建InstanceMetaData

根据mode调用

创建元数据上下文

创建数据库连接元数据

调用

加载分片规则

new

ShardingSphereAutoConfiguration

ShardingSphereDataSourceFactory.createDataSource

ShardingSphereDataSource

ShardingSphereDataSource.createContextManager

JDBCContext

InstanceMetaDataBuilderFactory.create

StandaloneContextManagerBuilder.build

MetaDataContextsFactory.create

ShardingSphereDatabasesFactory.create

ShardingSphereDatabase.create

DatabaseRulesBuilder.build

ShardingSphereDatabase

分片规则加载原理

分片规则、审计规则、key生成规则都是通过SPI的方式加载，自动配置类ShardingSphereAutoConfiguration中创建ShardingSphereDataSource的时候，会加载配置的分片规则，创建核心配置类ShardingRule，在ShardingRule的创建中会通过SPI的方式加载分片规则。加载的过程如下：

创建数据源bean

查询实例

通过SPI Class获取服务实例

Y:创建新的service实例

N:Map中获取service单例

创建分片规则

创建分片规则

创建核心分库分表规则

分片规则

Key生成规则

审计规则

通过工厂创建分片算法

获取注册的service

SPI方式获取service

通过工厂创建key生成算法

通过工厂创建审计算法

ShardingSphereAutoConfiguration

ShardingSphereDataSource

一系列加载...

DatabaseRulesBuilder.build

OrderedSPIRegistry.getRegisteredServices

ShardingSphereServiceLoader.getServiceInstances(spiClass)

带@SingletonSPI注解?

service.getClass().getDeclaredConstructor().newInstance()

SERVICES.getOrDefault(serviceInterface, Collections.emptyList())

ShardingRuleBuilder.build

new ShardingRule

ShardingAlgorithmFactory.newInstance

KeyGenerateAlgorithmFactory.newInstance

ShardingAuditAlgorithmFactory.newInstance

ShardingSphereAlgorithmFactory.createAlgorithm

TypedSPIRegistry.getRegisteredService

ShardingSphereServiceLoader.getServiceInstances(spiClass)

SPI核心实现类ShardingSphereServiceLoader中会将SPI接口进行Map缓存管理，需要时直接获取。如果Map中不存在，就通过反射的方式新建服务实例，具体实现源码如下：

public final class ShardingSphereServiceLoader {
    
    // 缓存service实例，
    // 缓存的Key,如：
    //  org.apache.shardingsphere.sharding.spi.ShardingAlgorithm
    //  org.apache.shardingsphere.sharding.spi.KeyGenerateAlgorithm
    //  org.apache.shardingsphere.transaction.spi.ShardingSphereTransactionManager
    private static final Map<Class<?>, Collection<Object>> SERVICES = new ConcurrentHashMap<>();
    
    /**
     * 注册服务实例
     *
     * @param 服务接口
     */
    public static void register(final Class<?> serviceInterface) {
        if (!SERVICES.containsKey(serviceInterface)) {
            SERVICES.put(serviceInterface, load(serviceInterface));
        }
    }
    
    private static <T> Collection<Object> load(final Class<T> serviceInterface) {
        Collection<Object> result = new LinkedList<>();
        for (T each : ServiceLoader.load(serviceInterface)) {
            result.add(each);
        }
        return result;
    }
    
    /**
     * 获取服务实例
     * 
     * @param 服务接口
     * @param  服务类型
     * @return 服务实例
     */
    public static <T> Collection<T> getServiceInstances(final Class<T> serviceInterface) {
        return null == serviceInterface.getAnnotation(SingletonSPI.class) ? createNewServiceInstances(serviceInterface) : getSingletonServiceInstances(serviceInterface);
    }
    
    @SneakyThrows(ReflectiveOperationException.class)
    @SuppressWarnings("unchecked")
    private static <T> Collection<T> createNewServiceInstances(final Class<T> serviceInterface) {
        if (!SERVICES.containsKey(serviceInterface)) {
            return Collections.emptyList();
        }
        Collection<Object> services = SERVICES.get(serviceInterface);
        if (services.isEmpty()) {
            return Collections.emptyList();
        }
        Collection<T> result = new LinkedList<>();
        for (Object each : services) {
            // 通过反射新建实例
            result.add((T) each.getClass().getDeclaredConstructor().newInstance());
        }
        return result;
    }
    
    @SuppressWarnings("unchecked")
    private static <T> Collection<T> getSingletonServiceInstances(final Class<T> serviceInterface) {
        return (Collection<T>) SERVICES.getOrDefault(serviceInterface, Collections.emptyList());
    }
}