Evénements Java Beans Java RMI X. BLANC & J. DANIEL Xavier.Blanc@lip6.fr , Jerome.Daniel@der.edf.fr

Les événements dans Java X. BLANC & J. DANIEL Xavier.Blanc@lip6.fr , Jerome.Daniel@der.edf.fr

Le modèle événementiel Les événements sont un moyen de communication alternatif entre deux objets. Les communications par événements sont asynchrones. Un objet lance un événement et un autre objet attrape cet événement. Exemples d’événements : click de sourie, changement d’une base de donnée …

Le modèle événementiel

Le modèle événementiel Le modèle événement de Java est tout objet. Le lanceur d’événement est un objet Le receveur d’événement est un objet L’événement est un objet.

Exemple d'événement La classe JButton est capable de lancer l’événement java.awt.Event.ActionEvent Cet événement est lancé lorsque l’on clique sur un bouton. Les classes capables de recevoir cet événement doivent implanter l’interface java.awt.event.ActionListener Pour qu’un receveur (listener) se connecte à un lanceur, il doit appeler la méthode addActionListener() du lanceur. Lorsque le lanceur lance un événement, il appelle les méthodes actionPerformed(ActionEvent e) de l ’interface ActionListener

Exemple d’événement // la classe receveur public class MonListener implements java.awt.event.ActionListener { public void actionPerformed(ActionEvent e) { System.out.println(“evenement recu !”); } … // quelque part dans le programme, le lien entre le receveur et le lanceur java.swing.JButton button = new java.swing.JButton(“click”); button.addActionListener(new MonListener());

Le Lanceur d’événements Un objet qui lance des événements doit proposer des méthodes pour que des receveurs puissent d’enregistrer. Ces méthodes sont toujours sous la forme addXXXListener() Où XXX est le type d’événement lancé. Lorsqu’il jette un événement, le lanceur le jette vers tout les objets qui se sont enregistrés. Les méthodes removeXXXListener() Permettent de ne plus enregistrer des objets.

L'événement Les événements doivent tous hériter de la classe java.util.Event Cette classe dispose de deux méthodes public String toString() Cette méthode donne une représentation de l ’événement sous forme de chaîne de caractère (inintéressant). public Object getSource() Cette méthode donne une référence vers l’objet qui a crée cet événement (très intéressant)

Le receveur d’événements Le receveur d’événement doit implanter l’interface correspondant à l’événement. XXXListener Cette interface contient les méthodes appelées lorsque l’évenement est jeté. Toutes ces interfaces héritent de l’interface java.util.EventListener Cette interface n’a aucune méthode.

Architecture Il y a différents choix d’architecture possibles. Soit une classe qui centralise tous les événements. Cette classe est le recepteur, elle implante toute les interface Listener. Soit plusieurs classes receveur. Chaque receveur est lié avec un certain nombre de lanceur. Soit une classe interne pour chaque événement.

ActionListener Cette interface doit être implantée par les receveurs d’événement Action public void actionPerformed(ActionEvent e) est la seule méthode de cette interface. ActionEvent est l’objet représentant un événement de type action. Ces événements sont jetés par les Button, List, Menu, ...

WindowListener Cette interface doit être implantée par les receveurs d’événement Window public void windowActivated(WindowEvent e) public void windowClosed(WindowEvent e) public void windowIconified(WindowEvent e) ... Sont des méthodes de cette interface. WindowEvent est l’objet représentant un événement de type window. Ces événements sont jeté par les Window, Frame ...

MouseListener Cette interface doit être implantée par les receveurs d’événement Mouse public void mousePressed(MouseEvent e) public void mouseClicked(MouseEvent e) public void mouseExited(MouseEvent e) ... Sont des méthodes de cette interface. MouseEvent est l’objet représentant un événement de type mouse. Ces événements sont jeté par les Window, Button, ...

