Introduction
Les JavaBeans définissent un modèle de composant simple et puissant pour Java. Ils ont pour objectif d'offrir des
unités autonomes et réutilisables qui peuvent être manipulées au moyen de la programmation par des développeurs, ou de
manière visuelle dans des outils de génération.
Les JavaBeans peuvent être des commandes d'interface graphique ou ne posséder aucune représentation visuelle. Dans
Java, les commandes d'interface graphique sont généralement des JavaBeans destinés à être manipulés par les outils de
génération. Dans J2EE, les JavaBeans simples sont généralement utilisés à partir des JSP, où ils permettent la
distinction entre la présentation HTML et le code Java contenu dans les JavaBeans.
Un JavaBean est une classe Java comportant trois caractéristiques distinctes :
Propriétés des JavaBeans
Les propriétés d'un JavaBean peuvent être accessibles par d'autres composants. Habituellement, une propriété est une
valeur privée accessible grâce à des méthodes d'accès set et get, mais il peut également s'agir d'une valeur calculée.
Les mises à jour de propriété peuvent engendrer différents effets secondaires.
Les accesseurs sont des méthodes d'accès à des propriétés en consultation et en modification qui respectent les
conventions d'attribution de nom :
void setPropertyName(PropertyType value); // setter
PropertyType getPropertyName() // getter
Pour une propriété booléenne, un accesseur en consultation peut se présenter comme suit :
boolean isPropertyName() // getter for a boolean property
Exemple : Bean Client
Voici l'exemple d'un JavaBean simple (Client) comportant deux propriétés simples : nom et e-mail. Notez la manière dont
les paires de méthodes de modification/consultation définissent les propriétés.
public class Customer {
private String name;
private String email;
public String getName() {
return name;
}
public void setName(String aName) {
name = aName;
}
public String getEmail() {
return email;
}
public void setEmail(String aEmail) {
email = aEmail;
}
}
Des JavaBeans aussi simples sont souvent utilisés dans les JSP, où ils permettent le transfert de valeurs à partir de
formulaires sur les pages Web
Propriétés indexées
Une propriété peut être simple et posséder une seule valeur, mais elle peut également représenter un ensemble de
valeurs contenues dans un tableau.
Les propriétés indexées peuvent renvoyer une valeur ou la totalité du tableau des valeurs à l'index spécifié.
Les propriétés indexées se caractérisent par les signatures suivantes :
void setPropertyName(int index, PropertyType value); // indexed setter
PropertyType getter(int index); // indexed getter
void setPropertyName(PropertyType values[]); // array setter
PropertyType[]getPropertyName(); // array getter
Propriétés liées
Le mécanisme de propriété liée fournit un service de notification lorsque la propriété change. Les objets concernés qui
souhaitent être notifiés du changement s'enregistrent à l'avance, et lorsque ce changement a lieu, une notification
leur est envoyée. Généralement, cette notification est effectuée par un événement mis en application par le composant qui possède la propriété liée, après
définition de cette dernière.
Un JavaBean qui possède une propriété liée expose des méthodes pour enregistrer et désenregistrer les objets concernés,
appelés écouteurs. Les développeurs peuvent définir leur propre mécanisme de notification, mais les bibliothèques Java
offrent un certain nombre de classes de support couramment utilisées dans le package java.beans.
Propriétés contraintes
Les propriétés contraintes sont semblables aux propriétés liées, mais la notification survient avant que la propriété
soit effectivement définie, ce qui permet aux parties concernées de rejeter le changement de la propriété en lançant
une exception PropertyVetoException.
Evénements et notification
Les événements désignent la fonction des JavaBeans qui permet aux composants développés séparément de communiquer entre
eux, grâce à la transmission des informations relatives au changement d'état. Dans ce modèle, certains composants
mettent en application des événements, qui sont traités par d'autres composants jouant le rôle d'écouteurs
d'événements.
Pour prendre en charge ce modèle de communication, le modèle de composant JavaBeans offre :
-
des propriétés qui peuvent mettre les événements en application (propriétés liées
et contraintes)
-
des méthodes d'enregistrement, qui permettent aux écouteurs de s'enregistrer
-
des événements, qui transmettent les informations relatives au changement
-
des écouteurs, capables de réagir à l'événement reçu
Le diagramme de classes suivant illustre ces concepts, en prenant l'exemple d'un JavaBean appelé EventSource qui
possède une propriété int simple.
Lors de la configuration, des écouteurs concrets s'enregistrent auprès du JavaBean. Plus tard, un autre objet appelle
la méthode setProperty, qui lance le processus de notification en créant l'objet événement. Le JavaBean
EventSource appelle alors la méthode propertyChange sur tous les écouteurs enregistrés. Les écouteurs
d'événements reçoivent l'événement, lisent les valeurs contenues et réagissent en conséquence.
Le diagramme de séquence suivant illustre l'ordre des appels :
La notification des écouteurs est synchrone par rapport à l'instance de JavaBean, qui est la source de l'événement,
mais l'écouteur peut traiter les événements dans une autre unité d'exécution.
Introspection
L'introspection est un mécanisme d'exécution qui permet de détecter les propriétés,
événements et méthodes d'un JavaBean. Utilisée par les outils de développement
et par les programmes qui n'emploient pas de dépendance définie dans le code sur d'autres composants, elle peut être
réalisée grâce à l'élaboration et à la définition d'un ensemble de conventions d'attribution de nom pour les méthodes
et les interfaces. Ses fonctions supplémentaires sont prises en charge par la classe BeanInfo. Les conventions
d'attribution de nom des JavaBeans utilisées pour l'introspection sont parfois appelées "patterns de conception", mais
vous ne devez pas les confondre avec son homonyme en conception orientée objet.
Persistance
Un JavaBean peut être conservé grâce à un mécanisme de sérialisation. Cette sérialisation peut être automatique ou
personnalisée, selon que le JavaBean implémente des interfaces sérialisables ou externalisables. JDK 1.4
introduit des classes XMLEncoder et XMLDecoder qui permettent de stocker les instances de JavaBeans au
format XML.
Personnalisation
L'apparence et le comportement d'un JavaBean peuvent être personnalisés lors de la conception. Ce processus est
particulièrement important pour les JavaBeans visuels qui sont utilisés dans des interfaces graphiques. La
personnalisation s'effectue grâce à un éditeur de propriétés ou à des personnaliseurs. Ces derniers offrent une
interface utilisateur personnalisée qui permet de configurer une instance de JavaBean lors de la conception.
BeanContext
BeanContext définit une hiérarchie des conteneurs logique qui permet aux JavaBeans d'interroger leur environnement pour
obtenir des fonctions et des services. Les mécanismes de BeanContext prennent en charge la hiérarchie des conteneurs
logique des JavaBeans et la recherche de services offerts par les JavaBeans dans cette hiérarchie.
JavaBeans™ Activation Framework
Java Activation Framework est une extension Java standard qui permet de déterminer le type d'une donnée, de
l'encapsuler, de trouver ses opérations disponibles et d'instancier un composant de logiciel qui correspond à
l'opération souhaitée sur la donnée.
Plus d'informations
Pour plus d'informations sur les JavaBeans, reportez-vous à la spécification JavaBeans API Specification, Version 1.01,
à l'adresse http://java.sun.com/. Suivez les liens Docs &
Training > Java 2 Platform, Standard Edition > Java 2 SDK, SE v1.3 documentation > JavaBeans > JavaBeans
Specification.
|