3-dubbo框架,应用程序,模块领域模型Model对象的初始化

在上一章中我们详细看了服务配置ServiceConfig类型的初始化,不过我们跳过了AbstractMethodConfig的构造器中创建模块模型对象的过程

那为什么会在Dubbo3的新版本中加入这个域模型呢,主要有如下原因
之前dubbo都是只有一个作用域的，通过静态类属性共享
增加域模型是为了:

1.让Dubbo支持多应用的部署，这块一些大企业有诉求
2.从架构设计上，解决静态属性资源共享、清理的问题
3.分层模型将应用的管理和服务的管理分开
可能比较抽象，可以具体点来开Dubbo3中在启动时候需要启动配置中心，元数据中心
这个配置中心和元数据中心可以归应用模型来管理，Dubbo作为RPC框架有需要启动服务和引用服务，服务级别的管理就交给了这个模块模型来管理，分层次的管理方便我们理解和处理逻辑，父子级别的模型又方便了数据传递。

了解过JVM类加载机制的同学应该就比较清楚 JVM类加载过程中的数据访问模型,子类加载器先去父类加载器去找不到则从子类型加载器中查找类型,Dubbo的分层模型类似这样一种机制,这一章先来简单了解下后面用到时候具体细说。

模型对象的关系

在这里插入图片描述
看最新图

模型对象一共有4个,公共的属性和操作放在了域模型类型中,下面我们来详细说下这几个模型类型:

ExtensionAccessor 扩展的统一访问器
- 用于获取扩展加载管理器ExtensionDirector对象
- 获取扩展对象ExtensionLoader
- 根据扩展名字获取具体扩展对象
- 获取自适应扩展对象
- 获取默认扩展对象
ScopeModel 模型对象的公共抽象父类型
- 内部id用于表示模型树的层次结构
- 公共模型名称，可以被用户设置
- 描述信息
- 类加载器管理
- 父模型管理parent
- 当前模型的所属域ExtensionScope有:FRAMEWORK(框架),APPLICATION(应用),MODULE(模块),SELF(自给自足，为每个作用域创建一个实例，用于特殊的SPI扩展，如ExtensionInjector)
- 具体的扩展加载程序管理器对象的管理:ExtensionDirector
- 域Bean工厂管理,一个内部共享的Bean工厂ScopeBeanFactory
FrameworkModel dubbo框架模型，可与多个应用程序共享
- FrameworkModel实例对象集合,allInstances
- 所有ApplicationModel实例对象集合,applicationModels
- 发布的ApplicationModel实例对象集合pubApplicationModels
- 框架的服务存储库FrameworkServiceRepository类型对象(数据存储在内存中)
- 内部的应用程序模型对象internalApplicationModel
ApplicationModel 表示正在使用Dubbo的应用程序，并存储基本元数据信息，以便在RPC调用过程中使用。ApplicationModel包括许多关于发布服务的ProviderModel和许多关于订阅服务的Consumer Model。
- ExtensionLoader、DubboBootstrap和这个类目前被设计为单例或静态（本身完全静态或使用一些静态字段）。因此，从它们返回的实例属于流程范围。如果想在一个进程中支持多个dubbo服务器，可能需要重构这三个类。
- 所有ModuleModel实例对象集合moduleModels
- 发布的ModuleModel实例对象集合pubModuleModels
- 环境信息Environment实例对象environment
- 配置管理ConfigManager实例对象configManager
- 服务存储库ServiceRepository实例对象serviceRepository
- 应用程序部署器ApplicationDeployer实例对象deployer
- 所属框架FrameworkModel实例对象frameworkModel
- 内部的模块模型ModuleModel实例对象internalModule
- 默认的模块模型ModuleModel实例对象defaultModule
ModuleModel 服务模块的模型
- 所属应用程序模型ApplicationModel实例对象applicationModel
- 模块环境信息ModuleEnvironment实例对象moduleEnvironment
- 模块服务存储库ModuleServiceRepository实例对象serviceRepository
- 模块的服务配置管理ModuleConfigManager实例对象moduleConfigManager
- 模块部署器ModuleDeployer实例对象deployer用于导出和引用服务