MouseMotionListener Cette interface doit être implantée par les receveurs d’événement MouseMotion public void mouseDragged(MouseEvent e) public void mouseMoved(MouseEvent e) ... Sont des méthodes de cette interface. MouseEvent est l’objet représentant un événement de type sourie. Ces événements sont jeté par les Component, Button, ...

KeyListener Cette interface doit être implantée par les receveurs d’événement Key public void keyPressed(KeyEvent e) public void keyReleased(KeyEvent e) ... Sont des méthodes de cette interface. KeyEvent est l’objet représentant un événement de type key. Ces événements sont jeté par les List, Button, Frame ...

FocusListener Cette interface doit être implantée par les receveurs d’événement Focus public void focusGained(FocusEvent e) public void FocusLost(FocusEvent e) ... Sont des méthodes de cette interface. FocusEvent est l’objet représentant un événement de type focus. Ces événements sont jeté par les Component, Button, ...

AdjustmentListener Cette interface doit être implantée par les receveurs d’événement Adjustement public void adjustmentValueChanged(AdjustmentEvent e) est la seule méthode de cette interface. AdjustmentEvent est l’objet représentant un événement de type adjustment. Ces événements sont jeté par les Scrollbar ...

Les Adapter Lorsque l’on veut créer un Listener il faut que la classe du listener implante toutes les méthodes de l’interface. Cependant, il n’est pas dit que toutes les méthodes nous intéresse. Ex : WindowListener (iconified, closed …) Les classes Adapter sont des classes abstraites qui implantent les interface Listener.

Exemple : MouseAdapter La classe java.awt.event.MouseAdapter implante l’interface MouseListener Ainsi pour créer un recepteur de MouseEvent, il suffit de créer une classe qui hérite de MouseAdapter. Les autres adapter : KeyAdapter MouseAdpter WindowAdapter ContainerAdapter ...

Construire ses événements Le modèle événementiel de Java n’est qu’une architecture. Pour créer ses propres événements il faut Créer sa classe événement qui hérite de java.util.Event Créer l’interface Listener qui hérite de java.util.EventListener Dans la classe lanceur créer les méthode pour inscrire les receveur. Gérer le fait de lancer un événement.

Construire ses événements On ne peut pas créer de nouveaux événements graphiques. Le seul moyen est de les utiliser. Ou, en hériter.

Exercice Construire une classe Pile qui génère un événement de NewItem dès qu’un nouvel élément est inséré dans la pile.

Attention ce modèle est celui de AWT 1.1 Le modèle événementiel présenté ici est celui définie dans AWT 1.1 Le modèle événementiel de AWT 1.0 est tout à fait différent. D’où utilisation de jdk1.1.x ou jdk1.2.x

X. BLANC & J. DANIEL Xavier.Blanc@lip6.fr , Jerome.Daniel@der.edf.fr Java Beans X. BLANC & J. DANIEL Xavier.Blanc@lip6.fr , Jerome.Daniel@der.edf.fr

Java Beans Modèle de Composant auto-descriptif réutilisable principalement visuel java

Java Beans Construction d’un Beans Déploiement d’un Beans Modèle Beans Règles syntaxiques Pacquage Déploiement d’un Beans Utilisation d’outils graphiques Exécution d’un Beans programme classique

Construction d’un Beans Modèle Beans et Règles de syntaxes

Modèle Beans Un Bean est une classe Cette classe doit être conforme au modèle Beans Ce modèle permet aux outils de découvrir les Beans Un Bean encapsule sa propre description =>Propriété générale des COMPOSANTS

Modèle Beans Un Beans est une classe Java Implante l’interface java.io.Serializable Fournir un constructeur public sans argument Possède des propriétés Peu envoyer des événements

Propriétés du Bean Un Beans possède des propriétés Les propriétés d’un Beans sont les aspects du Beans qui pourront être modifier lors du déploiement du Bean Ex: couleurDeFond, typeDeFont ...

