2023
2024
GROUPE 1
PROF : MR AKANATE
2023 2024
EXPOSE SUR LES JAVABEANS
EXPOSE SUR LES JAVABEANS
I. INTRODUCTION
Les JavaBeans sont des composants logiciels en Java qui suivent des
conventions de design strictes. De nombreuses fonctionnalités ont ensuite été
ajoutées pour développer des caractéristiques de ces composants. Les
JavaBeans sont couramment appelés beans tout simplement.
Les beans sont prévus pour pouvoir interagir avec d'autres beans au point de
pouvoir développer une application simplement en assemblant des beans avec
un outil graphique dédié. Sun fournit gratuitement un tel outil : le B.D.K. (Bean
Development Kit).
II. La présentation des Java beans
Des composants réutilisables sont des objets autonomes qui doivent pouvoir
être facilement assemblés entres eux pour créer un programme.
Microsoft propose la technologie ActiveX pour définir des composants mais
celle-ci est spécifiquement destinée aux plates-formes Windows.
Les Javabeans proposés par Sun reposent bien sûr sur Java et de fait en
possèdent toutes les caractéristiques : indépendance de la plate-forme, taille
réduite du composant, ...
La technologie JavaBeans propose de simplifier et faciliter la création et
l'utilisation de composants.
Avantages des Javabeans :
Réutilisabilité : Ils peuvent être utilisés dans différents contextes sans
modification.
Portabilité : Ils adhèrent aux standards Java, ce qui garantit leur
compatibilité sur diverses plateformes.
Interopérabilité : Ils peuvent interagir avec d'autres composants Java,
facilitant ainsi l'intégration système.
Les JavaBeans possèdent plusieurs caractéristiques :
La persistance : elle permet grâce au mécanisme de sérialisation de
sauvegarder l'état d'un bean pour le restaurer. Ainsi si on assemble plusieurs
beans pour former une application, on peut la sauvegarder.
GROUPE 1
EXPOSE SUR LES JAVABEANS
2 La communication, grâce à des événements, qui utilise le modèle des
écouteurs introduit par Java 1.1
L’introspection : ce mécanisme permet de découvrir de façon dynamique
l'ensemble des éléments qui composent le bean (attributs, méthodes et
événements) sans avoir le code source.
La possibilité de paramétrer le composant : les données du paramétrage sont
conservées dans des propriétés.
Ainsi, les beans sont des classes Java qui doivent respecter un certain nombre
de règles :
Ils doivent posséder un constructeur sans paramètre. Celui-ci devra
initialiser l'état du bean avec des valeurs par défauts.
Ils peuvent définir des propriétés : celles-ci sont identifiées par des
méthodes dont le nom et la signature sont normalisés
Ils devraient implémenter l'interface serialisable : ceci est obligatoire
pour les beans qui possèdent une partie graphique pour permettre la
sauvegarde de leur état
Ils définissent des méthodes utilisables par les composants extérieurs :
elles doivent être public et prévoir une gestion des accès concurrents
Ils peuvent émettre des événements en gérant une liste d'écouteurs qui
s'y abonnent grâce à des méthodes dont les noms sont normalisés
Le type de composants le plus adapté est le composant visuel. D'ailleurs, les
composants des classes A.W.T. et Swing pour la création d'interfaces
graphiques sont tous des beans. Mais les beans peuvent aussi être des
composants non visuels pour prendre en charge les traitements.
III. Propriétés
1. Encapsulation
L'encapsulation est un principe fondamental en programmation orientée
objet. Elle permet de cacher les détails d'implémentation d'une classe et
d'exposer uniquement les méthodes nécessaires pour interagir avec l'objet.
2. Constructeur par Défaut
La présence d'un constructeur sans argument assure que le JavaBean peut être
instancié de manière générique, sans nécessiter de paramètres spécifiques.
GROUPE 1
EXPOSE SUR LES JAVABEANS
3
3. Accesseurs (Getters) et Mutateurs (Setters)
Les accesseurs et mutateurs sont des méthodes publiques qui permettent de
lire et de modifier les valeurs des propriétés privées d'un JavaBean.
IV. Les événements
Pour dialoguer, Les beans utilisent les événements définis dans le modèle par
délégation introduit par le J.D.K. 1.1. Par respect de ce modèle, le bean est la
source et les autres composants qui souhaitent être informés sont nommés «
Listeners » ou « écouteurs » et doivent s'enregistrer auprès du bean qui
maintient la liste des composants enregistrés.
Il est nécessaire de définir les méthodes qui vont permettre de gérer la liste des
écouteurs désirant recevoir l'événement. Il faut définir deux méthodes :
public void addXXXListener( XXXListener li) pour enregistrer l'écouteur li.
public void removeXXXListener (XXXListener li) pour enlever l'écouteur li de la
liste.
L'objet de type XXXListener doit obligatoirement implémenter l'interface
[Link] et son nom doit terminer par « Listener ».
Les événements peuvent être mono ou multi écouteurs.
Pour les événements mono écouteurs, la méthode addXXXListener() doit
indiquer dans sa signature qu'elle est susceptible de lever l'exception
[Link] si un écouteur tente de s'enregistrer et
qu'il y en a déjà un présent.
V. L'introspection
L'introspection est un mécanisme qui permet de déterminer de façon
dynamique les caractéristiques d'une classe et donc d'un bean. Les
caractéristiques les plus importantes sont les propriétés, les méthodes et les
événements. Le principe de l'introspection permet à Sun d'éviter de rajouter
des éléments au langage pour définir ces caractéristiques.
GROUPE 1
EXPOSE SUR LES JAVABEANS
4 L'API JavaBean définit la classe [Link] qui facilite et
standardise la recherche des propriétés, méthodes et événements du bean.
Cette classe possède des méthodes pour analyser le bean et retourner un objet
de type BeanInfo contenant les informations trouvées.
La classe Introspector utilise deux techniques pour retrouver ces informations :
Un objet de type BeanInfo, s'il y en a un défini par les développeurs du
bean.
Les mécanismes fournis par l'API reflexion pour extraire les entités qui
respectent leurs modèles (design pattern) respectifs.
Il est donc possible de définir un objet BeanInfo qui sera directement utilisé par
la classe Introspector. Cette définition est utile si le bean ne respecte pas
certains modèles (design patterns) ou si certaines entités héritées ne doivent
pas être utilisables. Dans ce cas, le nom de cette classe doit obligatoirement
respecter le modèle XXXBeanInfo ou XXX est le nom du bean correspondant. La
classe Introspector recherche une classe respectant ce modèle.
Si une classe BeanInfo est définie pour un bean, une classe qui hérite du bean
n'est pas obligée d'en définir une. Dans ce cas, la classe Introspector utilise les
informations du BeanInfo de la classe mère et ajoute les informations
retournées par l'API Reflection sur le bean.
Sans classe BeanInfo associée au bean, les méthodes de la classe Introspector
utilisent les techniques d'introspection pour analyser le bean.
1. Les modèles (design patterns)
La classe Introspector utilise l'API reflection pour déterminer les informations
sur le bean et utilise en même temps un ensemble de modèles sur chacune des
entités propriétés, méthodes et événements.
Pour déterminer les propriétés, la classe Introspector recherche les méthodes
getXxx(), setXxx() et isXxx() où Xxx représente le nom de la propriété dont la
première lettre est en majuscule. La première lettre du nom de la propriété est
remise en minuscule sauf si les deux premières lettres de la propriété sont en
majuscules.
GROUPE 1
EXPOSE SUR LES JAVABEANS
5 Pour déterminer les méthodes, la classe Introspector va rechercher toutes les
méthodes publiques.
Pour déterminer les événements, la classe Introspector recherche les
méthodes addXxxListener() et removeXxxListener(). Si les deux sont présentes,
elle en déduit que l'événement xxx est défini dans le bean. Comme pour les
propriétés, la première lettre du nom de l'événement est mise en minuscule.
2. La classe BeanInfo
La classe BeanInfo contient des informations sur un bean et possède plusieurs
méthodes pour les obtenir.
La méthode getBeanInfo() prend en paramètre un objet de type Class qui
représente la classe du bean et elle renvoie des informations sur la classe et
toutes ses classes mères.
Une version surchargée de la méthode accepte deux objets de type Class : le
premier représente le bean et le deuxième représente une classe appartenant
à la hiérarchie du bean. Dans ce cas, la recherche d'informations s'arrêtera
juste avant d'arriver à la classe précisée en deuxième argument.
Exemple : obtenir des informations sur le bean uniquement (sans informations
sur ses super-classes)
Exemple (code Java 1.1) :
Class monBeanClasse = [Link]("monBean");
BeanInfo bi = [Link](monBeanClasse,
[Link]());
La méthode getBeanDescriptor() permet d'obtenir des informations générales
sur le bean en renvoyant un objet de type BeanDescriptor()
La méthode getPropertyDescriptors() permet d'obtenir un tableau d'objets de
type PropertyDescriptor qui contiennent les caractéristiques d'une propriété.
Plusieurs méthodes permettent d'obtenir ces informations.
Exemple (code Java 1.1) :
PropertyDescriptor[] propertyDescriptor =
[Link]();
for (int i=0; i<[Link]; i++) {
GROUPE 1
EXPOSE SUR LES JAVABEANS
[Link](" Nom propriete : " +
6
propertyDescriptor[i].getName());
[Link](" Type propriete : "
+ propertyDescriptor[i].getPropertyType());
[Link](" Getter propriete : "
+ propertyDescriptor[i].getReadMethod());
[Link](" Setter propriete : "
+ propertyDescriptor[i].getWriteMethod());
}
La méthode getMethodDescriptors() permet d'obtenir un tableau d'objets de
type MethodDescriptor. Cette classe fournit plusieurs méthodes pour extraire
les informations des objets contenus dans le tableau.
Exemple (code Java 1.1) :
MethodDescriptor[] methodDescriptor =
[Link]();
for (int i=0; i < [Link]; i++) {
[Link](" Methode :
"+methodDescriptor[i].getName());
}
La méthode getEventSetDescriptors() permet d'obtenir un tableau d'objets de
type EventSetDescriptor qui contient les caractéristiques d'un événement.
Plusieurs méthodes permettent d'obtenir ces informations.
Exemple (code Java 1.1) :
EventSetDescriptor[] unEventSetDescriptor =
[Link]();
for (int i = 0; i < [Link]; i++) {
[Link](" Nom evt : "
+ unEventSetDescriptor[i].getName());
[Link](" Methode add evt : " +
unEventSetDescriptor[i].getAddListenerMethod());
[Link](" Methode remove evt : " +
GROUPE 1
EXPOSE SUR LES JAVABEANS
unEventSetDescriptor[i].getRemoveListenerMethod());
7
methodDescriptor =
unEventSetDescriptor[i].getListenerMethodDescriptors();
for (int j = 0; j < [Link]; j++) {
[Link](" Event Type: " +
methodDescriptor[j].getName());
}
}
Exemple (code Java 1.1) :
import [Link].*;
import [Link].*;
import [Link].*;
public class BeanIntrospection {
static String nomBean;
public static void main(String args[]) throws Exception {
nomBean = args[0];
new BeanIntrospection();
}
public BeanIntrospection() throws Exception {
Class monBeanClasse = [Link](nomBean);
MethodDescriptor[] methodDescriptor;
BeanInfo bi = [Link](monBeanClasse,
[Link]());
BeanDescriptor unBeanDescriptor = [Link]();
[Link]("Nom du bean : " +
[Link]());
GROUPE 1
EXPOSE SUR LES JAVABEANS
[Link]("Classe du bean : " +
8
[Link]());
[Link]("");
PropertyDescriptor[] propertyDescriptor =
[Link]();
for (int i=0; i<[Link]; i++) {
[Link](" Nom propriete : " +
propertyDescriptor[i].getName());
[Link](" Type propriete : "
+ propertyDescriptor[i].getPropertyType());
[Link](" Getter propriete : "
+ propertyDescriptor[i].getReadMethod());
[Link](" Setter propriete : "
+ propertyDescriptor[i].getWriteMethod());
}
[Link]("");
methodDescriptor = [Link]();
for (int i=0; i < [Link]; i++) {
[Link](" Methode :
"+methodDescriptor[i].getName());
}
[Link]("");
EventSetDescriptor[] unEventSetDescriptor =
[Link]();
for (int i = 0; i < [Link]; i++) {
[Link](" Nom evt : "
+ unEventSetDescriptor[i].getName());
[Link](" Methode add evt : " +
unEventSetDescriptor[i].getAddListenerMethod());
[Link](" Methode remove evt : " +
GROUPE 1
EXPOSE SUR LES JAVABEANS
unEventSetDescriptor[i].getRemoveListenerMethod());
9
methodDescriptor =
unEventSetDescriptor[i].getListenerMethodDescriptors();
for (int j = 0; j < [Link]; j++) {
[Link](" Event Type: " +
methodDescriptor[j].getName());
}
}
[Link]("");
}
VI. La persistance
Les propriétés du bean doivent pouvoir être sauvegardées pour être restituées
ultérieurement. Le mécanisme utilisé est la sérialisation. Pour permettre
d'utiliser ce mécanisme, le bean doit implémenter l'interface Serializable.
EXEMPLE DE CODE JAVABEANS
// [Link]
public class PersonBean implements Serializable {
private String name;
private boolean major;
// Constructeur par défaut (ne prend pas
d'arguments).
public PersonBean() { }
public String getName() {
return [Link];
}
public void setName(String name) {
[Link] = name;
GROUPE 1
EXPOSE SUR LES JAVABEANS
10 }
/* Sémantique différente pour les booléens. (get vs
is)
Ici, nous optons pour un préfixe 'is'. */
public boolean isMajor() {
return [Link];
}
public void setMajor(boolean major) {
[Link] = major;
}
}
[Link]
public class TestPersonBean {
public static void main(String[] args) {
PersonBean person = new PersonBean();
[Link]("Bob");
[Link](true);
// Affiche : "Bob [majeur]"
[Link]([Link]());
[Link]([Link]() ? "
[majeur]" : " [mineur]");
}
}
VII. Conclusion
GROUPE 1
EXPOSE SUR LES JAVABEANS
11 En résumé, les JavaBeans sont essentiels pour le développement Java. Ils
offrent une structure standardisée pour créer des composants logiciels qui sont
à la fois réutilisables et faciles à maintenir.
GROUPE 1
