Architecture logicielle à base de composants

Les architectures logicielles à base de composants représentent une évolution logique des l’architectures logicielles à base d’objets. Elles décrivent les systèmes comme un ensemble de composants (unité de calcul ou de stockage) qui communiquent entre eux par l’intermédiaire de connecteurs (unité d’interactions). Leurs objectifs consistent à réduire les coûts de développement, à améliorer la réutilisation des modèles, à faire partager des concepts communs aux utilisateurs de systèmes et enfin à construire des systèmes hétérogènes à base de composants réutilisables sur étagères (COTS²). Pour asseoir le développement de telles architectures, il est nécessaire de disposer de notations formelles et d’outils d’analyse de spécifications architecturales. Les langages de description d’architecture (notés ADLs pour Architectures Description Languages) constituent une bonne réponse. La communauté académique a proposé ces dernières années un nombre considérable d’ADLs pour décrire et raisonner sur les architectures logicielles. Dans cette section, nous présentons les concepts de base de l’architecture logicielle à base de composants.

1.3.2.1 Concepts de base de l’approche orientée composant

Après les technologies objets qui ont modifié profondément l’ingénierie des systèmes logiciels améliorant ainsi leur analyse, leur conception et leur développement, nous abordons une nouvelle ère de conception de systèmes, « l’orienté composant », qui a émergé au sein de la communauté de recherche sur les « architectures logicielles » [Bass et al. 1998] [Garlan 1995] [Perry et Wolf 1992]. L’orienté composant consiste à concevoir et à développer des systèmes par assemblage de composants réutilisables à l’image par exemple des composants électroniques ou des composants mécaniques [Heineman et Councill 2001]. Plus précisément, il s’agit de :

- Concevoir et développer des systèmes à partir de composants préfabriqués, préconçus et pré-testés,

- Réutiliser ces composants dans d’autres applications, - Faciliter leur maintenance et leur évolution,

- Favoriser leur adaptabilité et leur configurabilité pour produire de nouvelles fonctionnalités et de nouvelles caractéristiques.

Le terme composant existe dans le vocabulaire informatique depuis la naissance du génie logiciel. Il a cependant d’abord désigné des fragments de code alors qu’aujourd’hui, il englobe toute unité de réutilisation [Barbier et al. 2004].

A l’origine, l’approche par composants est fortement inspirée des composants de circuits électroniques. L’expérience gagnée dans cette discipline a largement contribué aux concepts de composants et de leur réutilisation. Concernant les composants électroniques, il suffit de connaître leur principe de fonctionnement et la façon dont ils communiquent avec leur environnement pour construire un système complet sans pour autant dévoiler les détails de leur implémentation. Comme le souligne Cox [Cox 1986] l’idée de circuits logiciels intégrés conduit à la notion d’éléments logiciels qui peuvent être connectés ou déconnectés d’un système plus complexe, remplacés et/ou configurés. Les constructeurs d’applications adoptent de plus en plus cette démarche. Il s’agit alors d’assembler à partir de composants logiciels de natures très diverses pour construire une application, on ne parlera alors plus de programmation d’applications mais plutôt de composition d’applications.

Aujourd’hui le développement d’applications à base de composants constitue une voie prometteuse. Pour réduire la complexité du développement, le coût de maintenance et accroître le niveau de réutilisabilité deux principes fondamentaux doivent être respectés : « acheter plutôt que de construire » et « réutiliser plutôt que d’acheter » [McIlroy 1968].

Ainsi, le concept de réutilisation de composants logiciels a été introduit par McIlroy en 1968 [McIlroy 1968] dans une conférence de l’OTAN consacrée à la crise du logiciel suite à un échec patent de la part de développeurs pour livrer des logiciels de qualité à temps et à un prix compétitif. L’idée est de mettre en place une industrie du logiciel pour accroître la productivité des développeurs et réduire le temps de mise sur le marché (time-to-market). Pour ce faire, les développeurs doivent construire des applications à partir de composants logiciels sur étagère plutôt que de les créer à partir de rien (from scratch). Ainsi, la construction d’applications pourrait se faire d’une manière plus rapide en assemblant des composants préfabriqués.

