ShardingSphere~2

功能的注册与配置加载

以Governance分布式治理的注册中心为例

代码包整体是按照功能点划分，具体到每个功能，比如治理-代码大致分为spring-boot-starter启动加载相关；context上下文信息定义；core核心执行逻辑，比如对于注册中心，core包含了各类事件，监听的定义，等；api定义了基本的对外交互模型；对于注册中心，不同的实现又具有单独的repository-etcd类似结构目录，结构间的依赖关系源码已经定义好了

每个主要功能都有对应的启动加载类（sharding/shadow/readwrite/encrypt/db-discovery相同），注册中心起始于shardingsphere-jdbc-governance-spring-boot-starter

大体逻辑都是通过判断配置文件逻辑是否符合规范，符合则加载配置，创建对应的资源

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.apache.shardingsphere.spring.boot.governance;

import com.google.common.base.Preconditions;
import lombok.RequiredArgsConstructor;
import org.apache.shardingsphere.driver.governance.internal.datasource.GovernanceShardingSphereDataSource;
import org.apache.shardingsphere.infra.config.RuleConfiguration;
import org.apache.shardingsphere.governance.core.yaml.config.swapper.RegistryCenterConfigurationYamlSwapper;
import org.apache.shardingsphere.governance.repository.api.config.GovernanceConfiguration;
import org.apache.shardingsphere.spring.boot.datasource.DataSourceMapSetter;
import org.apache.shardingsphere.spring.boot.governance.common.GovernanceSpringBootRootConfiguration;
import org.apache.shardingsphere.spring.boot.governance.rule.LocalRulesCondition;
import org.springframework.beans.factory.ObjectProvider;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.AutoConfigureBefore;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.EnvironmentAware;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Conditional;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.Environment;

import javax.sql.DataSource;
import java.sql.SQLException;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;

/**
 * Governance spring boot configuration.
 */
@Configuration
@ComponentScan("org.apache.shardingsphere.spring.boot.converter")
@EnableConfigurationProperties(GovernanceSpringBootRootConfiguration.class)
@ConditionalOnProperty(prefix = "spring.shardingsphere", name = "enabled", havingValue = "true", matchIfMissing = true)
@RequiredArgsConstructor
@AutoConfigureBefore(DataSourceAutoConfiguration.class)
public class ShardingSphereGovernanceAutoConfiguration implements EnvironmentAware {
    
    private final Map<String, DataSource> dataSourceMap = new LinkedHashMap<>();
    
    private final GovernanceSpringBootRootConfiguration root;
    
    private final RegistryCenterConfigurationYamlSwapper swapper = new RegistryCenterConfigurationYamlSwapper();
    
    /**
     * Get governance configuration.
     *
     * @return governance configuration
     */
    @Bean
    public GovernanceConfiguration governanceConfiguration() {
        Preconditions.checkState(Objects.nonNull(root.getGovernance()), "The governance configuration is invalid, please configure governance");
        return new GovernanceConfiguration(root.getGovernance().getName(), swapper.swapToObject(root.getGovernance().getRegistryCenter()), root.getGovernance().isOverwrite());
    }
    
    /**
     * Get governance ShardingSphere data source bean by local configuration.
     *
     * @param rules rules configuration
     * @param governanceConfig governance configuration
     * @return governance sharding data source bean
     * @throws SQLException SQL exception
     */
    @Bean
    @Conditional(LocalRulesCondition.class)
    @Autowired(required = false)
    public DataSource localShardingSphereDataSource(final ObjectProvider<List<RuleConfiguration>> rules, final GovernanceConfiguration governanceConfig) throws SQLException {
        List<RuleConfiguration> ruleConfigurations = Optional.ofNullable(rules.getIfAvailable()).orElse(Collections.emptyList());
        return createDataSourceWithRules(ruleConfigurations, governanceConfig);
    }
    
