Skywalking-13：Skywalking模块加载机制

「爱情、让人受尽委屈。」 2022-08-28 10:55 506阅读 0赞

# 模块加载机制 #

## 基本概述 ##

> `Module` 是 `Skywalking` 在 `OAP` 提供的一种管理功能特性的机制。通过 `Module` 机制，可以方便的定义模块，并且可以提供多种实现，在配置文件中任意选择实现。

模块相关配置文件可以参考：[Backend setup][]、[Configuration Vocabulary][]

## 类图 ##

`Skywalking` 中模块管理相关功能都在 `org.apache.skywalking.oap.server.library.module` 包下。

通过类图可以了解 `Skywalking` 模块机制大致分成如下几个模块：

*  模块配置： `ApplicationConfiguration` 、 `ModuleConfiguration` 、 `ProviderConfiguration`
    
     *  PS：刚好对应 `application.yml` 三层结构：模块->模块实现->某个模块实现的配置。
 *  模块定义类： `ModuleDefine`
 *  模块提供类： `ModuleProvider`
 *  服务： `Service`
 *  管理类： `ModuleManager`
 *  一些辅助类
    
     *  `ModuleDefineHolder` ：模块管理类需要实现的接口，提供查找模块相关功能
     *  `ModuleProviderHolder` ：模块定义类需要实现的接口，提供获取模块的服务类功能
     *  `ModuleServiceHolder` ：模块提供类需要实现的接口，提供注册服务实现、获取服务对象的功能
     *  `ModuleConfig` ：模块配置类，模块定义类会将`ProviderConfiguration` 映射为 `ModuleConfig`
     *  `ApplicationConfigLoader`：`ApplicationConfiguration` 的辅助类，将 `application.yml` 配置文件加载到内存， 设置 `selector` 对应的 `Provider` 的配置信息

![file][]

类图源文件：[Skywalking-Module.uml][]

## 源码解析 ##

### ModuleDefine ###

package org.apache.skywalking.oap.server.library.module;
    
    import java.lang.reflect.Field;
    import java.util.Enumeration;
    import java.util.Properties;
    import java.util.ServiceLoader;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    // 模块定义
    public abstract class ModuleDefine implements ModuleProviderHolder { 
        private static final Logger LOGGER = LoggerFactory.getLogger(ModuleDefine.class);
        // 模块实际的
        private ModuleProvider loadedProvider = null;
    
        private final String name;
    
        public ModuleDefine(String name) { 
            this.name = name;
        }
    
        // 模块名
        public final String name() { 
            return name;
        }
    
        // 实现类可以定义模块提供的服务类
        public abstract Class[] services();
    
        /** * Run the prepare stage for the module, including finding all potential providers, and asking them to prepare. * * @param moduleManager of this module * @param configuration of this module * @throws ProviderNotFoundException when even don't find a single one providers. */
        // 准备阶段，找到configuration配置类对应的ModuleProvider对象，进行初始化操作
        void prepare(
            // 模块管理对象
            ModuleManager moduleManager, 
            // 模块配置类
            ApplicationConfiguration.ModuleConfiguration configuration,
            // 模块提供类的服务加载器
            ServiceLoader<ModuleProvider> moduleProviderLoader
        ) throws ProviderNotFoundException, ServiceNotProvidedException, ModuleConfigException, ModuleStartException { 
            // 找到configuration配置类对应的ModuleProvider对象
            for (ModuleProvider provider : moduleProviderLoader) { 
                if (!configuration.has(provider.name())) { 
                    continue;
                }
                if (provider.module().equals(getClass())) { 
                    if (loadedProvider == null) { 
                        loadedProvider = provider;
                        loadedProvider.setManager(moduleManager);
                        loadedProvider.setModuleDefine(this);
                    } else { 
                        throw new DuplicateProviderException(this.name() + " module has one " + loadedProvider.name() + "[" + loadedProvider.getClass().getName() + "] provider already, " + provider.name() + "[" + provider.getClass().getName() + "] is defined as 2nd provider.");
                    }
                }
            }
            if (loadedProvider == null) { 
                throw new ProviderNotFoundException(this.name() + " module no provider found.");
            }
    
            // 复制提供类的配置文件至ModuleConfig对象
            LOGGER.info("Prepare the {} provider in {} module.", loadedProvider.name(), this.name());
            try { 
                copyProperties(
                    loadedProvider.createConfigBeanIfAbsent(), 
                    configuration.getProviderConfiguration(loadedProvider.name()), 
                    this.name(), 
                    loadedProvider.name()
                );
            } catch (IllegalAccessException e) { 
                throw new ModuleConfigException(this.name() + " module config transport to config bean failure.", e);
            }
            // 模块提供对象进入准备阶段
            loadedProvider.prepare();
        }
    
        // 使用反射复制属性
        private void copyProperties(ModuleConfig dest, Properties src, String moduleName, String providerName) throws IllegalAccessException { 
            if (dest == null) { 
                return;
            }
            Enumeration<?> propertyNames = src.propertyNames();
            while (propertyNames.hasMoreElements()) { 
                String propertyName = (String) propertyNames.nextElement();
                Class<? extends ModuleConfig> destClass = dest.getClass();
                try { 
                    Field field = getDeclaredField(destClass, propertyName);
                    field.setAccessible(true);
                    field.set(dest, src.get(propertyName));
                } catch (NoSuchFieldException e) { 
                    LOGGER.warn(propertyName + " setting is not supported in " + providerName + " provider of " + moduleName + " module");
                }
            }
        }
    
        private Field getDeclaredField(Class<?> destClass, String fieldName) throws NoSuchFieldException { 
            if (destClass != null) { 
                Field[] fields = destClass.getDeclaredFields();
                for (Field field : fields) { 
                    if (field.getName().equals(fieldName)) { 
                        return field;
                    }
                }
                return getDeclaredField(destClass.getSuperclass(), fieldName);
            }
            throw new NoSuchFieldException();
        }
    
        // 获取模块定义对应的Provider对象
        @Override
        public final ModuleProvider provider() throws DuplicateProviderException, ProviderNotFoundException { 
            if (loadedProvider == null) { 
                throw new ProviderNotFoundException("There is no module provider in " + this.name() + " module!");
            }
            return loadedProvider;
        }
    }

### ModuleProviderHolder ###

package org.apache.skywalking.oap.server.library.module;
    
    // 模块提供持有接口，通过该接口，可以获取模块Provider对象对应的Service持有接口，从而拿到模块Provider对象对应的服务对象
    public interface ModuleProviderHolder { 
        // 获取模块提供对象
        ModuleServiceHolder provider() throws DuplicateProviderException, ProviderNotFoundException;
    }