了解了这几个模型对象的关系我们可以了解到这几个模型对象的管理层级从框架到应用程序,然后到模块的管理(FrameworkModel->ApplicationModel->ModuleModel),他们主要用来针对框架,应用程序,模块的存储,发布管理,配置管理

ApplicationModel.defaultModel().getDefaultModule()

我们分析这一行做了哪些事情

使用双重校验锁获取框架模型对象

/**
     * During destroying the default FrameworkModel, the FrameworkModel.defaultModel() or ApplicationModel.defaultModel()
     * will return a broken model, maybe cause unpredictable problem.
     * Recommendation: Avoid using the default model as much as possible.
     * @return the global default FrameworkModel
     *
     *  在源码的注释上有这么一句话:在销毁默认的 FrameworkModel 时， FrameworkModel.defaultModel()
     *     *或ApplicationModel.defaultModel() 将返回一个损坏的模型
     *     *可能会导致不可预知的问题。建议：尽量避免使用默认模型。
     */
    public static FrameworkModel defaultModel() {
    
    
        FrameworkModel instance = defaultInstance;
        if (instance == null) {
    
    
            synchronized (globalLock) {
    
    
                resetDefaultFrameworkModel();
                if (defaultInstance == null) {
    
    
                    defaultInstance = new FrameworkModel();
                }
                instance = defaultInstance;
            }
        }
        Assert.notNull(instance, "Default FrameworkModel is null");
        return instance;
    }

创建FrameworkModel对象

public FrameworkModel() {
    
    
        super(null, ExtensionScope.FRAMEWORK, false);
        synchronized (globalLock) {
    
    
            synchronized (instLock) {
    
    
                /**
                 * 内部id用于表示模型树的层次结构，如层次结构:
                 * FrameworkModel（索引=1）->ApplicationModel（索引=2）->ModuleModel（索引=1，第一个用户模块）
                 * 这个index变量是static类型的为静态全局变量默认值从1开始,如果有多个框架模型对象则internalId编号从1开始依次递增
                 */
                this.setInternalId(String.valueOf(index.getAndIncrement()));
                // register FrameworkModel instance early
                allInstances.add(this);
                if (LOGGER.isInfoEnabled()) {
    
    
                    LOGGER.info(getDesc() + " is created");
                }
                initialize();

                TypeDefinitionBuilder.initBuilders(this);

                serviceRepository = new FrameworkServiceRepository(this);

                //Initializer 初始化程序 框架自身提供的一个扩展类
                //获取ScopeModelInitializer类型(域模型初始化器)的扩展加载器ExtensionLoader,
                // 每个扩展类型都会创建一个扩展加载器缓存起来
                ExtensionLoader<ScopeModelInitializer> initializerExtensionLoader = this.getExtensionLoader(ScopeModelInitializer.class);
                //获取ScopeModelInitializer类型的支持的扩展集合,这里当前版本存在10个扩展类型实现
                Set<ScopeModelInitializer> initializers = initializerExtensionLoader.getSupportedExtensionInstances();
                //遍历这些扩展实现调用他们的initializeFrameworkModel方法来传递FrameworkModel类型对象,细节我们待会再详细说下
                for (ScopeModelInitializer initializer : initializers) {
    
    
                    initializer.initializeFrameworkModel(this);
                }
                //创建一个内部的ApplicationModel类型,细节下面说
                internalApplicationModel = new ApplicationModel(this, true);
                //创建ApplicationConfig类型对象同时传递应用程序模型对象internalApplicationModel
                //获取ConfigManager类型对象,然后设置添加当前应用配置对象
                internalApplicationModel.getApplicationConfigManager().setApplication(
                    new ApplicationConfig(internalApplicationModel, CommonConstants.DUBBO_INTERNAL_APPLICATION));
                internalApplicationModel.setModelName(CommonConstants.DUBBO_INTERNAL_APPLICATION);
            }
        }
    }

