RÉUTILISABILITÉ DE COMPOSANTS WEB AU TRAVERS DUNE APPROCHE BASÉE SUR JSR 168

INSTITUT DE LA
FRANCOPHONIE POUR

EUROPEAN SCHOOLNET

L’INFORMATIQUE

RAPPORT DE STAGE DE FIN D’ÉTUDES

RÉUTILISABILITÉ DE COMPOSANTS WEB AU
TRAVERS D'UNE APPROCHE BASÉE SUR JSR-168
NGUYEN TRONG KHANH (A)
PROMOTION: 12

Lieu du stage: EUN - European Schoolnet
Responsable: PhD. Jean Noël Colin
Période du stage: du 10 Avril 2008 au 10 Octobre 2008

BRUXELLES, BELGIQUE 2008


Table des matières
TABLE DES MATIERES..................................................................................................................................... I
LISTE DES FIGURES ....................................................................................................................................... III
ABREVIATION.................................................................................................................................................. IV
REMERCIEMENTS ............................................................................................................................................ V
RESUME ............................................................................................................................................................. VI
ABSTRACT ....................................................................................................................................................... VII
1.
INTRODUCTION..................................................................................................................................1
1.1.

PROBLEMATIQUE .................................................................................................................................1
1.2.
MOTIVATION........................................................................................................................................1
1.3.
OBJECTIFS ............................................................................................................................................2
1.4.
ENVIRONNEMENT DE STAGE ................................................................................................................2
1.5.
CONTRIBUTION ....................................................................................................................................3
1.6.
2.

STRUCTURE DU RAPPORT ....................................................................................................................4

ÉTAT DE L’ART ...................................................................................................................................5
2.1.
GENERAL DE LA REUTILISATION DU LOGICIEL......................................................................................5
2.1.1.
Avantages et obstacles de la réutilisation ......................................................................................5
2.1.1.1.
2.1.1.2.

2.1.2.

Taxonomie et niveaux de réutilisation ...........................................................................................9

2.1.2.1.
2.1.2.2.

2.1.3.

2.1.4.

Avantages ........................................................................................................................................... 5
Obstacles ............................................................................................................................................ 7
Logiciel AVEC la réutilisation ........................................................................................................... 9
Logiciel POUR la réutilisation ......................................................................................................... 10

Modèle d’organisation pour réutilisation ....................................................................................13
Processus de réutilisation des logiciels .......................................................................................15

2.1.4.1.
2.1.4.2.

Processus POUR la réutilisation....................................................................................................... 16
Processus AVEC la réutilisation....................................................................................................... 18

2.1.5.
Evaluation de la réutilisation.......................................................................................................20
2.2.
COMPOSANTS ET REUTILISABILITE.....................................................................................................22
2.2.1.
Composants..................................................................................................................................22
2.2.2.
Caractéristique du composant réutilisable ..................................................................................23
2.2.3.
3.

4.

Réutilisation du composant dans le contexte de développement du web .....................................24

TECHNOLOGIE ET ENVIRONNEMENT D’EXPERIMENTATION.........................................26
3.1.
PORTLET ET JSR 168..........................................................................................................................26
3.1.1.
Portlet ..........................................................................................................................................26
3.1.2.
Caractéristique et contenu de la JSR 168 ....................................................................................27
3.2.
CONTENEUR DU PORTLET ...................................................................................................................28
3.2.1.
Liferay (lportal) ...........................................................................................................................30
3.3.
3.4.

JAVA SERVER FACES (JSF) ................................................................................................................30
ICEFACES ...........................................................................................................................................32

3.5.

JAVA ARCHITECTURE FOR XML BINDDING – JAXB .........................................................................33

IMPLEMENTATION..........................................................................................................................35
4.1.
INTRODUCTION ..................................................................................................................................35
4.1.1.
Project du portail eSkills..............................................................................................................35
4.1.2.
Sous-projet Survey .......................................................................................................................36
4.1.3.

Sous-projet LOM-Recherche........................................................................................................36
4.2.
PORTLET SURVEY ..............................................................................................................................37
4.2.1.
Général des fonctions fournies du portlet ....................................................................................37
4.2.2.
Structure Survey...........................................................................................................................39

i


4.2.3.

Réutilisation de la couche du service de Liferay..........................................................................41

4.2.4.
Développement des composants réutilisables ..............................................................................44
4.2.5.
Réutilisabilité du portlet et des composants.................................................................................44
4.3.
PORTLET LOM-RECHERCHE ..............................................................................................................47
4.3.1.
Structure et implémentation du portlet ........................................................................................47
4.3.2.
Réutilisation dans le projet ..........................................................................................................49
4.3.3.
Réutilisabilité du portlet...............................................................................................................49
4.4.
ANALYSE ...........................................................................................................................................49
4.4.1.

Analyse de portlet d’implémentation ...........................................................................................49
4.4.2.
5.

Recommandation du développement des composants réutilisables .............................................52

CONCLUSION.....................................................................................................................................56

ii


Liste des figures
Figure 2-1 Modèle d’organisation Ad-hoc ............................................................................................................13
Figure 2-2 Modèle d’organisation basée sur le dépôt de la réutilisation..............................................................14
Figure 2-3 Modèle d’organisation de centralisation de réutilisation....................................................................14
Figure 2-4 Modèle d’organisation de la réutilisation basé sur le domaine...........................................................15
Figure 2-5 Processus du développement des composants réutilisables.................................................................16
Figure 2-6 Étape de réingénierie dans le processus développement des composants REBOOT...........................17
Figure 2-7 Le processus de développement du logiciel avec réutilisation ............................................................18
Figure 3-1Modèle des couches d’un portail contenir des portlets ........................................................................27
Figure 3-2 La cycle de vie d’un portlet..................................................................................................................28
Figure 3-3 La structure interne du conteneur de portlet .......................................................................................29
Figure 3-4 La position de JSF avec JSP et Java Servlet .......................................................................................31
Figure 3-5 La structure d’activité de JSF..............................................................................................................31
Figure 3-6 L’architecture d’activité d’Icefaces.....................................................................................................32
Figure 3-7 L’architecture d’activité de JAXB .......................................................................................................33
Figure 4-1 La structure du portail eSkills et la position du portlet Survey ...........................................................36
Figure 4-2 Des questions fournis par le portlet Survey .........................................................................................39
Figure 4-3 Structure des couches du portlet Survey ..............................................................................................39
Figure 4-4 Modèle des questions dans Survey.......................................................................................................40