### ModuleProvider ###

package org.apache.skywalking.oap.server.library.module;
    
    import java.util.HashMap;
    import java.util.Map;
    import lombok.Setter;
    
    // 模块提供抽象类，所有的模块提供类都需要继承该抽象类
    // 一个模块定义可以配置多个模块提供类，通过在application.yml进行切换
    public abstract class ModuleProvider implements ModuleServiceHolder { 
        // 模块管理器
        @Setter
        private ModuleManager manager;
        // 模块定义对象
        @Setter
        private ModuleDefine moduleDefine;
        // 模块提供对应的服务对象map
        private final Map<Class<? extends Service>, Service> services = new HashMap<>();
    
        public ModuleProvider() { 
        }
    
        protected final ModuleManager getManager() { 
            return manager;
        }
    
        // 获取服务提供实现类的name，需要子类实现
        public abstract String name();
    
        // 定义模块提供者所实现的模块定义类
        public abstract Class<? extends ModuleDefine> module();
    
        // 创建模块定义配置对象
        public abstract ModuleConfig createConfigBeanIfAbsent();
    
        // 准备阶段（初始化与其他模块无关的事情）
        public abstract void prepare() throws ServiceNotProvidedException, ModuleStartException;
    
        // 启动阶段（该阶段模块间可以互相操作）
        public abstract void start() throws ServiceNotProvidedException, ModuleStartException;
    
        // 完成后通知阶段（在所有模块成功启动后执行）
        public abstract void notifyAfterCompleted() throws ServiceNotProvidedException, ModuleStartException;
    
        // 该模块需要依赖的其他模块名
        public abstract String[] requiredModules();
    
        // 注册服务实现类
        @Override
        public final void registerServiceImplementation(Class<? extends Service> serviceType, Service service) throws ServiceNotProvidedException { 
            if (serviceType.isInstance(service)) { 
                this.services.put(serviceType, service);
            } else { 
                throw new ServiceNotProvidedException(serviceType + " is not implemented by " + service);
            }
        }
    
        // 确保所有服务被实现
        void requiredCheck(Class<? extends Service>[] requiredServices) throws ServiceNotProvidedException { 
            if (requiredServices == null)
                return;
            for (Class<? extends Service> service : requiredServices) { 
                if (!services.containsKey(service)) { 
                    throw new ServiceNotProvidedException("Service:" + service.getName() + " not provided");
                }
            }
            if (requiredServices.length != services.size()) { 
                throw new ServiceNotProvidedException("The " + this.name() + " provider in " + moduleDefine.name() + " moduleDefine provide more service implementations than ModuleDefine requirements.");
            }
        }
    
        // 获取服务实现对象
        @Override
        public @SuppressWarnings("unchecked")
        <T extends Service> T getService(Class<T> serviceType) throws ServiceNotProvidedException { 
            Service serviceImpl = services.get(serviceType);
            if (serviceImpl != null) { 
                return (T) serviceImpl;
            }
            throw new ServiceNotProvidedException("Service " + serviceType.getName() + " should not be provided, based on moduleDefine define.");
        }
    
        ModuleDefine getModule() { 
            return moduleDefine;
        }
    
        String getModuleName() { 
            return moduleDefine.name();
        }
    }

### ModuleConfig ###

package org.apache.skywalking.oap.server.library.module;
    
    // 模块配置类
    public abstract class ModuleConfig { 
    }

### ModuleServiceHolder ###

package org.apache.skywalking.oap.server.library.module;
    
    // 模块服务持有接口
    public interface ModuleServiceHolder { 
        // 注册服务实现对象
        void registerServiceImplementation(Class<? extends Service> serviceType, Service service) throws ServiceNotProvidedException;
        
        // 获取服务实现对象
        <T extends Service> T getService(Class<T> serviceType) throws ServiceNotProvidedException;
    }

### Service ###

package org.apache.skywalking.oap.server.library.module;
    
    // 服务接口
    public interface Service { 
    }

### ModuleDefineHolder ###

package org.apache.skywalking.oap.server.library.module;
    
    // 模块定义持有接口
    public interface ModuleDefineHolder { 
        // 判断是否有该模块
        boolean has(String moduleName);
        
        // 通过模块名获取模块定义对象
        ModuleProviderHolder find(String moduleName) throws ModuleNotFoundRuntimeException;
    }

### ModuleManager ###

package org.apache.skywalking.oap.server.library.module;
    
    import java.util.Arrays;
    import java.util.HashMap;
    import java.util.LinkedList;
    import java.util.Map;
    import java.util.ServiceLoader;
    
    // 模块管理类，管理模块的生命周期
    public class ModuleManager implements ModuleDefineHolder { 
        // 所有模块是否已经通过准备阶段
        private boolean isInPrepareStage = true;
        
        // 所有被加载的模块定义对象map
        private final Map<String, ModuleDefine> loadedModules = new HashMap<>();
    
        // 初始化所有配置的模块
        public void init(ApplicationConfiguration applicationConfiguration) throws ModuleNotFoundException, ProviderNotFoundException, ServiceNotProvidedException, CycleDependencyException, ModuleConfigException, ModuleStartException { 
            // 获取配置类中的模块名
            String[] moduleNames = applicationConfiguration.moduleList();
            // SPI加载所有模块定义对象
            ServiceLoader<ModuleDefine> moduleServiceLoader = ServiceLoader.load(ModuleDefine.class);
            // SPI加载所有模块提供对象
            ServiceLoader<ModuleProvider> moduleProviderLoader = ServiceLoader.load(ModuleProvider.class);
            // 所有配置类中定义的模块，进行准备阶段
            LinkedList<String> moduleList = new LinkedList<>(Arrays.asList(moduleNames));
            for (ModuleDefine module : moduleServiceLoader) { 
                for (String moduleName : moduleNames) { 
                    if (moduleName.equals(module.name())) { 
                        module.prepare(this, applicationConfiguration.getModuleConfiguration(moduleName), moduleProviderLoader);
                        loadedModules.put(moduleName, module);
                        moduleList.remove(moduleName);
                    }
                }
            }
            // 准备阶段结束
            isInPrepareStage = false;
    
            if (moduleList.size() > 0) { 
                throw new ModuleNotFoundException(moduleList.toString() + " missing.");
            }
    
            // 根据模块提供对象中的requiredModules方法，确定模块的初始化顺序（被依赖的模块先行加载）
            BootstrapFlow bootstrapFlow = new BootstrapFlow(loadedModules);
            // 所有模块进入启动阶段
            bootstrapFlow.start(this);
            // 所有模块进入完成后通知阶段
            bootstrapFlow.notifyAfterCompleted();
        }
    
        // 判断是否有该模块
        @Override
        public boolean has(String moduleName) { 
            return loadedModules.get(moduleName) != null;
        }
    
        // 通过模块名获取模块定义对象
        @Override
        public ModuleProviderHolder find(String moduleName) throws ModuleNotFoundRuntimeException { 
            assertPreparedStage();
            ModuleDefine module = loadedModules.get(moduleName);
            if (module != null)
                return module;
            throw new ModuleNotFoundRuntimeException(moduleName + " missing.");
        }
    
        // 断言是否还在准备阶段，如果还在准备阶段，则抛出异常
        private void assertPreparedStage() { 
            if (isInPrepareStage) { 
                throw new AssertionError("Still in preparing stage.");
            }
        }
    }