ScopeModelInitializer 历史dubbo的spi机制，目前实现了10个实现类，FrameworkModel，ApplicationModel 和 ModuleModel，调用不同的初始化方法，完成不同Model的初始化工作，其实都是注册到BeanFactory中一些bean
在这里插入图片描述

初始类型定义构建器

 TypeDefinitionBuilder.initBuilders(this);
 public static void initBuilders(FrameworkModel model) {
    
    
        Set<TypeBuilder> tbs = model.getExtensionLoader(TypeBuilder.class).getSupportedExtensionInstances();
        BUILDERS = new ArrayList<>(tbs);
    }

服务存储仓库对象的创建

public FrameworkServiceRepository(FrameworkModel frameworkModel) {
    
    
        this.frameworkModel = frameworkModel;
    }

初始化FrameworkModel

这一部分是在ScopeModel中进行的，无论是FrameworkModel，还是ApplicationModel 和 ModuleModel 都是一样的

protected void initialize() {
    
    
        synchronized (instLock) {
    
    
            /**
             * 初始化ExtensionDirector是一个作用域扩展加载程序管理器。
             * ExtensionDirector支持多个级别，子级可以继承父级的扩展实例。
             * 查找和创建扩展实例的方法类似于Java classloader。
             */
            this.extensionDirector = new ExtensionDirector(parent != null ? parent.getExtensionDirector() : null, scope, this);
            ///这个参考了Spring的生命周期回调思想,添加一个扩展初始化的前后调用的处理器,
            // 在扩展初始化之前或之后调用的后处理器,参数类型为ExtensionPostProcessor
            this.extensionDirector.addExtensionPostProcessor(new ScopeModelAwareExtensionProcessor(this));
            //创建一个内部共享的域工厂对象,用于注册Bean,创建Bean,获取Bean,初始化Bean等
            this.beanFactory = new ScopeBeanFactory(parent != null ? parent.getBeanFactory() : null, extensionDirector);

            // Add Framework's ClassLoader by default
            // 将当前类的加载器存入加载器集合classLoaders中
            ClassLoader dubboClassLoader = ScopeModel.class.getClassLoader();
            if (dubboClassLoader != null) {
    
    
                this.addClassLoader(dubboClassLoader);
            }
        }
    }

创建ApplicationModel对象

public ApplicationModel defaultApplication() {
    
    
        ApplicationModel appModel = this.defaultAppModel;
        if (appModel == null) {
    
    
            // check destroyed before acquire inst lock, avoid blocking during destroying
            checkDestroyed();
            resetDefaultAppModel();
            if ((appModel = this.defaultAppModel) == null) {
    
    
                synchronized (instLock) {
    
    
                    if (this.defaultAppModel == null) {
    
    
                        this.defaultAppModel = newApplication();
                    }
                    appModel = this.defaultAppModel;
                }
            }
        }
        Assert.notNull(appModel, "Default ApplicationModel is null");
        return appModel;
    }

构造方法

 protected ApplicationModel(FrameworkModel frameworkModel) {
    
    
        this(frameworkModel, false);
    }
    
    protected ApplicationModel(FrameworkModel frameworkModel, boolean isInternal) {
    
    
        super(frameworkModel, ExtensionScope.APPLICATION, isInternal);
        synchronized (instLock) {
    
    
            Assert.notNull(frameworkModel, "FrameworkModel can not be null");
            this.frameworkModel = frameworkModel;
            //frameworkMode 添加 applicationModel
            frameworkModel.addApplication(this);
            if (LOGGER.isInfoEnabled()) {
    
    
                LOGGER.info(getDesc() + " is created");
            }
            initialize();
            //创建一个内部的模块模型对象
            this.internalModule = new ModuleModel(this, true);
            //创建一个独立服务存储对象
            this.serviceRepository = new ServiceRepository(this);

            //获取应用程序初始化监听器ApplicationInitListener扩展
            ExtensionLoader<ApplicationInitListener> extensionLoader = this.getExtensionLoader(ApplicationInitListener.class);
            //如果存在应用程序初始化监听器扩展则执行这个初始化方法,在当前的版本还未看到有具体的扩展实现类型
            Set<String> listenerNames = extensionLoader.getSupportedExtensions();
            for (String listenerName : listenerNames) {
    
    
                extensionLoader.getExtension(listenerName).init();
            }
            //初始化扩展(这个是应用程序生命周期的方法调用,这里调用初始化方法
            initApplicationExts();

            //获取域模型初始化器扩展对象列表,然后执行初始化方法
            ExtensionLoader<ScopeModelInitializer> initializerExtensionLoader = this.getExtensionLoader(ScopeModelInitializer.class);
            Set<ScopeModelInitializer> initializers = initializerExtensionLoader.getSupportedExtensionInstances();
            for (ScopeModelInitializer initializer : initializers) {
    
    
                initializer.initializeApplicationModel(this);
            }

            Assert.notNull(getApplicationServiceRepository(), "ApplicationServiceRepository can not be null");
            Assert.notNull(getApplicationConfigManager(), "ApplicationConfigManager can not be null");
            Assert.assertTrue(getApplicationConfigManager().isInitialized(), "ApplicationConfigManager can not be initialized");
        }
    }

