Java Beans

1
Programmation par composants (1/3)
La programmation par composant
vise le développement de logiciel par aggrégation de briques logicielles
existantes
est indépendante de la POO
La programmation par composant fait évoluer la POO
Réutilisabilité accrue du code
Persistance des objets
Distribution du code et des objets (des objets peuvent être partagés par des
applications différentes tournant sur des machines différentes)
Sécurité au niveau de l'exécution concurrente
2
Programmation par composants (2/3)
Un composant est une brique logicielle
Taille variable (d'une classe à une application entière)
Granularité variable (ossature logicielle, élément d'interface, classe métier, ...)
Fonctions variées
•Composants techniques : ossature du code, éléments d'interfaces graphiques,
utilitaires pour manipuler des données, ...
•Composants métiers : représentent des entités du domaine (client, produit, ...)
•Composants applicatifs : dédiés aux traitements internes d'une application (peu
réutilisables)
Un composant doit offrir
Robustesse : le comportement doit être celui attendu (et sans bug!)
Généricité : le composant doit pouvoir être adapté à l'application (sans le
modifier!)
Abstraction : le composant doit offrir une interface claire et être utilisable sans
consulter son code (son implémentation doit être autonome)

3
Programmation par composants (3/3)
Programmation par composants
Sélection des composants dans un catalogue
Eventuellement développement de nouveaux composants
Adaptation des composants à l'application
Assemblage des composants, avec ajout éventuel de code
Modèles de programmation par composants
EJB (Enterprise Java Beans) : programmation distribuée et interopérabilité
Java Beans : assemblage visuel (interfaces en particulier)
CORBA de l'OGM (Object Management Group)
OLE/ActiveX, COM et .NET dans le monde Microsoft
4
JavaBean (1/2)
Java propose un modèle de composant : Java Bean (grain de café)
Caractéristiques d'un JavaBean :
Règles de dénomination : permettent de normaliser le nommage des membres
des bean et donc d'automatiser leur manipulation
Réflexion : les beans (comme tous les objets Java) peuvent donner des
informations sur eux-mêmes, non seulement sur leur état mais aussi sur leur
constitution interne
Persistance : un bean peut être sauvegardé en l'état (avec les valeurs des
attributs) et réactivé plus tard par sérialisation
Communication : les beans communiquent via le modèle événementiel et le
pattern d'écouteur (Listener)

5
JavaBean (2/2)
Les JavaBeans sont toutes les classes Java qui respectent un
certains 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 attributs et
méthodes dont le nom et la signature sont normalisés
ils doivent implémenter l'interface Serializable : 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 publiques 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 via des méthodes dont les noms sont normalisés
Les classes des API graphiques de Java (AWT et Swing) sont des
JavaBeans
6
Propriétés dans un JavaBean
L'accès aux attributs (propriétés) est contrôlé
Attributs toujours privés (ou à la rigueur protégés)
Les attributs peuvent n'avoir qu'un accesseur (ils sont en lecture seule), qu'un
modifieur (ils sont en écriture seule)
Accesseurs et modifieurs sont normalisés
Accesseur : <type_attribut> get<nom_attribut>()
(is<nom_attribut> si l'attribut est booléen)
Modifieur : void set<nom_attribut>(<type_attribut>
<nom_variable>)
Le nom de l'attribut n'est pas forcément celui de la variable qui le contient!
public class GrainDeCafe{
private int poids;
private boolean truc;
...
public int getPoids(){return this.poids;}
public void setPoids(int a){this.poids = a;}
public void getArabica(){return this.truc;}
}

7
Propriétés indexées
Quand les attributs sont des tableaux, les accesseurs et modifieurs
ont un indice en paramètre supplémentaire
public class GrainDeCafe{
private float[] dimensions = new float[3];
private boolean truc;
public GrainDeCafe(){
dimensions[0] = 0.5;
dimensions[1] = 1.0;
dimensions[2] = 0.4;
truc = a;
}
public float getDimension(int axe){return this.dimensions[axe];}
public void setDimension(float a, int axe){this.dimensions[axe] = a;}
public void getArabica(){return this.truc;}
}
8
Propriétés liées (1/3)
Un JavaBean peut observer une propriété d'un autre JavaBean via un
mécanisme implémentant le pattern Observer. La propriété est alors
dite liée (bound property)
Le JavaBean observé intègre par composition un objet
PropertyChangeSupport
PropertyChangeSupport gère une liste d'écouteurs de type
PropertyChangeListener qui jouent le rôle d'observateurs
PropertyChangeSupport permet de notifier aux écouteurs les changements
intervenant sur une propriété liée
Les JavaBeans observateurs implémentent l'interface
PropertyChangeListener qui ne contient qu'une méthode
void propertyChange(PropertyChangeEvent evt)
La classe d'événements PropertyChangeEvent encapsule les données qui
décrivent le changement de valeur de la propriété (nom de la propriété,
ancienne valeur, nouvelle valeur, ...)

9
Propriétés liées (2/3)
public class GrainDeCafe{
private int poids;
private boolean truc;
private PropertyChangeSupport pcs;
public GrainDeCafe(){
...
pcs = new PropertyChangeSupport();
}
public void addPropertyChangeListener(PropertyChangeListener pcl){
pcs.addPropertyChangeListener(pcl);
}
public void removePropertyChangeListener(PropertyChangeListener pcl){
pcs.removePropertyChangeListener(pcl);
}
public void setPoids(int a){
int temp = poids; this.poids = a;
pcs.firePropertyChange("poids",new Integer(temp),new Integer(a));
}
...
}
10
Propriétés liées (3/3)
public class Torrefacteur implements PropertyChangeListener{
private MachineATorrefier mat;
public Torrefacteur(){...}
public void propertyChange(PropertyChangeEvent pce){
if(pce.getPropertyName().equals("poids"))
if(((Integer) pce.getNewValue()).intValue() > 3)
//changer la machine à torréfier
}
}
public class VendeurDeCafe implements PropertyChangeListener{
public VendeurDeCafe(){...}
public void propertyChange(PropertyChangeEvent pce){
if(pce.getPropertyName().equals("poids"))
if(((Integer) pce.getNewValue()).intValue()
- ((Integer) pce.getOldValue()).intValue())
//changer le prix de vente
}
}