### BootstrapFlow ###

package org.apache.skywalking.oap.server.library.module;
    
    import java.util.ArrayList;
    import java.util.LinkedList;
    import java.util.List;
    import java.util.Map;
    import org.apache.skywalking.oap.server.library.util.CollectionUtils;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    // 根据模块提供对象中的requiredModules方法，确定模块的初始化顺序（被依赖的模块先行加载）
    class BootstrapFlow { 
        private static final Logger LOGGER = LoggerFactory.getLogger(BootstrapFlow.class);
    
        private Map<String, ModuleDefine> loadedModules;
        // 按依赖顺序排序的模块提供对象列表
        private List<ModuleProvider> startupSequence;
    
        BootstrapFlow(Map<String, ModuleDefine> loadedModules) throws CycleDependencyException, ModuleNotFoundException { 
            this.loadedModules = loadedModules;
            startupSequence = new LinkedList<>();
    
            // 被依赖的模块先行加载
            makeSequence();
        }
    
        @SuppressWarnings("unchecked")
        void start(
            ModuleManager moduleManager) throws ModuleNotFoundException, ServiceNotProvidedException, ModuleStartException { 
            for (ModuleProvider provider : startupSequence) { 
                LOGGER.info("start the provider {} in {} module.", provider.name(), provider.getModuleName());
                provider.requiredCheck(provider.getModule().services());
    
                provider.start();
            }
        }
    
        void notifyAfterCompleted() throws ServiceNotProvidedException, ModuleStartException { 
            for (ModuleProvider provider : startupSequence) { 
                provider.notifyAfterCompleted();
            }
        }
    
        private void makeSequence() throws CycleDependencyException, ModuleNotFoundException { 
            List<ModuleProvider> allProviders = new ArrayList<>();
            // 判断所有被依赖的模块是否存在
            for (final ModuleDefine module : loadedModules.values()) { 
                String[] requiredModules = module.provider().requiredModules();
                if (requiredModules != null) { 
                    for (String requiredModule : requiredModules) { 
                        if (!loadedModules.containsKey(requiredModule)) { 
                            throw new ModuleNotFoundException(requiredModule + " module is required by " + module.provider().getModuleName() + "." + module.provider().name() + ", but not found.");
                        }
                    }
                }
    
                allProviders.add(module.provider());
            }
    
            do { 
                int numOfToBeSequenced = allProviders.size();
                for (int i = 0; i < allProviders.size(); i++) { 
                    ModuleProvider provider = allProviders.get(i);
                    String[] requiredModules = provider.requiredModules();
                    if (CollectionUtils.isNotEmpty(requiredModules)) { 
                        // 是否所有依赖的模块都在startupSequence中
                        boolean isAllRequiredModuleStarted = true;
                        for (String module : requiredModules) { 
                            boolean exist = false;
                            for (ModuleProvider moduleProvider : startupSequence) { 
                                if (moduleProvider.getModuleName().equals(module)) { 
                                    exist = true;
                                    break;
                                }
                            }
                            if (!exist) { 
                                isAllRequiredModuleStarted = false;
                                break;
                            }
                        }
                        // 所有依赖的模块都在startupSequence，则将该模块提供对象加入startupSequence
                        if (isAllRequiredModuleStarted) { 
                            startupSequence.add(provider);
                            allProviders.remove(i);
                            i--;
                        }
                    } else { 
                        // 如果该模块提供对象不依赖任何其他模块，则加入startupSequence
                        startupSequence.add(provider);
                        allProviders.remove(i);
                        i--;
                    }
                }
    
                // 如果一次循环后，没有任何一个对象加入到startupSequence，则证明有循环依赖
                if (numOfToBeSequenced == allProviders.size()) { 
                    StringBuilder unSequencedProviders = new StringBuilder();
                    allProviders.forEach(provider -> unSequencedProviders.append(provider.getModuleName()).append("[provider=").append(provider.getClass().getName()).append("]\n"));
                    throw new CycleDependencyException("Exist cycle module dependencies in \n" + unSequencedProviders.substring(0, unSequencedProviders.length() - 1));
                }
            } while (allProviders.size() != 0); // 当提供对象列表不为空，则一直循环执行下去
        }
    }

### ApplicationConfiguration ###

package org.apache.skywalking.oap.server.library.module;
    
    import java.util.HashMap;
    import java.util.Properties;
    
    // OAP应用配置类
    public class ApplicationConfiguration { 
        // 模块定义配置map
        private HashMap<String, ModuleConfiguration> modules = new HashMap<>();
    
        // 模块配置名列表
        public String[] moduleList() { 
            return modules.keySet().toArray(new String[0]);
        }
    
        // 添加模块定义配置
        public ModuleConfiguration addModule(String moduleName) { 
            ModuleConfiguration newModule = new ModuleConfiguration();
            modules.put(moduleName, newModule);
            return newModule;
        }
    
        // 判断指定模块名是否存在模块定义配置map中
        public boolean has(String moduleName) { 
            return modules.containsKey(moduleName);
        }
    
        // 获取模块定义配置
        public ModuleConfiguration getModuleConfiguration(String name) { 
            return modules.get(name);
        }
    
        // 模块定义配置类
        public static class ModuleConfiguration { 
            // 模块提供对象map
            private HashMap<String, ProviderConfiguration> providers = new HashMap<>();
    
            private ModuleConfiguration() { 
            }
    
            // 获取模块提供配置
            public Properties getProviderConfiguration(String name) { 
                return providers.get(name).getProperties();
            }
    
            // 是否存在模块提供配置
            public boolean has(String name) { 
                return providers.containsKey(name);
            }
    
            // 添加模块提供配置
            public ModuleConfiguration addProviderConfiguration(String name, Properties properties) { 
                ProviderConfiguration newProvider = new ProviderConfiguration(properties);
                providers.put(name, newProvider);
                return this;
            }
        }
    
        // 模块提供配置类
        public static class ProviderConfiguration { 
            // 模块提供属性
            private Properties properties;
    
            ProviderConfiguration(Properties properties) { 
                this.properties = properties;
            }
    
            private Properties getProperties() { 
                return properties;
            }
        }
    }

