-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathnlayer-architecture.html
160 lines (144 loc) · 13.5 KB
/
nlayer-architecture.html
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
<title>Entités</title>
<link type="text/css" rel="stylesheet" href="bootstrap.min.css" />
</head>
<body>
<ul>
<li><a href="#DocIntroLayers">Introduction</a></li>
<li><a href="#DocAbpArchitecture">Architecture de ASP.NET Boilerplate</a><ul>
<li><a href="#DocDomainLayer">Couche Métier</a></li>
<li><a href="#DocAppLayer">Couche Applicative</a></li>
<li><a href="#DocInfraLayer">Couche Infrastructure</a></li>
<li><a href="#DocPresentationLayer">Couche de Présentation et Web</a></li>
<li><a href="#DocOthers">Autres</a></li>
</ul>
</li>
<li><a href="#DocLayeringSummary">En résumé</a></li>
</ul>
<h3 id="DocIntroLayers">Introduction</h3>
<p>La technique du développement applicatif en n-couches est une technique mature et reconnue pour rendre l'application moins complexe à maintenir et cela permet également de bien réutiliser les différentes fonctionnalités déjà développées. Pour garantir cela, ASP.NET Boilerplate se conforme aux principes du <strong>Domain Driven
Design</strong> qui introduit quatre couches principales:</p>
<ul>
<li><strong>La Couche de Présentation</strong>: Elle fournit une interface avec laquelle l'utilisateur peut interagir avec l'application, et réciproquement. </li>
<li><strong>La Couche Applicative</strong>: Elle dialogue avec la couche de Présentation et la Couche Métier. C'est le chef d'orchestre qui manipule les objets métiers pour réaliser des tâches spécifiques.</li>
<li><strong>La Couche Métier</strong>: Elle rassemble les différents objets métiers et leurs relations. C'est le coeur de l'application.</li>
<li><strong>La Couche Infrastructure</strong>: Elle mets à disposition des autres couches, un ensemble de fonctionnalités. A titre d'exemple, l'entrepôt permet à la couche applicative d'interagir,<em> in fine</em>, avec une base de données via un ORM.</li>
</ul>
<p>Il peut y avoir des couches supplémentaires selon les besoins. Par exemple :</p>
<ul>
<li><strong>La couche de distribution de services</strong>: Elle est utilisée pour exposer les fonctionnalités de l'application à d'autres clients. Il s'agit d'outils tels qu'ASP.NET Web API et WCF.</li>
</ul>
<p>Ce sont toutes les couches usuelles d'un architecture orientée Métier. On peut également trouver quelques écarts mineurs d'implémentation.</p>
<h3 id="DocAbpArchitecture">L'Architecture d'ASP.NET Boilerplate</h3>
<p>Un apperçu de ses couches et composants sont listés ci-dessous:</p>
<table class="table layers-table">
<thead>
<tr>
<th colspan="2"><h3>Couches</h3></th>
</tr>
</thead>
<tbody>
<tr>
<td class="layer-name col-sm-2">
Présentation
</td>
<td class="layer-building-blocks col-sm-10">
<span>View Models (Javascript)</span>
<span>Views (HTML/CSS)</span> <span><a href="/Pages/Documents/Localization">Internationalisation</a></span></td>
</tr>
<tr>
<td class="layer-name">
Web
</td>
<td class="layer-building-blocks">
<span>Web API Controllers</span>
<span>Controleurs MVC</span></td>
</tr>
<tr>
<td class="layer-name">
Application
</td>
<td class="layer-building-blocks">
<span><a href="/Pages/Documents/Application-Services">Services Applicatifs</a></span>
<span><a href="/Pages/Documents/Data-Transfer-Objects">DTOs</a></span><span><a href="/Pages/Documents/Data-Transfer-Objects#DocAutoMapping">DTO Mappers</a></span>
</td>
</tr>
<tr>
<td class="layer-name">
Métier (Core)</td>
<td class="layer-building-blocks">
<span><a href="/Pages/Documents/Entities">Entitiés</a></span>
<span>Value Objects</span> <span><a href="/Pages/Documents/Repositories">Entrepôts</a></span> Classes Métier <span>Services sur les Données Métiers</span> <span><a href="/Pages/Documents/Unit-Of-Work">Unités de travail</a></span> <span><a href="/Pages/Documents/EventBus-Domain-Events">Evènements des données métier</a></span></td>
</tr>
<tr>
<td class="layer-name">
Infrastructure</td>
<td class="layer-building-blocks">
<span>ORM</span>
<span>Outils de Migration BDD</span></td>
</tr>
</tbody>
<thead>
<tr>
<th colspan="2"><h3>Autres</h3>
</th>
</tr>
</thead>
<tbody>
<tr>
<td class="layer-name">
Côté Serveur
</td>
<td class="layer-building-blocks">
<span><a href="/Pages/Documents/Dependency-Injection">Injection de dépendance</a></span> <span><a href="/Pages/Documents/Logging">Journalisation</a></span></td>
</tr>
</tbody>
</table>
<p>La solution suivante comporte cinq projets, c'est une application multi-couches assez simple:</p>
<p>
<img alt="A solution structure" height="114" src="/SiteFiles/Content/Documents/Resources/StsSolutionStructure2.png" width="248" /></p>
<p>L'implémentation d'une couche peut se faire à travers une ou plusieurs projets. Il peut être conseillé de créer plus d'un assembly pour gérer les dépendances tierces (comme NHibernate)</p>
<h4>Couche Métier (Core)</h4>
<p>La Couche Métier est le lieu où toutes les données métiers et leurs relations doivent être implémentées.</p>
<p><a href="/Pages/Documents/Entities">Les Entitiés</a> représentent les données et les opérations liées aux opérations métier. Généralement, elles sont mappées aux tables de la base de données.</p>
<p><a href="/Pages/Documents/Repositories">Les entrepôts</a> sont comme des collections d'objets et sont utilisés pour récupérer et faire persister les données. La Couche Métier indique la composition des entrepôts mais ne les implémentent car c'est la tâche confiée à la couche Infrastructure.</p>
<p><a href="/Pages/Documents/EventBus-Domain-Events">Les évènements Métiers</a> sont utilisés pour définir des évènements exclusifs à des évènements Métiers comme les trigger et permet de les intercepter. Les Services Métiers fonctionnent avec les entités et implémentent les règles métiers au delà d'une entité isolée ; elles définissent les règles d'interactions des différents ensembles d'entités.</p>
<p><a href="/Pages/Documents/Unit-Of-Work">L'unité de travail</a> est un modèle de conception pour manipuler les entités qui ont été affectées par la logique métier afin d'en faire persister leur contenu final en base de données.</p>
<p>Cette couche devrait être indépendante de librairies tierces dans la mesure du possible..</p>
<h4 id="DocAppLayer">Couche Applicative</h4>
<p>La couche Applicative rassemble les <a href="/Pages/Documents/Application-Services">
services de l'application</a> qui sont utilisés par la couche de Présentation. Une méthode de service applicatif reçoit un <a href="/Pages/Documents/Data-Transfer-Objects">DTO</a>
(Data Transfer Object) comme paramètre d'entrée, utilise ces informations d'entrée pour exécuter différentes manipulation spécifiques avec la couche Métier et peut retourner un autre DTO, si nécessaire. Généralement, elle ne reçoit ou ne retourne pas d'entité qui permettrait à la couche de Présentation de s'afranchir de la couche Métier. Une méthode de service applicative est généralement considérée comme <a href="/Pages/Documents/Unit-Of-Work#DocAppServices">une unité de travail</a>.
<a href="/Pages/Documents/Validating-Data-Transfer-Objects">La validation de la saisie utilisateur</a> est aussi implémentée dans cette couche. ASP.NET Boilerplate fournit une infrastructure pour implémenter facilement cette validation. Une possibilité est également offerte d'utiliser un outil pour gérer les correspondances entre les entités et les DTOs tel que la librairie <a href="http://automapper.org" target="_blank">AutoMapper</a>.</p>
<h4 id="DocInfraLayer">Couche Infrastructure</h4>
<p>Alors que la Couche Métier definit les interfaces de l'<a href="/Pages/Documents/Repositories">entrepôt</a>,
la Couche Infrastructure implémente ces interfaces en utilisant des ORM comme <a href="/Pages/Documents/NHibernate-Integration" target="_blank">NHibernate</a> ou
<a href="/Pages/Documents/EntityFramework-Integration" target="_blank">EntityFramework</a>.
ASP.NET Boilerplate prévoit des classes mères pour travailler avec l'un ces ORM. La Couche Infrastrcture est utilisée pour s'afranchir des dépendances des librairies tierces.
<a href="http://www.codeproject.com/Articles/768664/Introduction-to-ASP-NET-Boilerplate#InfraMigrations" target="_blank">
Database Migrations</a> peut être aussi utile.</p>
<h4 id="DocPresentationLayer">Couche Présentation & Web</h4>
<p>La couche Web est implémentée en utilisant ASP.NET MVC et Web API. Deux approches peuvent être utilisées ici. Single-Page Applications et Multi-Page
Applications.</p>
<p>En <strong>Single-Page Application (SPA), </strong>toutes les ressources sont chargées une seul fois (ou une ressource principale et chargée et les suivantes sont chargées, à la demande, selon les besoins par le client avec les données issues du serveur. La page n'est jamais rechargée, les vues sont justes interchangées lorsque nécessaire. Il existe beaucoup de framework Javascript pour faire du SPA, comme, par exemple : <a href="https://angularjs.org/" target="_blank">AngularJs</a>,
<a href="http://durandaljs.com/" target="_blank">DurandalJs</a>,
<a href="http://backbonejs.org" target="_blank">BackboneJs</a>, et <a href="http://emberjs.com/" target="_blank">EmberJs</a>. ASP.NET Boilerplate
peut travailler avec chacun d'eux, mais il fournit davantage d'exemple et d'outils pour faciliter l'intégration de AngularJs et de DurandalJs.</p>
<p>En <strong>Multi-Page (Classic) Application (MPA)</strong>, le client envoit les requêtes au serveur, le serveur (via les Controleurs d'ASP.NET MVC) interroge la base de données et Razor génère le HTML adéquat. Les pages ainsi compilées sont renvoyées au client qui se charge de l'affichage. Chaque changement de page nécessite un rechargement entier de la page.</p>
<p>SPA and MPA mettent en scène des architectures complètement différentes. Une interface d'administration en SPA est tout à fait indiqué. Mais d'un autre côté, un blog relève plutôt du modèle MPA en raison de l'indexation des moteurs de recherche. Toutefois, il existe des méchanismes en SPA pour permettre l'indexation par les moteurs de recherche. Le choix de la technologie relève surtout du temps disponible pour atteindre ses objectifs.</p>
<p><a href="http://www.asp.net/signalr" target="_blank">SignalR</a> est un bon outil pour l'envoi et réception de notifications serveurs vers le client. Il permet d'offrir une expérience utilisateur riche et en temps réel.</p>
<p>Il existe plusieurs librairies et framework Javascript côté client. <a href="http://jquery.com" target="_blank">jQuery</a> est la plus populaire du secteur avec des centaines de plug-ins gratuits. Il y a aussi des outils et framework qui facilite l'écriture HTML & CSS. Par exemple, <a href="http://getbootstrap.com/" target="_blank">Twitter Bootstrap</a> est très populaire sur ces aspects.</p>
<p>ASP.NET Boilerplate fournit l'infrastructure pour créer une Couche Web API pour les services applicatifs et facilite son usage depuis Javascript (se reporter à la
<a href="/Pages/Documents/Dynamic-Web-API">documentation</a>). De plus, il est possible de bénéficier de mécanismes pour gérer facilement des menus, <a href="/Pages/Documents/Localization">l'internationnalisation</a>,
et le support multi-lingues. Disponible également, une <a href="/Pages/Documents/Javascript-API">API Javascript</a> pour simplifier l'affichage de notifications systèmes.</p>
<p>ASP.NET Boilerplate gère automatiquement l'interception des erreurs côtés serveur afin de fournir une réponse appropriée, côté client.</p>
<h3 id="DocOthers">Autres</h3>
<p>ASP.NET Boilerplate supporte et utilise l'<a href="/Pages/Documents/Dependency-Injection">Injection de Dépendance</a> à travers le framework <a href="http://docs.castleproject.org/Windsor.MainPage.ashx" target="_blank">Castle Windsor</a>.
Il utilise <a href="http://logging.apache.org/log4net/" target="_blank">Log4Net</a> pour <a href="/Pages/Documents/Logging">la gestion des logs</a> côté serveur. il est également possible de mettre en place facilement d'autres librairies, sans modifier le code source, en s'appuyant sur les fonctionnalités de Castle Windsor.</p>
<h3 id="DocLayeringSummary">En résumé</h3>
<p>ASP.NET Boilerplate met en oeuvre quelques une des meilleurs framework et librairies en plus de ses propres classes pour fournir une bonne architecture sur laquelle il est plus facile de construire des applications web multi-couches. Des <a href="/Templates">templates</a> sont disponibles pour créer ses différentes couches facilement et bénéficier ainsi d'un bon point de départ pour vos applications.</p>
</body>
</html>