Propriétés Simples L’accès aux propriétés se fait par des méthodes set / get. Example : private int toto; // La propriete public int gettoto() { return toto;} //La syntaxe doit être respectée public void settoto(int value) { toto=value;} //idem Ces règles syntaxiques permettent aux outils de découvrir les méthodes.

Propriétés Indexées Les propriétés indexées public void setXXX(int index, type value); public void setXXX(type values[]); public type getXXX(int index); public type[] getXXX();

Propriétés Liées Les propriétés peuvent être liées: un changement d’une propriété d’un Beans entraîne un changement d’une propriété d’un autre Beans. Le lien entre deux propriétés est unidirectionnel. Il y a donc la propriété dépendante et la propriété lié. En fait, il y a la propriété lié et le bean qui contient la propriété dépendante. L ’utilisation d’une propriété liée consiste plus particulièrement à notifier divers événements aux beans intéresséS.

Propriétés Liées Le Beans contenant la propriété liée import java.beans.*; private PropertyChangeSupport changes = new PropertyChangeSupport(this); public void addPropertyChangeListener( PropertyChangeListener l) { changes.addPropertyChangeListener(l); } public void removePropertyChangeListener(PropertyChangeListener l) { changes.removePropertyChangeListener(l); } public void setLabel(String newLabel) { String oldLabel = label; label = newLabel; sizeToFit(); changes.firePropertyChange("label", oldLabel, newLabel);

Propriétés Liées Le Beans contenant la propriété dépendante public class MyClass implements java.beans.PropertyChangeListener, java.io.Serializable { … public void propertyChange(PropertyChangeEvent evt) {…} ... }

Propriétés Contraintes Un propriété de Beans peut être contrainte. Les contraintes sont un cas particulier des propriétés liées, un bean peu émettre un veto sur le changement d’une propriété contrainte. Les mécanismes de propriété contrainte sont similaires aux propriétés liées. Les méthodes set doivent générer l’exception PropertyVetoException

Propriétés Contraintes Le Beans qui contient la propriété contrainte import java.beans.*; private VetoableChangeSupport vetos = new VetoableChangeSupport(this); public void addVetoableChangeListener(VetoableChangeListener l) { vetos.addVetoableChangeListener(l)} public void removeVetoableChangeListener(VetoableChangeListener l){ vetos.removeVetoableChangeListener(l);} public void setPriceInCents(int newPriceInCents) throws PropertyVetoException { int oldPriceInCents = ourPriceInCents; vetos.fireVetoableChange("priceInCents",new Integer(oldPriceInCents), new Integer(newPriceInCents)); ourPriceInCents = newPriceInCents; changes.firePropertyChange("priceInCents",new Integer(oldPriceInCents), }

Propriétés Contraintes Beans émettant le veto public class MyClass implements VetoableChangeListener interface { …. void vetoableChange(PropertyChangeEvent evt) throws PropertyVetoException { …. }

Exercice Créer un Bean possédant les propriétés : int a; String b; Puis faite que a soit une propriété contrainte

Communication par événements Les Java Beans communique par événements. Un bean envoie un événement vers un bean capable de comprendre ce type d’événement Lorsqu’un bean génère des événements, il faut qu’il possède ces méthodes pour chacun des événements qu’il est capable de générer.: public void add<EventListenerType>(<EventListenerType> a) public void remove<EventListenerType>(<EventListenerType a)

Méthodes du bean Pour qu’un bean puisse offrir ces services, il faut que les méthodes soient public. public type nom_methode(parametre) {…}

Comment connaître un Java Bean Introspection Comment connaître un Java Bean

Principe Un bean est un composant qui va être manipulé par des outils graphiques. Le bean doit donc permettre à ces outils de savoir comment le bean fonctionne. L’introspection permet de connaître les propriétés, les méthodes et les événements que manipule le bean.

Le package reflect Java propose une API pur découvrir une classe lors de l’exécution. Ce qui permet d’exécuter dynamiquement une méthode sur une classe. Le package reflect peut être utilisé pour n ’importe quelle classe Java, donc aussi pour les bean.

La classe Introspector Le package java.beans propose une autre manière de découvrir une classe Cette manière se fait à travers la classe Introspector. L’introspection de Java Bean utilise la réflexion mais aussi les règles syntaxiques de Java Beans L’introspection permet aussi d’utiliser la classe BeanInfo pour décrire un Java Bean

Obtenir la référence vers un BeanInfo Si aucun BeanInfo n’a été proposé par le constructeur de bean, il en sera généré un automatiquement. MonBean mb = new MonBean(); BeanInfo bi = Introspector.getBeanInfo(mb.getClass());

La classe BeanInfo La classe BeanInfo est une interface qui contient toute les méthodes permettant de connaître un Bean. Un objet de type BeanInfo est retourné lors de l’appel à l’introspector. Si, le bean possède un BeanInfo qui lui est propre, cette objet sera de ce type.

Des méthodes de la classe BeanInfo public MethodDescriptor[] getMethodDescriptors() public PropertyDescriptor[] getPropertyDescriptors() public EventSetDescriptor[] getEventSetDescriptors() public BeanDescriptor getBeanDescriptor()

Des méthodes de PropertyDescriptor public Class getPropertyType() public boolean isConstrained() ...

Création d’un BeanInfo Le nom de la classe BeanInfo doit être le nom du bean précédé de BeanInfo Ex: MonBeanBeanInfo Cette classe doit hériter de SimpleBeanInfo Re-écrire les méthodes que l’on veut modifier.

Property Editors / Customizers Les Beans sont manipulés par un outil graphique. Cet outil va permettre de saisir les valeurs de bases des propriétés. Les Property Editors permettent de paramètrer la façon de saisir les informations dans l’outil graphique. Les Customizers sont des composants graphiques qui vont être intégrés dans l’outil pour la saisie des propriétés.

Exercice Proposer une méthode qui prend le nom d’un Bean et qui affiche à l’écran le nom de toutes les méthodes du bean.

Utilisation de la Bean Box Déploiement de Beans Utilisation de la Bean Box

Principe Nous avons vu qu’un bean était constitué de plusieurs classe Java. Cependant, ces classes forment un tout : le bean. Voilà pourquoi il faut archiver toutes les classes dans un seul fichier. Un fichier .jar

Le manifest du fichier Jar Dans tout archive .jar, il y a un fichier manifest.mnf qui décrit le contenu de l’archive. Pour les Java Beans le manifest doit contenir: Name: toto.class Java-Bean: True

Le fichier Jar Pour archiver des classes dans un fichier Jar: jar cfm fichier.jar fichier.mnf liste_fichier ex:jar cfm toto.jar toto.mnf *.class

X. BLANC & J. DANIEL Xavier.Blanc@lip6.fr , Jerome.Daniel@der.edf.fr Java RMI X. BLANC & J. DANIEL Xavier.Blanc@lip6.fr , Jerome.Daniel@der.edf.fr

Principe de Java RMI Java RMI pour Java Remote Method Invocation C’est un façon pour faire communiquer deux classes situés sur deux machines différentes. Une classe située dans une machine virtuelle appelle la méthode d’une classe située dans une autre machine virtuelle. Java RMI est une architecture Sun (contrairement à CORBA

Architecture de Java RMI Client Serveur Stub Skeleton Remote Reference Layer Transport Layer

Obtention du stub à l’exécution Il faut disposer du stub de l’objet pour pouvoir invoquer des méthodes à distance. Si on ne dispose pas du stub, il est possible de l’obtenir au moment de l’utilisation de l’objet. La classe implantant le stub est rechercher en locale Si la classe n’est pas trouvée en locale, on la cherche sur le site distant Le stub est transmis au poste client puis chargé par le client lui-même Ce mécanisme est automatiquement géré par Java.

Définir une interface distante Java Une interface distante décrit un objet distant. Elle doit hériter de java.rmi.Remote Cette interface identifie le décrit le type des objets répartis Toute les méthodes qui constituent l’interface distante doivent pouvoir générer une exception de type RemoteException

Exemple d’interface Import java.rmi.*; public interface Calculatrice extends Remote { public add(int a, int b) throws RemoteException; }

Implanter une interface On définie une classe qui implante l’interface distante. Cette classe doit hériter de UnicastRemoteObject import java.rmi.*; import java.rmi.server.*; public class CalculatriceImpl extends UnicastRemoteObject Implements Calculatrice { public int add(int a, int b) throws RemoteException { return a+b;} }

Rendre accessible un serveur Pour cela on doit : créer un manager de sécurité ajouter le serveur a ceux disponible sous Java RMI (bind) public static void main(String args[]) { try { System.setSecurityManager(new RMISecurityManager()); CalculatriceImpl calc = new CalculatriceImpl(); String nom =   "Calculatrice"; Naming.rebind(nom.calc); } catch (Exception ex) {…}

Générer le stub et le skeleton Pour cela, on utilise le compilateur rmic fourni avec Java. Les arguments de rmic sont identiques à ceux de javac La génération du stub et du skeleton s ’effectue à partir de la classe d’implantation rmic CalculatriceImpl

Développer un client Le client est une classe traditionnelle qui va utiliser le service de désignation de Java RMI pour retrouver le serveur auquel il souhaite accéder. Le service de désignation va retourner une référence sur l’objet (RemoteObject) qui devra être convertie vers l’objet que l’on souhaite utiliser (cast). L’opération qui retourne le serveur prend en paramètre une sorte d ’URL (//host/name).

Exemple de client Import java.rmi.*; public class CalculatriceClient { public static void main(String args[]) { String serverName =   "Calculatrice"; CalculatriceInterface calc; try { calc = (CalculatriceInterface) Naming.lookup(serveurName.toString()); System.out.println("  6+2=  "+calc.add(6,2); } catch (RemoteException ex) {…} catch (Exception e) {…}

Exécuter l’application répartie On doit en premier lieux, lancer le service de désignation de Java RMI (rmiregistry) sur la machine ou se situ le serveur Ce service doit connaître l’endroit où les classes sont accessibles (c’est à dire que le CLASSPATH doit être positionné avent le lancement de l’utilitaire. On lance ensuite le serveur, puis le client

Exercice Créer une classe accessible à distance. Cette classe sera une pile.

Sérialisation des objets La sérialisation est un mécanisme utilisé pour l’encodage et décodage des paramètres lors d’un appel distant. En particulier, dans le cas ou l’on devrait passer une structure de données particulière lors d’un appel, notre structure devrait supporter la notion de sérialisation pour pouvoir être transmise (c ’est à dire implanter l’interface java.io.Serializable).

Les exceptions avec Java RMI Toutes les méthodes d’une interface doivent signaler l’exception RemoteException car: il peut survenir un problème lors d’une communication client/serveur : dans ce cas, c’est RMI qui généra cette exception. Toutes les exceptions définies par l’utilisateur devront hériter de la classe RemoteException.

Garbage collector d’objets distants De façon à maintenir une cohérence dans la modèle Java. Java RMI dispose d’un mécanisme de garbage collection d’objets distants Ce mécanisme utilise un algorithme complexe qui maintient un liste de toutes les références à des objets distants. Un protocole entre les références d ’objets permet l’incrémentation et la décrémentation des références. Ainsi, RMI assure un compteur de référence pour chaque objet distant, lorsque le compteur arrive à 0, l’objet est alors détruit. La méthode finalize est bien entendue appelée au moment de la destruction de l ’objet.