将ApplicationModel添加至FrameworkModel容器中

void addApplication(ApplicationModel applicationModel) {
    
    
        // can not add new application if it's destroying
        checkDestroyed();
        synchronized (instLock) {
    
    
            if (!this.applicationModels.contains(applicationModel)) {
    
    
                applicationModel.setInternalId(buildInternalId(getInternalId(), appIndex.getAndIncrement()));
                this.applicationModels.add(applicationModel);
                if (!applicationModel.isInternal()) {
    
    
                    //如果非内部的则也向公开应用模型集合pubApplicationModels中添加一下
                    this.pubApplicationModels.add(applicationModel);
                }
            }
        }
    }

三者的序列号生成

 protected String buildInternalId(String parentInternalId, long childIndex) {
    
    
        // FrameworkModel    1
        // ApplicationModel  1.1
        // ModuleModel       1.1.1
        if (StringUtils.hasText(parentInternalId)) {
    
    
            return parentInternalId + "." + childIndex;
        } else {
    
    
            return "" + childIndex;
        }
    }

调用父类的初始化

和FrameModel一样不再详细说明

initApplicationExts() 初始化应用程序扩展方法

这里目前是Environment 和 ConfigManger类实现， Enviroment 是应用环境相关信息，后面单独写一章
在这里插入图片描述

 //初始化扩展(这个是应用程序生命周期的方法调用,这里调用初始化方法
            initApplicationExts();
// already synchronized in constructor
    private void initApplicationExts() {
    
    
        //这个扩展实现一共有两个可以看下面那个图扩展类型为ConfigManager和Environment
        Set<ApplicationExt> exts = this.getExtensionLoader(ApplicationExt.class).getSupportedExtensionInstances();
        for (ApplicationExt ext : exts) {
    
    
            ext.initialize();
        }
    }

ConfigManager类型的initialize方法