Figure 4-5 Processus de la réutilisation de la couche du service de Liferay ........................................................41
Figure 4-6 Une partie du fichier service.xml dans la couche du service réutilisable............................................42
Figure 4-7 Modèle d’objet généré par Liferay ......................................................................................................43
Figure 4-8 Modèle de la couche du service généré par Liferay ............................................................................43
Figure 4-9 Structure du composant réutilisable du Survey ...................................................................................44
Figure 4-10 Une partie code et l’interface correspondante du composant réutilisable ........................................45
Figure 4-11 L’architecture du portlet LOM-Recherche ........................................................................................47
Figure 4-12 L’interface de recherche dans portlet LOM-Recherche ....................................................................48
Figure 4-13 Résultat de recherche du portlet LOM-Recherche ............................................................................48
Figure 4-14 La position du projet pour réutilisation............................................................................................52
Figure 4-15 Cycle de vie du développement ..........................................................................................................54

iii


Abréviation
EUN
JSF
JSP
XML
JSR

European Schoolnet
Java Server Faces
Java Server Page
Extensible Markup Language
Java Portlet Specification

WSRP
LOM

Web Services for Remote Portlets
Learning Object Metadata

LRE
JAXB
GPL
REBOOT
FORM
PECOS
IBM
SSI
CSI

Learning Resource Exchange
Java Architecture for XML Binding
GNU General Public Licence
Reuse Based on Object-Oriented Techniques
Méthode de réutilisation orientée caractéristique (feature-oriented reuse method)
Pervasive Component Systems
International Business Machines Corporation
Shipped source instruction
Changed source instruction

RSI
SIRBO

Reused source instruction
Source instructions reused by others

LOC
PDR
RCA
SCA
DCA
RVA
ADC
J2EE

Line of code
Pourcentage de réutilisation
Coût de réduction de la réutilisation
Coût de réduction du service
Coûte du développement
Valeur ajoutée de la réutilisation
Valeur ajoutée du développement
Java 2 Platform Enterprise Edition

URL
HTML

Uniform Resource Locator
HyperText Markup Language

API
AOS
AOWS
CAS
LDAP

Application Programming Interface
Architecture Orientée Service
Architecture Orientée WebService
Système d'authentification unique
Lightweight Directory Access Protocol

MVC2
IOC

Modèle Vue Contrôleur 2
Inversion of Control

LAAS
DES

Laboratory for Analysis and Architecture of Systems
Data Encryption Standard

MD5
RSA

Message-Digest Algorithm 5
Rivest Shamir Adleman - Algorithme asymétrique de cryptographie à clé publique

Ajax
DOM
SAX
JAXP
XVD

Asynchronous JavaScript and XML
Document Object Model
Simple API for XML
Java API for XML processing
Exchange of Vocabulary Definition Specification

iv


Remerciements
Je tiens en premier lieu à remercier tout particulièrement celui qui m’a dirigé pour
mon mémoire de fin d’études, Monsieur Jean Noël Colin, pour ses commentaires
éclairés et sles judicieux conseils.
J’adresse un grand merci à Jose Fernandez et Benedicte Clouet pour leurs opinions et
la correction du français de ce rapport.
Je tiens à remercier Monsieur Alain Pirotte et Monsieur David Massart qui m’ont aidé
et accueilli en Belgique pour ce stage.
Je remercie également tous les membres de European Schoolnet, qui font d’EUN un
environnement idéal de travail.
Enfin, j’exprime mon entière reconnaissance à ma famille et mes amis pour leur
soutien et leurs encouragements.

v


Résumé
La réutilisation de composant du logiciel devient de jour en jour plus importante dans
le génie logiciel. La construction et réutilisation des composants du web est encore un
nouveau problème quand la plupart du logiciel est transmis à l’environnement du web.
Dans le cadre du stage de master de recherche effectué dans l’organisation European

Schoolnet, nous avons abordé des problèmes concernant la réutilisation du logiciel, le
composant réutilisable et notamment le composant réutilisable du web et la
réutilisation de ces composants à travers une approche basée sur JSR168.
L’objectif de ce travail fut de rassembler des expériences à travers l’étude de la
réutilisation des technologies par la construction d’applications sous la forme portlet,
le développement des composants réutilisables à partir de ces applications et enfin la
proposition de recommandations sur la réutilisabilité et le processus de développement
des composants réutilisables du web.
Deux applications, que nous construisons ici, sont SurveyPortlet et LOMRecherche
intégrées dans le portail eSkills. Elles sont construites par réutilisation de composants
réutilisables. Nous créons aussi des composants réutilisables Survey à partir de
SurveyPortlet pour les réutiliser dans d’autres projets dans le futur.
Des recommandations proposées contribuent à l’orientation du développement des
composants du web plus favorablement
Mots clés : réutilisation, composant du web, composant réutilisable, réutilisation dans
le portlet, processus de développement du composant réutilisable.

vi