### ApplicationConfigLoader ###

package org.apache.skywalking.oap.server.starter.config;
    
    import java.io.FileNotFoundException;
    import java.io.Reader;
    import java.util.HashSet;
    import java.util.Map;
    import java.util.Properties;
    import java.util.Set;
    import lombok.extern.slf4j.Slf4j;
    import org.apache.skywalking.apm.util.PropertyPlaceholderHelper;
    import org.apache.skywalking.oap.server.library.module.ApplicationConfiguration;
    import org.apache.skywalking.oap.server.library.module.ProviderNotFoundException;
    import org.apache.skywalking.oap.server.library.util.CollectionUtils;
    import org.apache.skywalking.oap.server.library.util.ResourceUtils;
    import org.yaml.snakeyaml.Yaml;
    
    // application.yml加载类, 三层结构:模块定义名.模块提供名.属性key
    @Slf4j
    public class ApplicationConfigLoader implements ConfigLoader<ApplicationConfiguration> { 
        // 当不配置模块提供者时，使用"-"
        private static final String DISABLE_SELECTOR = "-";
        // 该字段选择模块提供者
        private static final String SELECTOR = "selector";
    
        private final Yaml yaml = new Yaml();
    
        @Override
        public ApplicationConfiguration load() throws ConfigFileNotFoundException { 
            ApplicationConfiguration configuration = new ApplicationConfiguration();
            this.loadConfig(configuration);
            this.overrideConfigBySystemEnv(configuration);
            return configuration;
        }
    
        @SuppressWarnings("unchecked")
        private void loadConfig(ApplicationConfiguration configuration) throws ConfigFileNotFoundException { 
            try { 
                Reader applicationReader = ResourceUtils.read("application.yml");
                Map<String, Map<String, Object>> moduleConfig = yaml.loadAs(applicationReader, Map.class);
                if (CollectionUtils.isNotEmpty(moduleConfig)) { 
                    selectConfig(moduleConfig);
                    moduleConfig.forEach((moduleName, providerConfig) -> { 
                        if (providerConfig.size() > 0) { 
                            log.info("Get a module define from application.yml, module name: {}", moduleName);
                            ApplicationConfiguration.ModuleConfiguration moduleConfiguration = configuration.addModule(moduleName);
                            providerConfig.forEach((providerName, config) -> { 
                                log.info("Get a provider define belong to {} module, provider name: {}", moduleName, providerName);
                                final Map<String, ?> propertiesConfig = (Map<String, ?>) config;
                                final Properties properties = new Properties();
                                if (propertiesConfig != null) { 
                                    propertiesConfig.forEach((propertyName, propertyValue) -> { 
                                        if (propertyValue instanceof Map) { 
                                            Properties subProperties = new Properties();
                                            ((Map) propertyValue).forEach((key, value) -> { 
                                                subProperties.put(key, value);
                                                replacePropertyAndLog(key, value, subProperties, providerName);
                                            });
                                            properties.put(propertyName, subProperties);
                                        } else { 
                                            properties.put(propertyName, propertyValue);
                                            replacePropertyAndLog(propertyName, propertyValue, properties, providerName);
                                        }
                                    });
                                }
                                moduleConfiguration.addProviderConfiguration(providerName, properties);
                            });
                        } else { 
                            log.warn("Get a module define from application.yml, but no provider define, use default, module name: {}", moduleName);
                        }
                    });
                }
            } catch (FileNotFoundException e) { 
                throw new ConfigFileNotFoundException(e.getMessage(), e);
            }
        }
    
        private void replacePropertyAndLog(final Object propertyName, final Object propertyValue, final Properties target, final Object providerName) { 
            final String valueString = PropertyPlaceholderHelper.INSTANCE.replacePlaceholders(propertyValue + "", target);
            if (valueString != null) { 
                if (valueString.trim().length() == 0) { 
                    target.replace(propertyName, valueString);
                    log.info("Provider={} config={} has been set as an empty string", providerName, propertyName);
                } else { 
                    // Use YAML to do data type conversion.
                    final Object replaceValue = yaml.load(valueString);
                    if (replaceValue != null) { 
                        target.replace(propertyName, replaceValue);
                        log.info("Provider={} config={} has been set as {}", providerName, propertyName, replaceValue.toString());
                    }
                }
            }
        }
    
        private void overrideConfigBySystemEnv(ApplicationConfiguration configuration) { 
            for (Map.Entry<Object, Object> prop : System.getProperties().entrySet()) { 
                overrideModuleSettings(configuration, prop.getKey().toString(), prop.getValue().toString());
            }
        }
    
        private void selectConfig(final Map<String, Map<String, Object>> moduleConfiguration) { 
            final Set<String> modulesWithoutProvider = new HashSet<>();
            for (final Map.Entry<String, Map<String, Object>> entry : moduleConfiguration.entrySet()) { 
                final String moduleName = entry.getKey();
                final Map<String, Object> providerConfig = entry.getValue();
                if (!providerConfig.containsKey(SELECTOR)) { 
                    continue;
                }
                final String selector = (String) providerConfig.get(SELECTOR);
                final String resolvedSelector = PropertyPlaceholderHelper.INSTANCE.replacePlaceholders(
                    selector, System.getProperties()
                );
                providerConfig.entrySet().removeIf(e -> !resolvedSelector.equals(e.getKey()));
    
                if (!providerConfig.isEmpty()) { 
                    continue;
                }
    
                if (!DISABLE_SELECTOR.equals(resolvedSelector)) { 
                    throw new ProviderNotFoundException("no provider found for module " + moduleName + ", " + "if you're sure it's not required module and want to remove it, " + "set the selector to -");
                }
    
                // now the module can be safely removed
                modulesWithoutProvider.add(moduleName);
            }
    
            moduleConfiguration.entrySet().removeIf(e -> { 
                final String module = e.getKey();
                final boolean shouldBeRemoved = modulesWithoutProvider.contains(module);
                if (shouldBeRemoved) { 
                    log.info("Remove module {} without any provider", module);
                }
                return shouldBeRemoved;
            });
        }
    
        private void overrideModuleSettings(ApplicationConfiguration configuration, String key, String value) { 
            int moduleAndConfigSeparator = key.indexOf('.');
            if (moduleAndConfigSeparator <= 0) { 
                return;
            }
            String moduleName = key.substring(0, moduleAndConfigSeparator);
            String providerSettingSubKey = key.substring(moduleAndConfigSeparator + 1);
            ApplicationConfiguration.ModuleConfiguration moduleConfiguration = configuration.getModuleConfiguration(moduleName);
            if (moduleConfiguration == null) { 
                return;
            }
            int providerAndConfigSeparator = providerSettingSubKey.indexOf('.');
            if (providerAndConfigSeparator <= 0) { 
                return;
            }
            String providerName = providerSettingSubKey.substring(0, providerAndConfigSeparator);
            String settingKey = providerSettingSubKey.substring(providerAndConfigSeparator + 1);
            if (!moduleConfiguration.has(providerName)) { 
                return;
            }
            Properties providerSettings = moduleConfiguration.getProviderConfiguration(providerName);
            if (!providerSettings.containsKey(settingKey)) { 
                return;
            }
            Object originValue = providerSettings.get(settingKey);
            Class<?> type = originValue.getClass();
            if (type.equals(int.class) || type.equals(Integer.class))
                providerSettings.put(settingKey, Integer.valueOf(value));
            else if (type.equals(String.class))
                providerSettings.put(settingKey, value);
            else if (type.equals(long.class) || type.equals(Long.class))
                providerSettings.put(settingKey, Long.valueOf(value));
            else if (type.equals(boolean.class) || type.equals(Boolean.class)) { 
                providerSettings.put(settingKey, Boolean.valueOf(value));
            } else { 
                return;
            }
            log.info("The setting has been override by key: {}, value: {}, in {} provider of {} module through {}", settingKey, value, providerName, moduleName, "System.properties");
        }
    }

