關於Angular動態元件你知道多少？這裡有在angularjs中動態創建元件詳解

本文主要解釋如何在 Angular 中動態建立元件（註：在模板中使用的元件可稱為靜態地建立元件）。下面就讓我們一起來看這篇文章吧

如果你之前使用AngularJS（第一代Angular 框架）來編程，可能會使用$compile 服務產生HTML，並連接到資料模型從而獲得雙向綁定功能：

const template = '<span>generated on the fly: {{name}}</span>'
const linkFn = $compile(template);
const dataModel = $scope.$new();
dataModel.name = 'dynamic';

// link data model to a template
linkFn(dataModel);

AngularJS 中指令可以修改DOM，但是沒法知道修改了什麼。這種方式的問題和動態環境一樣，很難優化效能。動態模板當然不是 AngularJS 效能慢的主要元兇，但也是重要原因之一。

我在看了Angular 內部程式碼一段時間後，發現這個新設計的框架非常重視效能，在Angular 原始碼裡你會經常發現這幾句話（註：為清晰理解，不翻譯）：

Attention: Adding fields to this is performance sensitive!

Note: We use one type for all nodes so that loops that loop over all nodes of a ViewDefinition stay monomorphic!

For performance reasons, we want to check and update the list every five seconds.

所以，Angular 設計者決定犧牲靈活性來獲得巨大的性能提升，如引入了JIT 和AOT Compiler，靜態模板（static templates），指令/模組工廠（ComponentFactory ），工廠解析器（ComponentFactoryResolver）。對 AngularJS 社群來說，這些概念很陌生，甚至充滿敵意，不過不用擔心，如果你之前只是聽說過這些概念，但現在想知道這些是什麼，繼續閱讀本文，將讓你茅塞頓開。

註：實際上，JIT/AOT Compiler 說的是同一個 Compiler，只是這個 Compiler 在 building time 階段還是在 running time 階段被使用而已。

至於factory，是Angular Compiler 把你寫的元件如a.component.ts 編譯為a.component.ngfactory.js，即Compiler 使用@Component decorator 作為原材料，把你寫的元件/指令類編譯為另一個視圖工廠類別。

回到剛剛的JIT/AOT Compiler，如果a.component.ngfactory.js 是在build 階段產生的那就是AOT Compiler，這個Compiler 不會被打包到依賴包裡；如果是在run 階段生成，那麼Compiler 就需要被打包到依賴包裡，被用戶下載到本地，在運行時Compiler 會編譯組件/指令類生成對應的視圖工廠類，僅此而已。下文將會看下這些 *.ngfactory.js 檔案程式碼是什麼樣的。

至於 factory resolver，那就更簡單了，就是一個對象，透過它拿到那些編譯後的 factory 物件。

元件工廠和編譯器

Angular 中每一個元件是由元件工廠創建的，元件工廠又是由編譯器根據你寫的@Component 裝飾器裡的元資料編譯產生的。如果你上網讀了大量的 decorator 文章還有點迷惑，可以參考我寫的這篇 Medium 文章 Implementing custom component decorator 。

Angular 內部使用了 視圖 概念，或者說整個框架是一顆視圖樹。每一個視圖是由大量不同類型節點（node）組成的：元素節點，文字節點等等（註：可查看 翻譯 Angular DOM 更新機制）。每一個節點都有其專門作用，這樣每一個節點的處理只需要花很少的時間，並且每一個節點都有ViewContainerRef 和TemplateRef# 等服務供使用，還可以使用ViewChild/ViewChildren 和ContentChild/ContentChildren 做DOM 來查詢這些節點。

註：簡單點說就是Angular 程式是一顆視圖樹，每一個視圖（view）又是有多種節點（node）組成的，每一個節點又提供了模板操作API 給開發者使用，這些節點可以透過DOM Query API 拿到。

每一個節點包含大量訊息，並且為了效能考慮，一旦節點被創建就生效，後面不容許更改（註：被創建的節點會被緩存起來）。節點產生過程是編譯器蒐集你寫的元件資訊（註：主要是你寫的元件裡的模板資訊），並以元件工廠形式封裝起來。

假設你寫瞭如下的一個元件：

@Component({
  selector: 'a-comp',
  template: '<span>A Component</span>'
})
class AComponent {}

編譯器根據你寫的資訊產生類似如下的元件工廠程式碼，程式碼只包含重要部分（註：下面整個程式碼可理解為視圖，其中elementDef2 和jit_textDef3 可理解為節點）：