Abstract
Reusing of software components is becoming more and more important in the software
engineering. Building and re-using the web component is still a new problem when the
most of software is transformed to the web environment. This report of master of
research is carried out in the European Schoolnet partnership. We deal with a problem
of relative software re-use, and reusable component, especially reusable web
component and reuse of this component via an approach based JSR168.
Purpose of this work is to draw more thought in the study of reuse and technology by
building the applications in the form of portlet, the development of reusable
components in these applications. It also proposes best-practices on reusability and the

process development of reusable web components.
Two applications were built for SurveyPortlet and LOMRecherche which are
integrated into the portal eSkills. They are built by reusing the reusable components
and we create also reusable components Survey from SurveyPortlet for reuse in other
project in the future.
These best-practices contribute to the developmental orientation of web components
more favorably.
Keywords: software reuse, web component, reuse component, portlet reuse, process
development of the reuse web component.

vii


1.

Introduction

1.1. Problématique
Aujourd’hui, le logiciel est rarement créé à partir de zéro. Le logiciel devient de jour
en jour plus complexe, le cycle de vie d’un logiciel est plus court, le logiciel demande
à être développé plus rapidement. Donc, la réutilisation des produits du logiciel est
nécessaire.
La réutilisation du logiciel est le processus de création d’un logiciel à partir d’éléments
réutilisables existants. Avant, la réutilisation était réalisée par copier-coller du code
des algorithmes. Ensuite, on a parqué des fonctions dans la bibliothèque du langage de
programmation pour les réutiliser. Et aujourd’hui, la réutilisation du logiciel est
apparue sous plusieurs formes différentes, ad-hoc ou symétrique, à codes simples ou à
structures complexes, de la boîte noire à la boîte blanche. Il y a beaucoup de produits
réutilisables comme le code, la conception, le document, etc.
La réutilisation du composant est devenue plus importante dans divers aspects du

génie logiciel. Le composant est développé, maintenu et réutilisé dans plusieurs
logiciels différents. Le composant a beaucoup d’avantages. Il est facile de le distribuer
à différents ingénieurs qui le développeront parallèlement. Il est facile de maintenir le
composant quand ils ont une bonne conception d’interface car les modifications dans
la région locale n’influent pas le système. Il est facile de replacer un composant pour
mettre à niveau le système.
Le composant a une grande influence, tant sur la structure du logiciel, que sur le
processus de développement du logiciel. Mais actuellement il y a encore des
problèmes qui demandent des réponses. Quel est le composant réutilisable ? Quelles
sont les caractéristiques de la réutilisabilité du composant ? Le processus de
développement du composant et l’évaluation de réutilisation ?
Dans le monde, la plupart des logiciels a été transmis à l’environnement du web pour
fournir des services en ligne. Donc, le composant dans cet environnement a aussi
introduit des changements sur les exigences, les caractéristiques et le processus du
développement. Donc les problèmes ci-dessous deviennent plus complexes. Ils
demandent des études et expériences de développement dans ce domaine-ci.

1.2. Motivation
La réutilisation dans l’environnement du web est à partir de l’utilisation des liens dans
la page pour se connecter à d’autres pages. Il joue un rôle important dans la
réutilisation des parties du web et son contenu. L’apparition du composant du web
produit un changement dans la réutilisation dans le web. Il est utilisé dans l’application
1


complexe remplaçant des pages simples. Le portail est en cela un perfectionnement
pour construire des applications dans le domaine du web. Le portail fournit en effet un
environnement personnalisable pour que des applications du web puissent s’exécuter.
Le portlet est une application dans le portail, comparable à une mini-application web
avec une interface GUI propre. Mais, parce que le portlet est indépendant par rapport

au portail, il peut être réutilisé dans un autre portail. Et en tant qu’application, il peut
donc réutiliser des composants réutilisables. Comment construit-on des composants
réutilisables du web? Comment peut-on réutiliser des composants du web pour
construire des portlets ? Quelle est la réutilisabilité du portlet ? Ce sont des problèmes
sur lesquelles nous voulons étudier avec le titre : «La réutilisabilité de composants web
au travers d’une approche basée sur JSR168 »
Cependant, la recherche est très vaste. Dans la situation réelle, nous n’avons pas la
prétention de rechercher et proposer un processus de développement ou une nouvelle
approche. Nous nous limiterons donc à poser des recommandations quand nous
réalisons les projets du portail sous la direction de la réutilisation des composants du
web et développement des composants réutilisables.

1.3. Objectifs
Dans ce rapport, nous allons résoudre les problèmes suivants :
-

Étude des caractéristiques du composant réutilisable, particulièrement dans
l’environnement du web et dans l’environnement du portlet. Étude de la
technologie de réutilisation du logiciel dans l’entreprise, des avantages et
obstacles.

-

Avec le développement de plusieurs modules réutilisables : des composants du
Web réutilisable, des portlets réutilisables. Dans ce cas-là, nous devons
construire des applications complètes sous la forme de portlet. Les composants
développés dans ces applications deviennent des composants réutilisables.

-

Proposition de recommandations, à l’usage de la construction de composants
réutilisables.

1.4. Environnement de stage
European Schoolnet est une organisation internationale à but non lucratif, composée
de vingt-huit ministères de l’éducation en Europe. Fondé en 1997, European
Schoolnet fournit des solutions pour l’enseignement, l’étude et la collaboration dans le
domaine de l’éducation à travers la construction de portails. L’objectif est d’apporter
le changement dans les écoles par l’utilisation des nouvelles technologies.
2


1.5. Contribution
Mon stage de fin d'études s’est déroulé sur une période de 6 mois au sein de
l’organisation European Schoolnet. : Dans le cadre de ce stage, j’ai réalisé les tâches
suivantes, divisées en trois étapes, chacune correspondant environ à deux mois.
Première étape :
-