先简单说下ConfigManager的作用,无锁配置管理器（通过ConcurrentHashMap），用于快速读取操作。写入操作锁带有配置类型的子配置映射，用于安全检查和添加新配置。其实ConfigManager实现类中并没有这个初始化方法initialize,不过ConfigManager的父类型AbstractConfigManager中是有initialize方法的,如下所示:

 @Override
    public void initialize() throws IllegalStateException {
    
    
        if (!initialized.compareAndSet(false, true)) {
    
    
            return;
        }
        //从模块环境中获取组合配置,目前Environment中有6种重要的配置,我们后面详细说
        CompositeConfiguration configuration = scopeModel.getModelEnvironment().getConfiguration();

        // dubbo.config.mode
        // dubbo.config.mode获取配置模式,配置模式对应枚举类型ConfigMode,
        // 目前有这么几个STRICT,OVERRIDE,OVERRIDE_ALL,OVERRIDE_IF_ABSENT,IGNORE,
        // 这个配置决定了属性覆盖的顺序,当有同一个配置key多次出现时候,以最新配置为准,
        // 还是以最老的那个配置为准,还是配置重复则抛出异常,默认值为严格模式STRICT重复则抛出异常
        String configModeStr = (String) configuration.getProperty(ConfigKeys.DUBBO_CONFIG_MODE);
        try {
    
    
            if (StringUtils.hasText(configModeStr)) {
    
    
                this.configMode = ConfigMode.valueOf(configModeStr.toUpperCase());
            }
        } catch (Exception e) {
    
    
            String msg = "Illegal '" + ConfigKeys.DUBBO_CONFIG_MODE + "' config value [" + configModeStr + "], available values " + Arrays.toString(ConfigMode.values());
            logger.error(COMMON_PROPERTY_TYPE_MISMATCH, "", "", msg, e);
            throw new IllegalArgumentException(msg, e);
        }

        // dubbo.config.ignore-duplicated-interface
        String ignoreDuplicatedInterfaceStr = (String) configuration
                .getProperty(ConfigKeys.DUBBO_CONFIG_IGNORE_DUPLICATED_INTERFACE);
        if (ignoreDuplicatedInterfaceStr != null) {
    
    
            this.ignoreDuplicatedInterface = Boolean.parseBoolean(ignoreDuplicatedInterfaceStr);
        }

        // print
        Map<String, Object> map = new LinkedHashMap<>();
        map.put(ConfigKeys.DUBBO_CONFIG_MODE, configMode);
        map.put(ConfigKeys.DUBBO_CONFIG_IGNORE_DUPLICATED_INTERFACE, this.ignoreDuplicatedInterface);
        logger.info("Config settings: " + map);
    }

Environment类型的initialize方法

这是一个与环境配置有关系的类型,我们先来简单了解下它的初始化方法,后期再详细说明:
Environment类型的initialize方法

@Override
    public void initialize() throws IllegalStateException {
    
    
        if (initialized.compareAndSet(false, true)) {
    
    
            //PropertiesConfiguration从系统属性和dubbo.properties中获取配置
            this.propertiesConfiguration = new PropertiesConfiguration(scopeModel);
            //SystemConfiguration获取的是JVM参数 启动命令中-D指定的
            this.systemConfiguration = new SystemConfiguration();
            //EnvironmentConfiguration是从环境变量中获取的配置
            this.environmentConfiguration = new EnvironmentConfiguration();
            //外部的Global配置config-center global/default config
            this.externalConfiguration = new InmemoryConfiguration("ExternalConfig");
            //外部的应用配置如:config-center中的应用配置
            this.appExternalConfiguration = new InmemoryConfiguration("AppExternalConfig");
            //本地应用配置 , 如Spring Environment/PropertySources/application.properties
            this.appConfiguration = new InmemoryConfiguration("AppConfig");
            //服务迁移配置加载 dubbo2升级dubbo3的一些配置
            loadMigrationRule();
        }
    }
 /**
     * @deprecated MigrationRule will be removed in 3.1
     * //服务迁移配置加载 JVM  > env >  代码路径dubbo-migration.yaml
     */
    @Deprecated
    private void loadMigrationRule() {
    
    
        if (Boolean.parseBoolean(System.getProperty(CommonConstants.DUBBO_MIGRATION_FILE_ENABLE, "false"))) {
    
    
            //文件路径配置的key dubbo.migration.file
            // JVM参数中获取
            String path = System.getProperty(CommonConstants.DUBBO_MIGRATION_KEY);
            if (StringUtils.isEmpty(path)) {
    
    
                //env环境变量中获取
                path = System.getenv(CommonConstants.DUBBO_MIGRATION_KEY);
                if (StringUtils.isEmpty(path)) {
    
    
                    //类路径下获取文件dubbo-migration.yaml
                    path = CommonConstants.DEFAULT_DUBBO_MIGRATION_FILE;
                }
            }
            this.localMigrationRule = ConfigUtils.loadMigrationRule(scopeModel.getClassLoaders(), path);
        } else {
    
    
            this.localMigrationRule = null;
        }
    }

