Архитектура Angular 2

Приложения Angular 2 в основном состоят из следующих 8 частей:

  • 1. Модули
  • 2. Компоненты
  • 3. Шаблоны
  • 4. Метаданные
  • 5. Привязка данных
  • 6. Директивы
  • 7. Сервисы
  • 8. Внедрение зависимостей

На следующей диаграмме показано, как каждая часть работает вместе:

На диаграмме шаблоны состоят из синтаксиса HTML, расширенного Angular; классы компонентов управляют этими шаблонами; логика приложения реализуется через сервисы; затем сервисы и компоненты упаковываются в модули; наконец, приложение запускается путем начальной загрузки корневого модуля.

Далее мы разберем вышеуказанные 8 частей по отдельности:


Модули

Модуль состоит из блока кода, который можно использовать для выполнения простой задачи.

Приложения Angular являются модульными и имеют собственную систему модулей: NgModules.

Каждое приложение Angular должно иметь как минимум один модуль (корневой модуль), который обычно можно назвать: AppModule.

Модуль Angular — это класс с декоратором @NgModule, который получает объект метаданных, описывающий свойства модуля.

Несколько важных свойств:

  • declarations- Классы представлений относятся к этому модулю. В Angular есть три типа классов представлений: компоненты, директивы и каналы.

  • exports- Подмножество объявлений, которые можно использовать в шаблонах компонентов других модулей.

  • imports- Модули, экспортируемые классы которых нужны в шаблонах компонентов этого модуля.

  • providers- Создатели сервисов. Этот модуль добавляет их в глобальную таблицу сервисов, делая их доступными из любой части приложения.

  • bootstrap- Основное представление приложения, называемое корневым компонентом, которое является хостом всех остальных представлений приложения. Только корневому модулю нужно задавать свойство bootstrap.

Простейший корневой модуль:

Файл app/app.module.ts:

import { NgModule } from '@angular/core'; import { BrowserModule } from '@angular/platform-browser'; @NgModule({ imports: [ BrowserModule ], providers: [ Logger ], declarations: [ AppComponent ], exports: [ AppComponent ], bootstrap: [ AppComponent ] }) export class AppModule { }

Далее мы запускаем приложение, инициализируя корневой модуль. В процессе разработки AppModule обычно инициализируется в файле main.ts следующим образом:

файл app/main.ts:

import { platformBrowserDynamic } from '@angular/platform-browser-dynamic'; import { AppModule } from './app.module'; platformBrowserDynamic().bootstrapModule(AppModule);

Компоненты

Компонент — это класс управления для шаблона, используемый для обработки части представления приложения и логики страниц.

Компоненты — это основа и ядро приложений Angular, и они могут использоваться во всём приложении.

Компонент знает, как отображать себя и настраивать внедрение зависимостей.

Компоненты взаимодействуют с представлением через API, состоящий из свойств и методов.

Есть три шага для создания компонента Angular:

  • Импортируйте декоратор Component из @angular/core
  • Создайте обычный класс и декорируйте его с помощью @Component
  • В @Component установите selectorпользовательский тег, и templateШаблон

Шаблоны

Язык шаблонов Angular по умолчанию — HTML.

Мы можем указать Angular, как отображать компонент, используя шаблоны для определения представления компонента. Ниже приведён простой пример:

<div>
网站地址 : {{site}}
</div>

В Angular двойные фигурные скобки по умолчанию используются как синтаксис интерполяции, и значение между фигурными скобками обычно является именем переменной свойства компонента.


Метаданные

Метаданные сообщают Angular, как обрабатывать класс.

Рассмотрим следующую ситуацию: у нас есть компонент под названием Component, который является классом, пока мы не сообщим Angular, что это компонент.

Вы можете прикрепить метаданные к этому классу, чтобы сообщить Angular, что Component — это компонент.

В TypeScript мы используем декораторы для прикрепления метаданных.

Пример

@Component({
   selector : 'mylist',
   template : '<h2>Example</h2>'
   directives : [ComponentDetails]
})
export class ListComponent{...}

Декоратор @Component может принимать объект конфигурации и помечает следующий за ним класс как класс компонента.

Angular создаст и отобразит компонент и его представление на основе этой информации.

Элементы конфигурации в @Component:

  • selector- CSS-селектор, который указывает Angular найти тег <mylist> в родительском HTML, затем создать компонент и вставить его в этот тег.

  • templateUrl- Адрес HTML-шаблона компонента.

  • directives- Массив, содержащий компоненты или директивы, от которых зависит этот шаблон.

  • providers- Массив, содержащий провайдеры внедрения зависимостей для сервисов, от которых зависит компонент.


