Principes des composants logiciels
Le composant logiciel est le résultat d'une modélisation
Le composant logiciel traite un aspect particulier d'un logiciel, assez grand pour représenter un besoin de l'utilisateur (il est compréhensible par l'utilisateur), assez petit pour permettre de multiples combinaisons d'assemblage (souplesse de la solution globale).
Sa finalité n'est pas de résoudre un problème d'informaticien mais de répondre à une demande de l'utilisateur final.
Dans un système d'informations, il peut représenter :
des documents,
des acteurs,
des actions.
Les documents sont, par exemple, des factures, des bulletins de salaire, des bordereaux comptables, des règlements, des échéanciers, etc. Les acteurs sont des clients, des salariés, des courtiers, des articles, des dépôts, des familles, des machines-outils, etc. Les actions sont des transformations de pièces, des opérations périodiques, des mailings spécialisés etc.
Quel que soit le type d'information, le composant contient ses propres règles de cohérence et de présentation.
Grâce à ses modèles et ses instructions spécifiques, Oxygène est particulièrement adapté pour écrire des composants de gestion.
A partir de l'analyse des besoins de l'utilisateur, le programmeur définit les composants qu'il juge pertinents. La première question que le programmeur peut se poser est de savoir quelle va être la taille des composants mis en œuvre :
trop petite (granularité fine), chaque composant risque d'avoir une très faible autonomie (besoin de nombreux autres composants pour fonctionner), chacun d'eux ne prenant pas en compte dans sa globalité un aspect du logiciel ;
trop grosse, il rendra extrêmement lourd le paramétrage et l'évolution du logiciel, car les composants créés seront difficilement réutilisables.
De manière abstraite, on peut dire qu'un bon découpage du logiciel est celui qui favorise, à la fois, une forte cohérence interne et une bonne autonomie de chaque composant.
Le découpage en composants n'est pas unique. Il dépend de l'activité à modéliser et de l'angle de vue avec lequel on analyse cette activité. Le type d'évolution ou d'adaptation qui devra être possible est en particulier un facteur clé.
Le composant logiciel est spécialisé, autonome et dérivable
La spécialisation
La spécialisation découle du fait que le composant remplit le plus complètement possible un aspect du logiciel. Dans le domaine de la gestion, il remplit une fonction précise de l'entreprise (du type document, acteur ou action). Lorsqu'il est installé sur le système informatique, le composant est connu sous un nom public (CLIENT, FACTURE, REGLEMENT...) et est interrogeable par tout autre composant présent.
Il présente un certain nombre de points d'entrée publics, documentés et qui sont les seules méthodes d'accès au composant. Sous cet aspect, le composant se présente comme une boîte noire. Il est garant des données stockées et de leur cohérence. Du reste, les autres composants ne peuvent avoir directement accès à ses données, persistantes ou non. L'aspect monolithique du composant garantit une plus grande fiabilité et robustesse.
L'autonomie
Un composant logiciel est constitué de programmes, de ressources et de données. Oxygène fournit des structures d'accueil indépendantes pour ces différents constituants. Les programmes sont des classes C++ générées à partir du L4G, puis compilées et stockées dans des librairies dynamiques (DLL). Les ressources sont les définitions d'écrans, d'états, de menus et de dessins et se retrouvent dans un fichier de ressources (GLB).
Quant aux données, elles sont structurées par bases et tables et chaque composant doit avoir son propre référentiel. Cependant, l'autonomie n'est véritablement réelle que si les composants peuvent se connecter entre eux de manière dynamique. C'est le cas avec les composants Oxygène : on peut écrire et générer un composant qui est susceptible de se connecter à un composant non encore écrit ou bien non présent lors de la génération. Dans la syntaxe d'appel d'un composant, le point d'entrée appelé peut, du reste, être formulé sous la forme d'une expression calculée.
La dérivabilité
Les composants Oxygène sont dérivables : ceci est une caractéristique fondamentale de leur programmation qui permet de réutiliser des composants existants afin de les adapter à des besoins spécifiques. Ce mécanisme de dérivation (ou héritage) ne remet pas en cause le code existant. En effet, l'écriture d'un composant dérivé ne nécessite pas de retoucher (voire même de posséder) les sources du composant de base : il suffit de connaître les méthodes et les données du composant de base et leurs fonctions. On peut alors décider de réécrire partiellement ou totalement certaines méthodes ou d'en définir de nouvelles. De plus, Oxygène possède un mécanisme simple d'installation de composants dérivés sur le système informatique cible. Sitôt après l'installation d'un composant dérivé sur le système, tous les appels faits à des méthodes redéfinies par le composant dérivé se font effectivement en direction du composant dérivé au lieu d'être faits vers le composant de base.
Le composant logiciel communique avec les autres composants
Bien qu'autonomes, les composants Oxygène n'en sont pas moins communicants. Ils incorporent en effet des mécanismes de communication puissants comme l'envoi de messages synchrones ou asynchrones.
En premier lieu, les liens entre composants sont dynamiques : on peut construire par programme le nom du composant et de la méthode à appeler sans que ce lien n'ait été prévu explicitement lors de la fabrication du composant.
Différents modes de communication existent comme le mode serveur (une même instance d'un composant serveur reçoit des messages en provenance de plusieurs composants clients) ou le mode point à point (une instance du composant serveur est utilisée pour une instance du composant client).
Afin de pouvoir effectuer des traitements parallèles, on peut utiliser des instances différentes du même composant.
L'échange des données entre composants peut se faire traditionnellement par le passage de paramètres associés aux méthodes appelées. Mais, il existe également la possibilité d'utiliser des structures d'interface offrant les avantages suivants :
Elles assurent efficacement le transfert de grosses quantités d'information avec une programmation minimale grâce à des automatismes incorporés.
Elles sont définies à l'extérieur du programme permettant ainsi un premier niveau d'évolution des structures de données sans remettre en cause la programmation.
Le composant est une boîte noire
Le composant est une boîte noire : il n'est pas nécessaire de connaître son contenu pour l'exploiter à partir des autres composants. Ceci est réalisé par la notion d'interface. L'interface est la partie publique du composant, la seule visible depuis l'extérieur.
On pourra restructurer complètement l'intérieur du composant : tant que la même interface sera respectée, les autres composants ne verront pas la différence !
De même qu'avec un permis de conduire unique, il est possible de conduire nombre de voitures différentes quelles que soient leurs technologies, car toutes ont les mêmes pédales, le même volant, le même levier de vitesses, la simple connaissance de l'interface d'un composant permet de l'exploiter, quelle qu'en soit la version.
A l'intérieur du composant, l'adaptation se fait par dérivation en utilisant la programmation objet. Ces modifications vont altérer le fonctionnement du composant sans le couper de l'original. Les évolutions pourront ainsi être reportées sans difficultés sur une nouvelle version du composant.