创建ModuleModel对象

 protected ModuleModel(ApplicationModel applicationModel, boolean isInternal) {
    
    
        super(applicationModel, ExtensionScope.MODULE, isInternal);
        synchronized (instLock) {
    
    
            Assert.notNull(applicationModel, "ApplicationModel can not be null");
            this.applicationModel = applicationModel;
            applicationModel.addModule(this, isInternal);
            if (LOGGER.isInfoEnabled()) {
    
    
                LOGGER.info(getDesc() + " is created");
            }

            initialize();

            this.serviceRepository = new ModuleServiceRepository(this);

            initModuleExt();

            ExtensionLoader<ScopeModelInitializer> initializerExtensionLoader = this.getExtensionLoader(ScopeModelInitializer.class);
            Set<ScopeModelInitializer> initializers = initializerExtensionLoader.getSupportedExtensionInstances();
            for (ScopeModelInitializer initializer : initializers) {
    
    
                initializer.initializeModuleModel(this);
            }
            Assert.notNull(getServiceRepository(), "ModuleServiceRepository can not be null");
            Assert.notNull(getConfigManager(), "ModuleConfigManager can not be null");
            Assert.assertTrue(getConfigManager().isInitialized(), "ModuleConfigManager can not be initialized");

            // notify application check state
            // 获取应用程序发布对象,通知检查状态
            ApplicationDeployer applicationDeployer = applicationModel.getDeployer();
            if (applicationDeployer != null) {
    
    
                applicationDeployer.notifyModuleChanged(this, DeployState.PENDING);
            }
        }
    }

将模块模型添加至应用模型中


    void addModule(ModuleModel moduleModel, boolean isInternal) {
    
    
        synchronized (instLock) {
    
    
            if (!this.moduleModels.contains(moduleModel)) {
    
    
                checkDestroyed();
                this.moduleModels.add(moduleModel);
                //设置模块模型内部id,这个内部id生成过程与上面将应用模型添加到框架模型中的方式是一致的
                //可以参考 3.3.2 将ApplicationModel添加至FrameworkModel容器中
                moduleModel.setInternalId(buildInternalId(getInternalId(), moduleIndex.getAndIncrement()));
                if (!isInternal) {
    
    
                    //如果不是内部模型则添加到公开模块模型中
                    pubModuleModels.add(moduleModel);
                }
            }
        }
    }

初始化

调用父类的

模块服务存储库的创建

ModuleServiceRepository存储库中使用框架存储库frameworkServiceRepository来间接存储
这里我们看下怎么通过模块模型获取框架服务存储库frameworkServiceRepository:通过代码

public ModuleServiceRepository(ModuleModel moduleModel) {
    
    
        this.moduleModel = moduleModel;
        frameworkServiceRepository = ScopeModelUtil.getFrameworkModel(moduleModel).getServiceRepository();
    }


    public static FrameworkModel getFrameworkModel(ScopeModel scopeModel) {
    
    
        if (scopeModel == null) {
    
    
            return FrameworkModel.defaultModel();
        }
        //通过成员变量获取(构造器初始化的时候将FrameworkModel赋值给了ApplicationModel的成员变量
        if (scopeModel instanceof ApplicationModel) {
    
    
            return ((ApplicationModel) scopeModel).getFrameworkModel();
        } else if (scopeModel instanceof ModuleModel) {
    
    
            ModuleModel moduleModel = (ModuleModel) scopeModel;
            //间接通过ApplicationModel获取,不越级获取、
            return moduleModel.getApplicationModel().getFrameworkModel();
        } else if (scopeModel instanceof FrameworkModel) {
    
    
            return (FrameworkModel) scopeModel;
        } else {
    
    
            throw new IllegalArgumentException("Unable to get FrameworkModel from " + scopeModel);
        }
    }

当scopeModel instanceof ModuleModel 时返回的是FrameworkModel

模块配置管理器对象的创建与初始化

代码比较简单看一下uml结构吧
在这里插入图片描述

@Override
    public void initialize() throws IllegalStateException {
    
    
        if (initialized.compareAndSet(false, true)) {
    
    
            this.orderedPropertiesConfiguration = new OrderedPropertiesConfiguration(moduleModel);
        }
    }

####。OrderedPropertiesConfiguration对象的创建