function View_AComponent_0(l) {
  return jit_viewDef1(0,[
      elementDef2(0,null,null,1,'span',...),
      jit_textDef3(null,['My name is ',...])
    ]

上面程式碼基本上描述了元件視圖的結構，並用來實例化一個元件。其中，第一個節點 elementDef2 是元素節點定義，第二個節點 jit_textDef3 是文字節點定義。你可以看到每一個節點都有足夠的參數資訊來實例化，而這些參數資訊是編譯器解析所有依賴生成的，並且在運行時由框架提供這些依賴的具體值。

从上文知道，如果你能够访问到组件工厂，就可以使用它实例化出对应的组件对象，并使用 ViewContainerRef API 把该组件/视图插入 DOM 中。如果你对 ViewContainerRef 感兴趣，可以查看 译 探索 Angular 使用 ViewContainerRef 操作 DOM。应该如何使用这个 API 呢（注：下面代码展示如何使用 ViewContainerRef API 往视图树上插入一个视图）：

export class SampleComponent implements AfterViewInit {
    @ViewChild("vc", {read: ViewContainerRef}) vc: ViewContainerRef;

    ngAfterViewInit() {
        this.vc.createComponent(componentFactory);
    }
}

好的，从上面代码可知道只要拿到组件工厂，一切问题就解决了。现在，问题是如何拿到 ComponentFactory 组件工厂对象，继续看。

模块（Modules）和组件工厂解析器（ComponentFactoryResolver）

尽管 AngularJS 也有模块，但它缺少指令所需要的真正的命名空间，并且会有潜在的命名冲突，还没法在单独的模块里封装指令。然而，很幸运，Angular 吸取了教训，为各种声明式类型，如指令、组件和管道，提供了合适的命名空间（注：即 Angular 提供的 Module，使用装饰器函数 @NgModule 装饰一个类就能得到一个 Module）。

就像 AngularJS 那样，Angular 中的组件是被封装在模块中。组件自己并不能独立存在，如果你想要使用另一个模块的一个组件，你必须导入这个模块：

@NgModule({
    // imports CommonModule with declared directives like
    // ngIf, ngFor, ngClass etc.
    imports: [CommonModule],
    ...
})
export class SomeModule {}

同样道理，如果一个模块想要提供一些组件给别的模块使用，就必须导出这些组件，可以查看 exports 属性。比如，可以查看 CommonModule 源码的做法（注：查看 L24-L25）：

const COMMON_DIRECTIVES: Provider[] = [
    NgClass,
    NgComponentOutlet,
    NgForOf,
    NgIf,
    ...
];

@NgModule({
    declarations: [COMMON_DIRECTIVES, ...],
    exports: [COMMON_DIRECTIVES, ...],
    ...
})
export class CommonModule {
}

所以每一个组件都是绑定在一个模块里，并且不能在不同模块里申明同一个组件，如果你这么做了，Angular 会抛出错误：

Type X is part of the declarations of 2 modules: ...

当 Angular 编译程序时，编译器会把在模块中 entryComponents 属性注册的组件，或模板里使用的组件编译为组件工厂（注：在所有静态模板中使用的组件如 <a-comp></a-comp>，即静态组件；在 entryComponents 定义的组件，即动态组件，动态组件的一个最佳示例如 Angular Material Dialog 组件，可以在 entryComponents 中注册 DialogContentComp 组件动态加载对话框内容）。你可以在 Sources 标签里看到编译后的组件工厂文件：

从上文中我们知道，如果我们能拿到组件工厂，就可以使用组件工厂创建对应的组件对象，并插入到视图里。实际上，每一个模块都为所有组件提供了一个获取组件工厂的服务 ComponentFactoryResolver。所以，如果你在模块中定义了一个 BComponent 组件并想要拿到它的组件工厂，你可以在这个组件内注入这个服务并使用它：

export class AppComponent {
  constructor(private resolver: ComponentFactoryResolver) {
    // now the `factory` contains a reference to the BComponent factory
    const factory = this.resolver.resolveComponentFactory(BComponent);
  }

这是在两个组件 AppComponent 和 BComponent 都定义在一个模块里才行，或者导入其他模块时该模块已经有组件 BComponent 对应的组件工厂。

动态加载和编译模块

但是如果组件在其他模块定义，并且这个模块是按需加载，这样的话是不是完蛋了呢？实际上我们照样可以拿到某个组件的组件工厂，方法同路由使用 loadChildren 配置项按需加载模块很类似。

有两种方式可以在运行时加载模块。第一种方式 是使用 SystemJsNgModuleLoader 模块加载器，如果你使用 SystemJS 加载器的话，路由在加载子路由模块时也是用的 SystemJsNgModuleLoader 作为模块加载器。SystemJsNgModuleLoader 模块加载器有一个 load 方法来把模块加载到浏览器里，同时编译该模块和在该模块中申明的所有组件。load 方法需要传入文件路径参数，并加上导出模块的名称，返回值是 NgModuleFactory：

loader.load('path/to/file#exportName')

注：NgModuleFactory 源码是在 packages/core/linker 文件夹内，该文件夹里的代码主要是粘合剂代码，主要都是一些接口类供 Core 模块使用，具体实现在其他文件夹内。

如果没有指定具体的导出模块名称，加载器会使用默认关键字 default 导出的模块名。还需注意的是，想要使用 SystemJsNgModuleLoader 还需像这样去注册它：

providers: [
    {
      provide: NgModuleFactoryLoader,
      useClass: SystemJsNgModuleLoader
    }
  ]

你当然可以在 provide 里使用任何标识（token），不过路由模块使用 NgModuleFactoryLoader 标识，所以最好也使用相同 token。（注：NgModuleFactoryLoader 注册可查看源码 L68，使用可查看 L78）

模块加载并获取组件工厂的完整代码如下：

@Component({
  providers: [
    {
      provide: NgModuleFactoryLoader,
      useClass: SystemJsNgModuleLoader
    }
  ]
})
export class ModuleLoaderComponent {
  constructor(private _injector: Injector,
              private loader: NgModuleFactoryLoader) {
  }

  ngAfterViewInit() {
    this.loader.load('app/t.module#TModule').then((factory) => {
      const module = factory.create(this._injector);
      const r = module.componentFactoryResolver;
      const cmpFactory = r.resolveComponentFactory(AComponent);
      
      // create a component and attach it to the view
      const componentRef = cmpFactory.create(this._injector);
      this.container.insert(componentRef.hostView);
    })
  }
}

但是在使用 SystemJsNgModuleLoader 时还有个问题，上面代码的 load() 函数内部（注：参见 L70）其实是使用了编译器的 compileModuleAsync 方法，该方法只会为在 entryComponents 中注册的或者在组件模板中使用的组件，去创建组件工厂。但是如果你就是不想要把组件注册在 entryComponents 属性里，是不是就完蛋了呢？仍然有解决方案 —— 使用 compileModuleAndAllComponentsAsync 方法自己去加载模块。该方法会为模块里所有组件生成组件工厂，并返回 ModuleWithComponentFactories 对象：

class ModuleWithComponentFactories<t> {
    componentFactories: ComponentFactory<any>[];
    ngModuleFactory: NgModuleFactory<t>;</t></any></t>

下面代码完整展示如何使用该方法加载模块并获取所有组件的组件工厂（注：这是上面说的 第二种方式）：

ngAfterViewInit() {
  System.import('app/t.module').then((module) => {
      _compiler.compileModuleAndAllComponentsAsync(module.TModule)
        .then((compiled) => {
          const m = compiled.ngModuleFactory.create(this._injector);
          const factory = compiled.componentFactories[0];
          const cmp = factory.create(this._injector, [], null, m);
        })
    })
}

然而，记住，这个方法使用了编译器的私有 API，下面是源码中的 文档说明：

One intentional omission from this list is @angular/compiler, which is currently considered a low level api and is subject to internal changes. These changes will not affect any applications or libraries using the higher-level apis (the command line interface or JIT compilation via @angular/platform-browser-dynamic). Only very specific use-cases require direct access to the compiler API (mostly tooling integration for IDEs, linters, etc). If you are working on this kind of integration, please reach out to us first.

运行时动态创建组件

从上文中我们知道如何通过模块中的组件工厂来动态创建组件，其中模块是在运行时之前定义的，并且模块是可以提前或延迟加载的。但是，也可以不需要提前定义模块，可以像 AngularJS 的方式在运行时创建模块和组件。

首先看看上文中的 AngularJS 的代码是如何做的：

const template = '<span>generated on the fly: {{name}}</span>'
const linkFn = $compile(template);
const dataModel = $scope.$new();
dataModel.name = 'dynamic'

// link data model to a template
linkFn(dataModel);

从上面代码可以总结动态创建视图的一般流程如下：

1. 定义组件类及其属性，并使用装饰器装饰组件类

2. 定义模块类，在模块类中申明组件类，并使用装饰器装饰模块类

3. 编译模块和模块中所有组件，拿到所有组件工厂

模块类也仅仅是带有模块装饰器的普通类，组件类也同样如此，而由于装饰器也仅仅是简单地函数而已，在运行时可用，所以只要我们需要，就可以使用这些装饰器如 @NgModule()/@Component() 去装饰任何类。下面代码完整展示如何动态创建组件：

@ViewChild('vc', {read: ViewContainerRef}) vc: ViewContainerRef;

constructor(private _compiler: Compiler,
            private _injector: Injector,
            private _m: NgModuleRef<any>) {
}

ngAfterViewInit() {
  const template = '<span>generated on the fly: {{name}}</span>';

  const tmpCmp = Component({template: template})(class {
  });
  const tmpModule = NgModule({declarations: [tmpCmp]})(class {
  });

  this._compiler.compileModuleAndAllComponentsAsync(tmpModule)
    .then((factories) => {
      const f = factories.componentFactories[0];
      const cmpRef = this.vc.createComponent(tmpCmp);
      cmpRef.instance.name = 'dynamic';
    })
}</any>

为了更好的调试信息，你可以使用任何类来替换上面代码中的匿名类。

Ahead-of-Time Compilation

上文中说到的编译器说的是 Just-In-Time(JIT) 编译器，你可能听说过 Ahead-of-Time(AOT) 编译器，实际上 Angular 只有一个编译器，它们仅仅是根据编译器使用在不同阶段，而采用的不同叫法。如果编译器是被下载到浏览器里，在运行时使用就叫 JIT 编译器；如果是在编译阶段去使用，而不需要下载到浏览器里，在编译时使用就叫 AOT 编译器。使用 AOT 方法是被 Angular 官方推荐的，并且官方文档上有详细的 原因解释 —— 渲染速度更快并且代码包更小。（想看更多就到PHP中文网AngularJS开发手册中学习）

如果你使用 AOT 的话，意味着运行时不存在编译器，那上面的不需要编译的示例仍然有效，仍然可以使用 ComponentFactoryResolver 来做，但是动态编译需要编译器，就没法运行了。但是，如果非得要使用动态编译，那就得把编译器作为开发依赖一起打包，然后代码被下载到浏览器里，这样做需要点安装步骤，不过也没啥特别的，看看代码：

import { JitCompilerFactory } from '@angular/compiler';

export function createJitCompiler() {
  return new JitCompilerFactory([{
    useDebug: false,
    useJit: true
  }]).createCompiler();
}

import { AppComponent }  from './app.component';

@NgModule({
  providers: [{provide: Compiler, useFactory: createJitCompiler}],
  ...
})
export class AppModule {
}

上面代码中，我们使用 @angular/compiler 的 JitCompilerFactory 类来实例化出一个编译器工厂，然后通过标识 Compiler 来注册编译器工厂实例。以上就是所需要修改的全部代码，就这么点东西需要修改添加，很简单不是么。

组件销毁

如果你使用动态加载组件方式，最后需要注意的是，当父组件销毁时，该动态加载组件需要被销毁：

ngOnDestroy() {
  if(this.cmpRef) {
    this.cmpRef.destroy();
  }
}

上面代码将会从视图容器里移除该动态加载组件视图并销毁它。

ngOnChanges

对于所有动态加载的组件，Angular 会像对静态加载组件一样也执行变更检测，这意味着 ngDoCheck 也同样会被调用（注：可查看 Medium 这篇文章 If you think ngDoCheck means your component is being checked — read this article）。然而，就算动态加载组件申明了 @Input 输入绑定，但是如果父组件输入绑定属性发生改变，该动态加载组件的 ngOnChanges 不会被触发。这是因为这个检查输入变化的 ngOnChanges 函数，只是在编译阶段由编译器编译后重新生成，该函数是组件工厂的一部分，编译时是根据模板信息编译生成的。因为动态加载组件没有在模板中被使用，所以该函数不会由编译器编译生成。

Github

本文的所有示例代码存放在 Github。

注：本文主要讲了组件 b-comp 如何动态加载组件 a-comp，如果两个在同一个 module，直接调用 ComponentFactoryResolver 等 API 就行；如果不在同一个 module，就使用 SystemJsNgModuleLoader 模块加载器就行。

好了，本篇文章到这就结束了（想看更多就到PHP中文网AngularJS使用手册中学习），有问题的可以在下方留言提问

以上是關於Angular動態元件你知道多少？這裡有在angularjs中動態創建元件詳解的詳細內容。更多資訊請關注PHP中文網其他相關文章！