Approche du projet eSkills, trouver les exigences et l’objectif du projet. Dans
cette étape, nous avons déterminé les problèmes de ce projet. Les technologies
sont proposées pour être utilisées dans le projet.

-

Apprentissage des technologies qui était utilisées dans notre projet:
o La technologie du web.
o JSP et Java Servlet.
o Java Server Faces (JSF).
o IceFaces.

o XML et JAXB.

-

Recherche de la réutilisation du logiciel, de modèles d’organisation pour la
réutilisation, de méthodes d’évaluation de la réutilisation, et du processus de la
réutilisation du logiciel.

-

Étude du composant, de ses caractéristiques, et de la réutilisation du composant,
composant pour web.

-

Étude du portlet et portail, de la réutilisation du portlet, et de la norme JSR 168.

Deuxième étape. Dans cette étape, nous nous sommes concentrés sur l’implémentation
des portlets. Pour ma part, il s’agissait des portlets Survey et LOMRecherche.
-

Installation du portail Liferay pour exécuter des portlets. Compiler
l’environnement étendu de Liferay

-

Étude de l’installation et de la réutilisation de la couche du service de Liferay
avec le support d’un spécialiste de la société IPPON

-

Conception et implémentation du portlet Survey

-

Développement des composants réutilisables à partir de portlet Survey

-

Étude du langage LRE et modèle des métadonnées LOM pour dans le portlet
LOMRecherche.

-

Conception et implémentation du portlet LOM Recherche
3


Troisième étape :
-

Test et maintien des portlets

-

Intégration des portlets dans le portail.

-

Estimation des portlets et réutilisation.

-

Rédaction du rapport de stage

1.6. Structure du rapport
Ce rapport présentera le stage effectué à European Schoolnet de la manière suivante :
La Section 2 fournit un aperçu de la réutilisation : avantages et obstacles, modèle
d’organisation supportée pour la réutilisation, processus et évaluation sur les deux
côtés du développement, et réutilisation des produits réutilisés, des composants et des
caractéristiques de la réutilisabilité de composant, de composant du web.
La Section 3 présente des technologies d’expérimentation que nous avons utilisées
pour construire les applications : la norme JSR 168, le portail Liferay. Des composants
réutilisables dans l’environnement du web : Java Server Faces (JSF) et Icefaces. La
technologie de traitement XML : JAXB.
La Section 4 décrit l’implémentation de notre portlet. Elle comprend la conception des
portlets, et la description des caractéristiques de la réutilisation et de la réutilisabilité
de chaque portlet. Dans la partie suivante de cette section, nous allons estimer des
applications, proposer des recommandations à propos du développement des
composants réutilisables du web, particulièrement dans le contexte du portlet.
La Section 5 est la conclusion de ce rapport, quelques remarques sur mon stage et la
réutilisation du logiciel.

4


2.

État de l’art

2.1.

Généralités sur la réutilisation du logiciel

2.1.1. Avantages et obstacles de la réutilisation
La réutilisation du logiciel a des avantages dans le développement du logiciel comme
le coût, la productivité, etc. Cependant, il y a aussi des obstacles faisant barrage à
l’utilisation.
2.1.1.1.

Avantages

La réutilisation fait augmenter la qualité et la productivité du logiciel, ainsi que la
confiance dans ce logiciel. En plus, elle fait diminuer l’effort de production du logiciel.
Ces caractéristiques ne sont pas indépendantes les unes des autres, elles font
interactions entre elles.
Augmentation de la qualité
-

Qualité

Nous savons qu’un logiciel ou un composant doit être testé avant livraison. Mais
toutes les erreurs ne peuvent pas être trouvées et corrigées exhaustivement. Donc, si le
temps du test est long ou le nombre de ces tests est grands, le taux d’erreur est
diminué. Si un logiciel est produit et utilisé une fois, le nombre des erreurs est plus
grand que s’il est utilisé plusieurs fois. Des erreurs sont fixées au travers des
réutilisations. La qualité est ainsi augmentée.
-

Productivité

Si un produit tout nouveau est développé, son temps de développement est grand. En
revanche, si un projet réutilise en partie d’autres produits, il ne doit pas créer ces
produits, et le temps de développement s’en trouve donc réduit. La productivité est
plus grande.
-

Confiance

La confiance dans le produit dépend du temps pendant lequel il a été utilisé et du
nombre d’utilisation dans des contextes réels ou dans les processus de test
indépendants. Quand un composant est réutilisé, sa qualité est assurée par les clients.
La confiance en ce composant est donc renforcée.
Réduction d’effort
-

Diminution du travail et du temps du développement

5


Comme expliqué ci-dessus, la réutilisation fait augmenter la productivité. Le temps de
développement est raccourci car vous ne devez pas développer les parties réutilisées
parce qu’elles sont disponibles.
-

Temps de mise sur le marché

Le processus de développement demande des étapes rigoureuses. Le test est
indispensable. Il prend beaucoup de temps. Après le temps du test dans l’entreprise, il

va être émis dans les étapes alpha et bêta avant d’être mis sur le marché pour être testé
par des utilisateurs. Si une partie d’un produit est réutilisé. Le temps du test est réduit
du temps du test de cette partie. En plus, si le temps de développement est plus court, il
peut être livré plus tôt.
-

Documentation

Le document est important dans le processus de maintenance du logiciel. Un module
réutilisable n’exige pas de refaire des documents. On n’a besoin de rédiger de
documents pour les nouveaux composants. Le document réutilisable peut être partagé
entre plusieurs projets différents.
-

Coût de l’entretien

Quand un projet est développé avec un, ou plusieurs composants réutilisables, on n’a
besoin que d’entretenir les nouveaux composants, parce que les composants
réutilisables sont assez fiables ou qu’ils sont entretenus par une autre équipe. En plus,
des composants sont entretenus par des groupes séparés plutôt que par des groupes de
développement des composants.
-

