Architecture d'Angular 2
Les applications Angular 2 sont principalement composées des 8 parties suivantes :
- 1. Modules
- 2. Composants
- 3. Modèles
- 4. Métadonnées
- 5. Liaison de données
- 6. Directives
- 7. Services
- 8. Injection de dépendances
Le diagramme suivant montre comment chaque partie fonctionne ensemble :

Dans le diagramme, les Templates sont composés de syntaxe HTML étendue par Angular ; les classes de composants gèrent ces templates ; la logique applicative est réalisée via les Services ; puis les services et les composants sont empaquetés dans des modules ; enfin, l'application est démarrée en amorçant le module racine.
Ensuite, nous analyserons séparément les 8 parties ci-dessus :
Modules
Un module est constitué d'un bloc de code qui peut être utilisé pour effectuer une tâche simple.
Les applications Angular sont modulaires et possèdent leur propre système de modules : NgModules.
Chaque application Angular doit avoir au moins un module (le module racine), qui peut généralement être nommé : AppModule.
Un module Angular est une classe avec un décorateur @NgModule, qui reçoit un objet de métadonnées décrivant les propriétés du module.
Plusieurs propriétés importantes sont les suivantes :
declarations- Les classes de vue appartiennent à ce module. Angular possède trois types de classes de vue : les composants, les directives et les pipes.
exports- Un sous-ensemble de déclarations qui peuvent être utilisées dans les modèles de composants d'autres modules.
imports- Modules dont les classes exportées sont nécessaires dans les modèles de composants de ce module.
providers- Créateurs de services. Ce module les ajoute à la table globale des services, ce qui les rend accessibles depuis n'importe quelle partie de l'application.
bootstrap- La vue principale de l'application, appelée composant racine, qui est l'hôte de toutes les autres vues de l'application. Seul le module racine doit définir la propriété bootstrap.
Le module racine le plus simple :
Le fichier app/app.module.ts :
Ensuite, nous démarrons l'application en amorçant le module racine. Dans le processus de développement, AppModule est généralement amorcé dans le fichier main.ts, comme suit :
fichier app/main.ts :
Composants
Un composant est une classe de contrôle pour un template, utilisée pour gérer la partie vue de l'application et la logique des pages.
Les composants constituent la base et le cœur des applications Angular et peuvent être utilisés dans toute l'application.
Un composant sait comment effectuer son propre rendu et configurer l'injection de dépendances.
Les composants interagissent avec la vue via une API composée de propriétés et de méthodes.
Il y a trois étapes pour créer un composant Angular :
- Importez le décorateur Component depuis @angular/core
- Créez une classe normale et décorez-la avec @Component
- Dans @Component, définissez selectorbalise personnalisée, et templateModèle
Modèles
Le langage par défaut des modèles Angular est HTML.
Nous pouvons indiquer à Angular comment afficher un composant en utilisant des modèles pour définir la vue du composant. Voici un exemple simple :
<div>
网站地址 : {{site}}
</div>
Dans Angular, les doubles accolades sont utilisées par défaut comme syntaxe d'interpolation, et la valeur entre les accolades est généralement le nom d'une variable d'une propriété du composant.
Métadonnées
Les métadonnées indiquent à Angular comment gérer une classe.
Considérez la situation suivante : nous avons un composant appelé Component, qui est une classe, jusqu'à ce que nous indiquions à Angular qu'il s'agit d'un composant.
Vous pouvez attacher des métadonnées à cette classe pour indiquer à Angular que Component est un composant.
En TypeScript, nous utilisons des décorateurs pour attacher des métadonnées.
Exemple
@Component({
selector : 'mylist',
template : '<h2>Example</h2>'
directives : [ComponentDetails]
})
export class ListComponent{...}
Le décorateur @Component peut accepter un objet de configuration et marque la classe qui le suit comme une classe de composant.
Angular créera et affichera le composant et sa vue en fonction de ces informations.
Éléments de configuration dans @Component :
-
selector- Un sélecteur CSS qui indique à Angular de trouver une balise <mylist> dans le HTML parent, puis de créer le composant et de l'insérer dans cette balise.
templateUrl- L'adresse du modèle HTML du composant.
directives- Un tableau contenant les composants ou les directives dont ce modèle dépend.
providers- Un tableau contenant les fournisseurs d'injection de dépendances pour les services dont le composant dépend.
Liaison de données
La liaison de données fournit un moyen simple et cohérent pour les applications d'afficher des données et d'interagir avec les données. C'est un mécanisme de gestion des valeurs au sein d'une application.
Grâce à ce mécanisme, des valeurs peuvent être récupérées et assignées depuis HTML, ce qui rend la lecture et l'écriture des données, ainsi que les opérations de persistance des données, plus simples et plus rapides.
Comme le montre la figure, il existe quatre formes de syntaxe de liaison de données. Chaque forme a une direction—depuis le DOM, vers le DOM, bidirectionnelle—comme l'indiquent les flèches de la figure.