    /**
     * Get data source bean from registry center.
     *
     * @param governanceConfig governance configuration
     * @return data source bean
     * @throws SQLException SQL Exception
     */
    @Bean
    @ConditionalOnMissingBean(DataSource.class)
    public DataSource dataSource(final GovernanceConfiguration governanceConfig) throws SQLException {
        return createDataSourceWithoutRules(governanceConfig);
    }
    
    @Override
    public final void setEnvironment(final Environment environment) {
        dataSourceMap.putAll(DataSourceMapSetter.getDataSourceMap(environment));
    }
    
    private DataSource createDataSourceWithRules(final List<RuleConfiguration> ruleConfigs, final GovernanceConfiguration governanceConfig) throws SQLException {
        return new GovernanceShardingSphereDataSource(dataSourceMap, ruleConfigs, root.getProps(), governanceConfig);
    }
    
    private DataSource createDataSourceWithoutRules(final GovernanceConfiguration governanceConfig) throws SQLException {
        return new GovernanceShardingSphereDataSource(governanceConfig);
    }
}

如果是加了@***Condition的，会做逻辑配置逻辑检查

public final class ReadwriteSplittingSpringBootCondition extends SpringBootCondition {
    
    private static final String PREFIX = "spring.shardingsphere.rules.readwrite-splitting";
    
    @Override
    public ConditionOutcome getMatchOutcome(final ConditionContext conditionContext, final AnnotatedTypeMetadata annotatedTypeMetadata) {
        return PropertyUtil.containPropertyPrefix(conditionContext.getEnvironment(), PREFIX)
                ? ConditionOutcome.match() : ConditionOutcome.noMatch("Can't find ShardingSphere readwrite-splitting rule configuration in local file.");
    }
}

通过反射判断

    @SneakyThrows(ReflectiveOperationException.class)
    private static Object v2(final Environment environment, final String prefix, final Class<?> targetClass) {
        Class<?> binderClass = Class.forName("org.springframework.boot.context.properties.bind.Binder");
        Method getMethod = binderClass.getDeclaredMethod("get", Environment.class);
        Method bindMethod = binderClass.getDeclaredMethod("bind", String.class, Class.class);
        Object binderObject = getMethod.invoke(null, environment);
        String prefixParam = prefix.endsWith(".") ? prefix.substring(0, prefix.length() - 1) : prefix;
        Object bindResultObject = bindMethod.invoke(binderObject, prefixParam, targetClass);
        Method resultGetMethod = bindResultObject.getClass().getDeclaredMethod("get");
        return resultGetMethod.invoke(bindResultObject);
    }

最终通过按照转换后的配置对象构建对应的服务资源对象

--------------------------------------------------------------------------

注册中心目前支持zookeeper/etcd

服务加载方式全部是基于ServiceLoader，有些是默认在源码包里加载的，比如org.apache.shardingsphere.governance.repository.zookeeper.CuratorZookeeperRepository就通过下图文件启动，也有些可以自己实现然后添加的

加载方式

@NoArgsConstructor(access = AccessLevel.PRIVATE)
public final class RegistryCenterRepositoryFactory {
    
    static {
        ShardingSphereServiceLoader.register(RegistryCenterRepository.class);
    }
    
    /**
     * Create new instance of Registry center repository.
     * 
     * @param config governance configuration
     * @return new instance of Registry center repository
     */
    public static RegistryCenterRepository newInstance(final GovernanceConfiguration config) {
        RegistryCenterConfiguration registryCenterConfig = config.getRegistryCenterConfiguration();
        Preconditions.checkNotNull(registryCenterConfig, "Registry center configuration cannot be null.");
        RegistryCenterRepository result = TypedSPIRegistry.getRegisteredService(RegistryCenterRepository.class, registryCenterConfig.getType(), registryCenterConfig.getProps());
        result.init(config.getName(), registryCenterConfig);
        return result;
    }
}

 注册中心需要实现的逻辑也很简单，看图就知道了

整个注册中心基于临时节点跟session生命周期相同的特性实现实例和数据库的注册发现，基于监听机制实现配置变更的发现通知

通过google eventbus事件机制传递到观察者实现配置动态化

zk治理节点