Retrouvez le code des exemples et les exemples d'utilisation du JavaBean Thermomètre sur sourceforge

Un Bean c’est quoi ?

Un javaBean est une classe ou un ensemble de classe conçut pour la réutilisabilité (composant logiciel réutilisable). Les composants conçus comme Bean peuvent être composés (assemblés) avec un minimum de programmation pour constituer des composants ou des systèmes plus grands. Le Bean est l’équivalent logiciel du composant électronique, qui est bien définit et auto-suffisant (sel-contained). Les composants partagent un ensemble de protocoles leurs permettant de communiquer entre eux. Ce protocole est une communication au moyen de signaux sous la forme d’objets événements (EventObject). Chaque Bean peut-être adapté a travers les propriétés du Bean.

Notion de messages et évènements

Un message représente la spécification d'une communication entre objets qui transporte de l'information avec l'objectif de déclencher une activité chez le récepteur. Dans le monde objet quand deux objets connues souhaitent communiquer, l'objet source appel une méthode chez l'objet récepteurs, l'information est transmise au moyen des paramètres de la méthode. Par contre quand l'objet émetteur ne connais pas à priori les objets récepteurs l'information à transmettre ce fera au moyen du concept Observateur/observé dans notre cas au moyen d'évènements (EventObject) et d'écouteur (EventListener):

Comment fonctionne un Bean

Les Beans sont des composants adaptables et paramétrables. Toutefois en Java; il n’y as ni interface de Beans à implémenter ni une classe racine de Bean à hériter: Le Bean est une classe java (POJO) qui respecte certaines normes de conceptions.  La capacite de connaitre un Bean (ses propriétés et ses méthodes) est réalisé grâce à une API : l’API d’introspection de Java. Cette API va permettre à une application de connaitre l’ensemble des propriétés et méthodes du Bean. Nous verrons, par la suite sur des exemples, ces fameuses normes de conception qui permettent de définir un objet Java comme étant un JavaBean.

La part la plus importante de la conception d'un Bean est le choix du modèle d'évènements que le Bean utilisera. En fait comme nous l'avons vu plus tôt le modèle d'évènement définit la capacité de communication du Bean avec son environnement. 

Que faut-il implémenter ?

Conception d’un Bean

Définition des évènements

La première étape est la création du modèle d’événements. Le modèle d’évènement représente entre autre l’ensemble des évènements que le Bean générera et captera. Chaque évènement créé devra étendre (hériter de) java.util.EventObject. Les objets évènements définissent les informations de permettant de réaliser la communication entre le Bean et son environnement. L’évènement est l’information qui est issue de la source à destination du consommateur de l’événement qui permet de déclencher une activité.

Regardons un exemple typique pour éclaircir le concept d’évènement. Supposons que l’on souhaite modéliser un composant thermomètre ce composant a pour rôle de récupérer la température d’un matériau quelconque. Nous définirons alors une information d’alerte (température trop haute !).

public class TropChaudEvent extends java.util.EventObject {
    /** le constructeur avec la source, nécessaire pour tous les évènements
      */
    public TropChaudEvent (object source) {
        super(source);
    }
    public TropChaudEvent (object source, float t) {
         this (source);
         temperature=t;
    }

    /* information ou propriété de ce type d'évènement */
    private float temperature;

    /** c'est de disign pattern (getter/setter) accesseur
      */
    public void setTemperature(float t) {temperature=t;}

    public float getTemperature() { return temperature;}
}

Définition du type de Listener (écouteur)

Quand on définit le type d'évènement il faut ensuite définir un type d'écouteur sur cet évènement. C'est une interface qui définit les méthodes de notifications (ou les callback). les méthodes de notifications sont les méthodes que la source invoquera pour avertir les intéressés que l'évènement du type requis est survenu!

Pour chaque évènement XXX il faudra créer l'interface XXXListener, voici sur notre exemple:

Les applications intéressés par la température qui monte devrons implémenter cette interface et l'enregistrer chez la source.

public interface TropChaudEventListener extends java.util.EventListener {
    public void laTemperatureEstMontee(TropChaudEvent e) throws ThermometreCasseException;
}

public class ThermometreCasseException extends Exception;

Définition de la class du Bean

Le Bean est maintenant prêt a être développé. Un Bean doit être Serialisable (pour pouvoir, entre autre,  le rendre persistant), doit avoir un constructeur sans paramètres (pour pouvoir instancié un Bean sans connaitre comment le créer)
puuis definir:

1. les méthodes d’inscription de l’écouteur (Listener Registration)

2. Les propriétés

Écrire les méthodes d’inscription de l’écouteur (Listener Registration)

Tout composant souhaitant recevoir une notification d'un évènement créera une instance de classe implémentant le Listener et l'ajoutera à la liste des "Listener" de la source (ici dans notre cas le Bean)
On crera alors deux type de méthodes
addXXXListener(XXXListener) et removeXXXListener(XXXListener) qui ont pour rôle d'ajouter ou de suprimer un écouteur.

Les propriétés

Ce sont les propriétés (ie les valeurs paramétrées) qui permette a l'utilisateur de configurer un Bean à sa guise. Une propierte est simplement un attribut possédant les accesseur (getter/setter) un atrribut en lecture seul ne possède pas de setter.

Revenons a notre exemple pour clarifie tout ceci:

public class MonTermometreBean {
    /* constructeur obligatoire dans la norme Bean */
    public MonTermometreBean() {
       Runnable r= new Runnable() {
         public void run() {
             for (;;) {
                try { Thread.current.Thread().sleep(periode);
                } catch (InterruptedException e) {}
                float f = (float) Math.random();
                synchromized(this) //car la temperature peux etre accede depuis dáutre thread
                 {
                      float prev= temperature; temperature = f;
                 }
                 if (f > prev) //la temperature est monter donc activer lévenement
                 {
                     for (int i=0; i < tropChaudListeners.size(); i++) {
                          TropChaudEvent e = new TropChaudEvent(this, f);
                          ((TropChaudEventListener)tropChaudListeners.elementAt(i)).laTemperatureEstMontee(e);                    
                     }
                 }
          };
          Thread thread = new Thread(r);
          thread.start();
       }
    }

    private float temperature = (float) 0.0;

    /** le getter de temperature (la temperature est en lecture seul pas de setter)
      * synchronized pour une utilisation dans un contecte multi thread
       */
    public synchronized float getTemperature() { return temperature; }

    /** une propriété la période d'échantillonnage en milliseconde
       */
     private long periode = 10000; /* par defaut toutes les 10 secondes */

     public long getPeriode() {return periode;}
     public void setPeriode(long p) {periode=p;}

     /* la liste des listerner interesse par les evenement tropchaud */
     private transient Vector tropChaudListeners = new Vector();

     public void addTropChaudEventListener(TropChaudEventListener l) {
             tropChaudListeners.add(l);
     }
     public void removeTropChaudEventListener(TropChaudEventListener l) {
             tropChaudListeners.removeElement(l);
     }

}

 
CREER le package (jar) pour la collection de classe representant un Bean (Le JavaBean, Les evenements, les listeners)

TODO : a traduire http://gr5.org/javabean.htm la page en cours de traduction créer un javabean dans netbeans