Interpolation: Afficher les valeurs du composant dans les balises HTML.
<h3> {{title}} <img src="{{ImageUrl}}.html"> </h3>Liaison de propriété: Définit la propriété d'un élément sur la valeur d'une propriété du composant.
<img [src]="userImageUrl">
Liaison d'événement: Déclenchée lorsqu'un nom de méthode de composant est cliqué.
<button (click)="onSave()">保存</button>
Liaison bidirectionnelle: L'utilisation de la directive NgModel dans Angular peut rendre la liaison bidirectionnelle plus pratique.
<input [value]="currentUser.firstName" (input)="currentUser.firstName=$event.target.value" >
Directives
Les templates Angular sont dynamiques. Lorsqu'Angular les rend, il modifie le DOM en fonction des directives.
Une directive est une classe avec des "métadonnées de directive". En TypeScript, les métadonnées sont attachées à la classe via le décorateur @Directive.
Angular inclut les trois types de directives suivants :
- Directives d'attribut : directives utilisées sous la forme d'attributs d'élément.
- Directives structurelles : utilisées pour modifier la structure de l'arbre DOM.
- Composants : en tant que sous-classe importante des directives, les composants peuvent essentiellement être considérés comme des directives avec des templates.
<li *ngFor="let site of sites"></li> <site-detail *ngIf="selectedSite"></site-detail>
*ngFor indique à Angular de générer une balise <li> pour chaque élément de la liste sites.
*ngIf signifie que le composant SiteDetail sera inclus uniquement lorsque l'élément sélectionné existe.
Services
Un service dans Angular2 est un module indépendant qui encapsule une fonction spécifique et peut être utilisé par d'autres via injection.
Les services sont de nombreux types, notamment : des valeurs, des fonctions et des fonctionnalités requises par l'application.
Par exemple, lorsque du code dupliqué apparaît dans plusieurs composants, extrayez le code dupliqué dans un service pour assurer la réutilisation du code.
Voici plusieurs services courants :
- Service de journalisation
- Service de données
- Bus de messages
- Calculateur de taxes
- Configuration de l'application
L'exemple suivant est un service de journalisation utilisé pour enregistrer des journaux dans la console du navigateur :
export class Logger {
log(msg: any) { console.log(msg); }
error(msg: any) { console.error(msg); }
warn(msg: any) { console.warn(msg); }
}
Injection de dépendances
L'inversion de contrôle (IoC) est un principe de conception en programmation orientée objet qui peut être utilisé pour réduire le couplage entre le code informatique. La méthode la plus courante est appelée injection de dépendances (DI), et une autre méthode est appelée « recherche de dépendances ».
Grâce à l'inversion de contrôle, lorsqu'un objet est créé, une entité externe qui régule tous les objets du système lui transmet des références aux objets dont il dépend. En d'autres termes, les dépendances sont injectées dans l'objet.
Dans les modèles de développement traditionnels, l'appelant est responsable de la gestion des dépendances de tous les objets, et les dépendances circulaires ont toujours été un cauchemar. Mais dans le modèle d'injection de dépendances, cette responsabilité de gestion est confiée à l'injecteur, qui est chargé de remplacer les objets dépendants à l'exécution du logiciel plutôt qu'à la compilation. Cette inversion de contrôle et cette injection à l'exécution sont l'essence de l'injection de dépendances.
Angular peut déterminer quels services un composant nécessite en inspectant les types de paramètres de son constructeur. Par exemple, le constructeur du composant SiteListComponent nécessite un SiteService :
constructor(private service: SiteService) { }
Lorsqu'Angular crée un composant, il trouve d'abord un injecteur pour les services requis par le composant.
Un injecteur est un conteneur qui maintient les instances de service, en stockant les instances qui ont été créées précédemment.
Si le conteneur n'a pas encore l'instance de service demandée, l'injecteur crée une instance de service, l'ajoute au conteneur, puis renvoie le service à Angular.
Lorsque tous les services ont été résolus et renvoyés, Angular appelle le constructeur du composant avec ces services comme arguments. C'est l'injection de dépendances.
Autres extensions