Привязка данных

Привязка данных предоставляет простой и согласованный способ для приложений отображать данные и взаимодействовать с данными. Это механизм управления значениями внутри приложения.

Благодаря этому механизму значения можно извлекать и присваивать из HTML, что делает операции чтения и записи данных, а также сохранения данных проще и быстрее.

Как показано на рисунке, существует четыре формы синтаксиса привязки данных. Каждая форма имеет направление — из DOM, в DOM, двунаправленное — как показывают стрелки на рисунке.

  • Интерполяция: отображение значений компонента в тегах HTML.

    <h3>
    {{title}}
    <img src="{{ImageUrl}}.html">
    </h3>
    
  • Привязка свойств: устанавливает свойство элемента в значение свойства компонента.

    <img [src]="userImageUrl">
    
  • Привязка событий: срабатывает при щелчке по имени метода компонента.

    <button (click)="onSave()">保存</button>
    
  • Двусторонняя привязка: использование директивы NgModel в Angular делает двустороннюю привязку более удобной.

    <input [value]="currentUser.firstName"
           (input)="currentUser.firstName=$event.target.value" >
    

Директивы

Шаблоны Angular динамичны. Когда Angular рендерит их, он изменяет DOM в соответствии с директивами.

Директива — это класс с «метаданными директивы». В TypeScript метаданные прикрепляются к классу с помощью декоратора @Directive.

Angular включает следующие три типа директив:

  • Атрибутные директивы: директивы, используемые в форме атрибутов элемента.
  • Структурные директивы: используются для изменения структуры дерева DOM.
  • Компоненты: как важный подкласс директив, компоненты по сути можно рассматривать как директивы с шаблонами.
<li *ngFor="let site of sites"></li>
<site-detail *ngIf="selectedSite"></site-detail>

*ngFor указывает Angular создавать тег <li> для каждого элемента в списке sites.

*ngIf означает, что компонент SiteDetail будет включён только тогда, когда выбранный элемент существует.


Сервисы

Сервис в Angular2 — это независимый модуль, который инкапсулирует определённую функцию и может использоваться другими через внедрение зависимостей.

Сервисы бывают разных типов, включая: значения, функции и функциональные возможности, необходимые приложению.

Например, когда дублирующийся код появляется в нескольких компонентах, вынесите дублирующийся код в сервис, чтобы добиться повторного использования кода.

Вот несколько распространённых сервисов:

  • Сервис логирования
  • Сервис данных
  • Шина сообщений
  • Калькулятор налогов
  • Конфигурация приложения

В следующем примере представлен сервис логирования, используемый для записи логов в консоль браузера:

export class Logger {
  log(msg: any)   { console.log(msg); }
  error(msg: any) { console.error(msg); }
  warn(msg: any)  { console.warn(msg); }
}

Внедрение зависимостей

Инверсия управления (IoC) — это принцип проектирования в объектно-ориентированном программировании, который можно использовать для уменьшения связанности между программным кодом. Наиболее распространённый способ называется внедрением зависимостей (DI), а другой способ называется «поиском зависимостей».

Благодаря инверсии управления, когда создаётся объект, внешняя сущность, которая управляет всеми объектами в системе, передаёт ему ссылки на объекты, от которых он зависит. Иными словами, зависимости внедряются в объект.

В традиционных моделях разработки вызывающая сторона отвечает за управление зависимостями всех объектов, и циклические зависимости всегда были кошмаром. Но в шаблоне внедрения зависимостей эта ответственность за управление передаётся инжектору, который отвечает за замену зависимых объектов во время выполнения программы, а не во время компиляции. Эта инверсия управления и внедрение во время выполнения — суть внедрения зависимостей.

Angular может определить, какие сервисы нужны компоненту, проверив типы параметров его конструктора. Например, конструктору компонента SiteListComponent требуется SiteService:

constructor(private service: SiteService) { }

Когда Angular создаёт компонент, он сначала находит инжектор для сервисов, необходимых компоненту.

Инжектор — это контейнер, который хранит экземпляры сервисов, сохраняя ранее созданные экземпляры.

Если в контейнере ещё нет запрошенного экземпляра сервиса, инжектор создаёт экземпляр сервиса, добавляет его в контейнер и затем возвращает сервис Angular.

Когда все сервисы разрешены и возвращены, Angular вызывает конструктор компонента с этими сервисами в качестве аргументов. Это и есть внедрение зависимостей.

Другие расширения