Prix de la formation

Au fil du temps, les logiciels deviennent familiers pour beaucoup d’utilisateurs. Un
composant réutilisable n’exige des utilisateurs qu’ils se forment qu’une seule fois. Em
ce qui concerne les développeurs, ils ont déjà de bonnes connaissances sur les
composants réutilisables avant commencer à construire un nouveau logiciel.
-

Taille de l’équipe de développement

Dans une organisation, un grand groupe est plus difficile à gérer qu’un petit groupe,
qui va se montrer plus actif. Un groupe avec une taille double ne peut pas avoir une
productivité double. Si dans un projet, on réutilise beaucoup de composants, on peut
développer ce projet avec un petit groupe parce qu’on ne doit pas réaliser des codes
réduplicatifs.

6


2.1.1.2. Obstacles
Bien que la réutilisation nous apporte beaucoup de bénéfices, il y a néanmoins des
obstacles qui s'y opposent quand on l’applique dans le domaine de produit du logiciel,.
Il a plusieurs types d’obstacles concernant le facteur organisationnel, technique,
psychologique... Dans cette partie nous allons examiner ces différents types d’obstacle.
Obstacles organisationnels
Manque du support de gestion.
Normalement, quand on développe un projet, on s’intéresse à la méthode pour
compléter le produit le plus rapidement possible, mais on ne s’intéresse pas à la
stratégie pour réutiliser ce produit.
Les entreprises n’organisent pas des groupes pour la réutilisation. Les groupes
travaillent séparément. Il se peut donc que deux groupes fassent un même module dans
deux projets différents. Ce manque d’interconnexion entre les groupes et donc de
connaissance quant à la réalisation des produits, est un problème majeur. Les membres
des groupes travaillent pour résoudre un problème spécifique, ils ne développent pas
pour utiliser ensemble des modules. Donc, dans une société, la politique de réalisation
est importante. Mais beaucoup d’organisations ne disposent pas d’une telle politique.
Il ne faut surtout pas ignorer l’importance de la réutilisation, à laquelle ces entreprises

ne sont pas préparées.
Il n’y a pas d’invention ici
Beaucoup des personnes pensent que la réutilisation de logiciels externes fait barrage
au caractère créatif. Ils préfèrent développer un nouveau composant plutôt que de
réutiliser un autre.
Obstacles économiques
La réutilisation permet d’économiser sur la dépense, mais le logiciel réutilisable n’est
pas gratuit. Il faut payer pour avoir le droit de réutilisation, la formation d’utilisation,
la compréhension, la modification et adaptation au nouveau projet. Parfois, la dépense
pour réutilisation est plus importante que celles generee par la realisation d’un
nouveau produit. Nous devons comparer le bénéfice et la dépense avant de se décider
pour la réutilisation.
Obstacles techniques
La difficulté de trouver des ressources réutilisables. On ne peut pas réutiliser des
composants dans un nouveau projet si on ne trouve pas un composant adapté. La
recherche d’un composant approprié est difficiles si on n’organise pas bien le dépôt
7


qui stocke les composants réutilisables. En plus, les composants réutilisables peuvent
être produits par d’autres groupes, d’autres entreprises. Chaque groupe (entreprise)
organise les ressources réutilisables de manières différentes. La recherche est difficile
si tous les dépôts ne suivent pas la norme. Donc, une norme de stockage est nécessaire
pour résoudre ce problème.
Réutilisation du composant trouvé est impossible.
Parfois, nous avons trouvé un composant adapté aux exigences, mais que nous ne
pouvions pas utiliser dans notre projet. La modification et l’intégration de ce
composant pour l’utiliser dans un nouveau projet sont parfois plus chères que le
développement d’un composant tout nouveau. Quelques composants sont écrits dans
divers langages de programme. Si ces composant ne supporte pas la plate-forme du

projet, leur réutilisabilité est impossible.
Quelques composants ne s'accorde pas avec la réutilisation. Ce sont des composants
complexes. Ils sont développés pour un but spécifique. Pour pouvoir réutiliser ces
composants dans notre projet, nous devons installer ou intégrer beaucoup de
composants dépendants. Cela va rendre notre projet plus complexe ou trop
embarrassant. D’autre part, nous avons un grand composant réutilisable avec beaucoup
de fonctions, mais nous utilisons seulement certaines fonctions et nous ne pouvons pas
séparer les fonctions.
Modification et intégration
Un composant réutilisable n’est jamais exactement adapté à tout ce dont nous avons
besoin. Nous devons les modifier avant de les utiliser.
Quelques composants, quand ils sont intégrés aux systèmes, demandent un nouveau
système de logiciel. Si nous ne mettons pas à niveau le système du logiciel, il ne
marche pas. Dans les cas, nous réutilisons quelques composants. Chaque composant
demande une version différente du même un logiciel. Le conflit se passe. Donc, la
difficulté de modification ou d’intégration est un obstacle de la réutilisation.
Qualité pauvre
Le composant avec une qualité pauvre est une barrière à la réutilisation. Donc, nous
avons besoin d’avoir le certificat du composant réutilisable. D’autre part, nous avons
besoin de comprendre en détails les fonctions et qualité des composants, l’estimation
du composant pour s’adapter à chaque contexte de réutilisation.
Manquement du support.

8


Parfois, un composant peut satisfaire les exigences pour sa réutilisation, mais le
composant manque le support dans l’avenir. Par exemple, des composants sont
réutilisés comme la boîte noire, le programmeur ne peut pas modifier le composant, il
s’opposera à la mise à jour du système.