### ConfigLoader ###

package org.apache.skywalking.oap.server.starter.config;
    
    // 配置加载接口
    public interface ConfigLoader<T> { 
        T load() throws ConfigFileNotFoundException;
    }

### OAPServerBootstrap ###

package org.apache.skywalking.oap.server.starter;
    
    import lombok.extern.slf4j.Slf4j;
    import org.apache.skywalking.oap.server.core.RunningMode;
    import org.apache.skywalking.oap.server.library.module.ApplicationConfiguration;
    import org.apache.skywalking.oap.server.library.module.ModuleManager;
    import org.apache.skywalking.oap.server.starter.config.ApplicationConfigLoader;
    import org.apache.skywalking.oap.server.starter.config.ConfigLoader;
    import org.apache.skywalking.oap.server.telemetry.TelemetryModule;
    import org.apache.skywalking.oap.server.telemetry.api.MetricsCreator;
    import org.apache.skywalking.oap.server.telemetry.api.MetricsTag;
    
    // OAP启动类，加载配置文件，初始化模块
    @Slf4j
    public class OAPServerBootstrap { 
        public static void start() { 
            String mode = System.getProperty("mode");
            // 启动模式
            RunningMode.setMode(mode);
    
            ApplicationConfigLoader configLoader = new ApplicationConfigLoader();
            ModuleManager manager = new ModuleManager();
            try { 
                // 从配置文件中加载配置
                ApplicationConfiguration applicationConfiguration = configLoader.load();
                // 初始化模块
                manager.init(applicationConfiguration);
    
                // 将启动时间发送给Telemetry
                manager.find(TelemetryModule.NAME)
                       .provider()
                       .getService(MetricsCreator.class)
                       .createGauge("uptime", "oap server start up time", MetricsTag.EMPTY_KEY, MetricsTag.EMPTY_VALUE)
                       // Set uptime to second
                       .setValue(System.currentTimeMillis() / 1000d);
    
                if (RunningMode.isInitMode()) { 
                    log.info("OAP starts up in init mode successfully, exit now...");
                    System.exit(0);
                }
            } catch (Throwable t) { 
                log.error(t.getMessage(), t);
                System.exit(1);
            }
        }
    }

### OAPServerStartUp ###

package org.apache.skywalking.oap.server.starter;
    
    // OAP启动类
    public class OAPServerStartUp { 
        public static void main(String[] args) { 
            OAPServerBootstrap.start();
        }
    }

## 以 `Skywalking OAP` 启动流程分析模块加载机制 ##

### 时序图 ###

![file][file 1]

源文件：[OAPServerStartUp.sdt][]

### 案例：存储模块加载分析 ###

#### 配置文件 ####

从 `application.yml` 配置文件，可以看出。

模块是以三层结构来定义的：

*  第一层：模块定义名
 *  第二层：模块提供名/ `selector`
 *  第三层：模块提供配置信息/ `selector` 选择的模块提供配置

