You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@dubbo.apache.org by al...@apache.org on 2022/08/07 13:06:15 UTC
[dubbo-website] branch master updated: 框架,应用程序,模块领域模型Model对象的初始化 (#1342)
This is an automated email from the ASF dual-hosted git repository.
albumenj pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/dubbo-website.git
The following commit(s) were added to refs/heads/master by this push:
new c1a6e57c58 框架,应用程序,模块领域模型Model对象的初始化 (#1342)
c1a6e57c58 is described below
commit c1a6e57c588ba8bdb495744a3e771c0587325a9b
Author: songxiaosheng <81...@users.noreply.github.com>
AuthorDate: Sun Aug 7 21:06:08 2022 +0800
框架,应用程序,模块领域模型Model对象的初始化 (#1342)
* add dubbo3.0.8 1-demo blog
* add dubbo3.0.8 1-demo blog
* add authro
* add author
* remove author path
* add ServiceConfig
* Dubbo3.0.8源码解析ServiceConfig对象的建模
* Dubbo3.0.8源码解析ServiceConfig对象的建模
* Dubbo3.0.8源码解析ServiceConfig对象的建模
* Dubbo3.0.8源码解析ServiceConfig对象的建模
* 框架,应用程序,模块领域模型Model对象的初始化博客
* Dubbo扩展机制
* Dubbo扩展机制
---
.../java/codeanalysis/3.0.8/1-learn-from-a-demo.md | 2 +-
.../codeanalysis/3.0.8/2-serviceconfig-config.md | 2 +-
...232\204\345\210\235\345\247\213\345\214\226.md" | 918 +++++++++++++++++++++
...211\251\345\261\225\346\234\272\345\210\266.md" | 399 +++++++++
...etAdaptiveExtension\346\226\271\346\263\225.md" | 812 ++++++++++++++++++
...272\220\347\240\201\350\247\243\346\236\220.md" | 354 ++++++++
...272\220\347\240\201\350\247\243\346\236\220.md" | 225 +++++
static/imgs/blog/source-blog/3-extension.png | Bin 0 -> 74859 bytes
static/imgs/blog/source-blog/3-initextent.png | Bin 0 -> 141853 bytes
static/imgs/blog/source-blog/3-model.png | Bin 0 -> 53993 bytes
static/imgs/blog/source-blog/4-dubbo-arch.png | Bin 0 -> 161891 bytes
static/imgs/blog/source-blog/4-dubbo-arch2.png | Bin 0 -> 849298 bytes
static/imgs/blog/source-blog/4-dubbo-arch3.png | Bin 0 -> 200010 bytes
static/imgs/blog/source-blog/4-dubbo-extension.png | Bin 0 -> 71296 bytes
.../imgs/blog/source-blog/4-dubbo-extension2.png | Bin 0 -> 205415 bytes
15 files changed, 2710 insertions(+), 2 deletions(-)
diff --git a/content/zh/blog/java/codeanalysis/3.0.8/1-learn-from-a-demo.md b/content/zh/blog/java/codeanalysis/3.0.8/1-learn-from-a-demo.md
index e7fcdcddf7..28f354e67f 100644
--- a/content/zh/blog/java/codeanalysis/3.0.8/1-learn-from-a-demo.md
+++ b/content/zh/blog/java/codeanalysis/3.0.8/1-learn-from-a-demo.md
@@ -1,7 +1,7 @@
---
title: "01 从一个服务提供者的Demo说起"
linkTitle: "1-从一个服务提供者的Demo说起"
-date: 2022-07-30
+date: 2022-08-01
author: 宋小生
description: >
为了更方便了解Dubbo提供者原理,我们先来编写一个Demo,从例子中来看源码实现
diff --git a/content/zh/blog/java/codeanalysis/3.0.8/2-serviceconfig-config.md b/content/zh/blog/java/codeanalysis/3.0.8/2-serviceconfig-config.md
index 0bfcf7549d..1d2934f623 100644
--- a/content/zh/blog/java/codeanalysis/3.0.8/2-serviceconfig-config.md
+++ b/content/zh/blog/java/codeanalysis/3.0.8/2-serviceconfig-config.md
@@ -1,7 +1,7 @@
---
title: "02-启动服务前服务配置ServiceConfig类型是如何初始化的?"
linkTitle: "2-ServiceConfig类型是如何初始化的?"
-date: 2022-08-06
+date: 2022-08-02
author: 宋小生
description: >
[Dubbo 3.0.8源码解析] 了解一下服务配置的设计原理,有助于理解后面的服务治理的原理
diff --git "a/content/zh/blog/java/codeanalysis/3.0.8/3-\346\241\206\346\236\266,\345\272\224\347\224\250\347\250\213\345\272\217,\346\250\241\345\235\227\351\242\206\345\237\237\346\250\241\345\236\213Model\345\257\271\350\261\241\347\232\204\345\210\235\345\247\213\345\214\226.md" "b/content/zh/blog/java/codeanalysis/3.0.8/3-\346\241\206\346\236\266,\345\272\224\347\224\250\347\250\213\345\272\217,\346\250\241\345\235\227\351\242\206\345\237\237\346\250\241\345\236\213Model\345\257\271\ [...]
new file mode 100644
index 0000000000..5c00d29f29
--- /dev/null
+++ "b/content/zh/blog/java/codeanalysis/3.0.8/3-\346\241\206\346\236\266,\345\272\224\347\224\250\347\250\213\345\272\217,\346\250\241\345\235\227\351\242\206\345\237\237\346\250\241\345\236\213Model\345\257\271\350\261\241\347\232\204\345\210\235\345\247\213\345\214\226.md"
@@ -0,0 +1,918 @@
+---
+title: "03-框架,应用程序,模块领域模型Model对象的初始化"
+linkTitle: "3-框架,应用程序,模块领域模型Model对象的初始化"
+date: 2022-08-03
+author: 宋小生
+description: >
+ [Dubbo 3.0.8源码解析] 分层设计,框架,应用程序,模块领域模型Model对象的初始化了解下应用,模块的模型为后面的有效了解配置,启动的逻辑做铺垫
+---
+
+# 3-框架,应用程序,模块领域模型Model对象的初始化
+在上一章中我们详细看了服务配置ServiceConfig类型的初始化,不过我们跳过了AbstractMethodConfig的构造器中创建模块模型对象的过程,那这一章我们就来看下模块模型对象的初始化过程:
+
+```java
+public AbstractMethodConfig() {
+ super(ApplicationModel.defaultModel().getDefaultModule());
+ }
+```
+**那为什么会在Dubbo3的新版本中加入这个域模型呢**,主要有如下原因
+之前dubbo都是只有一个作用域的,通过静态类 属性共享
+增加域模型是为了:
+1. 让Dubbo支持多应用的部署,这块一些大企业有诉求
+2. 从架构设计上,解决静态属性资源共享、清理的问题
+3. 分层模型将应用的管理和服务的管理分开
+
+可能比较抽象,可以具体点来看Dubbo3中在启动时候需要启动配置中心,元数据中心这个配置中心和元数据中心可以归应用模型来管理,Dubbo作为RPC框架有需要启动服务和引用服务,服务级别的管理就交给了这个模块模型来管理,分层次的管理方便我们理解和处理逻辑,父子级别的模型又方便了数据传递。
+
+了解过JVM类加载机制的同学应该就比较清楚 JVM类加载过程中的数据访问模型,子类加载器先去父类加载器去找不到则从子类型加载器中查找类型,Dubbo的分层模型类似这样一种机制,这一章先来简单了解下后面用到时候具体细说。
+
+## 3.1 模型对象的关系
+为了不增加复杂性,我们这里仅仅列出模型对象类型类型之间的继承关系如下所示:
+
+<center>图3.1 模型对象的继承关系</center>
+
+模型对象一共有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),他们主要用来针对框架,应用程序,模块的**存储**,**发布管理,**,**配置管理**
+
+看来Dubbo3 针对应用服务治理与运维这一块也是在努力尝试.
+
+
+### 3.1.1 AbstractMethodConfig 配置对象中获取模型对象的调用
+
+模块模型(ModuleModel)参数对象的创建
+这个AbstractMethodConfig构造器在初始化的时候调调用了这么一行代码做为参数向父类型传递对象.
+
+```java
+ApplicationModel.defaultModel().getDefaultModule()
+```
+默认情况下使用ApplicationModel的静态方法获取默认的模型对象和默认的模块对象
+
+**ApplicationModel**(应用程序领域模型)类型中获取默认模型对象的方法:
+
+```java
+ public static ApplicationModel defaultModel() {
+ // should get from default FrameworkModel, avoid out of sync
+ return FrameworkModel.defaultModel().defaultApplication();
+ }
+```
+这里可以看到要想获取应用程序模型必须先通过框架领域模型来获取层级也是框架领域模型到应用程序领域模型
+
+### 3.1.2 使用双重校验锁获取框架模型对象
+FrameworkModel(框架模型)的默认模型获取工厂方法defaultModel()
+```java
+ /**
+ * 在源码的注释上有这么一句话:在销毁默认的 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;
+ }
+```
+
+### 3.1.3 刷新重置默认框架模型对象
+FrameworkModel中的重置默认框架模型resetDefaultFrameworkModel
+```java
+ private static void resetDefaultFrameworkModel() {
+ //全局悲观锁,同一个时刻只能有一个线程执行重置操作
+ synchronized (globalLock) {
+ //defaultInstance为当前成员变量FrameworkModel类型代表当前默认的FrameworkModel类型的实例对象
+ if (defaultInstance != null && !defaultInstance.isDestroyed()) {
+ return;
+ }
+ FrameworkModel oldDefaultFrameworkModel = defaultInstance;
+ //存在实例模型列表则直接从内存缓存中查后续不需要创建了
+ if (allInstances.size() > 0) {
+ //当前存在的有FrameworkModel框架实例多个列表则取第一个为默认的
+ defaultInstance = allInstances.get(0);
+ } else {
+ defaultInstance = null;
+ }
+ if (oldDefaultFrameworkModel != defaultInstance) {
+ if (LOGGER.isInfoEnabled()) {
+ LOGGER.info("Reset global default framework from " + safeGetModelDesc(oldDefaultFrameworkModel) + " to " + safeGetModelDesc(defaultInstance));
+ }
+ }
+ }
+ }
+```
+
+
+上面单例做了很多的初始化操作,这里开始调用构造器来创建框架模型对象,如下代码:
+## 3.2 创建FrameworkModel对象
+ FrameworkModel()构造器
+```java
+public FrameworkModel() {
+ //调用父类型ScopeModel传递参数,这个构造器的第一个参数为空代表这是一个顶层的域模型,第二个代表了这个是框架FRAMEWORK域,第三个false不是内部域
+ super(null, ExtensionScope.FRAMEWORK, false);
+ //内部id用于表示模型树的层次结构,如层次结构:
+ //FrameworkModel(索引=1)->ApplicationModel(索引=2)->ModuleModel(索引=1,第一个用户模块)
+ //这个index变量是static类型的为静态全局变量默认值从1开始,如果有多个框架模型对象则internalId编号从1开始依次递增
+ this.setInternalId(String.valueOf(index.getAndIncrement()));
+ // register FrameworkModel instance early
+ //将当前新创建的框架实例对象添加到容器中
+ synchronized (globalLock) {
+ //将当前框架模型实例添加到所有框架模型缓存对象中
+ allInstances.add(this);
+ //如上面代码所示重置默认的框架模型对象,这里将会是缓存实例列表的第一个,新增了一个刷新默认实例对象
+ resetDefaultFrameworkModel();
+ }
+ if (LOGGER.isInfoEnabled()) {
+ LOGGER.info(getDesc() + " is created");
+ }
+ //初始化框架模型领域对象
+ initialize();
+ }
+```
+
+ ExtensionScope.FRAMEWORK
+
+### 3.2.1 初始化FrameworkModel
+FrameworkModel框架模型的初始化方法initialize()
+```java
+@Override
+ protected void initialize() {
+ //这里初始化之前先调用下父类型ScopeModel的初始化方法我们在下面来看
+ super.initialize();
+ //使用TypeDefinitionBuilder的静态方法initBuilders来初始化类型构建器TypeBuilder类型集合
+ TypeDefinitionBuilder.initBuilders(this);
+ //框架服务存储仓库对象,可以用于快速查询服务提供者信息
+ serviceRepository = new FrameworkServiceRepository(this);
+ //获取ScopeModelInitializer类型(域模型初始化器)的扩展加载器ExtensionLoader,每个扩展类型都会创建一个扩展加载器缓存起来
+ ExtensionLoader<ScopeModelInitializer> initializerExtensionLoader = this.getExtensionLoader(ScopeModelInitializer.class);
+ //获取ScopeModelInitializer类型的支持的扩展集合,这里当前版本存在8个扩展类型实现
+ 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));
+ //设置公开的模块名字为常量DUBBO_INTERNAL_APPLICATION
+ internalApplicationModel.setModelName(CommonConstants.DUBBO_INTERNAL_APPLICATION);
+ }
+```
+
+
+
+继续上面代码的调用链路,我们来看
+FrameworkModel的super.initialize();方法 调用父类型ScopeModel的initialize()方法
+
+### 3.2.2 初始化ScopeModel
+ScopeModel类型的初始化方法initialize():
+```java
+protected void initialize() {
+ //初始化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);
+ //使用数据结构链表,创建销毁监听器容器,一般用于关闭进程,重置应用程序对象等操作时候调用
+ this.destroyListeners = new LinkedList<>();
+ //使用ConcurrentHashMap属性集合
+ this.attributes = new ConcurrentHashMap<>();
+ //使用ConcurrentHashSet存储当前域下的类加载器
+ this.classLoaders = new ConcurrentHashSet<>();
+
+ // Add Framework's ClassLoader by default
+ //将当前类的加载器存入加载器集合classLoaders中
+ ClassLoader dubboClassLoader = ScopeModel.class.getClassLoader();
+ if (dubboClassLoader != null) {
+ this.addClassLoader(dubboClassLoader);
+ }
+ }
+```
+
+
+### 3.2.3 初始类型定义构建器
+
+TypeDefinitionBuilder的初始化类型构造器方法initBuilders
+
+```java
+public static void initBuilders(FrameworkModel model) {
+ Set<TypeBuilder> tbs = model.getExtensionLoader(TypeBuilder.class).getSupportedExtensionInstances();
+ BUILDERS = new ArrayList<>(tbs);
+ }
+```
+
+
+#### 3.2.3.1 服务存储仓库对象的创建
+FrameworkServiceRepository对象的初始化
+
+```java
+public FrameworkServiceRepository(FrameworkModel frameworkModel) {
+ this.frameworkModel = frameworkModel;
+ }
+```
+
+### 3.2.4 域模型初始化器的获取与初始化回调
+域模型初始化器的获取与初始化(ScopeModelInitializer类型和initializeFrameworkModel方法)
+加载到的ScopeModelInitializer类型的SPI扩展实现
+
+```java
+ExtensionLoader<ScopeModelInitializer> initializerExtensionLoader = this.getExtensionLoader(ScopeModelInitializer.class);
+ //获取ScopeModelInitializer类型的支持的扩展集合,这里当前版本存在8个扩展类型实现
+ Set<ScopeModelInitializer> initializers = initializerExtensionLoader.getSupportedExtensionInstances();
+ //遍历这些扩展实现调用他们的initializeFrameworkModel方法来传递FrameworkModel类型对象,细节我们待会再详细说下
+ for (ScopeModelInitializer initializer : initializers) {
+ initializer.initializeFrameworkModel(this);
+ }
+```
+
+通过Debug查到域模型初始化器的SPI扩展类型有如下8个:
+
+
+
+这里我随机找两个说一下吧:
+容错域模型初始化器:ClusterScopeModelInitializer的initializeFrameworkModel方法:
+
+```java
+public class ClusterScopeModelInitializer implements ScopeModelInitializer {
+ @Override
+ public void initializeFrameworkModel(FrameworkModel frameworkModel) {
+ ScopeBeanFactory beanFactory = frameworkModel.getBeanFactory();
+ beanFactory.registerBean(RouterSnapshotSwitcher.class);
+ }
+```
+
+
+```java
+public class CommonScopeModelInitializer implements ScopeModelInitializer {
+ @Override
+ public void initializeFrameworkModel(FrameworkModel frameworkModel) {
+ ScopeBeanFactory beanFactory = frameworkModel.getBeanFactory();
+ beanFactory.registerBean(FrameworkExecutorRepository.class);
+ }
+```
+
+```java
+public class ConfigScopeModelInitializer implements ScopeModelInitializer {
+
+ @Override
+ public void initializeFrameworkModel(FrameworkModel frameworkModel) {
+ frameworkModel.addDestroyListener(new FrameworkModelCleaner());
+ }
+```
+
+### 3.2.5 将内部应用配置对象创建与添加至应用模型中
+创建ApplicationConfig对象让后将其添加至应用模型中
+内部应用程序模型,这里为应用配置管理器设置一个应用配置对象,将这个应用配置的模块名字配置名字设置为DUBBO_INTERNAL_APPLICATION,应用配置记录着我们常见的应用配置信息,如下面表格所示:
+```java
+ //获取ConfigManager类型对象,然后设置添加当前应用配置对象
+ internalApplicationModel.getApplicationConfigManager().setApplication(
+ new ApplicationConfig(internalApplicationModel, CommonConstants.DUBBO_INTERNAL_APPLICATION));
+ //设置公开的模块名字为常量DUBBO_INTERNAL_APPLICATION
+ internalApplicationModel.setModelName(CommonConstants.DUBBO_INTERNAL_APPLICATION);
+ ```
+ 来自官网目前版本的配置解释:
+ 官网当前的配置描述知道到了元数据类型,后面我再补充几个
+
+| 属性 | 对应URL参数 |类型 | 是否必填 |缺省值 | 作用 | 描述|兼容性|
+|--|--|--|--|--|--|--|--|
+| name| application | string| 必填 | | 服务治理 | 当前应用名称,用于注册中心计算应用间依赖关系,注意:消费者和提供者应用名不要一样,此参数不是匹配条件,你当前项目叫什么名字就填什么,和提供者消费者角色无关,比如:kylin应用调用了morgan应用的服务,则kylin项目配成kylin,morgan项目配成morgan,可能kylin也提供其它服务给别人使用,但kylin项目永远配成kylin,这样注册中心将显示kylin依赖于morgan | 1.0.16以上版本|
+| version| application.version | string| 可选| | 服务治理 | 当前应用的版本| 2.2.0以上版本|
+| owner| owner| string | 可选| | 服务治理| 应用负责人,用于服务治理,请填写负责人公司邮箱前缀 | 2.0.5以上版本|
+| organization | organization | string| 可选| | 服务治理 | 组织名称(BU或部门),用于注册中心区分服务来源,此配置项建议不要使用autoconfig,直接写死在配置中,比如china,intl,itu,crm,asc,dw,aliexpress等 | 2.0.0以上版本|
+| architecture| architecture| string| 可选 | | 服务治理| 用于服务分层对应的架构。如,intl、china。不同的架构使用不同的分层。 | 2.0.7以上版本
+| environment | environment| string| 可选 | | 服务治理| 应用环境,如:develop/test/product,不同环境使用不同的缺省值,以及作为只用于开发测试功能的限制条件 | 2.0.0以上版本|
+| compiler| compiler| string | 可选| javassist | 性能优化| Java字节码编译器,用于动态类的生成,可选:jdk或javassist | 2.1.0以上版本|
+| logger | logger| string | 可选| slf4j | 性能优化| 日志输出方式,可选:slf4j,jcl,log4j,log4j2,jdk | 2.2.0以上版本|
+| metadata-type | metadata-type | String | 可选| local | 服务治理 | metadata 传递方式,是以 Provider 视角而言的,Consumer 侧配置无效,可选值有:remote - Provider 把 metadata 放到远端注册中心,Consumer 从注册中心获取local - Provider 把 metadata 放在本地,Consumer 从 Provider 处直接获取 | 2.7.6以上版本|
+
+当前在Dubbo3.0.7中还有一些的配置我下面列举下:
+| 属性 | 对应URL参数 |类型 | 是否必填 |缺省值 | 作用 | 描述|兼容性|
+|--|--|--|--|--|--|--|--|
+|register-consumer| register-consumer|boolean|可选|false|服务治理|是否注册使用者实例,默认为false。||
+|register-mode|register-mode|string|可选|all|服务治理|将interface/instance/all 地址注册到注册中心,默认为all。|
+|enable-empty-protection|enable-empty-protection|boolean|可选|true|服务治理|在空地址通知上启用空保护,默认为true||
+|protocol|protocol|string|可选|dubbo|服务治理|此应用程序的首选协议(名称)||
+
+
+
+
+## 3.3 创建ApplicationModel对象
+ApplicationModel对象的初始化调用
+ 在前面 3.2.4 FrameworkModel框架模型的初始化方法initialize() 章节中,我们看到了代码ApplicationModel对象的初始化调用如下代码,这里我们来详细说一下:
+```java
+ internalApplicationModel = new ApplicationModel(this, true);
+ internalApplicationModel.getApplicationConfigManager().setApplication(
+ new ApplicationConfig(internalApplicationModel, CommonConstants.DUBBO_INTERNAL_APPLICATION));
+ internalApplicationModel.setModelName(CommonConstants.DUBBO_INTERNAL_APPLICATION);
+
+```
+
+### 3.3.1 ApplicationModel的构造器
+ApplicationModel(FrameworkModel frameworkModel, boolean isInternal)
+刚刚3.2.9那个地方我们看到了使用代码**new ApplicationModel(this, true)** 来创建对象这里我们详细看下代码细节:
+
+
+```java
+public ApplicationModel(FrameworkModel frameworkModel, boolean isInternal) {
+ //调用父类型ScopeModel传递参数,这个构造器的传递没与前面看到的FrameworkModel构造器的中的调用参数有些不同第一个参数我们为frameworkModel代表父域模型,第二个参数标记域为应用程序级别APPLICATION,第三个参数我们传递的为true代表为内部域
+ super(frameworkModel, ExtensionScope.APPLICATION, isInternal);
+ Assert.notNull(frameworkModel, "FrameworkModel can not be null");
+ //应用程序域成员变量记录frameworkModel对象
+ this.frameworkModel = frameworkModel;
+ //frameworkModel对象添加当前应用程序域对象
+ frameworkModel.addApplication(this);
+ if (LOGGER.isInfoEnabled()) {
+ LOGGER.info(getDesc() + " is created");
+ }
+ //初始化应用程序
+ initialize();
+ }
+```
+
+
+#### 3.3.1.1 将ApplicationModel添加至FrameworkModel容器中
+FrameworkModel的添加应用程序方法addApplication:
+
+```java
+void addApplication(ApplicationModel applicationModel) {
+ // can not add new application if it's destroying
+ //检查FrameworkModel对象是否已经被标记为销毁状态,如果已经被销毁了则抛出异常无需执行逻辑
+ checkDestroyed();
+ synchronized (instLock) {
+ //如果还未添加过当前参数传递应用模型
+ if (!this.applicationModels.contains(applicationModel)) {
+ //为当前应用模型生成内部id
+ applicationModel.setInternalId(buildInternalId(getInternalId(), appIndex.getAndIncrement()));
+ //添加到成员变量集合applicationModels中
+ this.applicationModels.add(applicationModel);
+ //如果非内部的则也向公开应用模型集合pubApplicationModels中添加一下
+ if (!applicationModel.isInternal()) {
+ this.pubApplicationModels.add(applicationModel);
+ }
+ resetDefaultAppModel();
+ }
+ }
+ }
+```
+内部id生成算法buildInternalId方法代码如下:
+看代码胜过,文字解释
+```java
+ 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;
+ }
+ }
+```
+
+ **重置默认的应用模型对象**
+FrameworkModel 重置默认的应用模型对象 resetDefaultAppModel()方法
+与默认框架模型设置方式类似取集合的第一个,这里应用模型需要使用公开的应用模型的第一个做为默认应用模型,代码如下所示:
+```java
+private void resetDefaultAppModel() {
+ synchronized (instLock) {
+ if (this.defaultAppModel != null && !this.defaultAppModel.isDestroyed()) {
+ return;
+ }
+ //取第一个公开的应用模型做为默认应用模型
+ ApplicationModel oldDefaultAppModel = this.defaultAppModel;
+ if (pubApplicationModels.size() > 0) {
+ this.defaultAppModel = pubApplicationModels.get(0);
+ } else {
+ this.defaultAppModel = null;
+ }
+ if (defaultInstance == this && oldDefaultAppModel != this.defaultAppModel) {
+ if (LOGGER.isInfoEnabled()) {
+ LOGGER.info("Reset global default application from " + safeGetModelDesc(oldDefaultAppModel) + " to " + safeGetModelDesc(this.defaultAppModel));
+ }
+ }
+ }
+ }
+```
+
+### 3.3.2 初始化ApplicationModel
+ApplicationModel的初始化initialize()方法
+在前面**3.2.10 ApplicationModel的构造器ApplicationModel(FrameworkModel frameworkModel, boolean isInternal)** 中的最后一行开始初始化应用模型我们还未详细说明下面可以来看下
+
+```java
+@Override
+ protected void initialize() {
+ //这个是调用域模型来初始化基础信息如扩展访问器等,可以参考 3.2.5 ScopeModel类型的初始化方法initialize()章节
+ super.initialize();
+ //创建一个内部的模块模型对象
+ 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);
+ }
+ }
+```
+
+ ### 3.3.4 initApplicationExts() 初始化应用程序扩展方法
+```java
+ private void initApplicationExts() {
+ //这个扩展实现一共有两个可以看下面那个图扩展类型为ConfigManager和Environment
+ Set<ApplicationExt> exts = this.getExtensionLoader(ApplicationExt.class).getSupportedExtensionInstances();
+ for (ApplicationExt ext : exts) {
+ ext.initialize();
+ }
+ }
+```
+
+
+
+#### 3.3.4.1 ConfigManager类型的initialize方法
+先简单说下ConfigManager的作用,无锁配置管理器(通过ConcurrentHashMap),用于快速读取操作。写入操作锁带有配置类型的子配置映射,用于安全检查和添加新配置。
+其实ConfigManager实现类中并没有这个初始化方法initialize,不过ConfigManager的父类型AbstractConfigManager中是有initialize方法的,如下所示:
+
+AbstractConfigManager的初始化方法initialize
+```java
+@Override
+ public void initialize() throws IllegalStateException {
+ //乐观锁判断是否初始化过
+ if (!initialized.compareAndSet(false, true)) {
+ return;
+ }
+ //从模块环境中获取组合配置,目前Environment中有6种重要的配置,我们后面详细说
+ CompositeConfiguration configuration = scopeModel.getModelEnvironment().getConfiguration();
+
+ // 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(msg, e);
+ throw new IllegalArgumentException(msg, e);
+ }
+
+ // dubbo.config.ignore-duplicated-interface
+ //忽略重复的接口(服务/引用)配置。默认值为false
+ 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);
+ }
+```
+
+
+#### 3.3.4.2 Environment类型的initialize方法
+这是一个与环境配置有关系的类型,我们先来简单了解下它的初始化方法,后期再详细说明:
+
+Environment类型的initialize方法
+```java
+ @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();
+ }
+ }
+ //服务迁移配置加载 JVM > env > 代码路径dubbo-migration.yaml
+ private void loadMigrationRule() {
+ //文件路径配置的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);
+ }
+```
+
+**ConfigUtils中读取迁移规则配置文件loadMigrationRule**
+这个我们不细说了,贴一下代码感兴趣可以了解下,这个代码主要是读取文件到内存字符串:
+
+```java
+ public static String loadMigrationRule(Set<ClassLoader> classLoaders, String fileName) {
+ String rawRule = "";
+ if (checkFileNameExist(fileName)) {
+ try {
+ try (FileInputStream input = new FileInputStream(fileName)) {
+ return readString(input);
+ }
+ } catch (Throwable e) {
+ logger.warn("Failed to load " + fileName + " file from " + fileName + "(ignore this file): " + e.getMessage(), e);
+ }
+ }
+
+ try {
+ List<ClassLoader> classLoadersToLoad = new LinkedList<>();
+ classLoadersToLoad.add(ClassUtils.getClassLoader());
+ classLoadersToLoad.addAll(classLoaders);
+ for (Set<URL> urls : ClassLoaderResourceLoader.loadResources(fileName, classLoadersToLoad).values()) {
+ for (URL url : urls) {
+ InputStream is = url.openStream();
+ if (is != null) {
+ return readString(is);
+ }
+ }
+ }
+ } catch (Throwable e) {
+ logger.warn("Failed to load " + fileName + " file from " + fileName + "(ignore this file): " + e.getMessage(), e);
+ }
+ return rawRule;
+ }
+
+ private static String readString(InputStream is) {
+ StringBuilder stringBuilder = new StringBuilder();
+ char[] buffer = new char[10];
+ try (BufferedReader reader = new BufferedReader(new InputStreamReader(is))) {
+ int n;
+ while ((n = reader.read(buffer)) != -1) {
+ if (n < 10) {
+ buffer = Arrays.copyOf(buffer, n);
+ }
+ stringBuilder.append(String.valueOf(buffer));
+ buffer = new char[10];
+ }
+ } catch (IOException e) {
+ logger.error("Read migration file error.", e);
+ }
+
+ return stringBuilder.toString();
+ }
+
+ /**
+ * check if the fileName can be found in filesystem
+ *
+ * @param fileName
+ * @return
+ */
+ private static boolean checkFileNameExist(String fileName) {
+ File file = new File(fileName);
+ return file.exists();
+ }
+```
+
+
+
+## 3.4 创建ModuleModel对象
+前面ApplicationModel对象初始化的时候创建了ModuleModel如下代码:
+
+```java
+internalModule = new ModuleModel(this, true);
+```
+
+这里我们来看下这个它所对应的构造器
+
+
+```java
+public ModuleModel(ApplicationModel applicationModel, boolean isInternal) {
+ //调用ScopeModel传递3个参数父模型,模型域为模块域,是否为内部模型参数为true
+ super(applicationModel, ExtensionScope.MODULE, isInternal);
+ Assert.notNull(applicationModel, "ApplicationModel can not be null");
+ //初始化成员变量applicationModel
+ this.applicationModel = applicationModel;
+ //将模块模型添加至应用模型中
+ applicationModel.addModule(this, isInternal);
+ if (LOGGER.isInfoEnabled()) {
+ LOGGER.info(getDesc() + " is created");
+ }
+ //初始化模块模型
+ initialize();
+ Assert.notNull(serviceRepository, "ModuleServiceRepository can not be null");
+ Assert.notNull(moduleConfigManager, "ModuleConfigManager can not be null");
+ Assert.assertTrue(moduleConfigManager.isInitialized(), "ModuleConfigManager can not be initialized");
+
+ // notify application check state
+ //获取应用程序发布对象,通知检查状态
+ ApplicationDeployer applicationDeployer = applicationModel.getDeployer();
+ if (applicationDeployer != null) {
+ applicationDeployer.notifyModuleChanged(this, DeployState.PENDING);
+ }
+ }
+```
+
+### 3.4.1 将模块模型添加至应用模型中
+如上面代码所示调用如下代码将模块模型添加到应用模型中:
+
+```java
+ applicationModel.addModule(this, isInternal);
+```
+这里我们来看下添加过程
+
+```java
+
+void addModule(ModuleModel moduleModel, boolean isInternal) {
+ //加锁
+ synchronized (moduleLock) {
+ //不存在则添加
+ 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);
+ }
+ }
+ }
+ }
+```
+
+### 3.4.2 初始化模块模型
+前面ModuleModel构造器中通过initialize()方法来进行初始化操作如下代码:
+
+```java
+@Override
+ protected void initialize() {
+ //调用域模型ScopeModel的初始化,可以参考 3.2.5 ScopeModel类型的初始化方法initialize()章节
+ super.initialize();
+ //创建模块服务存储库对象
+ this.serviceRepository = new ModuleServiceRepository(this);
+ //创建模块配置管理对象
+ this.moduleConfigManager = new ModuleConfigManager(this);
+ //初始化模块配置管理对象
+ this.moduleConfigManager.initialize();
+
+ //初始化模块配置扩展
+ initModuleExt();
+
+ //初始化域模型扩展
+ ExtensionLoader<ScopeModelInitializer> initializerExtensionLoader = this.getExtensionLoader(ScopeModelInitializer.class);
+ Set<ScopeModelInitializer> initializers = initializerExtensionLoader.getSupportedExtensionInstances();
+ for (ScopeModelInitializer initializer : initializers) {
+ initializer.initializeModuleModel(this);
+ }
+ }
+```
+#### 3.4.2.1 模块服务存储库的创建
+ModuleServiceRepository是模块模型中用来存储服务的通过如下代码调用
+
+```java
+//创建模块服务存储库对象
+ this.serviceRepository = new ModuleServiceRepository(this);
+
+```
+这里我们来看下模块服务存储库的构造器代码:
+
+```java
+ public ModuleServiceRepository(ModuleModel moduleModel) {
+ //初始化模块模型
+ this.moduleModel = moduleModel;
+ //
+ frameworkServiceRepository = ScopeModelUtil.getFrameworkModel(moduleModel).getServiceRepository();
+ }
+```
+
+ModuleServiceRepository存储库中使用框架存储库frameworkServiceRepository来间接存储
+这里我们看下怎么通过模块模型获取框架服务存储库frameworkServiceRepository:通过代码
+
+```java
+ScopeModelUtil.getFrameworkModel(moduleModel).getServiceRepository()
+```
+
+ScopeModelUtil工具类获取getFrameworkModel代码如下:
+```java
+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);
+ }
+ }
+```
+
+#### 3.4.2.2 模块配置管理器对象的创建与初始化
+
+
+```java
+ //创建模块配置管理对象
+ this.moduleConfigManager = new ModuleConfigManager(this);
+ //初始化模块配置管理对象
+ this.moduleConfigManager.initialize();
+```
+
+
+ModuleConfigManager的构造器代码如下:
+```java
+public ModuleConfigManager(ModuleModel moduleModel) {
+ //向抽象的配置管理器AbstractConfigManager传递参数
+ //模块模型参数,模块支持的配置类型集合
+ super(moduleModel, Arrays.asList(ModuleConfig.class, ServiceConfigBase.class, ReferenceConfigBase.class, ProviderConfig.class, ConsumerConfig.class));
+ //获取应用程序配置管理器
+ applicationConfigManager = moduleModel.getApplicationModel().getApplicationConfigManager();
+ }
+
+```
+
+ModuleConfigManager类型的初始化方法代码如下:
+
+```java
+@Override
+ public void initialize() throws IllegalStateException {
+ if (!initialized.compareAndSet(false, true)) {
+ return;
+ }
+ //获取组合配置对象
+ CompositeConfiguration configuration = scopeModel.getModelEnvironment().getConfiguration();
+
+ // dubbo.config.mode
+ //3.3.4.1提到过这里再重复一次 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(msg, e);
+ throw new IllegalArgumentException(msg, e);
+ }
+
+ // dubbo.config.ignore-duplicated-interface
+ //忽略重复的接口(服务/引用)配置。默认值为false
+ 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);
+ }
+```
+
+#### 3.4.2.3 模块配置扩展的初始化
+
+```java
+initModuleExt();
+```
+
+```java
+private void initModuleExt() {
+//目前这里的扩展只支持有一个类型ModuleEnvironment
+ Set<ModuleExt> exts = this.getExtensionLoader(ModuleExt.class).getSupportedExtensionInstances();
+ for (ModuleExt ext : exts) {
+ ext.initialize();
+ }
+ }
+```
+ModuleEnvironment的初始化
+
+```java
+ @Override
+ public void initialize() throws IllegalStateException {
+ this.orderedPropertiesConfiguration = new OrderedPropertiesConfiguration(moduleModel);
+ }
+```
+
+OrderedPropertiesConfiguration对象的创建
+
+```java
+public OrderedPropertiesConfiguration(ModuleModel moduleModel) {
+ this.moduleModel = moduleModel;
+ refresh();
+ }
+
+ public void refresh() {
+ properties = new Properties();
+ //有序的配置提供器扩展获取
+ ExtensionLoader<OrderedPropertiesProvider> propertiesProviderExtensionLoader = moduleModel.getExtensionLoader(OrderedPropertiesProvider.class);
+ Set<String> propertiesProviderNames = propertiesProviderExtensionLoader.getSupportedExtensions();
+ if (CollectionUtils.isEmpty(propertiesProviderNames)) {
+ return;
+ }
+ List<OrderedPropertiesProvider> orderedPropertiesProviders = new ArrayList<>();
+ for (String propertiesProviderName : propertiesProviderNames) {
+ orderedPropertiesProviders.add(propertiesProviderExtensionLoader.getExtension(propertiesProviderName));
+ }
+
+ //order the propertiesProvider according the priority descending
+ //根据优先级进行排序,值越小优先级越高
+ orderedPropertiesProviders.sort((a, b) -> b.priority() - a.priority());
+
+
+ //override the properties. 目前没看到有具体的扩展实现
+ for (OrderedPropertiesProvider orderedPropertiesProvider : orderedPropertiesProviders) {
+ properties.putAll(orderedPropertiesProvider.initProperties());
+ }
+
+ }
+```
+
+
+
+原文: [<<框架,应用程序,模块领域模型Model对象的初始化>>](https://blog.elastic.link/2022/07/10/dubbo/3-kuang-jia-ying-yong-cheng-xu-mo-kuai-ling-yu-mo-xing-model-dui-xiang-de-chu-shi-hua/ )
diff --git "a/content/zh/blog/java/codeanalysis/3.0.8/4-Dubbo\347\232\204\346\211\251\345\261\225\346\234\272\345\210\266.md" "b/content/zh/blog/java/codeanalysis/3.0.8/4-Dubbo\347\232\204\346\211\251\345\261\225\346\234\272\345\210\266.md"
new file mode 100644
index 0000000000..5ce115cc07
--- /dev/null
+++ "b/content/zh/blog/java/codeanalysis/3.0.8/4-Dubbo\347\232\204\346\211\251\345\261\225\346\234\272\345\210\266.md"
@@ -0,0 +1,399 @@
+---
+title: "04-Dubbo的扩展机制"
+linkTitle: "4-Dubbo的扩展机制"
+date: 2022-08-04
+author: 宋小生
+description: >
+ [Dubbo 3.0.8源码解析] Dubbo是一个微内核框架,所有的实现都是通过扩展机制来实现的,了解扩展加载机制可以有效的逻辑代码的抽象与具体逻辑
+---
+
+
+# 4-Dubbo的扩展机制
+## 4.1 回顾我们前面使用到扩展场景
+在上一章中我们初始化应用模型对象的时候,了解到有几个地方用到了扩展机制来创建对象,这一章我们会详细来讲一下这个扩展对象的加载过程,这里我们先来回顾下哪些地方用到了扩展机制:
+
+
+```java
+// 使用扩展机制获取TypeBuilder
+Set<TypeBuilder> tbs = model.getExtensionLoader(TypeBuilder.class).getSupportedExtensionInstances();
+
+//获取域模型初始化器ScopeModelInitializer扩展对象,执行初始化方法
+ExtensionLoader<ScopeModelInitializer> initializerExtensionLoader = this.getExtensionLoader(ScopeModelInitializer.class);
+ Set<ScopeModelInitializer> initializers = initializerExtensionLoader.getSupportedExtensionInstances();
+
+// OrderedPropertiesConfiguration 中获取有序配置提供器对象
+ExtensionLoader<OrderedPropertiesProvider> propertiesProviderExtensionLoader = moduleModel.getExtensionLoader(OrderedPropertiesProvider.class);
+
+// ApplicationModel中获取配置管理器对象
+ configManager = (ConfigManager) this.getExtensionLoader(ApplicationExt.class)
+ .getExtension(ConfigManager.NAME);
+
+//ModuleModel中获取模块扩展对象
+Set<ModuleExt> exts = this.getExtensionLoader(ModuleExt.class).getSupportedExtensionInstances();
+
+// ApplicationModel中获Environment对象
+environment = (Environment) this.getExtensionLoader(ApplicationExt.class)
+ .getExtension(Environment.NAME);
+
+// ApplicationModel中获取应用初始化监听器ApplicationInitListener扩展对象
+ExtensionLoader<ApplicationInitListener> extensionLoader = this.getExtensionLoader(ApplicationInitListener.class);
+Set<String> listenerNames = extensionLoader.getSupportedExtensions();
+
+//ScopeModel中创建扩展访问器:
+this.extensionDirector = new ExtensionDirector(parent != null ? parent.getExtensionDirector() : null, scope, this);
+
+```
+
+有了以上的应用场景我们可以来看下扩展机制了
+
+## 4.2 为什么要用到扩展机制?
+为什么要用到扩展这个想必每个编程人员都比较了解,一个好的程序是要遵循一定的设计规范比如设计模式中的**开闭原则** 英文全称是 Open Closed Principle,简写为 OCP,对扩展开放、对修改关闭:
+
+**对扩展开放:** 指的是我们系统中的模块、类、方法对它们的提供者(开发者)应该是开放的,提供者可以对系统进行扩展(新增)新的功能。
+
+**对修改关闭:** 指的是系统中的模块、类、方法对它们的使用者(调用者)应该是关闭的。使用者使用这些功能时,不会因为提供方新增了功能而导致使用者也进行相应修改。
+
+我们再来了解下Dubbo的一些基本特性:
+下面这句话是我摘自官网的:
+*Apache Dubbo 是一款微服务开发框架,它提供了 **RPC通信** 与 **微服务治理** 两大关键能力。这意味着,使用 Dubbo 开发的微服务,将具备相互之间的远程发现与通信能力, 同时利用 Dubbo 提供的丰富服务治理能力,可以实现诸如服务发现、负载均衡、流量调度等服务治理诉求。同时 Dubbo 是高度可扩展的,用户几乎可以在**任意功能点去定制自己的实现**,以改变框架的默认行为来满足自己的业务需求。
+Dubbo3 基于 Dubbo2 演进而来,在保持原有核心功能特性的同时, Dubbo3 在易用性、超大规模微服务实践、云原生基础设施适配、安全设计等几大方向上进行了全面升级。 以下文档都将基于 Dubbo3 展开。*
+
+**对修改关闭的地方:** 对于Apache Dubbo来说 不变的是RPC调用流程,微服务治理这些抽象的概念,我们可以用摘自官网的下面几个图表示:
+
+<center>图4.1 Dubbo架构图</center>
+
+再来看一个调用链路的架构图
+
+
+<center>图4.2 Dubbo RPC调用链路</center>
+
+<br/>
+上面两个图整体来看都是Dubbo不变的地方涉及到服务的RPC调用和服务治理的一些概念与流程,但是对于每个环节又可以使用各种方式实现,比如序列化机制可以是Json,Java序列化,Hession2或者Protobuf等等,网络传输层可以是netty实现的tcp通信,也可以使用http协议,那Dubbo又是如何封装不变部分扩展这种可变部分呢?,那就是接下来要说的**微内核机制**,这个我们待会说
+
+**对扩展开放:** : 对于Apache Dubbo来说 变化的是RPC调用流程和微服务治理这些抽象的概念的具体实现,每个点应该用什么技术实现,又是用什么场景,这个可以用如下图来表示下:
+
+<center>图4.3 Dubbo的扩展生态</center>
+
+</br>
+
+看到这里 应该各位就明白了,我们写程序是为了业务,而针对不同的业务需求很多场景下我们是需要使用不同的实现来满足的,Dubbo使用微内核的架构,将具体的实现开放出来,让使用者可以根据自己的需求来选择,定制. Dubbo开放了很多的扩展点供大家扩展,可想而知使用Dubbo的灵活性是非常高的。
+
+**微内核架构:**
+微内核架构由两大架构模块组成:**核心系统**与**插件模块**,设计一个微内核体系关键工作全部集中于核心系统怎么构建。
+**核心系统** : 负责和具体业务功能无关的通用功能,例如模块加载、模块间通信等,这个其实对应着Dubbo的SPI机制。
+**插件模块** : 负责实现具体的业务逻辑,Dubbo,SPI接口与实现。
+
+
+
+## 4.3 Dubbo的扩展机制包含了哪些重要的组成部分?
+前面我们说了为什么要使用扩展机制,这里我们来看下具体实现
+
+先将扩展包里面的代码截个图认识认识各类型的单词
+
+
+顺便我们先简单看下类结构图,后续再详细看每个类型的解释:
+
+
+为了后续看具体的扩展加载流程我们先看下以上类型的解释说明:
+
+ - **ExtensionAccessor**
+ - 扩展的统一访问器
+ - **ExtensionDirector**
+ - ExtensionDirector是一个作用域扩展加载程序管理器。
+ - ExtensionDirector支持多个级别,子级可以继承父级的扩展实例。
+查找和创建扩展实例的方法类似于Java classloader。
+- **ExtensionScope**
+ - 扩展SPI域,目前有FRAMEWORK,APPLICATION,MODULE,SELF
+ - **FRAMEWORK** : 扩展实例在框架内使用,与所有应用程序和模块共享。
+框架范围SPI扩展只能获取FrameworkModel,无法获取ApplicationModel和ModuleModel。
+考虑:
+一些SPI需要在框架内的应用程序之间共享数据
+无状态SPI在框架内是安全共享的
+ - **APPLICATION** 扩展实例在一个应用程序中使用,与应用程序的所有模块共享,不同的应用程序创建不同的扩展实例。
+应用范围SPI扩展可以获取FrameworkModel和ApplicationModel,无法获取ModuleModel。
+考虑:
+在框架内隔离不同应用程序中的扩展数据
+在应用程序内部的所有模块之间共享扩展数据
+ - **MODULE** 扩展实例在一个模块中使用,不同的模块创建不同的扩展实例。
+模块范围SPI扩展可以获得FrameworkModel、ApplicationModel和ModuleModel。
+考虑:
+隔离应用程序内部不同模块中的扩展数据
+ - **SELF** 自给自足,为每个作用域创建一个实例,用于特殊的SPI扩展,如ExtensionInjector
+
+- **ExtensionLoader**
+ - ApplicationModel、DubboBootstrap和这个类目前被设计为单例或静态(本身完全静态或使用一些静态字段)。因此,从它们返回的实例属于process或classloader范围。如果想在一个进程中支持多个dubbo服务器,可能需要重构这三个类。
+ - 加载dubbo扩展
+ - 自动注入依赖项扩展
+ - 包装器中的自动包装扩展
+ - 默认扩展是一个自适应实例
+ - JDK自带SPI参考地址 [点击查看](https://docs.oracle.com/javase/1.5.0/docs/guide/jar/jar.html#Service%20Provider)
+ - @SPI 服务扩展接口 详细内容看后面
+ - @Adaptive自适应扩展点注解 详细内容看后面
+ - @Activate自动激活扩展点注解 详细内容看后面
+
+- **ExtensionPostProcessor**
+ - 在扩展初始化之前或之后调用的后处理器。
+- **LoadingStrategy**
+ - 扩展加载策略,目前有3个扩展加载策略分别从不同文件目录加载扩展
+- **DubboInternalLoadingStrategy**
+ - Dubbo内置的扩展加载策略,将加载文件目录为META-INF/dubbo/internal/的扩展
+- **DubboLoadingStrategy**
+ - Dubbo普通的扩展加载策略,将加载目录为META-INF/dubbo/的扩展
+- **ServicesLoadingStrategy**
+ - JAVA SPI加载策略 ,将加载目录为META-INF/services/的扩展
+- **Wrapper**注解
+- SPI注解
+- **ExtensionInjector**接口
+ - 为SPI扩展提供资源的注入器。
+- **ExtensionAccessorAware**
+ - SPI扩展可以实现这个感知接口,以获得适当的xtensionAccessor实例。
+- DisableInject注解
+- **AdaptiveClassCodeGenerator**
+ - 自适应类的代码生成器
+- **Adaptive**注解
+ - 为ExtensionLoader注入依赖扩展实例提供有用信息。
+ - **Activate**注解
+ - Activate。此注解对于使用给定条件自动激活某些扩展非常有用,例如:@Activate可用于在有多个实现时加载某些筛选器扩展。
+**group()**指定组条件。框架SPI定义了有效的组值。
+**value()**指定URL条件中的参数键。
+SPI提供程序可以调用ExtensionLoader。getActivateExtension(URL、String、String)方法以查找具有给定条件的所有已激活扩展。
+- **ActivateComparator**
+ - Activate扩展的排序器
+- **MultiInstanceActivateComparator**
+- **WrapperComparator**
+- **AdaptiveExtensionInjector**
+- **SpiExtensionInjector**
+
+
+
+## 4.4 扩展加载创建之前的调用过程
+### 4.4.1 扩展的调用代码示例
+了解了这么多与扩展相关的概念,接下来我们就来从前面的代码调用中找几个例子来看下扩展的调用过程:
+
+代码来源于FrameworkModel对象的初始化initialize()中的如下代码调用:
+
+```java
+ TypeDefinitionBuilder.initBuilders(this);
+```
+
+
+TypeDefinitionBuilder中初始化类型构建器代码如下:
+```java
+ public static void initBuilders(FrameworkModel model) {
+ Set<TypeBuilder> tbs = model.getExtensionLoader(TypeBuilder.class).getSupportedExtensionInstances();
+ BUILDERS = new ArrayList<>(tbs);
+ }
+```
+### 4.4.2 Dubbo的分层模型获取扩展加载器对象
+以上扩展调用的时候对于扩展加载器对象的获取代码如下所示,我们来看下它的调用链路
+```java
+model.getExtensionLoader(TypeBuilder.class)
+```
+
+getExtensionLoader方法来源于FrameworkModel类型的父类型ScopeModel的实现的接口ExtensionAccessor中的默认方法(JDK8 默认方法)
+
+ExtensionAccessor接口中的getExtensionLoader方法如下代码:
+
+```java
+default <T> ExtensionLoader<T> getExtensionLoader(Class<T> type) {
+ return this.getExtensionDirector().getExtensionLoader(type);
+ }
+```
+
+获取扩展加载器之前需要先获取扩展访问器:
+这里的链路先梳理下:
+
+**模型对象(FrameworkModel)-**--> **扩展访问器(ExtensionAccessor)** ---> **作用域扩展加载程序管理器(ExtensionDirector)** --->
+
+这个getExtensionDirector()方法来源于FrameworkModel的抽象父类型ScopeModel中的getExtensionDirector()如下代码:
+
+```java
+@Override
+ public ExtensionDirector getExtensionDirector() {
+ return extensionDirector;
+ }
+```
+
+这里直接返回了extensionDirector,,不知道介绍到这里记得这个扩展加载程序管理器extensionDirector对象的由来不, 在上个章节[《3-框架,应用程序,模块领域模型Model对象的初始化》](https://blog.elastic.link/2022/07/10/dubbo/3-kuang-jia-ying-yong-cheng-xu-mo-kuai-ling-yu-mo-xing-model-dui-xiang-de-chu-shi-hua/)中3.2.2 初始化ScopeModel的章节中的ScopeModel类型的初始化方法initialize()方法中我们提到过这个对象的创建,具体代码如下所示(这个代码比较简单):
+```java
+this.extensionDirector = new ExtensionDirector(parent != null ? parent.getExtensionDirector() : null, scope, this);
+
+```
+
+我们继续前面getExtensionLoader(type)方法调用逻辑,前面我们知道了这个扩展访问器的对象是ExtensionDirector,接下来我们看下ExtensionDirector中获取扩展加载器的代码(如下所示):
+在详细介绍扩展加载器对象获取之前我们先来看下当前我们要加载的扩展类型的源码,后续会用到:
+我们要加载的扩展类型TypeBuilder接口
+```java
+@SPI(scope = ExtensionScope.FRAMEWORK)
+public interface TypeBuilder extends Prioritized {
+
+ /**
+ * Whether the build accept the class passed in.
+ */
+ boolean accept(Class<?> clazz);
+
+ /**
+ * Build type definition with the type or class.
+ */
+ TypeDefinition build(Type type, Class<?> clazz, Map<String, TypeDefinition> typeCache);
+
+}
+```
+
+
+ExtensionDirector类型中获取扩展加载器的代码
+这个代码非常有意思 **其实就是前面说到的域模型架构的数据访问架构**类似于JVM类加载器访问加载类的情况,但是这个顺序可能有所不同,Dubbo的扩展加载器是如何访问的呢? 遵循以下顺序:
+- 先从**缓存中**查询扩展加载器
+- 如果前面没找到则查询扩展类型的scope所属域,如果是**当前域扩展**则从直接创建扩展加载器
+- 如果前面没找到就从**父扩展访问器**中查询,查询这个扩展是否数据父扩展域
+- 前面都没找到就尝试创建
+
+```java
+@Override
+ public <T> ExtensionLoader<T> getExtensionLoader(Class<T> type) {
+ //如果扩展加载器已经被销毁则抛出异常
+ checkDestroyed();
+ //这里参数类型传的是TypeBuilder.class不为空
+ if (type == null) {
+ throw new IllegalArgumentException("Extension type == null");
+ }
+ //扩展类型不为接口也要抛出异常,这个TypeBuilder.class具体类型代码往上看,这个类型是一个接口
+ if (!type.isInterface()) {
+ throw new IllegalArgumentException("Extension type (" + type + ") is not an interface!");
+ }
+ //这个判断逻辑是判断这个扩展接口是有有@SPI注解,TypeBuilder是有的
+ if (!withExtensionAnnotation(type)) {
+ throw new IllegalArgumentException("Extension type (" + type +
+ ") is not an extension, because it is NOT annotated with @" + SPI.class.getSimpleName() + "!");
+ }
+
+ // 1. find in local cache
+ //被加载的扩展类型对应的扩展加载器会放到extensionLoadersMap这个ConcurrentHashMap类型的集合中方便缓存
+ ExtensionLoader<T> loader = (ExtensionLoader<T>) extensionLoadersMap.get(type);
+ //查询扩展所属域,这个类型的扩展域是框架级别的ExtensionScope.FRAMEWORK
+ //extensionScopeMap为ConcurrentHashMap类型的扩展域缓存集合
+ ExtensionScope scope = extensionScopeMap.get(type);
+ if (scope == null) {
+ SPI annotation = type.getAnnotation(SPI.class);
+ scope = annotation.scope();
+ extensionScopeMap.put(type, scope);
+ }
+ //首次访问的时候当前类型的扩展加载器类型肯定是空的,会走如下两个逻辑中的其中一个进行创建扩展加载器
+ //1)如果 扩展域为SELF 自给自足,为每个作用域创建一个实例,用于特殊的SPI扩展,如{@link ExtensionInjector}
+ if (loader == null && scope == ExtensionScope.SELF) {
+ // create an instance in self scope
+ loader = createExtensionLoader0(type);
+ }
+
+ // 2. find in parent
+ //3) 从父扩展加载器中查询当前扩展加载器是否存在,这里parent是空的先不考虑
+ if (loader == null) {
+ if (this.parent != null) {
+ loader = this.parent.getExtensionLoader(type);
+ }
+ }
+
+ // 3. create it
+ //4) 这个是我们本次会走的逻辑,大部分是会走这个逻辑来创建扩展加载器对象的
+ if (loader == null) {
+ loader = createExtensionLoader(type);
+ }
+
+ return loader;
+ }
+```
+
+
+
+前面提到的withExtensionAnnotation判断代码如下:
+```java
+private static boolean withExtensionAnnotation(Class<?> type) {
+ return type.isAnnotationPresent(SPI.class);
+ }
+```
+
+
+ExtensionDirector类型的createExtensionLoader方法
+
+```java
+private <T> ExtensionLoader<T> createExtensionLoader(Class<T> type) {
+ ExtensionLoader<T> loader = null;
+ //当前类型注解的scope与当前扩展访问器ExtensionDirector的scope是否一致,不一致则抛出异常
+ //当前类型ExtensionDirector的scope是在构造器中传递的,在Model对象初始化的时候创建的本类型
+ if (isScopeMatched(type)) {
+ // if scope is matched, just create it
+ loader = createExtensionLoader0(type);
+ } else {
+ // if scope is not matched, ignore it
+ }
+ return loader;
+ }
+```
+
+ExtensionDirector类型的createExtensionLoader0方法
+```java
+ private <T> ExtensionLoader<T> createExtensionLoader0(Class<T> type) {
+ //检查当前扩展访问器是否被销毁掉了
+ checkDestroyed();
+ ExtensionLoader<T> loader;
+ //为当前扩展类型创建一个扩展访问器并缓存到,当前成员变量extensionLoadersMap中
+ extensionLoadersMap.putIfAbsent(type, new ExtensionLoader<T>(type, this, scopeModel));
+ loader = (ExtensionLoader<T>) extensionLoadersMap.get(type);
+ return loader;
+ }
+```
+### 4.4.3 扩展加载器对象ExtensionLoader的构造器
+扩展加载器相对来说是比较复杂的实现内容比较多,用到哪里我们说下哪里,这里先来看ExtensionLoader的构造器代码如下所示:
+
+```java
+ ExtensionLoader(Class<?> type, ExtensionDirector extensionDirector, ScopeModel scopeModel) {
+ //当前扩展加载器,需要加载的扩展的类型
+ this.type = type;
+ //创建扩展加载器的扩展访问器对象
+ this.extensionDirector = extensionDirector;
+ //从扩展访问器中获取扩展执行前后的回调器
+ this.extensionPostProcessors = extensionDirector.getExtensionPostProcessors();
+ //创建实例化对象的策略对象
+ initInstantiationStrategy();
+ //如果当前扩展类型为扩展注入器类型则设置当前注入器变量为空,否则的话获取一个扩展注入器扩展对象
+ this.injector = (type == ExtensionInjector.class ? null : extensionDirector.getExtensionLoader(ExtensionInjector.class)
+ .getAdaptiveExtension());
+ //创建Activate注解的排序器
+ this.activateComparator = new ActivateComparator(extensionDirector);
+ //为扩展加载器下的域模型对象赋值
+ this.scopeModel = scopeModel;
+ }
+```
+
+
+先来看 创建实例化对象的策略对象代码 initInstantiationStrategy();
+
+```java
+private void initInstantiationStrategy() {
+ for (ExtensionPostProcessor extensionPostProcessor : extensionPostProcessors) {
+ //ScopeModelAwareExtensionProcessor在域模型对象时候为扩展访问器添加了这个域模型扩展处理器对象ScopeModelAwareExtensionProcessor,这个类型实现了ScopeModelAccessor域模型访问器可以用来获取域模型对象
+ if (extensionPostProcessor instanceof ScopeModelAccessor) {
+
+ instantiationStrategy = new InstantiationStrategy((ScopeModelAccessor) extensionPostProcessor);
+ break;
+ }
+ }
+ if (instantiationStrategy == null) {
+ instantiationStrategy = new InstantiationStrategy();
+ }
+ }
+```
+
+再来看ExtensionInjector扩展对象的获取
+
+```java
+//1)这里有个type为空的判断,普通的扩展类型肯定不是ExtensionInjector类型 这里必定会为每个非扩展注入ExtensionInjector类型创建一个ExtensionInjector类型的扩展对象,
+//2) 这里代码会走extensionDirector.getExtensionLoader(ExtensionInjector.class)这一步进去之后的代码刚刚看过就不再看了,这个代码会创建一个为ExtensionInjector扩展对象的加载器对象ExtensionLoader
+//3) getAdaptiveExtension() 这个方法就是通过扩展加载器获取具体的扩展对象的方法我们会详细说
+ this.injector = (type == ExtensionInjector.class ? null : extensionDirector.getExtensionLoader(ExtensionInjector.class)
+ .getAdaptiveExtension());
+```
+
+
+
+原文: [<<Dubbo的扩展机制>>](https://blog.elastic.link/2022/07/10/dubbo/4-dubbo-de-spi-kuo-zhan-ji-zhi-yu-extensionloader-dui-xiang-de-chuang-jian-yuan-ma-jie-xi/ )
\ No newline at end of file
diff --git "a/content/zh/blog/java/codeanalysis/3.0.8/5 \350\207\252\351\200\202\345\272\224\346\211\251\345\261\225\345\257\271\350\261\241\347\232\204\345\210\233\345\273\272getAdaptiveExtension\346\226\271\346\263\225.md" "b/content/zh/blog/java/codeanalysis/3.0.8/5 \350\207\252\351\200\202\345\272\224\346\211\251\345\261\225\345\257\271\350\261\241\347\232\204\345\210\233\345\273\272getAdaptiveExtension\346\226\271\346\263\225.md"
new file mode 100644
index 0000000000..93c2b904c6
--- /dev/null
+++ "b/content/zh/blog/java/codeanalysis/3.0.8/5 \350\207\252\351\200\202\345\272\224\346\211\251\345\261\225\345\257\271\350\261\241\347\232\204\345\210\233\345\273\272getAdaptiveExtension\346\226\271\346\263\225.md"
@@ -0,0 +1,812 @@
+---
+title: "05-自适应扩展对象的创建getAdaptiveExtension方法"
+linkTitle: "5-自适应扩展对象的创建getAdaptiveExtension方法"
+date: 2022-08-05
+author: 宋小生
+description: >
+ [Dubbo 3.0.8源码解析] Dubbo是一个微内核框架,所有的实现都是通过扩展机制来实现的,了解扩展加载机制可以有效的逻辑代码的抽象与具体逻辑
+---
+
+
+## 5 自适应扩展对象的创建getAdaptiveExtension方法
+自适应扩展又称为动态扩展,可以在运行时生成扩展对象
+
+ExtensionLoader中的getAdaptiveExtension()方法,这个方法也是我们看到的第一个获取扩展对象的方法. ,这个方法可以帮助我们通过SPI机制从扩展文件中找到需要的扩展类型并创建它的对象,
+**自适应扩展:**如果对设计模式比较了解的可能会联想到**适配器模式**,自适应扩展其实就是适配器模式的思路,自适应扩展有两种策略:
+
+- 一种是我们自己实现自适应扩展:然后使用@Adaptive修饰这个时候适配器的逻辑由我们自己实现,当扩展加载器去查找具体的扩展的时候可以通过找到我们这个对应的适配器扩展,然后适配器扩展帮忙去查询真正的扩展,这个比如我们下面要举的扩展注入器的例子,具体扩展通过扩展注入器适配器,注入器适配器来查询具体的注入器扩展实现来帮忙查找扩展。
+
+- 还有一种方式是我们未实现这个自适应扩展,Dubbo在运行时通过字节码动态代理的方式在运行时生成一个适配器,使用这个适配器映射到具体的扩展. 第二种情况往往用在比如 Protocol、Cluster、LoadBalance 等。有时,有些拓展并不想在框架启动阶段被加载,而是希望在拓展方法被调用时,根据运行时参数进行加载。(如果还不了解可以考虑看下@Adaptive注解加载方法上面的时候扩展是如何加载的)
+
+```java
+ public T getAdaptiveExtension() {
+ //检查当前扩展加载器是否已经被销毁
+ checkDestroyed();
+ //从自适应扩展缓存中查询扩展对象如果存在就直接返回,这个自适应扩展类型只会有一个扩展实现类型如果是多个的话根据是否可以覆盖参数决定扩展实现类是否可以相互覆盖
+ Object instance = cachedAdaptiveInstance.get();
+ //这个if判断不太优雅 容易多层嵌套,上面instance不为空就可以直接返回了
+ if (instance == null) {
+ //创建异常则抛出异常直接返回(多线程场景下可能第一个线程异常了第二个线程进来之后走到这里)
+ if (createAdaptiveInstanceError != null) {
+ throw new IllegalStateException("Failed to create adaptive instance: " +
+ createAdaptiveInstanceError.toString(),
+ createAdaptiveInstanceError);
+ }
+ //加锁排队 (单例模式创建对象的思想 双重校验锁)
+ synchronized (cachedAdaptiveInstance) {
+ //加锁的时候对象都是空的,进来之后先判断下防止重复创建
+ instance = cachedAdaptiveInstance.get();
+ //只有第一个进来锁的对象为空开始创建扩展对象
+ if (instance == null) {
+ try {
+ //根据SPI机制获取类型,创建对象
+ instance = createAdaptiveExtension();
+ //存入缓存
+ cachedAdaptiveInstance.set(instance);
+ } catch (Throwable t) {
+ createAdaptiveInstanceError = t;
+ throw new IllegalStateException("Failed to create adaptive instance: " + t.toString(), t);
+ }
+ }
+ }
+ }
+
+ return (T) instance;
+ }
+```
+
+前面使用单例思想来调用创建自适应扩展对象的方法,下面就让我们深入探究下创建自适应扩展对象的整个过程createAdaptiveExtension();方法:
+
+
+## 5.1 创建扩展对象的生命周期方法-注意这个后续会详细解析这个声明周期方法的细节
+
+createAdaptiveExtension()
+我们先来看ExtensionLoader类型中的createAdaptiveExtension();方法,这个方法包含了扩展对象创建初始化的整个生命周期,如下代码所示:
+
+```java
+private T createAdaptiveExtension() {
+ try {
+ //获取扩展类型实现类, 创建扩展对象
+ T instance = (T) getAdaptiveExtensionClass().newInstance();
+ //注入扩展对象之前的回调方法
+ instance = postProcessBeforeInitialization(instance, null);
+ //注入扩展对象
+ instance = injectExtension(instance);
+ //注入扩展对象之后的回调方法
+ instance = postProcessAfterInitialization(instance, null);
+ //初始化扩展对象的属性,如果当前扩展实例的类型实现了Lifecycle则调用当前扩展对象的生命周期回调方法initialize()(来自Lifecycle接口)
+ //参考样例第一个instance为ExtensionInjector的自适应扩展对象类型为AdaptiveExtensionInjector,自适应扩展注入器(适配器)用来查询具体支持的扩展注入器比如scope,spi,spring注入器
+ initExtension(instance);
+ return instance;
+ } catch (Exception e) {
+ throw new IllegalStateException("Can't create adaptive extension " + type + ", cause: " + e.getMessage(), e);
+ }
+ }
+```
+
+## 5.2 SPI机制获取扩展对象实现类型getAdaptiveExtensionClass()
+这个方法可以帮助我们了解具体的Dubbo SPI机制 如果找到扩展类型的实现类,会寻找哪些文件,扩展文件的优先级又是什么,对我们自己写扩展方法很有帮助,接下来我们就来看下它的源码:
+
+```java
+ private Class<?> getAdaptiveExtensionClass() {
+ //获取扩展类型,将扩展类型存入成员变量cachedClasses中进行缓存
+ getExtensionClasses();
+ //在上个方法的详细解析中的最后一步loadClass方法中如果扩展类型存在Adaptive注解将会将扩展类型赋值给cachedAdaptiveClass,否则的话会把扩展类型都缓存起来存储在扩展集合extensionClasses中
+ if (cachedAdaptiveClass != null) {
+ return cachedAdaptiveClass;
+ }
+ //扩展实现类型没有一个这个自适应注解Adaptive时候会走到这里
+ //刚刚我们扫描到了扩展类型然后将其存入cachedClasses集合中了 接下来我们看下如何创建扩展类型
+ return cachedAdaptiveClass = createAdaptiveExtensionClass();
+ }
+```
+
+继续看获取扩展类型的方法**getExtensionClasses()**:
+
+```java
+ private Map<String, Class<?>> getExtensionClasses() {
+ //缓存中查询扩展类型是否存在
+ Map<String, Class<?>> classes = cachedClasses.get();
+ if (classes == null) {
+ //单例模式双重校验锁判断
+ synchronized (cachedClasses) {
+ classes = cachedClasses.get();
+ if (classes == null) {
+ //加载扩展类型
+ classes = loadExtensionClasses();
+ //将我们扫描到的扩展类型存入成员变量cachedClasses中
+ cachedClasses.set(classes);
+ }
+ }
+ }
+ return classes;
+ }
+```
+
+### 5.2.1 使用不同的的策略加载加载不同目录下的扩展
+加载扩展类型的方法**loadExtensionClasses()**
+
+```cpp
+ private Map<String, Class<?>> loadExtensionClasses() {
+ //检查扩展加载器是否被销毁
+ checkDestroyed();
+ //缓存默认的扩展名到成员变量cachedDefaultName中
+ cacheDefaultExtensionName();
+ //加载到的扩展集合
+ Map<String, Class<?>> extensionClasses = new HashMap<>();
+ //扩展策略,在4.3章节中我们介绍了这个类型的UML与说明
+ //LoadingStrategy扩展加载策略,目前有3个扩展加载策略
+ //DubboInternalLoadingStrategy:Dubbo内置的扩展加载策略,将加载文件目录为META-INF/dubbo/internal/的扩展
+ //DubboLoadingStrategy:Dubbo普通的扩展加载策略,将加载目录为META-INF/dubbo/的扩展
+ //ServicesLoadingStrategy:JAVA SPI加载策略 ,将加载目录为META-INF/services/的扩展
+ //扩展策略集合对象在什么时候初始化的呢在成员变量初始化的时候就创建了集合对象,这个可以看方法loadLoadingStrategies() 通过Java的 SPI加载策略
+ for (LoadingStrategy strategy : strategies) {
+ //根据策略从指定文件目录中加载扩展类型
+ loadDirectory(extensionClasses, strategy, type.getName());
+
+ // compatible with old ExtensionFactory
+ //如果当前要加载的扩展类型是扩展注入类型则扫描下ExtensionFactory类型的扩展
+ if (this.type == ExtensionInjector.class) {
+ //这个方法和上面那个方法是一样的就不详细说了 扫描文件 找到扩展类型
+ loadDirectory(extensionClasses, strategy, ExtensionFactory.class.getName());
+ }
+ }
+ //通过loadDirectory扫描 扫描到了ExtensionInjector类型的扩展实现类有3个 我们将会得到这样一个集合例子:
+ //"spring" -> "class org.apache.dubbo.config.spring.extension.SpringExtensionInjector"
+ //"scopeBean" -> "class org.apache.dubbo.common.beans.ScopeBeanExtensionInjector"
+ //"spi" -> "class org.apache.dubbo.common.extension.inject.SpiExtensionInjector"
+ return extensionClasses;
+ }
+```
+
+
+ 从文件中加载扩展实现loadDirectory方法:
+
+```java
+ private void loadDirectory(Map<String, Class<?>> extensionClasses, LoadingStrategy strategy, String type) {
+ //加载并根据策略的参数来加载
+ loadDirectory(extensionClasses, strategy.directory(), type, strategy.preferExtensionClassLoader(),
+ strategy.overridden(), strategy.includedPackages(), strategy.excludedPackages(), strategy.onlyExtensionClassLoaderPackages());
+ //下面两行就是要兼容alibaba的扩展包了
+ String oldType = type.replace("org.apache", "com.alibaba");
+ loadDirectory(extensionClasses, strategy.directory(), oldType, strategy.preferExtensionClassLoader(),
+ strategy.overridden(), strategy.includedPackagesInCompatibleType(), strategy.excludedPackages(), strategy.onlyExtensionClassLoaderPackages());
+ }
+```
+
+带扩展策略参数的loadDirectory方法
+
+关于扩展策略的参数列表我这里列个表格方便大家来看
+
+|扩展类型|dir(目录) | extensionLoaderClassLoaderFirst(优先扩展类型的类加载器)|overridden(是否允许覆盖同名扩展)|includedPackages (明确包含的扩展包) | excludedPackages (明确排除的扩展包)|onlyExtensionClassLoaderPackages(限制应该从Dubbo的类加载器加载的类)|
+|--|--|--|--|--|--|--|
+| DubboInternalLoadingStrategy | META-INF/dubbo/internal/ |false|false|null|null|[]|
+|DubboLoadingStrategy|META-INF/dubbo/|false|true|null|null|[]|
+|ServicesLoadingStrategy|META-INF/services/|false|true|null|null|[]|
+
+
+```java
+ /**
+ * 不同的扩展策略传递了不同的参数,但是扩展的加载流程是相同的,这里我们可以参考上面表格
+ * @param extensionClasses
+ * @param dir
+ * @param type 这里我们参考的示例这个值为org.apache.dubbo.common.extension.ExtensionInjector
+ * @param extensionLoaderClassLoaderFirst
+ * @param overridden false
+ * @param includedPackages
+ * @param excludedPackages
+ * @param onlyExtensionClassLoaderPackages
+ */
+private void loadDirectory(Map<String, Class<?>> extensionClasses, String dir, String type,
+ boolean extensionLoaderClassLoaderFirst, boolean overridden, String[] includedPackages,
+ String[] excludedPackages, String[] onlyExtensionClassLoaderPackages) {
+ //扩展目录 + 扩展类型全路径 比如: META-INF/dubbo/internal/org.apache.dubbo.common.extension.ExtensionInjector
+ String fileName = dir + type;
+ try {
+ List<ClassLoader> classLoadersToLoad = new LinkedList<>();
+
+ // try to load from ExtensionLoader's ClassLoader first
+ //是否优先使用扩展加载器的 类加载器
+ if (extensionLoaderClassLoaderFirst) {
+ ClassLoader extensionLoaderClassLoader = ExtensionLoader.class.getClassLoader();
+ if (ClassLoader.getSystemClassLoader() != extensionLoaderClassLoader) {
+ classLoadersToLoad.add(extensionLoaderClassLoader);
+ }
+ }
+
+ // load from scope model
+ //获取域模型对象的类型加载器 ,这个域模型对象在初始化的时候会将自己的类加载器放入集合中可以参考《3.2.2 初始化ScopeModel》章节
+ Set<ClassLoader> classLoaders = scopeModel.getClassLoaders();
+
+ //没有可用的类加载器则从使用
+ if (CollectionUtils.isEmpty(classLoaders)) {
+ //从用于加载类的搜索路径中查找指定名称的所有资源。
+ Enumeration<java.net.URL> resources = ClassLoader.getSystemResources(fileName);
+ if (resources != null) {
+ while (resources.hasMoreElements()) {
+ loadResource(extensionClasses, null, resources.nextElement(), overridden, includedPackages, excludedPackages, onlyExtensionClassLoaderPackages);
+ }
+ }
+ } else {
+ classLoadersToLoad.addAll(classLoaders);
+ }
+ //使用类加载资源加载器(ClassLoaderResourceLoader)来加载具体的资源
+ Map<ClassLoader, Set<java.net.URL>> resources = ClassLoaderResourceLoader.loadResources(fileName, classLoadersToLoad);
+ //遍历从所有资源文件中读取到资源url地址,key为类加载器,值为扩展文件url如夏所示
+ //jar:file:/Users/song/.m2/repository/org/apache/dubbo/dubbo/3.0.7/dubbo-3.0.7.jar!/META-INF/dubbo/internal/org.apache.dubbo.common.extension.ExtensionInjector
+ resources.forEach(((classLoader, urls) -> {
+ //从文件中加载完资源之后开始根据类加载器和url加载具体的扩展类型,最后将扩展存放进extensionClasses集合
+ loadFromClass(extensionClasses, overridden, urls, classLoader, includedPackages, excludedPackages, onlyExtensionClassLoaderPackages);
+ }));
+ } catch (Throwable t) {
+ logger.error("Exception occurred when loading extension class (interface: " +
+ type + ", description file: " + fileName + ").", t);
+ }
+ }
+```
+
+### 5.2.2 借助类加载器的getResources方法遍历所有文件进行扩展文件的查询
+
+查找扩展类型对应的扩展文件的url方法:ClassLoaderResourceLoader类型的loadResources源码:
+
+```cpp
+public static Map<ClassLoader, Set<URL>> loadResources(String fileName, List<ClassLoader> classLoaders) {
+ //
+ Map<ClassLoader, Set<URL>> resources = new ConcurrentHashMap<>();
+ //不同的类加载器之间使用不同的线程异步的方式进行扫描
+ CountDownLatch countDownLatch = new CountDownLatch(classLoaders.size());
+ for (ClassLoader classLoader : classLoaders) {
+ //多线程扫描,这个是个newCachedThreadPool的类型的线程池
+ GlobalResourcesRepository.getGlobalExecutorService().submit(() -> {
+ //
+ resources.put(classLoader, loadResources(fileName, classLoader));
+ countDownLatch.countDown();
+ });
+ }
+ try {
+ countDownLatch.await();
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ return Collections.unmodifiableMap(new LinkedHashMap<>(resources));
+ }
+```
+
+
+加载具体类加载器中的资源文件的loadResources方法
+```cpp
+public static Set<URL> loadResources(String fileName, ClassLoader currentClassLoader) {
+ Map<ClassLoader, Map<String, Set<URL>>> classLoaderCache;
+ //第一次进来类加载器资源缓存是空的
+ if (classLoaderResourcesCache == null || (classLoaderCache = classLoaderResourcesCache.get()) == null) {
+ //类对象锁
+ synchronized (ClassLoaderResourceLoader.class) {
+ if (classLoaderResourcesCache == null || (classLoaderCache = classLoaderResourcesCache.get()) == null) {
+ classLoaderCache = new ConcurrentHashMap<>();
+ //创建一个类资源映射url的软引用缓存对象
+ //软引用(soft references),用于帮助垃圾收集器管理内存使用和消除潜在的内存泄漏。当内存快要不足的时候,GC会迅速的把所有的软引用清除掉,释放内存空间
+ classLoaderResourcesCache = new SoftReference<>(classLoaderCache);
+ }
+ }
+ }
+ //第一次进来时候类加载器url映射缓存是空的,给类加载器缓存对象新增一个值,key是类加载器,值是map类型用来存储文件名对应的url集合
+ if (!classLoaderCache.containsKey(currentClassLoader)) {
+ classLoaderCache.putIfAbsent(currentClassLoader, new ConcurrentHashMap<>());
+ }
+
+ Map<String, Set<URL>> urlCache = classLoaderCache.get(currentClassLoader);
+ //缓存中没有就从文件里面找
+ if (!urlCache.containsKey(fileName)) {
+ Set<URL> set = new LinkedHashSet<>();
+ Enumeration<URL> urls;
+ try {
+ //getResources这个方法是这样的:加载当前类加载器以及父类加载器所在路径的资源文件,将遇到的所有资源文件全部返回!这个可以理解为使用双亲委派模型中的类加载器 加载各个位置的资源文件
+ urls = currentClassLoader.getResources(fileName);
+ //native配置 是否为本地镜像(k可以参考官方文档:https://dubbo.apache.org/zh/docs/references/graalvm/support-graalvm/
+ boolean isNative = NativeUtils.isNative();
+ if (urls != null) {
+ //遍历找到的对应扩展的文件url将其加入集合
+ while (urls.hasMoreElements()) {
+ URL url = urls.nextElement();
+ if (isNative) {
+ //In native mode, the address of each URL is the same instead of different paths, so it is necessary to set the ref to make it different
+ //动态修改jdk底层url对象的ref变量为可访问,让我们在用反射时访问私有变量
+ setRef(url);
+ }
+ set.add(url);
+ }
+ }
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ //存入缓存
+ urlCache.put(fileName, set);
+ }
+ //返回结果
+ return urlCache.get(fileName);
+ }
+```
+
+
+### 5.2.3 使用找到的扩展资源url加载具体扩展类型到内存
+
+ExtensionLoader类型中的loadFromClass方法 遍历url 开始加载扩展类型
+```java
+ private void loadFromClass(Map<String, Class<?>> extensionClasses, boolean overridden, Set<java.net.URL> urls, ClassLoader classLoader,
+ String[] includedPackages, String[] excludedPackages, String[] onlyExtensionClassLoaderPackages) {
+ if (CollectionUtils.isNotEmpty(urls)) {
+ for (java.net.URL url : urls) {
+ loadResource(extensionClasses, classLoader, url, overridden, includedPackages, excludedPackages, onlyExtensionClassLoaderPackages);
+ }
+ }
+ }
+```
+
+ExtensionLoader类型中的loadResource方法 使用IO流读取扩展文件的内容
+读取内容之前我这里先贴一下我们参考的扩展注入类型的文件中的内容如下所示:
+
+```cpp
+adaptive=org.apache.dubbo.common.extension.inject.AdaptiveExtensionInjector
+spi=org.apache.dubbo.common.extension.inject.SpiExtensionInjector
+scopeBean=org.apache.dubbo.common.beans.ScopeBeanExtensionInjector
+```
+
+扩展中的文件都是一行一行的,并且扩展名字和扩展类型之间使用等号隔开=
+了解了文件内容之后 应该下面的代码大致思路就知道了,我们可以详细看下
+
+```java
+private void loadResource(Map<String, Class<?>> extensionClasses, ClassLoader classLoader,
+ java.net.URL resourceURL, boolean overridden, String[] includedPackages, String[] excludedPackages, String[] onlyExtensionClassLoaderPackages) {
+ try {
+ //这里固定了文件的格式为utf8
+ try (BufferedReader reader = new BufferedReader(new InputStreamReader(resourceURL.openStream(), StandardCharsets.UTF_8))) {
+ String line;
+ String clazz;
+ //按行读取 例如读取到的内容:spring=org.apache.dubbo.config.spring.extension.SpringExtensionInjector
+ while ((line = reader.readLine()) != null) {
+ //不知道为何会有这么一行代码删除#之后的字符串
+ final int ci = line.indexOf('#');
+ if (ci >= 0) {
+ line = line.substring(0, ci);
+ }
+ line = line.trim();
+ //
+ if (line.length() > 0) {
+ try {
+ String name = null;
+ //扩展文件可能如上面我贴的那样 名字和类型等号隔开,也可能是无类型的,例如扩展加载策略使用的是JDK自带的方式services内容中只包含具体的扩展类型
+ int i = line.indexOf('=');
+ if (i > 0) {
+ name = line.substring(0, i).trim();
+ clazz = line.substring(i + 1).trim();
+ } else {
+ clazz = line;
+ }
+ //isExcluded是否为加载策略要排除的配置,参数这里为空代表全部类型不排除
+ //isIncluded是否为加载策略包含的类型,参数这里为空代表全部文件皆可包含
+ //onlyExtensionClassLoaderPackages参数是否只有扩展类的类加载器可以加载扩展,其他扩展类型的类加载器不能加载扩展 这里结果为false 不排除任何类加载器
+ if (StringUtils.isNotEmpty(clazz) && !isExcluded(clazz, excludedPackages) && isIncluded(clazz, includedPackages)
+ && !isExcludedByClassLoader(clazz, classLoader, onlyExtensionClassLoaderPackages)) {
+ //根据类全路径加载类到内存
+ loadClass(extensionClasses, resourceURL, Class.forName(clazz, true, classLoader), name, overridden);
+ }
+ } catch (Throwable t) {
+ IllegalStateException e = new IllegalStateException("Failed to load extension class (interface: " + type +
+ ", class line: " + line + ") in " + resourceURL + ", cause: " + t.getMessage(), t);
+ exceptions.put(line, e);
+ }
+ }
+ }
+ }
+ } catch (Throwable t) {
+ logger.error("Exception occurred when loading extension class (interface: " +
+ type + ", class file: " + resourceURL + ") in " + resourceURL, t);
+ }
+ }
+```
+
+
+ExtensionLoader类型中的loadClass方法加载具体的类到内存
+```java
+private void loadClass(Map<String, Class<?>> extensionClasses, java.net.URL resourceURL, Class<?> clazz, String name,
+ boolean overridden) throws NoSuchMethodException {
+ //当前clazz是否为type的子类型
+ //这里第一次访问到的type是ExtensionInjector,clazz是SpringExtensionInjector 父子类型关系满足情况
+ if (!type.isAssignableFrom(clazz)) {
+ throw new IllegalStateException("Error occurred when loading extension class (interface: " +
+ type + ", class line: " + clazz.getName() + "), class "
+ + clazz.getName() + " is not subtype of interface.");
+ }
+ //扩展子类型是否存在这个注解@Adaptive
+ if (clazz.isAnnotationPresent(Adaptive.class)) {
+ cacheAdaptiveClass(clazz, overridden);
+ } else if (isWrapperClass(clazz)) {
+ //扩展子类型构造器中是否有这个类型的接口 (这个可以想象下我们了解的Java IO流中的类型使用到的装饰器模式 构造器传个类型)
+ cacheWrapperClass(clazz);
+ } else {
+ //无自适应注解,也没有构造器是扩展类型参数 ,这个name我们在扩展文件中找到了就是等号前面那个
+ if (StringUtils.isEmpty(name)) {
+ //低版本中可以使用@Extension 扩展注解来标注扩展类型,这里获取注解有两个渠道:
+ //先查询@Extension注解是否存在如果存在则取value值,如果不存在@Extension注解则获取当前类型的名字
+ name = findAnnotationName(clazz);
+ if (name.length() == 0) {
+ throw new IllegalStateException("No such extension name for the class " + clazz.getName() + " in the config " + resourceURL);
+ }
+ }
+ //获取扩展名字数组,扩展名字可能为逗号隔开的
+ String[] names = NAME_SEPARATOR.split(name);
+ if (ArrayUtils.isNotEmpty(names)) {
+ //@Activate注解修饰的扩展
+ cacheActivateClass(clazz, names[0]);
+ for (String n : names) {
+ //cachedNames缓存集合缓存当前扩展类型的扩展名字
+ cacheName(clazz, n);
+ //将扩展类型加入结果集合extensionClasses中,不允许覆盖的话出现同同名字扩展将抛出异常
+ saveInExtensionClass(extensionClasses, clazz, n, overridden);
+ }
+ }
+ }
+ }
+```
+
+
+
+ExtensionLoader类型中cacheAdaptiveClass
+Adaptive 机制,即扩展类的自适应机制。即其可以指定想要加载的扩展名,也可以不指定。若不指定,则直接加载默认的扩展类。即其会自动匹配,做到自适应。其是通过@Adaptive注解实现的。
+自适应注解修饰的扩展同一个扩展名字只能有一个扩展实现类型, 扩展策略中提供的参数overridden是否允许覆盖扩展覆盖
+```java
+private void cacheAdaptiveClass(Class<?> clazz, boolean overridden) {
+ if (cachedAdaptiveClass == null || overridden) {
+ //成员变量存储这个自适应扩展类型
+ cachedAdaptiveClass = clazz;
+ } else if (!cachedAdaptiveClass.equals(clazz)) {
+ throw new IllegalStateException("More than 1 adaptive class found: "
+ + cachedAdaptiveClass.getName()
+ + ", " + clazz.getName());
+ }
+ }
+```
+
+ExtensionLoader类型中cacheWrapperClass
+Wrapper 机制,即扩展类的包装机制。就是对扩展类中的 SPI 接口方法进行增强,进行包装,是 AOP 思想的体现,是 Wrapper 设计模式的应用。一个 SPI 可以包含多个 Wrapper。这个也是可以同一个类型多个
+```java
+private void cacheWrapperClass(Class<?> clazz) {
+ if (cachedWrapperClasses == null) {
+ cachedWrapperClasses = new ConcurrentHashSet<>();
+ }
+ //缓存这个Wrapper类型的扩展
+ cachedWrapperClasses.add(clazz);
+ }
+```
+
+
+
+ExtensionLoader类型中cacheActivateClass
+Activate用于激活扩展类的。 这个扩展类型可以出现多个比如过滤器可以同一个扩展名字多个过滤器实现,所以不需要有override判断
+Activate 机制,即扩展类的激活机制。通过指定的条件来激活当前的扩展类。其是通过@Activate 注解实现的。
+
+```cpp
+private void cacheActivateClass(Class<?> clazz, String name) {
+ Activate activate = clazz.getAnnotation(Activate.class);
+ if (activate != null) {
+ //缓存Activate类型的扩展
+ cachedActivates.put(name, activate);
+ } else {
+ // support com.alibaba.dubbo.common.extension.Activate
+ com.alibaba.dubbo.common.extension.Activate oldActivate = clazz.getAnnotation(com.alibaba.dubbo.common.extension.Activate.class);
+ if (oldActivate != null) {
+ cachedActivates.put(name, oldActivate);
+ }
+ }
+ }
+```
+
+ExtensionLoader类型中的saveInExtensionClass方法
+
+ 上面扩展对象加载了这么多最终的目的就是将这个扩展类型存放进结果集合extensionClasses中,扩展策略中提供的参数overridden是否允许覆盖扩展覆盖
+```cpp
+private void saveInExtensionClass(Map<String, Class<?>> extensionClasses, Class<?> clazz, String name, boolean overridden) {
+ Class<?> c = extensionClasses.get(name);
+ if (c == null || overridden) {
+ //上面扩展对象加载了这么多最终的目的就是将这个扩展类型存放进结果集合中
+ extensionClasses.put(name, clazz);
+ } else if (c != clazz) {
+ // duplicate implementation is unacceptable
+ unacceptableExceptions.add(name);
+ String duplicateMsg = "Duplicate extension " + type.getName() + " name " + name + " on " + c.getName() + " and " + clazz.getName();
+ logger.error(duplicateMsg);
+ throw new IllegalStateException(duplicateMsg);
+ }
+ }
+```
+
+
+## 5.3 自适应扩展代理对象的代码生成与编译
+### 5.3.1 自适应扩展对象的创建
+
+Dubbo 的**自适应扩展机制**中如果 **自己生成了自适应扩展的代理类**
+
+Dubbo 的自适应扩展为了做什么:**在运行时动态调用扩展方法**。以及怎么做的:生成扩展代理类。比如: 代理类中根据 URL 获取扩展名,使用 SPI 加载扩展类,并调用同名方法,返回执行结果。
+
+看了上一个章节,我们了解到了Dubbo是如何通过扫描目录来查询扩展实现类的这一次我们看下扩展类我们找到了之后,如果这个扩展类型未加上这个@Adaptive注解那么是如何创建这个类型的,接下来看createAdaptiveExtensionClass方法,这个方法是借助字节码工具来动态生成所需要的扩展类型的包装类型的代码,这个代码在编译时我们可能看不到,但是在Debug的时候,我们还是可以看到这个对象名字的,但是往往Debug的时候又进不到具体的代码位置,这里可以注意下
+
+当扩展点的方法被@Adaptive修饰时,在Dubbo初始化扩展点时会自动生成和编译一个动态的Adaptive类。
+
+下面我们可以以interface org.apache.dubbo.rpc.Protocol 这个协议扩展类型来看 协议扩展类型目前没有一个是带有自适应注解的
+```java
+private Class<?> createAdaptiveExtensionClass() {
+ // Adaptive Classes' ClassLoader should be the same with Real SPI interface classes' ClassLoader
+ //获取加载器
+ ClassLoader classLoader = type.getClassLoader();
+ try {
+ // //native配置 是否为本地镜像(可以参考官方文档:https://dubbo.apache.org/zh/docs/references/graalvm/support-graalv
+ if (NativeUtils.isNative()) {
+ return classLoader.loadClass(type.getName() + "$Adaptive");
+ }
+ } catch (Throwable ignore) {
+
+ }
+ //创建一个代码生成器,来生成代码 详细内容我们就下一章来看
+ String code = new AdaptiveClassCodeGenerator(type, cachedDefaultName).generate();
+ //获取编译器
+ org.apache.dubbo.common.compiler.Compiler compiler = extensionDirector.getExtensionLoader(
+ org.apache.dubbo.common.compiler.Compiler.class).getAdaptiveExtension();
+ //生成的代码进行编译
+ return compiler.compile(type, code, classLoader);
+ }
+```
+
+
+
+## 5.4 为扩展对象的set方法注入自适应扩展对象
+在4.4.5小节中我们已经讲解了获取扩展类型实现类, 创建扩展对象
+
+```java
+ T instance = (T) getAdaptiveExtensionClass().newInstance();
+
+```
+
+接下来就让我们来看下为扩展对象的set方法注入自适应的扩展对象
+调用方法代码如下:
+
+```java
+ //注入扩展对象之前的回调方法
+injectExtension(instance);
+```
+
+ExtensionLoader类型的injectExtension方法具体代码如下:
+```cpp
+private T injectExtension(T instance) {
+ //如果注入器为空则直接返回当前对象
+ if (injector == null) {
+ return instance;
+ }
+
+ try {
+ //获取当前对象的当前类的所有方法
+ for (Method method : instance.getClass().getMethods()) {
+ //是否为set方法 不是的话则跳过,在这里合法的set方法满足3个条件:
+ //set开头,参数只有一个,public修饰
+ if (!isSetter(method)) {
+ continue;
+ }
+ /**
+ * Check {@link DisableInject} to see if we need auto injection for this property
+ */
+ //方法上面是否有注解DisableInject修饰,这种情况也直接跳过
+ if (method.isAnnotationPresent(DisableInject.class)) {
+ continue;
+ }
+ //方法的参数如果是原生类型也跳过
+ Class<?> pt = method.getParameterTypes()[0];
+ if (ReflectUtils.isPrimitives(pt)) {
+ continue;
+ }
+ try {
+ //获取set方法对应的成员变量如setProtocol 属性为protocol
+ String property = getSetterProperty(method);
+ //根据参数类型如Protocol和属性名字如protocol获取应该注入的对象
+ Object object = injector.getInstance(pt, property);
+ if (object != null) {
+ //执行对应对象和对应参数的这个方法
+ method.invoke(instance, object);
+ }
+ } catch (Exception e) {
+ logger.error("Failed to inject via method " + method.getName()
+ + " of interface " + type.getName() + ": " + e.getMessage(), e);
+ }
+
+ }
+ } catch (Exception e) {
+ logger.error(e.getMessage(), e);
+ }
+ return instance;
+ }
+```
+### 5.4.1 获取注入对象
+这里我们主要来看下如何通过注入器找到需要注入的那个对象 调用代码如下:
+```cpp
+ Object object = injector.getInstance(pt, property);
+```
+ 在前面看注入器扩展对象的获取的时候是会获取到ExtensionInjector扩展的一个自适应扩展注入器实现类型 AdaptiveExtensionInjector,这个地方对应的getInstance也是这个扩展里面的,我们来看下它的方法:
+
+```java
+ @Override
+ public <T> T getInstance(Class<T> type, String name) {
+ //遍历所有的扩展注入器
+ for (ExtensionInjector injector : injectors) {
+ //遍历所有的扩展注入器,如果可以获取到扩展对象则直接返回
+ T extension = injector.getInstance(type, name);
+ if (extension != null) {
+ return extension;
+ }
+ }
+ return null;
+ }
+```
+可以看到上面代码按扩展注入器顺序来遍历的第一个找到的对象就直接返回了,
+
+ 这个AdaptiveExtensionInjector在初始化的时候会获取所有的ExtensionInjector的扩展,非自适应的,它本身自适应的扩展,这里会获取非自适应的扩展列表一共有3个按顺序为:
+- ScopeBeanExtensionInjector
+- SpiExtensionInjector
+- SpringExtensionInjector
+
+
+接下来我们详细看下每种扩展注入器加载扩展对象的策略:
+
+### 5.4.2 域模型中的Bean扩展注入器ScopeBeanExtensionInjector
+
+ScopeBeanExtensionInjector的getInstance方法:
+每个域模型都会有个ScopeBeanFactory类型的对象用于存储共享对象,并且域模型之间按照层级子类型的Bean工厂可以从父域的Bean工厂中查询对象,
+
+```cpp
+@Override
+ public <T> T getInstance(Class<T> type, String name) {
+ return beanFactory.getBean(name, type);
+ }
+```
+
+ScopeBeanFactory的getBean方法
+先从当前域空间查询对象,如果找不到对应类型的扩展对象则从父域工厂查询扩展对象
+```cpp
+public <T> T getBean(String name, Class<T> type) {
+ //当前域下注册的扩展对象
+ T bean = getBeanInternal(name, type);
+ if (bean == null && parent != null) {
+ //父域中查找扩展对象
+ return parent.getBean(name, type);
+ }
+ return bean;
+ }
+```
+
+ScopeBeanFactory的getBeanInternal方法
+从当前域下找注册的参数类型的对象
+```cpp
+private <T> T getBeanInternal(String name, Class<T> type) {
+ checkDestroyed();
+ // All classes are derived from java.lang.Object, cannot filter bean by it
+ if (type == Object.class) {
+ return null;
+ }
+ List<BeanInfo> candidates = null;
+ BeanInfo firstCandidate = null;
+ //遍历列表查询
+ for (BeanInfo beanInfo : registeredBeanInfos) {
+ // if required bean type is same class/superclass/interface of the registered bean
+ if (type.isAssignableFrom(beanInfo.instance.getClass())) {
+ if (StringUtils.isEquals(beanInfo.name, name)) {
+ return (T) beanInfo.instance;
+ } else {
+ // optimize for only one matched bean
+ if (firstCandidate == null) {
+ firstCandidate = beanInfo;
+ } else {
+ if (candidates == null) {
+ candidates = new ArrayList<>();
+ candidates.add(firstCandidate);
+ }
+ candidates.add(beanInfo);
+ }
+ }
+ }
+ }
+
+ // if bean name not matched and only single candidate
+ if (candidates != null) {
+ if (candidates.size() == 1) {
+ return (T) candidates.get(0).instance;
+ } else if (candidates.size() > 1) {
+ List<String> candidateBeanNames = candidates.stream().map(beanInfo -> beanInfo.name).collect(Collectors.toList());
+ throw new ScopeBeanException("expected single matching bean but found " + candidates.size() + " candidates for type [" + type.getName() + "]: " + candidateBeanNames);
+ }
+ } else if (firstCandidate != null) {
+ return (T) firstCandidate.instance;
+ }
+ return null;
+ }
+```
+
+### 5.4.3 SPI扩展机制注入器SpiExtensionInjector
+
+SPI是Dubbo自行实现的一套扩展机制,我们来看下它是如何查找扩展对象的
+
+```cpp
+@Override
+ public <T> T getInstance(Class<T> type, String name) {
+ //如果是一个标准的被@SPI注解修饰的扩展接口则满足条件
+ if (type.isInterface() && type.isAnnotationPresent(SPI.class)) {
+ //使用扩展访问器来获取对应类型的扩展加载器
+ ExtensionLoader<T> loader = extensionAccessor.getExtensionLoader(type);
+ if (loader == null) {
+ return null;
+ }
+ //使用对应类型的扩展加载器来加载自适应扩展 这个加载的扩展可以参考4.4.6小节
+ if (!loader.getSupportedExtensions().isEmpty()) {
+ return loader.getAdaptiveExtension();
+ }
+ }
+ return null;
+ }
+```
+
+
+
+### 5.4.4 Spring扩展注入器
+SpringExtensionInjector
+
+Spring扩展注入器主要是用来从Spring容器中查询当前类型的Bean是否存在的,如下代码直接看代码吧
+```cpp
+@Override
+ @SuppressWarnings("unchecked")
+ public <T> T getInstance(Class<T> type, String name) {
+
+ if (context == null) {
+ // ignore if spring context is not bound
+ return null;
+ }
+
+ //check @SPI annotation ,类型需要满足SPI机制 @SPI修饰的接口
+ if (type.isInterface() && type.isAnnotationPresent(SPI.class)) {
+ return null;
+ }
+ //从Spring容器中查询Bean
+ T bean = getOptionalBean(context, name, type);
+ if (bean != null) {
+ return bean;
+ }
+
+ //logger.warn("No spring extension (bean) named:" + name + ", try to find an extension (bean) of type " + type.getName());
+ return null;
+ }
+```
+
+
+```cpp
+private <T> T getOptionalBean(ListableBeanFactory beanFactory, String name, Class<T> type) {
+ //要搜索的扩展名字为空就根据类型搜索
+ if (StringUtils.isEmpty(name)) {
+ //返回与给定类型(包括子类)匹配的bean的名称,对于FactoryBeans
+ String[] beanNamesForType = beanFactory.getBeanNamesForType(type, true, false);
+ if (beanNamesForType != null) {
+ if (beanNamesForType.length == 1) {
+ //返回指定bean的实例,该实例可以是共享的,也可以是独立的。
+ //根据Bean Name和类型 查询具体的扩展对象
+ return beanFactory.getBean(beanNamesForType[0], type);
+ } else if (beanNamesForType.length > 1) {
+ throw new IllegalStateException("Expect single but found " + beanNamesForType.length + " beans in spring context: " +
+ Arrays.toString(beanNamesForType));
+ }
+ }
+ } else {
+ //扩展名字不为空则直接通过名字搜索Bean
+ if (beanFactory.containsBean(name)) {
+ return beanFactory.getBean(name, type);
+ }
+ }
+ return null;
+ }
+```
+
+
+原文: [《自适应扩展对象的创建getAdaptiveExtension方法》](https://blog.elastic.link/2022/07/10/dubbo/5-dubbo-de-spi-kuo-zhan-ji-zhi-yu-zi-gua-ying-kuo-zhan-dui-xiang-de-chuang-jian-yu-kuo-zhan-wen-jian-de-sao-miao-yuan-ma-jie-xi/)
\ No newline at end of file
diff --git "a/content/zh/blog/java/codeanalysis/3.0.8/6-Dubbo\347\232\204SPI\346\211\251\345\261\225\346\234\272\345\210\266\344\271\213\346\231\256\351\200\232\346\211\251\345\261\225\345\257\271\350\261\241\347\232\204\345\210\233\345\273\272\344\270\216Wrapper\346\234\272\345\210\266\347\232\204\346\272\220\347\240\201\350\247\243\346\236\220.md" "b/content/zh/blog/java/codeanalysis/3.0.8/6-Dubbo\347\232\204SPI\346\211\251\345\261\225\346\234\272\345\210\266\344\271\213\346\231\256\351 [...]
new file mode 100644
index 0000000000..76c373f371
--- /dev/null
+++ "b/content/zh/blog/java/codeanalysis/3.0.8/6-Dubbo\347\232\204SPI\346\211\251\345\261\225\346\234\272\345\210\266\344\271\213\346\231\256\351\200\232\346\211\251\345\261\225\345\257\271\350\261\241\347\232\204\345\210\233\345\273\272\344\270\216Wrapper\346\234\272\345\210\266\347\232\204\346\272\220\347\240\201\350\247\243\346\236\220.md"
@@ -0,0 +1,354 @@
+---
+title: "06-Dubbo的SPI扩展机制之普通扩展对象的创建与Wrapper机制的源码解析"
+linkTitle: "6-Dubbo的SPI扩展机制之普通扩展对象的创建与Wrapper机制的源码解析"
+date: 2022-08-06
+author: 宋小生
+description: >
+ [Dubbo 3.0.8源码解析] 了解Spring的同学可能比较熟悉AOP机制的逻辑,Dubbo Wrapper机制就是类似AOP这样的切面机制用来增强扩展方法,Wrapper机制,即扩展点自动包装。Wrapper 类同样实现了扩展点接口,但是 Wrapper 不是扩展点的真正实现。它的用途主要是用于从 ExtensionLoader 返回扩展点时,包装在真正的扩展点实现外
+---
+
+
+# 6 Dubbo的SPI扩展机制之普通扩展对象的创建与Wrapper机制的源码解析
+## 6.1 普通扩展对象的加载与创建
+这里我们要分析的是ExtensionLoader类型的getExtension(String name)方法, 有了前面自适应扩展的铺垫,这里就更容易来看了getExtension是根据扩展名字获取具体扩展的通用方法,我们来根据某个类型来获取扩展的时候就是走的这里,比如在这个博客开头的介绍:
+
+- ApplicationModel中获取配置管理器对象
+```java
+ configManager = (ConfigManager) this.getExtensionLoader(ApplicationExt.class)
+ .getExtension(ConfigManager.NAME);
+
+```
+
+### 6.1.1 getExtension方法源码
+先来看下getExtension方法的源码,根据扩展名字查询扩展对象
+```cpp
+
+public T getExtension(String name) {
+ //这里并不能看到什么,只多传了个参数wrap为true调用另外一个重载的方法
+ T extension = getExtension(name, true);
+ if (extension == null) {
+ throw new IllegalArgumentException("Not find extension: " + name);
+ }
+ return extension;
+ }
+```
+
+
+
+
+```java
+public T getExtension(String name, boolean wrap) {
+ //检查扩展加载器是否已被销毁
+ checkDestroyed();
+ if (StringUtils.isEmpty(name)) {
+ throw new IllegalArgumentException("Extension name == null");
+ }
+ //扩展名字为true则加载默认扩展
+ if ("true".equals(name)) {
+ return getDefaultExtension();
+ }
+ //非wrap类型则将缓存的扩展名字key加上_origin后缀
+ //wrap是aop机制 俗称切面,这个origin在aop里面可以称为切点,下面的wrap扩展可以称为增强通知的类型,普通扩展和wrap扩展的扩展名字是一样的
+ String cacheKey = name;
+ if (!wrap) {
+ cacheKey += "_origin";
+ }
+ //从cachedInstances缓存中查询
+ final Holder<Object> holder = getOrCreateHolder(cacheKey);
+ Object instance = holder.get();
+ //缓存中不存在则创建扩展对象 双重校验锁
+ if (instance == null) {
+ synchronized (holder) {
+ //双重校验锁的方式
+ instance = holder.get();
+ if (instance == null) {
+ //创建扩展对象
+ instance = createExtension(name, wrap);
+ holder.set(instance);
+ }
+ }
+ }
+ return (T) instance;
+ }
+```
+
+
+我们先来看一下默认扩展的加载代码:
+
+```java
+public T getDefaultExtension() {
+ //加载扩展类型对应的所有扩展SPI实现类型,在加载所有扩展实现类型的时候会缓存这个扩展的默认实现类型,将对象缓存在cachedDefaultName中
+ getExtensionClasses();
+ if (StringUtils.isBlank(cachedDefaultName) || "true".equals(cachedDefaultName)) {
+ return null;
+ }
+ //再回到加载扩展的方法
+ return getExtension(cachedDefaultName);
+ }
+```
+
+
+创建扩展对象方法这个和自适应扩展的创建扩展类似
+createExtension:
+具体过程如下:
+- 加载扩展类型:getExtensionClasses()
+- 创建扩展对象:createExtensionInstance(clazz)
+- 注入自适应扩展: injectExtension(instance);
+- wrap处理
+
+```cpp
+private T createExtension(String name, boolean wrap) {
+ //扩展的创建的第一步扫描所有jar中的扩展实现,这里扫描完之后获取对应扩展名字的扩展实现类型的Class对象
+ Class<?> clazz = getExtensionClasses().get(name);
+ //出现异常了 转换下异常信息 再抛出
+ if (clazz == null || unacceptableExceptions.contains(name)) {
+ throw findException(name);
+ }
+ try {
+ //当前扩展对象是否已经创建过了则直接从缓存中获取
+ T instance = (T) extensionInstances.get(clazz);
+ if (instance == null) {
+ //第一次获取缓存中肯定没有则创建扩展对象然后缓存起来
+ //createExtensionInstance 这个是与自适应扩展对象创建对象的不同之处
+ extensionInstances.putIfAbsent(clazz, createExtensionInstance(clazz));
+ instance = (T) extensionInstances.get(clazz);
+ instance = postProcessBeforeInitialization(instance, name);
+ //注入扩展自适应方法,这个方法前面讲自适应扩展时候说了,注入自适应扩展方法的自适应扩展对象
+ injectExtension(instance);
+ instance = postProcessAfterInitialization(instance, name);
+ }
+ //是否开启了wrap
+ //Dubbo通过Wrapper实现AOP的方法
+ if (wrap) {
+ //这个可以参考下Dubbo扩展的加载
+ List<Class<?>> wrapperClassesList = new ArrayList<>();
+ //wrap类型排序 这个wrap类型是如何来的呢,在前面扫描扩展类型的时候如果当前扩展类型不是Adaptive注解修饰的,并且当前类型type有个构造器参数是type自身的也是前面加载扩展类型时候说的装饰器模式 可以参考DubboProtocol的构造器
+ if (cachedWrapperClasses != null) {
+ wrapperClassesList.addAll(cachedWrapperClasses);
+ //根据Wrapper注解的order值来进行排序值越小越在列表的前面
+ wrapperClassesList.sort(WrapperComparator.COMPARATOR);
+ //反转之后值越大就会在列表的前面
+ Collections.reverse(wrapperClassesList);
+ }
+ //从缓存中查到了wrapper扩展则遍历这些wrapp扩展进行筛选
+ if (CollectionUtils.isNotEmpty(wrapperClassesList)) {
+ for (Class<?> wrapperClass : wrapperClassesList) {
+ Wrapper wrapper = wrapperClass.getAnnotation(Wrapper.class);
+ //需要包装的扩展名。当此数组为空时,默认值为匹配
+ //看下当前扩展是否匹配这个wrap,如何判断呢?
+ //wrapper注解不存在或者matches匹配,或者mismatches不包含当前扩展
+ //如果匹配到了当前扩展对象是需要进行wrapp的就为当前扩展创建当前wrapper扩展对象进行包装
+ boolean match = (wrapper == null) ||
+ ((ArrayUtils.isEmpty(wrapper.matches()) || ArrayUtils.contains(wrapper.matches(), name)) &&
+ !ArrayUtils.contains(wrapper.mismatches(), name));
+ //这是扩展类型是匹配wrapp的则开始注入
+ if (match) {
+ //匹配到了就创建所有的wrapper类型的对象同时构造器参数设置为当前类型
+ instance = injectExtension((T) wrapperClass.getConstructor(type).newInstance(instance));
+ instance = postProcessAfterInitialization(instance, name);
+ }
+ }
+ }
+ }
+
+ // Warning: After an instance of Lifecycle is wrapped by cachedWrapperClasses, it may not still be Lifecycle instance, this application may not invoke the lifecycle.initialize hook.
+ //初始化扩展,如果当前扩展是Lifecycle类型则调用初始化方法
+ initExtension(instance);
+ return instance;
+ } catch (Throwable t) {
+ throw new IllegalStateException("Extension instance (name: " + name + ", class: " +
+ type + ") couldn't be instantiated: " + t.getMessage(), t);
+ }
+ }
+```
+
+
+
+### 6.1.2 创建扩展对象
+
+前面加载扩展类型在自适应扩展的时候已经说过了这里就不重复了,这里我们来看下
+扩展对象的创建过程:createExtensionInstance(clazz)
+
+前面看自适应扩展对象创建的时候自适应扩展对象仅仅是使用反射newInstance了一个扩展对象,而普通的扩展类型创建对象的过程就相对复杂一点,接下来我们来看下:
+
+
+ExtensionLoader的createExtensionInstance方法
+```cpp
+private Object createExtensionInstance(Class<?> type) throws ReflectiveOperationException {
+ //在ExtensionLoader构造器中,有个initInstantiationStrategy()方法中new了一个初始化策略InstantiationStrategy类型对象
+ return instantiationStrategy.instantiate(type);
+ }
+```
+
+
+InstantiationStrategy的实例化对象方法instantiate
+```cpp
+public <T> T instantiate(Class<T> type) throws ReflectiveOperationException {
+
+ // should not use default constructor directly, maybe also has another constructor matched scope model arguments
+ // 1. try to get default constructor
+ Constructor<T> defaultConstructor = null;
+ try {
+ //反射获取对应类型的无参构造器
+ defaultConstructor = type.getConstructor();
+ } catch (NoSuchMethodException e) {
+ // ignore no default constructor
+ }
+
+ // 2. use matched constructor if found
+ List<Constructor> matchedConstructors = new ArrayList<>();
+ //获取所有构造器
+ Constructor<?>[] declaredConstructors = type.getConstructors();
+ //遍历构造器列表,
+ for (Constructor<?> constructor : declaredConstructors) {
+ //如果存在构造器则构造器参数类型是否为ScopeModel类型,如果为ScopeModel则为匹配的构造器 说明我们扩展类型在这个版本如果想要让这个构造器生效必须参数类型为ScopeModel
+ if (isMatched(constructor)) {
+ matchedConstructors.add(constructor);
+ }
+ }
+ // remove default constructor from matchedConstructors
+ if (defaultConstructor != null) {
+ matchedConstructors.remove(defaultConstructor);
+ }
+
+ // match order:
+ // 1. the only matched constructor with parameters
+ // 2. default constructor if absent
+
+ Constructor targetConstructor;
+ //匹配的参数ScopeModel的构造器太多了就抛出异常
+ if (matchedConstructors.size() > 1) {
+ throw new IllegalArgumentException("Expect only one but found " +
+ matchedConstructors.size() + " matched constructors for type: " + type.getName() +
+ ", matched constructors: " + matchedConstructors);
+ } else if (matchedConstructors.size() == 1) {
+ //一个参数一般为一个参数类型ScopeModel的构造器
+ targetConstructor = matchedConstructors.get(0);
+ } else if (defaultConstructor != null) {
+ //如果没有自定义构造器则使用空参数构造器
+ targetConstructor = defaultConstructor;
+ } else {
+ //一个构造器也没匹配上也要报错
+ throw new IllegalArgumentException("None matched constructor was found for type: " + type.getName());
+ }
+
+ // create instance with arguments
+ //反射获取构造器参数的参数类型列表
+ Class[] parameterTypes = targetConstructor.getParameterTypes();
+ //如果存在参数则为参数设置值
+ Object[] args = new Object[parameterTypes.length];
+ for (int i = 0; i < parameterTypes.length; i++) {
+ //借助scopeModelAccessor工具获取参数类型,这个参数类型为当前的域模型对象
+ args[i] = getArgumentValueForType(parameterTypes[i]);
+ }
+ //创建扩展对象
+ return (T) targetConstructor.newInstance(args);
+ }
+```
+
+
+## 6.2 wrap机制
+### 6.2.1 Wrapper机制说明
+Dubbo通过Wrapper实现AOP的方法
+
+Wrapper机制,即扩展点自动包装。Wrapper 类同样实现了扩展点接口,但是 Wrapper 不是扩展点的真正实现。它的用途主要是用于从 ExtensionLoader 返回扩展点时,包装在真正的扩展点实现外。即从 ExtensionLoader 中返回的实际上是 Wrapper 类的实例,Wrapper 持有了实际的扩展点实现类。
+扩展点的 Wrapper 类可以有多个,也可以根据需要新增。
+通过 Wrapper 类可以把所有扩展点公共逻辑移至 Wrapper 中。新加的 Wrapper 在所有的扩展点上添加了逻辑,有些类似 AOP,即 Wrapper 代理了扩展点。
+
+Wrapper的规范
+Wrapper 机制不是通过注解实现的,而是通过一套 Wrapper 规范实现的。
+Wrapper 类在定义时需要遵循如下规范。
+
+- 该类要实现 SPI 接口
+- 该类中要有 SPI 接口的引用
+- 该类中必须含有一个含参的构造方法且参数只能有一个类型为SPI接口
+- 在接口实现方法中要调用 SPI 接口引用对象的相应方法
+- 该类名称以 Wrapper 结尾
+
+比如如下几个扩展类型
+
+```cpp
+ class org.apache.dubbo.rpc.protocol.ProtocolListenerWrapper
+ class org.apache.dubbo.qos.protocol.QosProtocolWrapper
+ class org.apache.dubbo.rpc.protocol.ProtocolListenerWrapper
+ class org.apache.dubbo.qos.protocol.QosProtocolWrapper
+```
+
+
+回顾下Wrapper扩展类型的扫描于对象的创建
+### 6.2.2 Wrapper类型的扫描
+**Wrapper类型的扫描代码如下:**
+
+来自4.5.2.3小节ExtensionLoader类型中的loadClass方法
+
+```cpp
+ //扩展子类型是否存在这个注解@Adaptive
+ if (clazz.isAnnotationPresent(Adaptive.class)) {
+ cacheAdaptiveClass(clazz, overridden);
+ } else if (isWrapperClass(clazz)) {
+ //扩展子类型构造器中是否有这个类型的接口 (这个可以想象下我们了解的Java IO流中的类型使用到的装饰器模式 构造器传个类型)
+ cacheWrapperClass(clazz);
+ } else {
+```
+
+isWrapperClass方法通过判断构造器类型是否为当前类型来判断是否为Wrapper类型
+```cpp
+ private boolean isWrapperClass(Class<?> clazz) {
+ try {
+ clazz.getConstructor(type);
+ return true;
+ } catch (NoSuchMethodException e) {
+ return false;
+ }
+ }
+```
+
+
+### 6.2.3 Wrapper类型的创建
+这个可以看下4.6.1 getExtension方法源码的获取扩展对象时候查询扩展对象是否有对应的Wrapper类型的扩展为其创建Wrapper扩展对象,如下代码
+
+```cpp
+//Dubbo通过Wrapper实现AOP的方法
+ if (wrap) {
+ //这个可以参考下Dubbo扩展的加载
+ List<Class<?>> wrapperClassesList = new ArrayList<>();
+ //wrap类型排序 这个wrap类型是如何来的呢,在前面扫描扩展类型的时候如果当前扩展类型不是Adaptive注解修饰的,并且当前类型type有个构造器参数是type自身的也是前面加载扩展类型时候说的装饰器模式 可以参考DubboProtocol的构造器
+ if (cachedWrapperClasses != null) {
+ wrapperClassesList.addAll(cachedWrapperClasses);
+ //根据Wrapper注解的order值来进行排序值越小越在列表的前面
+ wrapperClassesList.sort(WrapperComparator.COMPARATOR);
+ //反转之后值越大就会在列表的前面
+ Collections.reverse(wrapperClassesList);
+ }
+ //从缓存中查到了wrapper扩展则遍历这些wrapp扩展进行筛选
+ if (CollectionUtils.isNotEmpty(wrapperClassesList)) {
+ for (Class<?> wrapperClass : wrapperClassesList) {
+ Wrapper wrapper = wrapperClass.getAnnotation(Wrapper.class);
+ //需要包装的扩展名。当此数组为空时,默认值为匹配
+ //看下当前扩展是否匹配这个wrap,如何判断呢?
+ //wrapper注解不存在或者matches匹配,或者mismatches不包含当前扩展
+ //如果匹配到了当前扩展对象是需要进行wrapp的就为当前扩展创建当前wrapper扩展对象进行包装
+ boolean match = (wrapper == null) ||
+ ((ArrayUtils.isEmpty(wrapper.matches()) || ArrayUtils.contains(wrapper.matches(), name)) &&
+ !ArrayUtils.contains(wrapper.mismatches(), name));
+ //这是扩展类型是匹配wrapp的则开始注入
+ if (match) {
+ //匹配到了就创建所有的wrapper类型的对象同时构造器参数设置为当前类型
+ instance = injectExtension((T) wrapperClass.getConstructor(type).newInstance(instance));
+ instance = postProcessAfterInitialization(instance, name);
+ }
+ }
+ }
+ }
+```
+
+主要来看下什么情况下才为当前扩展类型创建Wrapper包装类型:
+- wrapper注解不存在(前面判断过Wrapper类型是构造器满足条件的)
+- 存在Wrapper注解:
+ - matches匹配,
+ - 或者mismatches不包含当前扩展
+
+如果匹配到了当前扩展对象是需要进行wrapp的就为当前扩展创建当前wrapper扩展对象进行包装
+
+
+ 原文: [《Dubbo的SPI扩展机制之普通扩展对象的创建与Wrapper机制的源码解析》](https://blog.elastic.link/2022/07/10/dubbo/6-dubbo-de-spi-kuo-zhan-ji-zhi-zhi-pu-tong-kuo-zhan-dui-xiang-de-chuang-jian-yu-wrapper-ji-zhi-de-yuan-ma-jie-xi/)
\ No newline at end of file
diff --git "a/content/zh/blog/java/codeanalysis/3.0.8/7-Dubbo\347\232\204SPI\346\211\251\345\261\225\346\234\272\345\210\266\344\271\213\350\207\252\345\212\250\346\277\200\346\264\273\346\211\251\345\261\225Activate\346\272\220\347\240\201\350\247\243\346\236\220.md" "b/content/zh/blog/java/codeanalysis/3.0.8/7-Dubbo\347\232\204SPI\346\211\251\345\261\225\346\234\272\345\210\266\344\271\213\350\207\252\345\212\250\346\277\200\346\264\273\346\211\251\345\261\225Activate\346\272\220\347\24 [...]
new file mode 100644
index 0000000000..625f13aca1
--- /dev/null
+++ "b/content/zh/blog/java/codeanalysis/3.0.8/7-Dubbo\347\232\204SPI\346\211\251\345\261\225\346\234\272\345\210\266\344\271\213\350\207\252\345\212\250\346\277\200\346\264\273\346\211\251\345\261\225Activate\346\272\220\347\240\201\350\247\243\346\236\220.md"
@@ -0,0 +1,225 @@
+---
+title: "7-Dubbo的SPI扩展机制之自动激活扩展Activate源码解析"
+linkTitle: "7-Dubbo的SPI扩展机制之自动激活扩展Activate源码解析"
+date: 2022-08-07
+author: 宋小生
+description: >
+ [Dubbo 3.0.8源码解析] @Activate可用于在有多个实现时加载某些筛选器扩展,一般带有同种类型多个扩展都要执行的情况,比如过滤器。
+---
+
+# 7-Dubbo的SPI扩展机制之自动激活扩展Activate源码解析
+## 7.1 Activate扩展的说明
+此注解对于使用给定条件自动激活某些扩展非常有用,例如:@Activate可用于在有多个实现时加载某些筛选器扩展。
+- **group()** 指定组条件。框架SPI定义了有效的组值。
+- **value()** 指定URL条件中的参数键。
+
+SPI提供程序可以调用ExtensionLoader。getActivateExtension(URL、String、String)方法以查找具有给定条件的所有已激活扩展。
+
+比如后面我们会说到的**过滤器扩展对象**的获取,如下通过调用**getActivateExtension方法的**代码:
+
+```java
+ List<Filter> filters;
+ filters = ScopeModelUtil.getExtensionLoader(Filter.class, moduleModels.get(0)).getActivateExtension(url, key, group);
+```
+
+
+## 7.2 获取自动激活扩展的源码
+
+前面我们看了激活扩展是通过调用getActivateExtension方法来获取对象的,那接下来就来看下这个方法做了什么操作:
+
+```java
+/**
+* @param url 服务的url
+* @param key 用于获取扩展点名称的url参数键 比如监听器:exporter.listener,过滤器:params-filter,telnet处理器:telnet
+*/
+ public List<T> getActivateExtension(URL url, String key) {
+ return getActivateExtension(url, key, null);
+ }
+```
+
+继续调用重载的方法
+```java
+/**
+ *
+ *
+ * @param url 服务的url
+ * @param key 用于获取扩展点名称的url参数键 比如监听器:exporter.listener,过滤器:params-filter,telnet处理器:telnet
+ * @param group group 用于筛选的分组,比如过滤器中使用此参数来区分消费者使用这个过滤器还是提供者使用这个过滤器他们的group参数分表为consumer,provider
+ * @return 已激活的扩展列表。
+ */
+ public List<T> getActivateExtension(URL url, String key, String group) {
+ //从参数中获取url指定的值
+ String value = url.getParameter(key);
+ //调用下个重载的方法
+ return getActivateExtension(url, StringUtils.isEmpty(value) ? null : COMMA_SPLIT_PATTERN.split(value), group);
+ }
+```
+
+
+上面的重载方法都是用来转换参数的,下面这个方法才是真正的逻辑
+```java
+ /**
+ * 获取激活扩展.
+ *
+ * @param url 服务的url
+ * @param values 这个value是扩展点的名字 当指定了时候会使用指定的名字的扩展
+ * @param group group 用于筛选的分组,比如过滤器中使用此参数来区分消费者使用这个过滤器还是提供者使用这个过滤器他们的group参数分表为consumer,provider
+ * @return 获取激活扩展.
+ */
+ public List<T> getActivateExtension(URL url, String[] values, String group) {
+ //检查扩展加载器是否被销毁了
+ checkDestroyed();
+ // solve the bug of using @SPI's wrapper method to report a null pointer exception.
+ //创建个有序的Map集合,用来对扩展进行排序
+ Map<Class<?>, T> activateExtensionsMap = new TreeMap<>(activateComparator);
+ //初始化扩展名字,指定了扩展名字values不为空
+ List<String> names = values == null ? new ArrayList<>(0) : asList(values);
+ //扩展名字使用Set集合进行去重
+ Set<String> namesSet = new HashSet<>(names);
+ //参数常量是 -default 扩展名字是否不包含默认的
+ if (!namesSet.contains(REMOVE_VALUE_PREFIX + DEFAULT_KEY)) {
+ //第一次进来肯定是没有缓存对象双重校验锁检查下
+ if (cachedActivateGroups.size() == 0) {
+ synchronized (cachedActivateGroups) {
+ // cache all extensions
+ if (cachedActivateGroups.size() == 0) {
+ //加载扩展类型对应的扩展类,这个具体细节参考源码或者《[Dubbo3.0.7源码解析系列]-5-Dubbo的SPI扩展机制与自适应扩展对象的创建与扩展文件的扫描源码解析》章节
+ getExtensionClasses();
+ for (Map.Entry<String, Object> entry : cachedActivates.entrySet()) {
+ String name = entry.getKey();
+ Object activate = entry.getValue();
+
+ String[] activateGroup, activateValue;
+ //遍历所有的activates列表获取group()和value()值
+ if (activate instanceof Activate) {
+ activateGroup = ((Activate) activate).group();
+ activateValue = ((Activate) activate).value();
+ } else if (activate instanceof com.alibaba.dubbo.common.extension.Activate) {
+ activateGroup = ((com.alibaba.dubbo.common.extension.Activate) activate).group();
+ activateValue = ((com.alibaba.dubbo.common.extension.Activate) activate).value();
+ } else {
+ continue;
+ }
+ //缓存分组值
+ cachedActivateGroups.put(name, new HashSet<>(Arrays.asList(activateGroup)));
+ String[][] keyPairs = new String[activateValue.length][];
+ //遍历指定的激活扩展的扩展名字列表
+ for (int i = 0; i < activateValue.length; i++) {
+ if (activateValue[i].contains(":")) {
+ keyPairs[i] = new String[2];
+ String[] arr = activateValue[i].split(":");
+ keyPairs[i][0] = arr[0];
+ keyPairs[i][1] = arr[1];
+ } else {
+ keyPairs[i] = new String[1];
+ keyPairs[i][0] = activateValue[i];
+ }
+ }
+ //缓存指定扩展信息
+ cachedActivateValues.put(name, keyPairs);
+ }
+ }
+ }
+ }
+
+ // traverse all cached extensions
+ //遍历所有激活的扩展名字和扩展分组集合
+ cachedActivateGroups.forEach((name, activateGroup) -> {
+ //筛选当前扩展的扩展分组与激活扩展的扩展分组是否可以匹配
+ if (isMatchGroup(group, activateGroup)
+ //不能是指定的扩展名字
+ && !namesSet.contains(name)
+ //也不能是带有 -指定扩展名字
+ && !namesSet.contains(REMOVE_VALUE_PREFIX + name)
+ //如果在Active注解中配置了value则当指定的键出现在URL的参数中时,激活当前扩展名。
+ //如果未配置value属性则默认都是匹配的(cachedActivateValues中不存在对应扩展名字的缓存的时候默认为true)
+ && isActive(cachedActivateValues.get(name), url)) {
+ //缓存激活的扩展类型映射的扩展名字
+ activateExtensionsMap.put(getExtensionClass(name), getExtension(name));
+ }
+ });
+ }
+
+ if (namesSet.contains(DEFAULT_KEY)) {
+ // will affect order
+ // `ext1,default,ext2` means ext1 will happens before all of the default extensions while ext2 will after them
+ ArrayList<T> extensionsResult = new ArrayList<>(activateExtensionsMap.size() + names.size());
+ for (int i = 0; i < names.size(); i++) {
+ String name = names.get(i);
+ if (!name.startsWith(REMOVE_VALUE_PREFIX)
+ && !namesSet.contains(REMOVE_VALUE_PREFIX + name)) {
+ if (!DEFAULT_KEY.equals(name)) {
+ if (containsExtension(name)) {
+ extensionsResult.add(getExtension(name));
+ }
+ } else {
+ extensionsResult.addAll(activateExtensionsMap.values());
+ }
+ }
+ }
+ return extensionsResult;
+ } else {
+ // add extensions, will be sorted by its order
+ for (int i = 0; i < names.size(); i++) {
+ String name = names.get(i);
+ if (!name.startsWith(REMOVE_VALUE_PREFIX)
+ && !namesSet.contains(REMOVE_VALUE_PREFIX + name)) {
+ if (!DEFAULT_KEY.equals(name)) {
+ if (containsExtension(name)) {
+ activateExtensionsMap.put(getExtensionClass(name), getExtension(name));
+ }
+ }
+ }
+ }
+ return new ArrayList<>(activateExtensionsMap.values());
+ }
+ }
+ ```
+
+
+再来回顾下扫描扩展类型的时候,与激活扩展的相关扫描代码:
+与激活注解关键的代码位置在这里ExtensionLoader的loadClass方法中
+我来贴下loadClass方法核心的代码:
+
+```java
+if (clazz.isAnnotationPresent(Adaptive.class)) {
+ cacheAdaptiveClass(clazz, overridden);
+ } else if (isWrapperClass(clazz)) {
+ cacheWrapperClass(clazz);
+ } else {
+ if (StringUtils.isEmpty(name)) {
+ name = findAnnotationName(clazz);
+ if (name.length() == 0) {
+ throw new IllegalStateException("No such extension name for the class " + clazz.getName() + " in the config " + resourceURL);
+ }
+ }
+
+ String[] names = NAME_SEPARATOR.split(name);
+ if (ArrayUtils.isNotEmpty(names)) {
+ //位置在这里其他地方就不标记注释了,前面判断了如果不是Adaptive也不是Wrapper类型则我们可以来判断是否为Activate 类型如果是的话调用cacheActivateClass方法将扩展缓存进cachedActivates缓存中
+ cacheActivateClass(clazz, names[0]);
+ for (String n : names) {
+ cacheName(clazz, n);
+ saveInExtensionClass(extensionClasses, clazz, n, overridden);
+ }
+ }
+ }
+```
+
+```java
+private void cacheActivateClass(Class<?> clazz, String name) {
+ Activate activate = clazz.getAnnotation(Activate.class);
+ if (activate != null) {
+ //注解存在则加入激活注解缓存
+ cachedActivates.put(name, activate);
+ } else {
+ // support com.alibaba.dubbo.common.extension.Activate
+ com.alibaba.dubbo.common.extension.Activate oldActivate = clazz.getAnnotation(com.alibaba.dubbo.common.extension.Activate.class);
+ if (oldActivate != null) {
+ cachedActivates.put(name, oldActivate);
+ }
+ }
+ }
+```
+
+ 原文: [《Dubbo的SPI扩展机制之自动激活扩展Activate源码解析》](https://blog.elastic.link/2022/07/10/dubbo/7-dubbo-de-spi-kuo-zhan-ji-zhi-zhi-zi-dong-ji-huo-kuo-zhan-activate-yuan-ma-jie-xi/)
\ No newline at end of file
diff --git a/static/imgs/blog/source-blog/3-extension.png b/static/imgs/blog/source-blog/3-extension.png
new file mode 100644
index 0000000000..631c016af3
Binary files /dev/null and b/static/imgs/blog/source-blog/3-extension.png differ
diff --git a/static/imgs/blog/source-blog/3-initextent.png b/static/imgs/blog/source-blog/3-initextent.png
new file mode 100644
index 0000000000..9a78201a3e
Binary files /dev/null and b/static/imgs/blog/source-blog/3-initextent.png differ
diff --git a/static/imgs/blog/source-blog/3-model.png b/static/imgs/blog/source-blog/3-model.png
new file mode 100644
index 0000000000..3504331c39
Binary files /dev/null and b/static/imgs/blog/source-blog/3-model.png differ
diff --git a/static/imgs/blog/source-blog/4-dubbo-arch.png b/static/imgs/blog/source-blog/4-dubbo-arch.png
new file mode 100644
index 0000000000..a3fad0b8ae
Binary files /dev/null and b/static/imgs/blog/source-blog/4-dubbo-arch.png differ
diff --git a/static/imgs/blog/source-blog/4-dubbo-arch2.png b/static/imgs/blog/source-blog/4-dubbo-arch2.png
new file mode 100644
index 0000000000..08ea8480e3
Binary files /dev/null and b/static/imgs/blog/source-blog/4-dubbo-arch2.png differ
diff --git a/static/imgs/blog/source-blog/4-dubbo-arch3.png b/static/imgs/blog/source-blog/4-dubbo-arch3.png
new file mode 100644
index 0000000000..7a9951690f
Binary files /dev/null and b/static/imgs/blog/source-blog/4-dubbo-arch3.png differ
diff --git a/static/imgs/blog/source-blog/4-dubbo-extension.png b/static/imgs/blog/source-blog/4-dubbo-extension.png
new file mode 100644
index 0000000000..b30dc78144
Binary files /dev/null and b/static/imgs/blog/source-blog/4-dubbo-extension.png differ
diff --git a/static/imgs/blog/source-blog/4-dubbo-extension2.png b/static/imgs/blog/source-blog/4-dubbo-extension2.png
new file mode 100644
index 0000000000..6d60685863
Binary files /dev/null and b/static/imgs/blog/source-blog/4-dubbo-extension2.png differ