La licence et la différence entre des licences
Dans le monde du logiciel source ouvert, la licence est un obstacle pour la
réutilisation. On réutilise un composant avec la licence GPL. Le projet doit suivre la
GPL. Ceci fait que l’utilisateur doit délibérer avant de les réutiliser.
Autre situation, si on utilise deux composants avec des licences différentes, la
réutilisation peut être impossible s’il y a des articles contradictoires entre eux.

2.1.2. Taxonomie et niveaux de réutilisation
Il y a beaucoup de méthodes de classification des réutilisations. Nous allons aborder
quelques types de taxonomie, ensuite, nous allons présenter les niveaux de
réutilisation, des types des facteurs dans le génie de logiciel que nous pouvons
réutiliser.
2.1.2.1. Logiciel AVEC la réutilisation
Logiciel avec la réutilisation est utilisé pour indiquer des produits qui sont construits
par réutilisation de parties d’autres produits. Il y a deux modèles de réutilisation : de
bas à haute, de simple à complexe. Ils sont ad-hoc et systématiques. Deux techniques
sont utilisées : la composition ou / et la génération.
2.1.2.1.1.
-

Modèle de réutilisation

Réutilisation ad-hoc

On cherche un fragment du code, une fonction, une classe, un composant d’un projet
existant sur l’internet, dans un forum ou autres. Les éléments sont obtenus à partir de
diverses locations plutôt qu’à partir d’un dépôt de la réutilisation. C’est la forme de
réutilisation apparue la première. Elle est la réutilisation sans la préparation, sans
processus de développement.
-

Réutilisation systématique

L’organisation comprend le rôle de la réutilisation. Elle fait un plan de réutilisation.
Préparation des ressources comme les ressources humaines, les équipements, le
processus de développement du logiciel, le dépôt de réutilisation… on dit que c’est la
réutilisation systématique. La réutilisation systématique est professionnelle dans

9


l’industrie de production du logiciel. Il fait augmenter la productivité, le taux de la
réutilisation.
2.1.2.1.2.
-

Réutilisation technique

Composition

Dans ce type d’approche, le programmeur construit des logiciels en se basant sur des
composants atomiques. Ces composants peuvent s’obtenir dans les bibliothèques. Des
composants sont parqués avec des fonctions claires. Normalement, les composants
sont considérés comme des boîtes noires. On n’a pas besoin de savoir le contenu et les
activités dedans, on n’a besoin que des interfaces de connexion avec d’autres
composants. Des fonctions que ce composant peut réaliser.
Avantages de ce type. Les programmeurs peuvent réutiliser facilement des composants
réutilisables dans leur projet sans avoir de connaissances sur ces composants. Mais il y
a des inconvénients, des composants sont parqués souvent en binaires. Le
programmeur ne peut pas modifier le contenu ou changer la fonction du composant. Il

est difficile d’évaluer la réutilisation parque on ne sait pas le nombre de lignes du code
du composant.
-

Génération

Dans ce type d’approche, un outil automatique ou un générateur travaille sur une entité
comme un fichier de configuration. Cet outil va générer les codes, les fragments, le
modèle, etc. Nous allons voir un exemple de ce type (réutilisation de la couche du
service) dans la partie sur l’implémentation. Cette partie utilisée n’est pas parquée
dans le dépôt ou la bibliothèque. Elle est l’ensemble des codes générés. Des outils ou
générateurs ne sont pas nécessaires après ils sont utilisés pour générer des codes.
Ce type a un avantage. Le programmeur peut modifier le code, changer les fonctions
pour adapter l’objectif d’utilisation. Cette partie réutilisée est considérée comme une
boîte blanche parce que le programmeur doit comprendre le contenu et les activités
dedans. Quelquefois, le code est seulement un modèle pour le développement, le
programmeur doit travailler pour compléter. A ce moment, il n’y a pas de distinction
entre la partie réutilisable et la nouvelle partie développée.
La génération peut être construite et implémentée par des programmeurs expérimentés.
Mais elle n’est appliquée que dans certains domaines limités. La composition est
appliquée dans des applications plus grandes variées.
2.1.2.2. Logiciel POUR la réutilisation
2.1.2.2.1.

Intention de réutilisation
10


-

Boîte noire (black box)

Le composant réutilisable est considéré comme une boîte boire. C’est-à-dire qu’on
l’utilise sans modification, sans changement ou sans connaissance du contenu. Le
composant fournit des informations d’utilisation pour ré-utilisateur. L’utilisateur n’a
besoin de s’inquiéter que de comment le composant fonctionne. L’implémentation du
composant peut être changée sans l’effet de ré-utilisateur.
Cependant, nous pouvons étendre des fonctions du composant par utilisant la
technique orientée objet dans la langage de programmation. La technique orientée
objet permet de la modification des activités du composant utilisant dans un
programme par la constructions d’un nouveau composant héritant ce composant dont
on n’a besoin pas de comprendre le contenu dedans du composant de père. Par
exemple, le programmeur écrit une classe héritée d’une classe dans le composant et
ajoute des fonctions nécessaires. Cependant, le composant réutilisable doit être
construit avec le support de cette modification.
-

Boîte blanche (white box)

Le contenu des composants réutilisables peut être changé suivant l’objectif du
programmeur. Pour chaque composant, on peut avoir beaucoup d’occasions
d’utilisation. Donc il y a beaucoup de sous-versions du composant. Comparée à la
boîte noire, la boîte blanche est plus chère à réutiliser. Elle demande des étapes
supplémentaires: le test, le maintien.
-

Boîte transparente (glass box)

Le composant est considéré comme la boîte boire quand il est réutilisé dans d’autres
projets, mais le programmeur peut voir le contenu interne du composant. C.-à-d, le

composant fournit des informations sur comment le composant fonctionne. Ces
informations peuvent être utiles au programmeur parce qu’elles l’aident à créer un
nouveau composant ou à tirer le meilleur parti du composant.
2.1.2.2.2.