storage:
      selector: ${ SW_STORAGE:h2}
      elasticsearch:
        nameSpace: ${ SW_NAMESPACE:""}
        clusterNodes: ${ SW_STORAGE_ES_CLUSTER_NODES:localhost:9200}
        # etc...
      elasticsearch7:
        nameSpace: ${ SW_NAMESPACE:""}
        clusterNodes: ${ SW_STORAGE_ES_CLUSTER_NODES:localhost:9200}
        # etc...
      h2:
        driver: ${ SW_STORAGE_H2_DRIVER:org.h2.jdbcx.JdbcDataSource}
        url: ${ SW_STORAGE_H2_URL:jdbc:h2:mem:skywalking-oap-db;DB_CLOSE_DELAY=-1}
        # etc...
      mysql:
        properties:
          jdbcUrl: ${ SW_JDBC_URL:"jdbc:mysql://localhost:3306/swtest"}
          dataSource.user: ${ SW_DATA_SOURCE_USER:root}
          dataSource.password: ${ SW_DATA_SOURCE_PASSWORD:root@1234}
          # etc...
      tidb:
        properties:
          jdbcUrl: ${ SW_JDBC_URL:"jdbc:mysql://localhost:4000/tidbswtest"}
          dataSource.user: ${ SW_DATA_SOURCE_USER:root}
          dataSource.password: ${ SW_DATA_SOURCE_PASSWORD:""}
          # etc...
      influxdb:
        url: ${ SW_STORAGE_INFLUXDB_URL:http://localhost:8086}
        user: ${ SW_STORAGE_INFLUXDB_USER:root}
        password: ${ SW_STORAGE_INFLUXDB_PASSWORD:}
        # etc...

#### 加载配置 ####

经过 `org.apache.skywalking.oap.server.starter.config.ApplicationConfigLoader#load` 的调用， `org.apache.skywalking.oap.server.starter.OAPServerBootstrap#start` 获取到了所有需要加载的模块，其中包括存储模块。

在 `org.apache.skywalking.oap.server.starter.config.ApplicationConfigLoader#selectConfig` 也通过 `storage.selector=h2` ，存储模块只保留了 `h2` 的配置信息：

storage:
        h2:
        driver: ${ SW_STORAGE_H2_DRIVER:org.h2.jdbcx.JdbcDataSource}
        url: ${ SW_STORAGE_H2_URL:jdbc:h2:mem:skywalking-oap-db;DB_CLOSE_DELAY=-1}
        # etc...

#### 准备阶段 ####

在`org.apache.skywalking.oap.server.library.module.ModuleManager#init` 中，通过 `SPI` 加载了模块定义对象，存储模块对应的定义类如下：

PS：可以看到定义了大量 `Service` 接口

package org.apache.skywalking.oap.server.core.storage;
    
    import org.apache.skywalking.oap.server.core.storage.cache.INetworkAddressAliasDAO;
    import org.apache.skywalking.oap.server.core.storage.management.UITemplateManagementDAO;
    import org.apache.skywalking.oap.server.core.storage.profile.IProfileTaskLogQueryDAO;
    import org.apache.skywalking.oap.server.core.storage.profile.IProfileTaskQueryDAO;
    import org.apache.skywalking.oap.server.core.storage.profile.IProfileThreadSnapshotQueryDAO;
    import org.apache.skywalking.oap.server.core.storage.query.IAggregationQueryDAO;
    import org.apache.skywalking.oap.server.core.storage.query.IAlarmQueryDAO;
    import org.apache.skywalking.oap.server.core.storage.query.IBrowserLogQueryDAO;
    import org.apache.skywalking.oap.server.core.storage.query.ILogQueryDAO;
    import org.apache.skywalking.oap.server.core.storage.query.IMetadataQueryDAO;
    import org.apache.skywalking.oap.server.core.storage.query.IMetricsQueryDAO;
    import org.apache.skywalking.oap.server.core.storage.query.ITopNRecordsQueryDAO;
    import org.apache.skywalking.oap.server.core.storage.query.ITopologyQueryDAO;
    import org.apache.skywalking.oap.server.core.storage.query.ITraceQueryDAO;
    import org.apache.skywalking.oap.server.library.module.ModuleDefine;
    
    /** * StorageModule provides the capabilities(services) to interact with the database. With different databases, this * module could have different providers, such as currently, H2, MySQL, ES, TiDB. */
    public class StorageModule extends ModuleDefine { 
    
        public static final String NAME = "storage";
    
        public StorageModule() { 
            super(NAME);
        }
    
        @Override
        public Class[] services() { 
            return new Class[]{ 
                    IBatchDAO.class,
                    StorageDAO.class,
                    IHistoryDeleteDAO.class,
                    INetworkAddressAliasDAO.class,
                    ITopologyQueryDAO.class,
                    IMetricsQueryDAO.class,
                    ITraceQueryDAO.class,
                    IMetadataQueryDAO.class,
                    IAggregationQueryDAO.class,
                    IAlarmQueryDAO.class,
                    ITopNRecordsQueryDAO.class,
                    ILogQueryDAO.class,
                    IProfileTaskQueryDAO.class,
                    IProfileTaskLogQueryDAO.class,
                    IProfileThreadSnapshotQueryDAO.class,
                    UITemplateManagementDAO.class,
                    IBrowserLogQueryDAO.class
            };
        }
    }

同时也会调用 `org.apache.skywalking.oap.server.library.module.ModuleDefine#prepare` 进入准备阶段

String[] moduleNames = applicationConfiguration.moduleList();
            ServiceLoader<ModuleDefine> moduleServiceLoader = ServiceLoader.load(ModuleDefine.class);
            ServiceLoader<ModuleProvider> moduleProviderLoader = ServiceLoader.load(ModuleProvider.class);
    
            LinkedList<String> moduleList = new LinkedList<>(Arrays.asList(moduleNames));
            for (ModuleDefine module : moduleServiceLoader) { 
                for (String moduleName : moduleNames) { 
                    if (moduleName.equals(module.name())) { 
                        module.prepare(this, applicationConfiguration.getModuleConfiguration(moduleName), moduleProviderLoader);
                        loadedModules.put(moduleName, module);
                        moduleList.remove(moduleName);
                    }
                }
            }

在 `org.apache.skywalking.oap.server.library.module.ModuleDefine#prepare` 会通过传入的配置，只匹配上配置文件选择的模块提供对象。

for (ModuleProvider provider : moduleProviderLoader) { 
                if (!configuration.has(provider.name())) { 
                    continue;
                }
    
                if (provider.module().equals(getClass())) { 
                    if (loadedProvider == null) { 
                        loadedProvider = provider;
                        loadedProvider.setManager(moduleManager);
                        loadedProvider.setModuleDefine(this);
                    } else { 
                        throw new DuplicateProviderException(this.name() + " module has one " + loadedProvider.name() + "[" + loadedProvider.getClass().getName() 
                                                             + "] provider already, " + provider.name() + "[" + provider.getClass().getName() + "] is defined as 2nd provider.");
                    }
                }
    
            }
    
            if (loadedProvider == null) { 
                throw new ProviderNotFoundException(this.name() + " module no provider found.");
            }
    
            LOGGER.info("Prepare the {} provider in {} module.", loadedProvider.name(), this.name());
            try { 
                copyProperties(loadedProvider.createConfigBeanIfAbsent(), configuration.getProviderConfiguration(loadedProvider.name()), this.name(), loadedProvider.name());
            } catch (IllegalAccessException e) { 
                throw new ModuleConfigException(this.name() + " module config transport to config bean failure.", e);
            }
            loadedProvider.prepare();

例如“配置文件”一节选择的`h2` ，则加载的提供类为 `org.apache.skywalking.oap.server.storage.plugin.jdbc.h2.H2StorageProvider`

它的 `prepare` 方法如下，可以看到：注册了所有 `StorageModule` 声明的 `Service` 接口

@Override
        public void prepare() throws ServiceNotProvidedException, ModuleStartException { 
            Properties settings = new Properties();
            settings.setProperty("dataSourceClassName", config.getDriver());
            settings.setProperty("dataSource.url", config.getUrl());
            settings.setProperty("dataSource.user", config.getUser());
            settings.setProperty("dataSource.password", config.getPassword());
            h2Client = new JDBCHikariCPClient(settings);
    
            this.registerServiceImplementation(IBatchDAO.class, new H2BatchDAO(h2Client));
            this.registerServiceImplementation(
                StorageDAO.class,
                new H2StorageDAO(
                    getManager(), h2Client, config.getMaxSizeOfArrayColumn(), config.getNumOfSearchableValuesPerTag())
            );
    
            this.registerServiceImplementation(
                INetworkAddressAliasDAO.class, new H2NetworkAddressAliasDAO(h2Client));
    
            this.registerServiceImplementation(ITopologyQueryDAO.class, new H2TopologyQueryDAO(h2Client));
            this.registerServiceImplementation(IMetricsQueryDAO.class, new H2MetricsQueryDAO(h2Client));
            this.registerServiceImplementation(
                ITraceQueryDAO.class, new H2TraceQueryDAO(
                    getManager(),
                    h2Client,
                    config.getMaxSizeOfArrayColumn(),
                    config.getNumOfSearchableValuesPerTag()
                ));
            this.registerServiceImplementation(IBrowserLogQueryDAO.class, new H2BrowserLogQueryDAO(h2Client));
            this.registerServiceImplementation(
                IMetadataQueryDAO.class, new H2MetadataQueryDAO(h2Client, config.getMetadataQueryMaxSize()));
            this.registerServiceImplementation(IAggregationQueryDAO.class, new H2AggregationQueryDAO(h2Client));
            this.registerServiceImplementation(IAlarmQueryDAO.class, new H2AlarmQueryDAO(h2Client));
            this.registerServiceImplementation(
                IHistoryDeleteDAO.class, new H2HistoryDeleteDAO(h2Client));
            this.registerServiceImplementation(ITopNRecordsQueryDAO.class, new H2TopNRecordsQueryDAO(h2Client));
            this.registerServiceImplementation(
                ILogQueryDAO.class,
                new H2LogQueryDAO(
                    h2Client,
                    getManager(),
                    config.getMaxSizeOfArrayColumn(),
                    config.getNumOfSearchableValuesPerTag()
                )
            );
    
            this.registerServiceImplementation(IProfileTaskQueryDAO.class, new H2ProfileTaskQueryDAO(h2Client));
            this.registerServiceImplementation(IProfileTaskLogQueryDAO.class, new H2ProfileTaskLogQueryDAO(h2Client));
            this.registerServiceImplementation(
                IProfileThreadSnapshotQueryDAO.class, new H2ProfileThreadSnapshotQueryDAO(h2Client));
            this.registerServiceImplementation(UITemplateManagementDAO.class, new H2UITemplateManagementDAO(h2Client));
        }

#### 启动阶段 ####

在`org.apache.skywalking.oap.server.library.module.ModuleManager#init` 通过调用 `org.apache.skywalking.oap.server.library.module.BootstrapFlow#start` 进入启动阶段

void start(
            ModuleManager moduleManager) throws ModuleNotFoundException, ServiceNotProvidedException, ModuleStartException { 
            for (ModuleProvider provider : startupSequence) { 
                LOGGER.info("start the provider {} in {} module.", provider.name(), provider.getModuleName());
                provider.requiredCheck(provider.getModule().services());
    
                provider.start();
            }
        }

例如“配置文件”一节选择的`h2` ，则加载的提供类为 `org.apache.skywalking.oap.server.storage.plugin.jdbc.h2.H2StorageProvider`

它的 `start` 方法如下，可以看到：启动 `h2client` 并监听 `ModelCreator`

@Override
        public void start() throws ServiceNotProvidedException, ModuleStartException { 
            final ConfigService configService = getManager().find(CoreModule.NAME)
                                                            .provider()
                                                            .getService(ConfigService.class);
            final int numOfSearchableTracesTags = configService.getSearchableTracesTags().split(Const.COMMA).length;
            if (numOfSearchableTracesTags * config.getNumOfSearchableValuesPerTag() > config.getMaxSizeOfArrayColumn()) { 
                throw new ModuleStartException("Size of searchableTracesTags[" + numOfSearchableTracesTags
                                                   + "] * numOfSearchableValuesPerTag[" + config.getNumOfSearchableValuesPerTag()
                                                   + "] > maxSizeOfArrayColumn[" + config.getMaxSizeOfArrayColumn()
                                                   + "]. Potential out of bound in the runtime.");
            }
            final int numOfSearchableLogsTags = configService.getSearchableLogsTags().split(Const.COMMA).length;
            if (numOfSearchableLogsTags * config.getNumOfSearchableValuesPerTag() > config.getMaxSizeOfArrayColumn()) { 
                throw new ModuleStartException("Size of searchableLogsTags[" + numOfSearchableLogsTags
                                                   + "] * numOfSearchableValuesPerTag[" + config.getNumOfSearchableValuesPerTag()
                                                   + "] > maxSizeOfArrayColumn[" + config.getMaxSizeOfArrayColumn()
                                                   + "]. Potential out of bound in the runtime.");
            }
    
            MetricsCreator metricCreator = getManager().find(TelemetryModule.NAME)
                                                       .provider()
                                                       .getService(MetricsCreator.class);
            HealthCheckMetrics healthChecker = metricCreator.createHealthCheckerGauge(
                "storage_h2", MetricsTag.EMPTY_KEY, MetricsTag.EMPTY_VALUE);
            h2Client.registerChecker(healthChecker);
            try { 
                h2Client.connect();
    
                H2TableInstaller installer = new H2TableInstaller(
                    h2Client, getManager(), config.getMaxSizeOfArrayColumn(), config.getNumOfSearchableValuesPerTag());
                getManager().find(CoreModule.NAME).provider().getService(ModelCreator.class).addModelListener(installer);
            } catch (StorageException e) { 
                throw new ModuleStartException(e.getMessage(), e);
            }
        }

#### 完成后通知阶段 ####

在`org.apache.skywalking.oap.server.library.module.ModuleManager#init` 通过调用 `org.apache.skywalking.oap.server.library.module.BootstrapFlow#notifyAfterCompleted` 进入完成后通知阶段

void notifyAfterCompleted() throws ServiceNotProvidedException, ModuleStartException { 
            for (ModuleProvider provider : startupSequence) { 
                provider.notifyAfterCompleted();
            }
        }

例如“配置文件”一节选择的`h2` ，则加载的提供类为 `org.apache.skywalking.oap.server.storage.plugin.jdbc.h2.H2StorageProvider`

它的 `notifyAfterCompleted` 方法如下，可以看到：不需要做什么

@Override
        public void notifyAfterCompleted() throws ServiceNotProvidedException, ModuleStartException { 
    
        }

#### `H2StorageProvider` 完整源码 ####

package org.apache.skywalking.oap.server.storage.plugin.jdbc.h2;
    
    // etc...
    
    /** * H2 Storage provider is for demonstration and preview only. I will find that haven't implemented several interfaces, * because not necessary, and don't consider about performance very much. * <p> * If someone wants to implement SQL-style database as storage, please just refer the logic. */
    @Slf4j
    public class H2StorageProvider extends ModuleProvider { 
    
        private H2StorageConfig config;
        private JDBCHikariCPClient h2Client;
    
        public H2StorageProvider() { 
            config = new H2StorageConfig();
        }
    
        @Override
        public String name() { 
            return "h2";
        }
    
        @Override
        public Class<? extends ModuleDefine> module() { 
            return StorageModule.class;
        }
    
        @Override
        public ModuleConfig createConfigBeanIfAbsent() { 
            return config;
        }
    
        @Override
        public void prepare() throws ServiceNotProvidedException, ModuleStartException { 
            Properties settings = new Properties();
            settings.setProperty("dataSourceClassName", config.getDriver());
            settings.setProperty("dataSource.url", config.getUrl());
            settings.setProperty("dataSource.user", config.getUser());
            settings.setProperty("dataSource.password", config.getPassword());
            h2Client = new JDBCHikariCPClient(settings);
    
            this.registerServiceImplementation(IBatchDAO.class, new H2BatchDAO(h2Client));
            this.registerServiceImplementation(
                StorageDAO.class,
                new H2StorageDAO(
                    getManager(), h2Client, config.getMaxSizeOfArrayColumn(), config.getNumOfSearchableValuesPerTag())
            );
    
            this.registerServiceImplementation(
                INetworkAddressAliasDAO.class, new H2NetworkAddressAliasDAO(h2Client));
    
            this.registerServiceImplementation(ITopologyQueryDAO.class, new H2TopologyQueryDAO(h2Client));
            this.registerServiceImplementation(IMetricsQueryDAO.class, new H2MetricsQueryDAO(h2Client));
            this.registerServiceImplementation(
                ITraceQueryDAO.class, new H2TraceQueryDAO(
                    getManager(),
                    h2Client,
                    config.getMaxSizeOfArrayColumn(),
                    config.getNumOfSearchableValuesPerTag()
                ));
            this.registerServiceImplementation(IBrowserLogQueryDAO.class, new H2BrowserLogQueryDAO(h2Client));
            this.registerServiceImplementation(
                IMetadataQueryDAO.class, new H2MetadataQueryDAO(h2Client, config.getMetadataQueryMaxSize()));
            this.registerServiceImplementation(IAggregationQueryDAO.class, new H2AggregationQueryDAO(h2Client));
            this.registerServiceImplementation(IAlarmQueryDAO.class, new H2AlarmQueryDAO(h2Client));
            this.registerServiceImplementation(
                IHistoryDeleteDAO.class, new H2HistoryDeleteDAO(h2Client));
            this.registerServiceImplementation(ITopNRecordsQueryDAO.class, new H2TopNRecordsQueryDAO(h2Client));
            this.registerServiceImplementation(
                ILogQueryDAO.class,
                new H2LogQueryDAO(
                    h2Client,
                    getManager(),
                    config.getMaxSizeOfArrayColumn(),
                    config.getNumOfSearchableValuesPerTag()
                )
            );
    
            this.registerServiceImplementation(IProfileTaskQueryDAO.class, new H2ProfileTaskQueryDAO(h2Client));
            this.registerServiceImplementation(IProfileTaskLogQueryDAO.class, new H2ProfileTaskLogQueryDAO(h2Client));
            this.registerServiceImplementation(
                IProfileThreadSnapshotQueryDAO.class, new H2ProfileThreadSnapshotQueryDAO(h2Client));
            this.registerServiceImplementation(UITemplateManagementDAO.class, new H2UITemplateManagementDAO(h2Client));
        }
    
        @Override
        public void start() throws ServiceNotProvidedException, ModuleStartException { 
            final ConfigService configService = getManager().find(CoreModule.NAME)
                                                            .provider()
                                                            .getService(ConfigService.class);
            final int numOfSearchableTracesTags = configService.getSearchableTracesTags().split(Const.COMMA).length;
            if (numOfSearchableTracesTags * config.getNumOfSearchableValuesPerTag() > config.getMaxSizeOfArrayColumn()) { 
                throw new ModuleStartException("Size of searchableTracesTags[" + numOfSearchableTracesTags
                                                   + "] * numOfSearchableValuesPerTag[" + config.getNumOfSearchableValuesPerTag()
                                                   + "] > maxSizeOfArrayColumn[" + config.getMaxSizeOfArrayColumn()
                                                   + "]. Potential out of bound in the runtime.");
            }
            final int numOfSearchableLogsTags = configService.getSearchableLogsTags().split(Const.COMMA).length;
            if (numOfSearchableLogsTags * config.getNumOfSearchableValuesPerTag() > config.getMaxSizeOfArrayColumn()) { 
                throw new ModuleStartException("Size of searchableLogsTags[" + numOfSearchableLogsTags
                                                   + "] * numOfSearchableValuesPerTag[" + config.getNumOfSearchableValuesPerTag()
                                                   + "] > maxSizeOfArrayColumn[" + config.getMaxSizeOfArrayColumn()
                                                   + "]. Potential out of bound in the runtime.");
            }
    
            MetricsCreator metricCreator = getManager().find(TelemetryModule.NAME)
                                                       .provider()
                                                       .getService(MetricsCreator.class);
            HealthCheckMetrics healthChecker = metricCreator.createHealthCheckerGauge(
                "storage_h2", MetricsTag.EMPTY_KEY, MetricsTag.EMPTY_VALUE);
            h2Client.registerChecker(healthChecker);
            try { 
                h2Client.connect();
    
                H2TableInstaller installer = new H2TableInstaller(
                    h2Client, getManager(), config.getMaxSizeOfArrayColumn(), config.getNumOfSearchableValuesPerTag());
                getManager().find(CoreModule.NAME).provider().getService(ModelCreator.class).addModelListener(installer);
            } catch (StorageException e) { 
                throw new ModuleStartException(e.getMessage(), e);
            }
        }
    
        @Override
        public void notifyAfterCompleted() throws ServiceNotProvidedException, ModuleStartException { 
    
        }
    
        @Override
        public String[] requiredModules() { 
            return new String[] { CoreModule.NAME};
        }
    }

# 总结 #

`Skywalking` 提供的模块机制是非常优良的设计，在工作中，如果有多个 `N` 选 `1` 的场景，是可以借鉴它的设计的。

# 参考文档 #

*  [Backend setup][]
 *  [Configuration Vocabulary][]

[Backend setup]: https://skywalking.apache.org/docs/main/v8.4.0/en/setup/backend/backend-setup/
[Configuration Vocabulary]: https://skywalking.apache.org/docs/main/v8.4.0/en/setup/backend/configuration-vocabulary/
[file]: /images/20220828/5dd274ef522846fcb2b1b0ff955f2495.png
[Skywalking-Module.uml]: https://github.com/Switch-vov/skywalking-learning/raw/main/module/Skywalking-Module.uml
[file 1]: /images/20220828/97742913f21a4075a34c526694f8aa8a.png
[OAPServerStartUp.sdt]: https://github.com/Switch-vov/skywalking-learning/raw/main/module/OAPServerStartUp.sdt