Cependant, plusieurs questions se posent dès lors qu’on aborde la problématique des composants. De fait, la situation des composants rappelle celle des objets au début des années soixante-dix : une syntaxe disparate qui renvoie à une sémantique ambiguë.

En effet, l’utilisation de l’approche « composant » dans le développement d’applications « grandeur réelle » révèle rapidement des interrogations. Par exemple : Quelle est la définition d’un composant ? Quelle est sa granularité ? Sa portée ? Comment peut-on distinguer et rechercher les composants de manière rigoureuse ? Comment peut-on les manipuler, les assembler, les réutiliser, les installer dans des contextes matériels et logiciels variant dans le temps, les administrer, les faire évoluer, etc.

1.3.2.2 Langages de description d’architectures (ADLs)

En accompagnement de la notion d’architecture logicielle, des formalismes sont apparus au cours des années 90 : les ADLs (Architecture Description Languages) ou langages de description d’architecture à base de composants qui sont utilisés pour décrire la structure comme un assemblage d’éléments logiciels. Cela est illustré par la Figure 1.3 où on voit un client et un serveur reliés par un appel de procédure à distance (Remote Procedure Call, RPC).

Figure 1.3- Assemblage d’éléments architecturaux pouvant être décrit à l’aide d’un ADL.

De nombreux ADLs ont été développés par le milieu académique, comme Wright, Darwin, ACME, UniCon, Rapide, Aesop, C2SADL, MetaH [Medvidovic et Taylor 2000]. De manière très générale, les entités manipulées par ces langages sont des éléments bien identifiés, suffisamment abstraits et les plus indépendants possibles les uns des autres. La spécification d’un assemblage de tels éléments constitue leur construction fondamentale. De ce point de vue, même s’ils affichent a priori une certaine adéquation avec la conception à base de composants lorsqu’elle vise la réalisation d’un système par assemblage de composants logiciels préexistants, nous rappelons qu’ils ont été originellement motivés par la maîtrise de la structure de plus en plus complexe des systèmes logiciels. Dans la section 1.4 nous décrivons l’ensemble des concepts que l’on trouve dans les ADLs.

1.3.2.3 Avantages et inconvénients de l’architecture à base de composants

Dans l’architecture logicielle à base de composants :

- les interfaces sont, en général, des entités de première classe décrites explicitement par des ports et des rôles,

- les interactions sont séparées des calculs et explicitement définies dans la plupart des ADLs [Medvidovic et Taylor 2000],

Client RPC Serveur

Configuration Connecteur

Composant

- les propriétés non-fonctionnelles sont prises en compte,

- les représentations hiérarchiques sont sémantiquement plus riches que de simples relations d’héritage. Elles permettent, par exemple, les représentations multi-vues d’une architecture [Garlan 2000],

- la description d’une architecture globale d’un système peut être spécifiée avant de compléter la construction de ses composants (implémentation),

- le niveau de granularité d’un composant ou d’un connecteur est plus élevé que celui d’un objet ou d’une association respectivement,

- un style architectural définit un vocabulaire de conception et indique un ensemble de contraintes portant sur ce vocabulaire. Les styles permettent à l’architecte de spécifier une tâche de conception aux domaines spécifiques et présentent des moyens pour améliorer l’analyse de systèmes.

Cependant l’architecture logicielle à base de composants :

- fournit seulement les modèles à un niveau élevé, sans expliciter comment ces modèles peuvent être reliés au code source. Comme le souligne Garlan [Garlan et al. 2000], de telles liaisons sont importantes pour préserver l’intégrité de la conception,

- reste un concept ad-hoc connu seulement par la communauté académique, actuellement, le monde industriel s’intéresse de plus en plus à cette discipline du génie logiciel,

- enfin, malgré la norme IEEE Std 1471-2000 [IEEE 2000], il n’y a pas un réel consensus vu que plusieurs notations et approches de description d’architectures logicielles sont proposées par la communauté d’architecture logicielle.