Niveau de réutilisation

Dans cette partie, nous allons présenter les niveaux de réutilisation. Ce sont des
facteurs qui sont parqués dans un composant ou qui concernent la construction d’un
composant. Ces facteurs sont considérés aussi comme des produits réutilisables dans le
domaine de logiciel.
-

Algorithme

Algorithme est une des parties réutilisables tôt. La forme de réutilisation d’algorithmes
est sous le papier ou sous le code source. Dans le livre, quelque algorithme est écrit
11


sous un pseudo-code, elle demande l’utilisateur doit transformer au langage de la
programmation nécessaire avant de l’utiliser. Normalement, on peut réutiliser
directement les algorithmes parqués, sans les modifier, ni comprendre comment ça
marche. On peut aussi modifier la structure des données pour les adapter à l’objectif de
l’utilisation.
-

La librairie des fonctions.

La fonction est la forme de réutilisation universelle. Une fonction peut parquer un

algorithme ou faire un objectif quelconque. Une fonction a des paramètres entrés et
sortis. On voit aussi que quand on utilise des commandes de langage de
programmation, on a réutilisé des fonctions.
-

Classe

La classe est une version orientée objet de la fonction. La classe fourni le mécanisme
le meilleur sur l’abstraction, la modification et l’adaptation pour réutilisation.
-

Architecture et conception

L’architecture d’un logiciel désigne la structure du système de ce logiciel. La
réutilisation de l’architecture et la conception est la construction d’applications basées
sur l’architecture et la conception d’un système existant. Normalement, une
architecture ou une conception réutilisable est d’un modèle du système célèbre ou
une étude sur un système d’une organisation. Elles sont des normes illégitimes,
utilisées universellement. La réutilisation de l’architecture ou de la conception
augmente la possibilité d’échange de données, les possibilités de modification par
d’autres groupes et la réutilisation de parties du programme.
-

Pattern

Le pattern ou patron de conception se situe en arrière de la conception. Il s’agit de la
norme pour une unité. Le pattern est utilisé pour minimiser la dépendance entre les
différentes classes quand implémenter des objets, des opérations, représentations,
implémentations, héritage dans le projet.
Le pattern est un moyen de transport des conceptions du logiciel, des expériences et

des connaissances de programmation. Il est la norme technique dans le développement
du logiciel au niveau inférieur.
-

Application

Une application peut être considérée comme un composant qui fournit des services
pour d’autres applications. La réutilisation d’application est de type ‘boîte noire’. Les
applications disposent d’un mécanisme d’interconnexion par message ou d’un
12


mécanisme propre comme un plug-in. Chaque application doit fournir des interfaces
pour qu’une autre application puisse envoyer les commandes. La composition des
applications est conçue un mécanisme ouvert pour la réutilisation.
-

Document

Un document est une partie importante dans le système du logiciel. Il aide les
utilisateurs à utiliser les produits. On pense que les documents ne peuvent pas être
réutilisés d’un projet à un autre, mais dans la plupart des entreprises, les documents ont
des formes semblables, parce qu’ils sont construits à partir de modèles communs et
réutilisés dans des projets différents.

2.1.3. Modèle d’organisation pour la réutilisation
Certes la technologie est importante, mais les hommes qui utilisent la technologie pour
créer des produits sont plus importants. Donc, les ressources humaines jouent un rôle
central dans le développement du logiciel de la réutilisation. En effet, pour que le
logiciel puisse être réutilisé, il faut que l’entreprise soit organisée de manière à pouvoir

supporter cette réutilisation. Plusieurs modèles d’organisation sont supposés supporter
la réutilisation. Ici, nous présentons quatre modèles universels en réel [Johan. 1997].
D’autres modèles sont basés sur ces modèles mais introduisent quelques modifications
comme dans l’approche REBOOT, Even-André Karlsso [Karl. 1995] divisée en trois
modèles d’organisations.
o Ad-hoc
L’entreprise organise des groupes basés sur les projets. La plupart des réutilisations se
passe dans le même projet. La réutilisation dans des projets différents est rare.

AVEC

Groupe

Groupe

POUR

Figure 2-1 Modèle d’organisation Ad-hoc

Un groupe développe des composants et ces composants peuvent être réutilisés dans
un autre groupe mais dans un projet similaire. Les composants ne sont pas destinés à
être réutilisés. Les composants ne sont donc adaptés qu’à un seul projet.
o Réutilisation basée sur le dépôt
Dans ce type d’organisation, le niveau de réutilisation est plus haut. Il y a un dépôt de
la réutilisation.
13


AVEC

Groupe

Groupe

POUR

Dépôt
Figure 2-2 Modèle d’organisation basée sur le dépôt de la réutilisation

Les groupes ont conscience du rôle de la réutilisation. Ils ont créé un dépôt pour
partager les ressources réutilisables. Cependant, il n’y a pas encore de réglementation
de stockage dans le dépôt. Les groupes ajoutent librement des composants au dépôt.
Donc, il est difficile pour d’autres personnes de réutiliser ces composants.
o Centralisation de réutilisation par les groupes du composant
Un groupe responsable de la réutilisation est ajouté au modèle décrit ci-dessus. Ce
groupe développe, cherche et organise les composants réutilisables. Grâce à ce travail,
d’autres groupes peuvent réutiliser les composants.

AVEC

POUR

Groupe

Groupe

Groupe de réutilisation

Dépôt
Figure 2-3 Modèle d’organisation de centralisation de réutilisation

L’organisation suivant ce modèle est plus professionnelle. Les bénéfices de la
réutilisation s’en trouvent augmentés.
o Réutilisation basée sur le domaine
Ce modèle est développé à partir du modèle 3 mais ajoute en plus une spécialisation
par domaine de réutilisation. Chacun des groupes est responsable de la réutilisation
dans un domaine. Ils développent des composants et aident les autres groupes pour la
réutilisation.

14


Groupe

Groupe
AVEC

Groupe de
POUR

Groupe de
domaine

domaine

Dépôt
Figure 2-4 Modèle d’organisation de la réutilisation basé sur le domaine

Tous les modèles au dessus ont des avantages et des inconvénients. Le modèle simple
est adapté aux petites organisations, le modèle complexe aux grandes organisations, il

demande beaucoup de ressources humaines et de connaissances sur la réutilisation.

2.1.4. Processus de réutilisation des logiciels
Les processus de développement dans les entreprises sont différents, ils dépendent de
l’organisation et de la préparation à la réutilisation. Normalement, l’entreprise propose
des approches différentes adaptées à son modèle d’organisation. L’approche ici se
comprend comme le processus de développement des logiciels avec/pour la
réutilisation et la méthode d’organisation d’entreprise, la méthode d’évaluation de la
réutilisation et de la conception de réutilisation. Des études de ces approches se
concentrent sur deux directions : le domaine d’ingénierie (Domain Engineering
Processes) et le processus du Product-Line [Poulin. 2007].
Le domaine d’ingénierie désigne les activités de collection, d’organisation, de
stockage des expériences de construction des systèmes du logiciel, particulièrement
dans le domaine de réutilisation des composants, pour fournir des connaissances aifn
de pouvoir construire de nouvelles applications.
Un exemple dans ce domaine est l’étude de Neighbors [Neighbors, 1980]. Neighbors
propose un prototype en se basant sur la technologie de transformation. Il inclut
l’analyse du domaine, le langage du domaine spécifique et composant, ils sont
considérés comme un ensemble de transformation. Cette approche est rappelée Draco.
Une autre approche FORM (la méthode de réutilisation orientée caractéristique) [Kang
et al., 1998] . FORM est une méthode sémantique. Elle contient deux processus

d’ingénierie : l’ingénierie du domaine et l’ingénierie de l’application. L’ingénierie du
domaine traite des activités pour analyser le système dans un domaine et créer des
références d’architectures et composants réutilisables basés sur d’analyse des résultats.
L’ingénierie de l’application traite des activités pour développer des applications
utilisant des composants créés dans l’ingénierie du domaine.
15

Le processus de Product-Line est le processus de développement des grandes
applications relatives rapidement et moins chère, par utilisation de composants
réutilisables. PECOS est un exemple de ce processus, PECOS se concentre sur deux
problèmes : maintenance, mise à jour et personnalisation des composants réutilisables
dans les systèmes embarqués.
Toutes les approches du processus de développement des réutilisations décrivent deux
activités principales : le développement pour réutilisation et le développement avec
réutilisation.
2.1.4.1. Processus POUR réutilisation
Généralement, le processus de développement pour réutilisation doit traverser les
étapes décrites ci-dessous [Karl. 1995] :
Réingénieries

Qualification

Classification
Figure 2-5 Processus du développement des composants réutilisables

o Réingénierie (Re-engineering)
Pour économiser la dépense de développement du logiciel, beaucoup d’entreprises ne
développent pas de composants réutilisables. Quand ils ont besoin des parties pour
réutiliser, ils les trouvent et les modifient avant les utiliser. Les composants
réutilisables ne sont donc pas disponibles et cela fait diminuer la possibilité de
réutilisation par l’entreprise.
Par conséquent, il est indispensable de développer des composants qui soient
réutilisables avant même que le besoin d’utilisation se pose. La réingénierie est la
première étape nécessaire pour concevoir un composant réutilisable.
La réingénierie extrait le composant ou une partie du système d’un grand système.
Les étapes de ce processus de réingénierie sont les suivantes :
-

Analyser les éléments existants.

-

Identifier des bonnes parties dans le système.

-

Choisir des candidatures pour créer des composants réutilisables.

-

Mélanger des candidatures pour devenir des composants réutilisables.
16


À partir d’un système existant. On doit analyser des éléments dans ce système comme
l’algorithme, des fragments du code, les fonctions et les classes. Puis on évalue ces
éléments afin de trouver de bons éléments. Les meilleurs éléments vont devenir des
candidats pour construire les composants. Ensuite, on mélange ces candidatures pour
former des composants réutilisables.
REBOOT utilise la technique «cluster» pour trouver des éléments. Cette methode
consiste à mesurer de la distance entre les données propres d’éléments. La distance
peut-être calculée en se basant sur des flux de données, des références et des branches
de flux de contrôle.

Analyse

Objet

Cluster des
données

Cluster des
fonctions

Clore fonction

Déterminer la

Isolation

Envelopper

réutilisabilité
Découvrir le sens

Pas candidature

Composant
réutilisable

Figure 2-6 Étape de réingénierie dans le processus développement des composants REBOOT

C’est la méthode de réingénierie de REBOOT pour créer un composant réutilisable.
Apres l’analyse des objets, ils sont ‘cluster’ en fonction de deux facteurs: données et
fonctions. On déterminer la possibilité de réutilisabilité des éléments. Ensuite, on
découvre la relation entre des éléments. Tous les éléments qui ne satisfont pas aux
critères et règles sont éliminés. Les dernières étapes sont le développement du

composant réutilisable à partir des candidatures assurant des caractéristiques de
réutilisabilité.
o Qualification
La qualification est l’évaluation du composant réutilisable grâce aux caractéristiques
de réutilisabilité. Des caractéristiques sont présentées dans la partie d’introduction du
composant. REBOOT utilise quatre facteurs pour évaluer la réutilisabilité. Ce sont la
portabilité, la flexibilité, la compréhensibilité et la confiance.
17