Programmation Java Avancee Francais

Programmation JAV avance A Sun service formation
Projet : Programmation JAVA avance Copyright Sun Service Formation Rf. Sun : SL275
Rvision : Date :
F-beta 18/2/99
Rvision : Date :
F-beta 18/2/99
Rvision : Date :
F-beta 18/2/99
Rvision : Date :
F-beta 18/2/99
Rvision : Date :
Sun Microsystems
Sun Microsystems
Sun Microsystems
Sun Microsystems
Sun Microsystems

F-beta 18/2/99
Programmation JAV avance A

Projet : avance Copyright Rf. Sun : Rvision : Date :
Sun service formation
Projet : avance Copyright Rf. Sun :
Programmation JAVA Sun Service Formation SL275
Projet : avance Copyright Rf. Sun :
Rvision : Date :
F-beta 18/2/99
Rvision : Date :
F-beta 18/2/99
F-beta 18/2/99
Sun Microsystems France
Programmation JAVA avance Sun service formation
Intitul Cours : Copyright Rf. Sun : Sun Microsystems France S.A. Service Formation 143 bis, avenue de Verdun 92442 ISSY LES MOULINEAUX Cedex Tel 01 41 33 17 17 Fax 01 41 33 17 20 Rvision : Date :
Programmation JAVA avance Sun Service Formation SL275 F-beta 18/2/99
Protections Juridiques
1998 Sun Microsystems, Inc. 2550 Garcia Avenue, Mountain View, California 94043-1100 U.S.A.
AVERTISSEMENT
Ce produit ou document est protg par un copyright et distribu avec des licences qui en restreignent lutilisation, la copie, la distribution, et la dcompilation. Aucune partie de ce produit ou de sa documentation associe ne peut tre reproduite sous aucune forme, par quelque moyen que ce soit, sans lautorisation pralable et crite de Sun et de ses bailleurs de licence, sil y en a. Des parties de ce produit pourront tre drives du systme UNIX licenci par Novell, Inc. et du systme Berkeley 4.3 BSD licenci par lUniversit de Californie. UNIX est une marque enregistre aux Etats-Unis et dans dautres pays et licencie exclusivement par X/Open Company Ltd. Le logiciel dtenu par des tiers, et qui comprend la technologie relative aux polices de caractres, est protg par un copyright et licenci par des fournisseurs de Sun. Sun, Sun Microsystems, le logo Sun, sont des marques dposes ou enregistres de Sun Microsystems, Inc. aux Etats-Unis et dans dautres pays. Toutes les marques SPARC, utilises sous licence, sont des marques dposes ou enregistres de SPARC International, Inc. aux Etats-Unis et dans dautres pays. Les produits portant les marques SPARC sont bass sur une architecture dveloppe par Sun Microsystems, Inc. Les interfaces dutilisation graphique OPEN LOOK et Sun ont t dveloppes par Sun Microsystems, Inc. pour ses utilisateurs et licencis. Sun reconnat les efforts de pionniers de Xerox pour la recherche et le dveloppement du concept des interfaces dutilisation visuelle ou graphique pour lindustrie de linformatique. Sun dtient une licence non exclusive de Xerox sur linterface dutilisation graphique Xerox, cette licence couvrant aussi les licencis de Sun qui mettent en place linterface dutilisation graphique OPEN LOOK et qui en outre se conforment aux licences crites de Sun. Le systme X Window est un produit de X Consortium, Inc. CETTE PUBLICATION EST FOURNIE EN LETAT SANS GARANTIE DAUCUNE SORTE, NI EXPRESSE NI IMPLICITE, Y COMPRIS, ET SANS QUE CETTE LISTE NE SOIT LIMITATIVE, DES GARANTIES CONCERNANT LA VALEUR MARCHANDE, LAPTITUDE DES PRODUITS A RPONDRE A UNE UTILISATION PARTICULIERE, OU LE FAIT QUILS NE SOIENT PAS CONTREFAISANTS DE PRODUITS DE TIERS.
Protections Juridiques
Intutil Cours : Programmation JAVA avance Copyright Sun Service Formation Rf. Sun : SL275
7
Rvision : F-beta Date : 18/2/99
Applets (rappels), archives jar ...............................................12

Applets : lancement ........................................................................... 13 Applets: protocoles ............................................................................ 15 Applets : cycle de vie ......................................................................... 17 Applets : demandes au navigateur.................................................. 18 Applets : demandes du systme de fentrage ............................... 19 Applets : exemple............................................................................... 20 Applets : utilisation darchives Jar .................................................. 21 Applets : Ressources dans une archive Jar..................................... 22 Le systme de scurit de Java......................................................... 23 Applications autonomes: scurit ................................................... 24 Applications autonomes : archives Jar............................................ 25
Le package AWT (rappels), LayoutManagers .....................28

Accs aux manipulations graphiques ............................................. 29 Les gestionnaires de Disposition (LayoutManager) ..................... 31 FlowLayout : ....................................................................................... 32 BorderLayout :.................................................................................... 33 GridLayout :........................................................................................ 34 CardLayout : ....................................................................................... 35 GridBagLayout : ................................................................................. 36
Le traitement des vnements AWT (rappels)....................40

Les vnements .................................................................................. 41 Modle dvnements JDK 1.1 ....................................................... 42 Comportement de linterface graphique utilisateur Java............. 46 Tableau des interfaces de veille ....................................................... 47 Evnements gnrs par les composants AWT............................. 48 Dtails sur les mcanismes ............................................................... 49 Adaptateurs dvnements............................................................... 50
Les composants SWING..........................................................54

Java Foundation Classes ................................................................... 55 Les Composants SWING .................................................................. 57 SWING : hirarchie des composants............................................... 58 Une application Swing de base : ...................................................... 59 La classe JComponent ....................................................................... 62
Les Threads ................................................................................64

Concept de thread.............................................................................. 65 Cration dun Thread Java................................................................ 67 Demarrage dun Thread Java ........................................................... 69 Contrle de base des threads ........................................................... 72 Dautres faons de crer des threads............................................... 73 Etats dun Thread (rsum) .............................................................. 74
Accs concurrents .....................................................................76

table des matires
Copyright February 18, 1999 Sun Microsystems, Inc. Tous droits rservs. SunService Month 1992
viii
Utilisation du mot-cl synchronized............................................... 77 Interaction de threads- wait() et notify() ........................................ 87 Pour assembler le tout ....................................................................... 92 Classe SyncStack ................................................................................ 98 Etats dun Thread (rsum) ............................................................ 101
Principes des Entres/Sorties ...............................................104

Fots E/S avec Java............................................................................ 105 Streams de base ................................................................................ 109 Flots dentre sur URL .................................................................... 111 Readers et Writers............................................................................ 112 Fichiers............................................................................................... 114 Tests de fichiers et utilitaires .......................................................... 115 Fichiers accs direct ...................................................................... 116
La programmation rseau......................................................120
Modles de connexions rseau en Java......................................... 121 Programmation rseau en Java ...................................................... 122 Le modle rseau de Java................................................................ 123 Principe dun Serveur TCP/IP....................................................... 124 Principe dun Client TCP/IP.......................................................... 125 changes UDP.................................................................................. 126 Exemple de Serveur UDP .............................................................. 127 Exemple de client UDP ................................................................. 129 UDP en diffusion (Multicast) ...................................................... 131 Exemple de Serveur Multicast ...................................................... 132 Exemple de client Multicast ........................................................... 133
Linarisation des objets (Serialization)..............................136

Introduction ...................................................................................... 137 Architecture de srialisation........................................................... 138 Ecriture et lecture dun flot dobjets .............................................. 142 Effets de la linarisation .................................................................. 144 Personnalisation de la linarisation............................................... 145
RMI (introduction technique) ..............................................148

Fonction de larchitecture RMI en Java......................................... 150 Packages et hirarchies RMI........................................................... 151 Cration dune application RMI .................................................... 154 Cration dune application RMI .................................................... 155 Scurit RMI...................................................................................... 175
JDBC (introduction technique) ............................................178

Introduction ...................................................................................... 179 Pilote JDBC.................................................................................... 180 Organigramme JDBC....................................................................... 182 Organigramme JDBC....................................................................... 183
ix introduction a Java et au Java Computing
Exemple JDBC .................................................................................. 184 Cration de pilotes JDBC ................................................................ 186 Pilotes JDBC ...................................................................................... 188 Instructions JDBC............................................................................. 191 Mthodes setXXX .......................................................................... 193 Mthodes getXXX .......................................................................... 198 Correspondance des types de donnes SQL en Java .................. 199 Utilisation de lAPI JDBC................................................................ 200
Annexe : JNI.............................................................................202
Pourquoi raliser du code natif?.................................................... 203 un exemple : "Hello World" en C................................................... 204 prsentation de JNI .......................................................................... 211 JNI: types, accs aux membres, cration dobjets........................ 212 rfrences sur des objets JAVA: ..................................................... 215 exceptions.......................................................................................... 216 invocation de JAVA dans du C...................................................... 217
Annexe : collections................................................................218
gnralits ......................................................................................... 219 Vector (java 1.1) ................................................................................ 220 Hashtable (java 1.1).......................................................................... 224 Properties .......................................................................................... 226 Enumeration (java 1.1) .................................................................... 229 Collections en plateforme Java 2.................................................... 230 Collections : dictionnaires, ensembles .......................................... 231 Ordre naturel, comparateurs...................................................... 232 Classes de service : Collections , Arrays ....................................... 233 Itrateurs ........................................................................................... 234
Annexe : les composants AWT.............................................236

List...................................................................................................... 241 TextArea ............................................................................................ 244 Frame ................................................................................................. 246 Panel................................................................................................... 247 Dialog................................................................................................. 248 FileDialog .......................................................................................... 250 ScrollPane.......................................................................................... 251 Menus ................................................................................................ 252 MenuBar ............................................................................................ 253 Menu .................................................................................................. 254 MenuItem .......................................................................................... 255 CheckboxMenuItem ........................................................................ 256 PopupMenu ...................................................................................... 257 Contrle des aspects visuels........................................................... 259 Impression......................................................................................... 262
table des matires

Annexe : lvolution des APIs JAVA ..................................264

Graphique, Multimedia................................................................... 265 Rseau................................................................................................ 266 Utilitaires, composants.................................................................... 267 Utilitaires programmation .............................................................. 268 Accs donnes .................................................................................. 269 Echanges scuriss ........................................................................... 270 Embarqu lger ................................................................................ 271 Systme.............................................................................................. 272 Produits divers ................................................................................. 274 Java Enterprise APIs ........................................................................ 275 Sun Microsystems France 278
xi
introduction a Java et au Java Computing

Applets (rappels), archives jar

points essentiels :
Rappels :
Les Applets constituent des petites applications java hberges au sein dune page html, leur code est tlcharg par le navigateur. Une Applet est, la base, un panneau graphique. Un protocole particulier le lie au navigateur qui le met en oeuvre (cycle de vie de lApplet). Le code de lApplet fait ventuellement appel du code ou des ressources qui sont situes sur le serveur http. Pour minimiser les changes navigateur/serveur il est intressant de mettre les codes et les ressources concernes dans des archives Jar. Les codes de lApplet sont soumis des restrictions de scurit. Il est galement possible dutiliser des archives jar et les mcanismes de scurit pour des applications autonomes.
Intitul Cours: Programmation JAVA avance Copyright Sun Service Formation Rf. Sun : SL275
1
Applets : lancement
Syntaxe des balises HTML : <APPLET [archive=ListeArchives] code=package.NomApplet.class width=pixels height=pixels [codebase=codebaseURL] [alt=TexteAlternatif] [name=nomInstance] [align=alignement] [vspace=pixels] [hspace=pixels] > [<PARAM name=Attribut1 value=value>] [<PARAM name=Attribut2 value=value>] . . . . . [alternateHTML] </APPLET> Exemple : <APPLET code=fr.acme.MonApplet.class width=300 height=400 > </APPLET>
Evolutions futures (HTML 4) : <OBJECT codetype=application/java classid="fr.acme.MonApplet.class" width=300 height=400> > </OBJECT>

1/13
1
Applets : lancement
Au sein dun document HTML une Applet est une zone graphique gre par un programme tlcharg par le navigateur. La balise HTML APPLET comporte les attributs suivant :
code=appletFile.class - Cet attribut obligatoire fournit le nom du chier contenant la classe compile de lapplet (drive de java.applet.Applet). Son format pourrait galement tre aPackage.appletFile.class.
Note La localisation de ce chier est relative lURL de base du chier HTML de chargement de lapplet.
width=pixels height=pixels - Ces attributs obligatoires fournissent la largeur et la hauteur initiales (en pixels) de la zone dafchage de lapplet, sans compter les ventuelles fentres ou botes de dialogue afches par lApplet. codebase=codebaseURL - Cet attribut facultatif indique lURL de base de lapplet : le rpertoire contenant le code de lapplet. Si cet attribut nest pas prcis, cest lURL du document qui est utilis. name=appletInstanceName -- Cet attribut, facultatif, fournit un nom pour linstance de lapplet et permet de ce fait aux applets situes sur la mme page de se rechercher mutuellement (et de communiquer entre-elles). archive=ListeArchives permet de spcier une liste de chiers archive .jar contenant les classes excutables et, ventuellement des ressources. Les noms des archives sont spars par des virgules. object=objectFile.ser permet de spcier une instance dobjet charger.
<param name=appletAttribute1 value=value> -- Ces lments permettent de spcier un paramtre lapplet. Les applets accdent leurs paramtres par la mthode getParameter().

1/14
1
Applets: protocoles
Les changes HTTP correspondant une demande dApplet : serveur demande de document HTML demande de document applet ........ application/java navigateur
Les APIs entre lApplet et son environnement : ressource code Java
navigateur
notications cycle de vie Applet chargement de code au travers du rseau
demandes de ressources rafraichissements graphiques
systme de fentrage local

1/15
1
Applets: protocoles
Une Applet hrite de la classe java.applet.Applet qui, elle mme, drive de java.awt.Panel qui dcrit un panneau graphique (ceci dit une Applet nest pas ncessairement un objet graphique). Ce qui caractrise le programme qui sexcute en tant quApplet est quil na pas de point dentre (main), quil est charg et lanc par le navigateur et que ses interactions potentielles avec lenvironnement se font selon trois catgories dAPIs:
Les mthodes qui dcrivent le cycle de vie de lApplet. init(), start(), stop(), destroy() Ces mthodes sont appeles par le navigateur pour notier lApplet certains venements comme linitialisation de lApplet, liconisation de la page HTML hte, etc. Par dfaut ces mthodes ne font rien et il faut en rednir certaines dentre elles pour obtenir un comportement de lApplet. Les mthodes qui permettent lApplet dobtenir du navigateur des informations sur la page HMTL courante, ou dobtenir la recherche et le chargement de ressources (distantes). Les mthodes qui sont appeles par le systme graphique pour la notication de demande de rafrachissement dune zone de lcran: repaint(), update(Graphics), paint(Graphics) La rednition ventuelle de certaines de ces mthodes permet lApplet dagir, un bas niveau, sur son aspect graphique.

1/16
1
Applets : cycle de vie
init() : Cette mthode est appele au moment o lapplet est cre et charge pour la premire fois dans un navigateur activ par Java (comme AppletViewer). Lapplet peut utiliser cette mthode pour initialiser les valeurs des donnes. Cette mthode nest pas appele chaque fois que le navigateur ouvre la page contenant lapplet, mais seulement la premire fois juste aprs le changement de lapplet. La mthode start() est appele pour indiquer que lapplet doit tre "active". Cette situation se produit au dmarrage de lapplet, une fois la mthode init() termine. Elle se produit galement lorsque le navigateur est restaur aprs avoir t iconis ou lorsque la page qui lhberge redevient la page courante du navigateur. Cela signie que lapplet peut utiliser cette mthode pour effectuer des tches comme dmarrer une animation ou jouer des sons. public void start() { musicClip.play(); } La mthode stop() est appele lorsque lapplet cesse de "vivre". Cette situation se produit lorsque le navigateur est icnis ou lorsque le navigateur prsente une autre page que la page courante. Lapplet peut utiliser cette mthode pour effectuer des tches telles que larrt dune animation. public void stop() { musicClip.stop(); } Les mthodes start() et stop() forment en fait une paire, de sorte que start() peut servir dclencher un comportement dans lapplet et stop() dsactiver ce comportement.
destroy() : Cette mthode est appele avant que lobjet applet ne soit dtruit c.a.d enlev du cache du navigateur.

1/17
1
Applets : demandes au navigateur
Lapplet peut demander des ressources (gnralement situes sur le rseau). Ces ressources sont dsignes par des URLs (classe java.net.URL). Deux URL de rfrence sont importantes :
lURL du document HTML qui contient la description de la page courante. Cette URL est obtenue par getDocumentBase() . lURL du code racine de lApplet (celui qui est dcrit par lattribut code). Cette URL est obtenue par getCodeBase() .
En utilisant une de ces URLs comme point de base on peut demander des ressources comme des images ou des sons :
getImage(URL base, String dsignation) : permet daller rechercher une image, rend une instance de la classe Image. getAudioClip(URL base, String dsignation) : permet daller rechercher un son, rend une instance de la classe AudioClip.

Les dsignations de ressource par rapport une URL de base peuvent comprendre des cheminoms relatifs (par ex: ../../images/truc.gif). Attention toutefois : certains systmes nautorisent pas des remontes dans la hirarchie des rpertoires. Le moteur son de la plateforme Java2 sait traiter des chiers .wav, .aiff et .au ainsi que des ressource MIDI. Une nouvelle mthode newAudioClip(URL) permet de charger un AudioClip.
La mthode getParameter(String nom) permet de rcuprer, dans le chier source HTML de la page courante, la valeur dun des lments de lapplet courante, dcrit par une balise <PARAM> et ayant lattribut name=nom . Cette valeur est une chane String.

1/18
1
Applets : demandes du systme de fentrage
Les mises jour du systme graphique de bas niveau :
repaint()
Thread AWT (attente) Exposition
update(Graphics) :
effacer zone appeler paint(Graphics)
paint(Graphics)
repaint() : demande de rafraichissement de la zone graphique. Cette demande est asynchrone et appelle update(Graphics). Linstance de java.awt.Graphics donne un contexte graphique qui permet aux mthodes de dessin doprer. update(Graphics) : par dfaut efface la zone et appelle paint(Graphics). Cette mthode peut-tre rednie pour viter des papillotements de lafchage (sries deffacement/dessin). paint(Graphics) : la rednition de cette mthode permet de dcrire des procdures logiques de (re)construction des dessins lmentaires qui constituent la prsentation graphique. Lorsque lon utilise des composants graphiques de haut niveau il nest souvent pas ncessaire dintervenir et le systme AWT gre automatiquement ces (re)afchages.

1/19
1
Applets : exemple
// Suppose lexistence de "sounds/cuckoo.au" // partir du rpertoire du fichier HTML dorigine import java.awt.Graphics; import java.applet.*; public class HwLoop extends Applet { AudioClip sound; public void init() { sound = getAudioClip(getDocumentBase(), "sounds/cuckoo.au"); } public void paint(Graphics gr) { // mthode de dessin de java.awt.Graphics gr.drawString("Audio Test", 25, 25); } public void start () { sound.loop(); } public void stop() { sound.stop(); } }

1/20
1
Applets : utilisation darchives Jar
Chaque fois quune Applet a besoin du code dune autre classe situe sur le site serveur ou chaque fois quelle a besoin de charger une ressource il y a une transaction HTTP entre le navigateur et le serveur. Il peut savrer ncessaire de diminuer ce nombre de transactions en regroupant lensemble de ces ressources dans une (ou plusieurs) archives jar. Les archives Jar permettent de regrouper dans un chier compress (format ZIP) un ensemble de rpertoires. Des meta-informations sont prsentes dans un chier Manifest. Cration dune archive partir du rpertoire repClasses et contenant tout le package fr.acme.applets jar cvf MesApplets.jar -C repClasses fr/acme/applets Mise jour du contenu avec les ressources du rpertoire images jar uvf MesApplets.jar images Larchive Jar contiendra alors sous sa racine :
le rpertoire fr (sous lequel se trouvent les codes des classes) le rpertoire images (qui contient les images) le repertoire META-INF (qui contient les meta-informations sur les ressources contenues dans le jar: chier MANIFEST.MF .
Pour connatre le contenu dun jar : jar tvf MesApplets.jar

1/21
1
Applets : Ressources dans une archive Jar
Pour exploiter larchive Jar gnre dans lexemple prcdent : Extrait du HTML : <APPLET archive=MesApplets.jar code=fr.acme.applets.MonApplet.class width=200 height=300> <PARAM name=image1 value=/images/duke.gif> </APPLET> Code java de MonApplet: Image im ; public void init() { Class maClasse = this.getClass() ; // ou fr.acme.applets.MonApplet.class im = getImage(maClasse.getResource( getParameter(image1))); } public void paint(Graphics gr) { gr.drawImage(im,0,0,this) ; }
La mthode getResource sadresse au ClassLoader qui a charg la classe courante pour obtenir lURL dune ressource.

1/22
1
Le systme de scurit de Java
Sauf indication contraire de lutilisateur du navigateur une Applet est considre comme non able et ne peut :
obtenir des informations sur lenvironnement local (nom de lutilisateur, rpertoire daccueil, etc.). Seules des informations sur le type de systme et de JVM sont accessibles. connatre ou ouvrir des chiers dans le systme local, lancer des tches locales. obtenir une connexion sur le rseau avec une adresse autre que celle du site dorigine de la page HTML (une Applet peut donc ouvrir une connexion avec son hte dorigine).
La classe AccessControler est charge des contrles de scurit. Il est possible de modier les droits daccs en dnissant une politique de scurit. Les droits sont accords des codes (en les dsignant par leur URL) et sont dcrits dans des ressources locales. Exemple de politique de $JAVA_HOME/lib/security/java.policy : site dans chier
grant codeBase "file:${java.home}/lib/ext/-" { permission java.security.AllPermission; }; //illustre les droits des extensions installes Politique propre un utilisateur dans $HOME/.java.policy: grant codeBase http://www.acme.fr { permission java.io.FilePermission /tmp/*,read ; }

Attention : la notation de codeBase est celle dune URL (avec sparateur /), la notation du nom de chier dans FilePermission est locale au systme (utiliser la variable ${/} pour avoir un sparateur portable)

1/23
1
Applications autonomes: scurit
Il est possible de dclencher les contrles de scurit sur une application autonome en la lanant avec un SecurityManager: java -Djava.security.manager MonApplication Dans le CLASSPATH la scurit distingue les classes systme ables (proprit java.sys.class.path) des autres classes soumises aux contrles de scurit (proprit java.class.path). Ds quune application autonome met en oeuvre un SecurityManager il est vivement conseill de personnaliser la politique de scurit qui sapplique spciquement cette application. On peut passer un chier de description de politique de scurit au lancement dune application : java -Djava.security.policy=monfichier.policy MonApplication Les descriptions contenues dans le chier monchier.policy compltent alors la politique de scurit courante. Il est galement possible de rednir (et remplacer) compltement la politique courante en utilisant une autre syntaxe : java -Djava.security.policy==total.policy MonApplication

1/24
1
Applications autonomes : archives Jar
Par ailleurs il est galement possible de mettre une application autonome dans un chier jar. Il faut crer le chier jar en initialisant lentre MainClass du chier Manifest. Exemple : soit le chier monManifeste : Main-Class: fr.acme.MonApplication
Cration du chier jar : jar cvfm appli.jar monManifeste -C classes fr/acme Lancement de lapplication (ici sans gestionnaire de scurit): java -jar appli.jar

1/25
1
Approfondissements
* Pour les oprations graphiques de bas niveau voir :
Lutilisation de la Classe java.awt.MediaTracker. Le chargement des images (par exemple) se fait de manire asynchrone. Si, pour manipuler des images, on a besoin dattendre leur chargement complet, utiliser un MediaTracker. Les classes java.awt.Graphics et java.awt.Graphics2D Notre sminaire java media (SL-053)
* Pour plus dinformations sur les archives JAR voir la documentation dans docs/guide/jar/index.html. Pour des oprations sur ces chiers voir le package java.util.jar ( approfondir aprs mairise des mcanismes dentre/sortie) * Pour des approfondissemnts sur la scurit et en particulier sur la signature des archives Jar voir docs/guide/security/index.html, voir galement nos cours SL-051 et SL-303.

1/26

1/27
Le package AWT (rappels), LayoutManagers

points essentiels
Le package AWT concerne les services du terminal virtuel portable:
Les composants AWT sappuient sur des services natifs du systme de fentrage local. Ainsi par exemple un Button (bouton) correspondra un composant natif bouton-Motif, boutonWindows, etc. Un autre package (Swing) permet de disposer de composants graphiques 100% pur java. Les composants principaux sont des Components; certains dentre eux sont aussi des Containers, cest dire des composants qui peuvent en contenir dautres. La disposition des Components lintrieur des Containers est sous le contrle de gestionnaires de disposition (LayoutManager).
2
Accs aux manipulations graphiques
Button

2/29
2
Accs au manipulations graphiques
Le package AWT
Le package AWT fournit les objets pour accder aux services du terminal virtuel portable. Une notion fondamentale dans ce package est la hirarchie Component (un objet graphique) et Container (driv du prcdent: on peut disposer plusieurs Components DANS un Container) Exemples de Container : Frame (une fentre), Panel (un "panneau") et son driv particulier quest lApplet. Exemples de Component: Button, Label (un tiquette), TextField (une zone de saisie Texte), Canvas (zone de dessin graphique).

2/30
2
Les gestionnaires de Disposition (LayoutManager)
Un des points forts de JAVA est de permettre de faire excuter le mme programme sur des plateformes diffrentes sans en modier le code. Pour les interactions graphiques une des consquences de cette situation est quun mme programme va devoir safcher sur des crans ayant des caractristiques trs diffrentes. On ne peut donc raisonnablement sappuyer sur un positionnement des composants en absolu (avec des coordonnes X et Y xes). La disposition relative des diffrents composants lintrieur dun Container sera prise en charge par un "gestionnaire de disposition" attach ce container. Ce LayoutManager va savoir grer les positions des composants en fonctions des dformations subies par le Container correspondant. A chaque Container est associ une liste des composants contenus. Attention une instance de composant ne peut tre dispose qu UN SEUL endroit (il ne sert rien de faire plusieurs oprations add() avec le mme composant -sauf si on veut explicitement le faire changer de zone dafchage-)

2/31
2
FlowLayout :
FlowLayout : dispose les composants "en ligne". Cest le gestionnaire par dfaut des Panels. exemple de FlowLayout
La disposition se fait par une srie dappels add(Component) (lordre des appels est important puisquil dtermine les positions relatives des composants) panneau.add(new Button("bouton 1")) ; panneau.add(new Button("bouton 2")) ;

2/32
2
BorderLayout :
BorderLayout : dispose des zones dans des points cardinaux autour dune zone centrale qui tend occuper la plus large place possible. Cest le gestionnaire par dfaut des Frames. Exemple de BorderLayout :
retaillage de fentre Les appels add() sont qualis (on dsigne lemplacement dans le zonage particulier au gestionnaire). Les composants ajouts sont souvent des Containers ayant eux-mme leur propre gestionnaire de disposition. Exemple: Panel panCentral = new Panel() ; Panel panBas = new Panel() ; fentre.add(panCentral, BorderLayout.CENTER); fentre.add(panBas, BorderLayout.SOUTH); // le panneau bas a son propre gestionnaire panbas.add(new Button (OK)) ;

2/33
2
GridLayout :
Gridlayout : permet de disposer des composants dans une grille. Toutes les cellules de la grille prennent la mme taille et contraignent les composants quelles contiennent se dformer.
retaillage de fentre
On peut utiliser deux constructeurs diffrents par ex : setLayout(new GridLayout(int rows, int cols); ou setLayout(new GridLayout( int rows, int cols, int hgap, int vgap); Lordre des appels add() est important puisquil dtermine les positions relatives des composants : fentre.setLayout(new GridLayout(0,2)) ; fentre.add(new Button(1)) ;// position 0 0 fentre.add(newButton(2)) ; // position 0 1 fentre.add(new Button(3)) ;// position 1 0 ...

2/34
2
CardLayout :
CardLayout : permet de disposer des composants dans une "pile" seul le composant du dessus est visible et on dispose de mthodes spciales pour faire passer un composant particulier sur le "dessus" de la pile.
Il faut crire un programme permettant de passer dun panneau lautre...
Les appels add() sont qualis (on donne dynamiquement un nom au niveau occup par le composant, ce nom sera utilis pour rechercher ultrieurement ce niveau). Les composants ajouts sont souvent des Containers ayant eux-mme leur propre gestionnaire de disposition. CardLayout cartes = new CardLayout() ; fen.setLayout(cartes); fen.add(panel1, Un) ; fen.add(panel2,Deux) ; .... cartes.show(fen,Un) ;

2/35
2
GridBagLayout :
GridBagLayout : dispose les composants lintrieur des "cellules" dune table. Chaque ligne ou colonne de la table peut avoir des dimensions diffrentes de celles des autres lignes ou colonnes (quadrillage irrgulier).
Les paramtres controlant la mise en place dun composant particulier sont dcrits par une instance de la classe GridBagConstraints (on peut utiliser sans risque la mme instance pour plusieurs composants) a. gridx, gridy : donne les coordonnes x, y de lobjet dans la grille (celle-ci dduit automatiquement son propre nombre de lignes et de colonnes) b. gridwidth, gridheight : nombre de cellules occupes par le composant c. ll : direction du remplissage (le composant tend alors occuper toute sa cellule dans la direction donne). Valeurs: NONE, BOTH, VERTICAL, HORIZONTAL d. anchor: lorsquun composant est plus petit que sa cellule, bord dancrage du composant (un point cardinal: EAST, NORTHEAST, etc..) e. insets: dtermination des "gouttires" (distance minimum entre le composant et les frontires de sa cellule) f. weightx,weighty : "poids" relatif de la cellule (valeur de type double comprise entre 0 et 1)

2/36
2
g. ipadx, ipady : Signale le remplissage interne, savoir la quantit ajouter la taille minimale du composant. La largeur minimale du composant est la somme de la largeur minimale et de ipadx*2 pixels (puisque le remplissage sapplique dans les deux sens). Dans la mme logique, la hauteur minimale du composant est la somme de la hauteur minimale et de ipady*2 pixel
// on a un tableau a deux dimensions comprenant des composants Component[][] tb = { {...}, {...}, ... } ; this.setLayout(new GridBagLayout()) ; GridBagConstraints gbc = new GridBagConstraints (0,0, 1,1, // x,y, w, h 1.0, 1.0, // weightx,y GridBagConstraints.WEST , //anchor GridBagConstraints.NONE , //fill new Insets(3,5,3,5) , 0,0 ); //ipadx, ipady for (int iy = 0 ; iy <tb.length; iy ++ ) { gbc.gridy= iy ; for (int ix = 0 ; ix< tb[iy].length ; ix++) { gbc.gridx = ix ; if( null != tb[iy][ix] ) { add(tb[iy][ix], gbc) ; } } } }

2/37
2
Approfondissements
* Voir en annexe quelques composants AWT courants. * Les primitives graphiques de dessin sont lies aux classes Graphics et Graphics2D * Les primitives graphiques peuvent tre utilises pour "dcorer" des composants dun type prdni ou mme pour crer des "Composants poids-plume" en agissant sur des objets crs en sous-classant directement Component ou Container.De tels objets graphiques sont initialement transparents et ne sont pas associs des objets natifs du systme de fentrage local, il faut grer par programme lensemble de leur comportement (aspects , vnements). De tels objets constituent lessentiel de bibliothques dobjets dinteraction comme les composants SWING

2/38

2/39
Le traitement des vnements AWT (rappels)

Points essentiels :
Le traitement des vnements permet dassocier des comportements des prsentations AWT :
Le modle de gestion des vnements a chang entre les versions 1.0 et 1.1 de Java. A partir de la version 1.1 il faut associer un gestionnaire dvnement un composant sur lequel on veut surveiller un type donn dvnement. A chaque type dvnement correspond un contrat dinterface. Lorsque la ralisation de ce contrat dinterface conduit un code trop bavard on peut faire driver le gestionnaire dvnement dune classe Adapter.
3
Les vnements
Lorsque lutilisateur effectue une action au niveau de linterface utilisateur, un vnement est mis. Les vnements sont des objets qui dcrivent ce qui sest produit. Il existe diffrents types de classes dvnements pour dcrire des catgories diffrentes dactions utilisateur.
Evnements sources
Un vnement source (au niveau de linterface utilisateur) est le rsultat dune action utilisateur sur un composant AWT. A titre dexemple, un clic de la souris sur un composant bouton gnre (source) un ActionEvent. LActionEvent est un objet (une instance de la classe) contenant des informations sur le statut de lvnement : q ActionCommand : nom de commande associ laction. q modiers : tous modicateurs mobiliss au cours de laction.
Traitements dvnements
Lorsquun vnement se produit, ce dernier est reu par le composant avec lequel lutilisateur interagit (par exemple un bouton, un curseur, un textField, etc.). Un traitement dvnement est une mthode qui reoit un objet Event de faon ce que le programme puisse traiter linteraction de lutilisateur.

3/41
3
Modle dvnements JDK 1.1
Modle de dlgation (JDK 1.1)
JDK 1.1 a introduit un nouveau modle dvnement appel modle dvnement par dlgation. Dans un modle dvnement par dlgation, les vnements sont envoys au composant, mais cest chaque composant denregistrer une routine de traitement dvnement (appel veilleur: Listener) pour recevoir lvnement. De cette faon, le traitement dvnement peut gurer dans une classe distincte du composant. Le traitement de lvnement est ensuite dlgu une classe spare.
Applet Panel Bouton
Panel et Applet Traitements dvnements vnement action Traitement dactio actionPerformed(ActionEvent .... }

3/42
3
modle dvnements JDK 1.1
Les vnements sont des objets qui ne sont renvoys quaux veilleurs enregistrs. A chaque type dvnement est associ une interface dcoute correspondante. A titre dexemple, voici un cadre simple comportant un seul bouton : import java.awt.*; public class TestButton { public static void main (String args[]){ Frame f = new Frame ("Test"); Button b = new Button("Press Me!"); b.addActionListener(new ButtonHandler()); f.add(b,BorderLayout.CENTER); f.pack(); f.setVisible(true); } } La classe ButtonHandler dnit une instance de traitement de lvnement . import java.awt.event.*; public class ButtonHandler implements ActionListener{ public void actionPerformed(ActionEvent e) { System.out.println("Action occured"); } }

3/43
3
Modle dvnements JDK 1.1
Modle de dlgation (JDK 1.1) (suite)

La classe Button comporte addActionListener(ActionListener). une mthode
Linterface ActionListener dnit une mthode actionPerformed qui recevra un ActionEvent.
simple,
Lorsquun objet de la classe Button est cr, lobjet peut enregistrer un veilleur pour les ActionEvent par lintermdiaire de la mthode addActionListener, en prcisant la classe dobjets qui implmente linterface ActionListener. Lorsque lon clique sur lobjet Bouton avec la souris, un ActionEvent est envoy chaque ActionListener enregistr par lintermdiaire de la mthode actionPerformed (ActionEvent).

3/44
3
modle dvnements JDK 1.1
Modle de dlgation (JDK 1.1) (suite)
Cette approche prsente plusieurs avantages :
Il est possible de crer des classes de ltres pour classier les vnements . Le modle de dlgation est plus adapt la rpartition du travail entre les classes. Le nouveau modle dvnement supporte Java BeansTM.
Certains problmes/inconvnients du modle mritent galement dtre considrs :
Il est plus difcile comprendre, au moins au dpart. Le passage du code JDK 1.0 au code JDK 1.1 est compliqu. Bien que la version actuelle de JDK gre le modle dvnement JDK 1.0 en plus du modle de dlgation, les modles dvnements JDK 1.0 et JDK 1.1 ne peuvent pas tre mlangs.

3/45
3
Comportement de linterface graphique utilisateur Java
Catgories dvnements
Le mcanisme gnral de rception des vnements partir de composants a t dcrit dans le contexte dun seul type dvnement. Plusieurs vnements sont dnis dans le package java.awt.event, et des composants tiers peuvent sajouter cette liste. Pour chaque catgorie dvnements, il existe une interface qui doit tre implmente par toute classe souhaitant recevoir ces vnements. Cette interface exige aussi quune ou plusieurs mthodes soient dnies. Ces mthodes sont appeles lorsque des vnements particuliers surviennent. Le tableau de la page suivante liste les catgories et indique le nom de linterface correspondante ainsi que les mthodes associes. Les noms de mthodes sont des mnmoniques indiquant les conditions gnrant lappel de la mthode. On remarquera quil existe des vnements de bas niveau (une touche est presse, on clique la souris) et des vnements abstraits de haut niveau (Action = sur un bouton on a cliqu, sur un TextField on a fait un <retour chariot>, ...)

3/46
3
Tableau des interfaces de veille
Catgorie
Action Item
Interface
ActionListener ItemListener
Methodes
actionPerformed(ActionEvent) itemStateChanged(ItemEvent) mouseDragged(MouseEvent) mouseMoved(MouseEvent) mousePressed(MouseEvent) mouseReleased(MouseEvent) mouseEntered(MouseEvent) mouseExited(MouseEvent) mouseClicked(MouseEvent) keyPressed(KeyEvent) keyReleased(KeyEvent) keyTyped(KeyEvent) focusGained(FocusEvent) focusLost(FocusEvent)
Mouse MotionMouseMotionListener Mouse

MouseListener
Key
KeyListener
Focus
FocusListener
Adjustement AdjustmentListeneradjustementValueChanged(AdjustementEvt) Component

ComponentListener
componentMoved(ComponentEvent) componentHidden(ComponentEvent) componentResize(ComponentEvent) componentShown(ComponentEvent)
Window
WindowListener
windowClosing(WindowEvent) windowOpened(WindowEvent) windowIconified(WindowEvent) windowDeiconified(WindowEvent) windowClosed(WindowEvent) windowActivated(WindowEvent) windowDeactivated(WindowEvent) componentAdded(ContainerEvent) componentremoved(ContainerEvent) textValueChanged(TextEvent)
Container Text
ContainerListener TextListener

3/47
3
Evnements gnrs par les composants AWT
Table 1: Acti on adju st com pon ent q q q cont aine r focu s q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q mou se q q q mou se moti on q q q win dow
Composant AWT
item
key
text
Button Canvas Checkbox CheckboxMenuItem Choice Component Container Dialog Frame Label List MenuItem Panel Scrollbar ScrollPane TextArea TextComponent TextField Window
q q q

3/48
3
Dtails sur les mcanismes
Obtention dinformations sur un vnement
Lorsque les mthodes de traitement, telles que mouseDragged() sont appeles, elles reoivent un argument qui peut contenir des informations importantes sur lvnement initial. Pour savoir en dtail quelles informations sont disponibles pour chaque catgorie dvnement, reportez-vous la documentation relative la classe considre dans le package java.awt.event.
Rcepteurs multiples
La structure dcoute des vnements AWT permet actuellement dassocier plusieurs veilleurs au mme composant. En gnral, si on veut crire un programme qui effectue plusieurs actions bases sur un mme vnement, il est prfrable de coder ce comportement dans la mthode de traitement. Cependant, la conception dun programme exige parfois que plusieurs parties non lies du mme programme ragissent au mme vnement. Cette situation peut se produire si, par exemple, un systme daide contextuel est ajout un programme existant. Le mcanisme dcoute permet dappeler une mthode add*Listener aussi souvent que ncessaire en spciant autant dcouteurs diffrents que la conception lexige. Les mthodes de traitement de tous les couteurs enregistrs sont appeles lorsque lvnement survient.

Lordre dappel des mthodes de traitement nest pas dni. En gnral, si cet ordre a une importance, les mthodes de traitement ne sont pas lies et on ne doit pas utiliser cette fonction pour les appeler. Au lieu de cela, il faut enregistrer simplement le premier couteur et faire en sorte quil appelle directement les autres. Cest ce quon appelle un multiplexeur dvnements

3/49
3
Adaptateurs dvnements
Il est vident que la ncessit dimplanter toutes les mthodes de chaque interface dcouteur reprsente beaucoup de travail, en particulier pour les interfaces MouseListener et ComponentListener. A titre dexemple, linterface MouseListener dnit les mthodes suivantes :

mouseClicked (MouseEvent) mouseEntered (MouseEvent) mouseExited (MouseEvent) mousePressed (MouseEvent) mouseReleased(MouseEvent)
Pour des questions pratiques, Java fournit une classe dadaptateurs pour pratiquement chaque interface de veiller, cette classe implante linterface approprie, mais ne dnit pas les actions associes chaque mthode. De cette faon, la routine dcoute que lon dnit peut hriter de la classe dadaptateurs et ne surcharger que des mthodes choisies.

3/50
3
Adaptateurs dvnements
Par exemple : import java.awt.*; import.awt.event.*; public class MouseClickHandler extends MouseAdapter { //Nous avons seulement besoin du traitement mouseClick, //nous utilisons donc ladaptateur pour ne pas avoir //crire toutes les mthodes de traitement dvnement public void mouseClicked (MouseEvent e) { //Faire quelque chose avec le clic de la souris . . . } }

3/51
3
Approfondissements
* Il y a deux manires principales dassurer les services de surveillance dvnements :
soit un conteneur englobant assure le service de Listener et cest sa rfrence qui est passe au addXXXListener correspondant. soit on cre une classe spcique qui peut tre une classe interne et, ventuellement, une classe anonyme.
Les deux techniques ont des avantages et des inconvnients : la seconde permet une meilleure indpendance des composants les uns par rapport aux autres, la premire est parfois plus facile mettre en oeuvre. * La cration de composants poids-plume saccompagne dune gestion des vnements (voir enableEvents() et processEvent() de Component, etc.).

3/52

3/53
Les composants SWING

Points Essentiels :
La plateforme Java 2 intgre de nouveaux services pour raliser des prsentations graphiques :
Java2D permet de raliser des oprations graphiques sophistiques et Swing constitue un ensemble cohrent de services et de composants dinteractions graphiques. La hirarchie des composants comprend dun cot des composants racine comme JFrame qui drivent de composants lourds comme Frame, et dautre part des composants lgers crits en Java qui drivent de la classe JComponent. Les deux types de classes offrent de nombreux services spciques qui les distinguent des composants AWT classiques.
4
Java Foundation Classes

4/55
4
Java Foundation Classes
Outre AWT et ses sous-packages les JFC (Java Foundation Classes) comprennent les API suivantes :
Java2D ; complte les primitive graphiques avec des mcanismes de dessin sophistiqus (formes complexes, textures, superpositions de dessins avec transparence, etc.) Voir java.awt.Graphics2D, et les sous-packages de awt : geom, image, color, font, print . lAPI daccessibilit (javax.accessibility) : interfaces pour des technologies daide aux interactions pour des personnes handicapes (lecteurs dcran, magnieurs, etc.) Drag & Drop (java.awt.dnd, java.awt.datatransfer) : permet le coup/coll et de lchange de donnes entre applications. Swing : offre une bibliothque de composants et des mcanismes plus riches que ceux de lAWT standard. La portabilit de ces composants est assure par le fait que ce sont essentiellement des composants crits en Java : on na donc pas lobligation davoir un composant natif correspondant dans le systme de fentrage local. Dun point de vue organisationnel la mise en place de ces composant permet lutilisation de paradigmes plus riches (modle vue-controleur) et permet de dcharger le programmeur de certaines tches dintendance (double-buffering, etc).

4/56
4
Les Composants SWING
Quelques composants SWING
JOptionPane JButton
JLabel
JSlider JScrollPane JToolTip
JList
JTree
JTable
Ces composants sont batis partir de JComponent qui drive de la classe AWT Container. Ceci permet des combinaisons complexes et permet denrichir ces composants de nombreuses dcorations.

4/57
4
SWING : hirarchie des composants
java.awt.Container javax.swing.JComponent JTextComponent JTextArea JTextField JEditorPane JPasswordField
AbstractButton JPanel JComboBox JLabel JLayeredPane JList JToolBar JMenuBar JPopupMenu JPanel JScrollBar JScrollPane JSlider JTable JSeparator JTree JProgressBar JRootPane JSplitPane JToggleButton JButton JMenuItem JCheckBox JRadioButton
JRadioButtonMenuItem JCheckBoxMenuItem JMenu
Les composants SWING et les classes qui les accompagnent sont situs dans le package javax.swing et ses sous-packages.

4/58
4
Une application Swing de base :
import java.awt.*; import java.awt.event.*; import javax.swing.*; public class HelloSwing extends JFrame implements ActionListener { // en fait un JPanel private JComponent contentPane = (JComponent) getContentPane(); private JLabel jLabel; private JButton jButton; private String labelPrefix = Nombre de clics: ; private int numClicks = 0; public static void main(String[] args) { HelloSwing helloSwing = new HelloSwing(composants SWING!); helloSwing.init(); helloSwing.start(); }// main public HelloSwing(String message) { super(message) ; // que faire si on ferme la fentre (WindowConstants) this.setDefaultCloseOperation(DISPOSE_ON_CLOSE); // et pour faire bonne mesure on arrte le programme // avec une petite classe anonyme this.addWindowListener( new WindowAdapter() { public void windowClosing(WindowEvent e) { System.exit(0); } }); } public void start() { this.pack(); this.setVisible(true); }//start() // traitement vnements bouton public void actionPerformed(ActionEvent e) { numClicks++; jLabel.setText(labelPrefix + numClicks); }

4/59
public void init() { // // // // // // // // // on peut ici fixer le lookAndFeel try { UIManager.setLookAndFeel( UIManager.getLookAndFeel()); } catch (UnsupportedLookAndFeelException e) { System.err.println(Couldnt use the + default look and feel + e); }
// le LABEL jLabel = new JLabel( cliquez sur le bouton pour dclencher le compteur); // le BOUTON jButton = new JButton( Je suis un Bouton SWING! ); // un acclrateur ALT-B (mme effet quun clic souris) jButton.setMnemonic(b); jButton.addActionListener(this); // le CONTAINER // on met une bordure autour du contentPane contentPane.setBorder( BorderFactory.createEmptyBorder( 30,30,10,30)); // on positionne les composants dans contentPane contentPane.add(jButton, BorderLayout.CENTER); contentPane.add(jLabel, BorderLayout.SOUTH); }//init() }

4/60
4
Une application Swing de base (commentaires):
import : les utilitaires swing sont situs dans le package javax.swing . Bien qutant une extension standard swing fait partie de lAPI java de base livre avec le JDK. On peut raisonnablement esprer que cette extension sera installe sur tous les sites supportant la plateforme Java 2. JFrame : Il est prfrable de disposer des composants Swing dans un Container de plus haut niveau qui soit lui-mme un Composant Swing. Les Containers racine (JFrame, JApplet, JWindow, JDialog) drivent de composants AWT lourds (JFrame drive de Frame) et sont conus pour hberger les autres composants Swing qui sont des composants poids-plume (des composants 100% Java). particularits de JFrame : Ce container dispose de plus de services que son parent Frame : par exemple il est possible de spcier lopration effectuer au moment de la fermeture de cette fentre (mthode setDefaultCloseOperation()). ajouts de composants un container racine (top-level) : on ne dispose pas directement des composants lintrieur dun des Containers racine. Chacun de ces Containers contient lui mme un Container gnral (contentPane) sur lequel on ralise toutes les oprations dinsertion de composants. Pour rcuprer ce Container utiliser getContentPane(), pour affecter un Container comme container gnral utiliser setContentPane(). Look and Feel (PLAF) : les composants Swing sont adaptables des aspects de divers systmes de fentrage. Il est possible de donner une application un aspect Motif sur un systme Windows et rciproquement. Swing dnit un look and feel qui lui est propre (Metal) et permet lutilisateur courageux de dnir sa propre charte graphique. Dans lexemple les modications sur le look and feel sont mises en commentaire puisque lon cherche simplement obtenir laspect standard de la plateforme locale. nouveaux services sur les composants : affectation dacclrateurs clavier (mthode setMnemonic() de AbstractButton), services gnraux de JComponent (setBorder()).

4/61
4
La classe JComponent
Tous les composants Swing (hors les composants racine) drivent de JComponent et en implantent les services :
bordures : En utilisant la mthode setBorder(0 on peut spcier une bordure autour du composant courant. Cette Bordure peut tre un espace vide (lusage de EmptyBorder remplace lutilisation de setInsets()) ou un dessin de bordure (implantant linterface Border et rendu par la classe BorderFactory). double buffering : les techniques de double-buffering permettent dviter les effets visuels de clignotement lors de rafraichissements frquents de limage du composant. On na plus crire soi-mme le doublebuffering, Swing gre par dfaut les contextes graphiques ncessaires. bulles daide (Tool tips): en utilisant la mthode setToolTipText() et en lui passant une chane de caractres explicative on peut fournir lutilisateur une petite bulle daide. Lorsque le curseur fait une pause sur le composant la chane explicative est afche dans une petite fentre indpendante qui apparat proximit du composant cible. utilisation du clavier : en utilisant la mthode registerKeyBoardAction() on peut permettre lutilisateur dutiliser uniquement le clavier pour naviguer dans linterface utilisateur et pour dclencher des actions. La combinaison caractre + touche de modication est reprsente par lobjet KeyStroke. pluggable look and feel : au niveau global de lapplication un UIManager gre le look and feel. La modication de laspect par setLookAndFeel() est soumise des contrles de scurit. Derrire chaque JComponent il y a un ComponentUI qui gre le dessin, les vnements, la taille, etc.

4/62
4
Approfondissements
* La mise en oeuvre des composants Swing constitue un domaine complet de spcialisation (voir notre cours SL-320) * Outre la matrise des spcicits des composants standard il convient de sintresser la mise en oeuvre du modle vue-controleur (voir les classes DefaultXXXModel) et aux composants de trs haut niveau : JTree (arbre), JTable (tables) ou EditorKit lintrieur dune JEditorPane.

4/63
Les Threads
Les points importants:
Comment faire raliser plusieurs tches en mme temps? En conant ces tches des processus diffrents. Java dispose dun mcanisme de processsus lgers (threads) qui sexcutent en parallle au sein dune mme JVM.
La notion de Thread Cration de Threads, gestion du code et des donnes, Cycle de vie dun Thread et contrles de lexcution
5
Concept de thread
Quentend-on par thread ?
Une dnition simple, mais utile, dun ordinateur revient dire que celuici possde une UC qui excute le calcul informatique, de la mmoire morte (ROM) contenant le programme excutant lUC et de la mmoire vive (RAM) comprenant les donnes sur lesquelles le programme opre. Dans ce cas de gure, une seule tche peut tre excute la fois. Une vision plus approfondie dun ordinateur moderne admet la possibilit deffectuer plusieurs tches simultanment ou pour le moins donne limpression quil en est ainsi. Pour lheure, nous allons nous concentrer sur le processus de programmation plutt que danalyser comment leffet est obtenu. Si nous avons au moins deux oprations ralises, cela revient dire que nous possdons au moins deux ordinateurs. Nous allons considrer un thread ou unit dexcution comme lencastrement dune UC virtuelle avec son propre code de programmation et ses propres donnes. La classe java.lang.Thread contenue dans les bibliothques de base Java permet la cration et le contrle de nos propres threads. Tout au long de ce module, nous employons Thread lorsque nous faisons rfrence la classe java.lang.Thread et thread pour renvoyer la notion dunit dexcution.
Les Threads
5/65
5
Concept de thread
Les trois parties dun thread
UC
Code Donnes
Un thread ou une unit dexcution
Un thread comprend trois parties principales: LUC, le code excut par cette UC et nalement les donnes avec lesquelles travaille le code. Avec Java, lUC virtuelle est incarne dans la classe Thread. Lors de la mise sur pied dun thread, ce dernier envoie le code excuter et les donnes appliquer par le biais des arguments du constructeur. Signalons que ces trois aspects sont, en fait, indpendants. Un thread peut excuter le mme code quun autre thread ou un code diffrent. Il peut, dans la mme logique, accder des donnes identiques ou diffrentes de celles utilises par un autre thread.
Les Threads
5/66
5
Cration dun Thread Java
Cration dun thread
Nous allons maintenant expliquer les phases de cration dun thread et examiner comment les arguments du constructeur fournissent le code et les donnes pour ce thread lors de son excution. Le code excut par le thread, provient de linstance de classe dont la rfrence est passe en argument au constructeur du Thread. Un constructeur Thread prend un argument qui consiste en une instance dune interface Runnable. En dautres termes, il nous faut dclarer une classe pour lancer linterface Runnable et construire une instance de cette classe. La rfrence obtenue est un argument conforme au constructeur.
Par exemple:
public class xyz implements Runnable { int i; public void run() { while (true) { System.out.println("Hello " + i++); } } } Ceci nous permet la construction dun thread tel que : Runnable r = new xyz(); Thread t = new Thread(r);
Les Threads
5/67
5
Cration dun Thread Java
Cration dun thread (suite)
A ce stade, nous avons un nouveau thread incarn dans la rfrence Thread t, qui a pour but dexcuter le code de dmarrage laide de la mthode run() de la classe xyz. (Linterface Runnable ncessite quune mthode public void run() soit disponible.) Les donnes utilises par ce thread sont fournies par linstance de la classe xyz, que nous appelons r.
le nouveau thread
}
UC Code Donnes
Les Threads
Thread t
classe xyz
Instance r de xyz
En rsum, un thread est subordonn une instance dun objet Thread. Le code, excut par le thread, provient de la classe de largument envoy au constructeur Thread. Cette classe doit mettre en oeuvre linterface Runnable. Les donnes, utilises par le thread, proviennent de linstance prcise de Runnable passe au constructeur de Thread.
5/68
5
Demarrage dun Thread Java
Pour mettre en route le thread
Une fois cr, le thread nest pas oprationnel. Pour le mettre en service, il est ncessaire dappliquer la mthode start(), qui se trouve dans la classe Thread, cest--dire quil faut donner linstruction: t.start(); Une fois cette tape franchie, lUC virtuelle reprsente dans le thread devient excutable. Gardez ceci lesprit lorsque vous activez lUC virtuelle.
Eligibilit dun thread

Le fait que le thread soit devenu excutable ne signie pas ncessairement quil dmarre instantanment. Sur une machine qui ne possde quune UC, il est vident que seule peut tre excute une tche la fois. Nous allons maintenant examiner plus en dtail la faon dont une UC est affecte lorsquil sagit dexcuter plusieurs threads. Avec Java, les threads sont dordinaire premptifs sans pour autant tre soumis un partage du temps -time-slicing-. (Il y a une confusion gnralise entre le terme premptif et lexpression time-slicing qui, en ralit, sont deux choses bien distinctes.) La rgle rgissant les priorits est que beaucoup de threads sont prts tre excuts, mais que seul lun dentre eux est effectivement lanc. Ce processus se poursuit tant quil est excutable ou quun autre processus de priorit suprieure devient excutable. Dans ce dernier cas de gure, le thread de moindre priorit est devanc par le thread de priorit suprieure.
Les Threads
5/69
5
Eligibilit dun thread (suite)
Linterruption dun thread peut tre imputable diverses raisons, dont lappel Thread.sleep() lanc dlibrment an dtablir une pause ou lattente dune entre/sortie sur un periphrique, fonctionnant lentement. Tous les threads excutables hors service sont conservs dans des les dattente selon leur priorit. Cest le premier thread de la le dattente de priorit suprieure qui est dabord lanc. Lorsquun thread sarrte pour des raisons de premption, son tat actuel est conserv et il vient sajouter la le dattente en se plaant la n. De mme, un thread qui redevient excutable aprs avoir t bloqu (en sommeil ou en attente pour lE/S par exemple) rejoint toujours la n de la le dattente. Compte tenu que les threads de Java ne sont pas forcment soumis au time-slicing , vous devez veiller ce que le code permette le lancement dautres threads. Pour ce faire, vous pouvez provoquer lappel de sleep() . public class xyz implements Runnable { public void run() { while (true) { // on fait des choses : // laisser leur chance aux autres try { Thread.sleep(10); } catch (InterruptedException e) { // interruption! r } } } }
Les Threads
5/70
5
Eligibilit dun thread (suite)
Observez lutilisation des mthodes try et catch. Par ailleurs, lappel sleep() correspond une mthode static dans la classe Thread et est nomme Thread.sleep(x). Largument prcise le nombre minimum de millimes de seconde au cours desquelles le thread doit tre inactif. Lexcution du thread ne reprend quaprs cette priode. Une autre mthode issue de la classe Thread, est yield() elle laisse sexcuter dautres threads . Si dautres threads de mme priorit sont excutables, yield() renvoie le thread demandeur la n de la le dattente excutable et laisse ainsi la voie libre pour le lancement dun autre thread. La mthode yield() nest effective qu condition quil existe dautres threads excutables prsentant la mme priorit. Remarquez que la mthode sleep() permet le lancement de threads de moindre priorit alors que la mthode yield() na dincidence que sur les threads de mme priorit.
Les Threads
5/71
5
Contrle de base des threads
Pour terminer un thread
Lorsquun thread a atteint la n de la mthode run(), il est neutralis. En clair, linstance courante ne peut plus tre excut. La mthode stop() qui permettait darrter un Thread est considre comme trs dangereuse si elle nest pas appele par le Thread courant, pour cette raison elle a t rendue obsolete par la version 2 de Java.
Test dun thread

Il arrive parfois que le thread se trouve dans un tat inconnu (ceci se produit si votre code ne contrle pas directement un thread particulier). Au moyen de la mthode isAlive(), vous tes en mesure de vous renseigner sur la viabilit dun thread. Cette mthode nindique pas si le thread est en cours dexcution, mais signale quil a dmarr et quun terme na pas t mis son excution.
Pour mettre les threads en attente

La mthode join() fait en sorte que le thread en cours attende que le thread sur lequel la mthode en question est appele se termine. Par exemple : TimerThread tt = new TimerThread (100); tt.start (); ... public void timeout() { //on attend tranquillement tt.join (); ... // et a repart! ... } Cette mthode peut aussi tre invoque avec une temporisation en millimes de seconde : void join (long timeout);
Les Threads
5/72
5
Dautres faons de crer des threads
Nous avons prsent la cration de threads au moyen de diffrentes classes ralisant linterface Runnable. Il existe une autres approche qui consiste dnir un thread par drivation de la classe Thread. public class myThread extends Thread { public void run() { while (running) { // on en fait des choses! sleep(100); } } public static void main(String args[]) { Thread t = new myThread(); t.start(); } } Dans ce cas de gure, il ny a quune seule classe, en loccurence myThread. Lorsque lobjet Thread est cr, aucun argument nest fourni. Ce genre de constructeur cre un thread qui utilise sa propre structure avec une mthode run() redfinie.
Les Threads
5/73
5
Etats dun Thread (rsum)
En Attente
n attente interruption
sleep()/join()
new
start()
Ordonnanceur Eligible yield()
Actif
mort
les dattente (sera vu ultrieurement)
Les Threads
5/74
5
Approfondissements
* Avant la version 2 de Java, les mthodes suspend(), resume(), stop() permettaient de suspendre lactivit dun Thread , de le ractiver et de larrter. Ces mthodes conduisant des situations dangereuses elles ont t supprimes de lAPI (voir chapitre suivant). * On peut agir sur la priorit dun Thread (mthode setPriority()) et les niveaux vont de 1 (MIN_PRIORITY) 10 (MAX_PRIORITY). Par ailleurs on peut dclarer un Thread comme tche de fond (mthode setDaemon()); une JVM sarrte lorsque tous les Threads actifs ne sont plus que du type daemon. * java.lang.ThreadGroup permet de crer des groupes de Threads et des frontires determinant les droits relatifs de modications entre Threads (voir Thread.checkAccess()). La mthode uncaughtException() permet de dterminer un traitement par dfaut pour les exceptions susceptibles de terminer un Thread. * java.lang.ThreadLocal et InheritableThreadLocal permettent de grer des variables globales lintrieur dun Thread donn. On peut ainsi grer des identifants de session, dutilisateur, de transaction,... qui sont accessibles commes des variables statiques mais qui sont propre au Thread courant.
Les Threads
5/75
Accs concurrents
Points Essentiels
Dans la mesure o lon ne contrle pas compltement lordonnancement des tches qui agissent en parallle, il peut savrer ncessaire de controler laccs un objet de manire ce que deux Threads ne le modient pas de manire inconsistante. Pour adresser ce problme Java a adopt un modle de moniteur (C.A.R. Hoare).
Lorsquun Thread rentre dans un bloc de code synchronized rattach un objet , il y a un seul de ces Thread qui peut tre actif, les autres attendent que le Thread qui possde le verrou ainsi acquis le restitue. Un Thread en attente dune ressource peut se mettre dans une le dattente o il attendra une notication dun autre Thread qui rend la ressource disponible (mcanisme wait/notify).
6
Utilisation du mot-cl synchronized
Introduction
Nous allons expliquer ici comment se servir du mot-cl synchronized qui dote le langage Java dun mcanisme permettant au programmeur davoir une emprise sur les threads qui partagent des donnes.
Problme
Supposons une classe reprsentant une pile. Au premier abord, cette classe devrait se prsenter comme suit : class Stack { int idx = 0; char [] data = new char[6]; public void push(char c) { data[idx] = c; idx++; } public char pop() { idx--; return data[idx]; } } Notez que la classe ne tente pas de soccuper du dbordement ou du manque de pile et que la capacit de la pile est plutt limite. Mais laissons ceci pour nous concentrer sur dautres aspects de la pile. Notez que le comportement de ce modle requiert que la valeur indicielle dnisse lindice de tableau de la prochaine cellule vide dans la pile, au moyen de lapproche "prdcrment, post-increment".
Accs concurrents
6/77
6
Problme (suite)
Admettons maintenant que deux threads font rfrence une instance unique de cette classe. Lun pousse les donnes vers la pile et lautre, dune faon peu ou prou indpendante, extrait les lments de la pile. Ceci devrait se traduire par un ajout et une suppression des donnes sans ambages. Cependant, un problme pourrait survenir. Supposons que le thread "a" ajoute et que le thread "b" supprime des caractres. Le thread "a" vient de dposer un caractre, mais na pas encore incrment lindex du compteur. Dsormais, ce thread est prslectionn. A ce stade, les donnes reprsentes dans notre objet sont incohrentes. buffer |p|q|r| | | | idx = 2 ^ En fait, au nom de la cohrence il faudait soit que idx = 3, soit que le caractre nait pas encore t ajout. Dans lhypothse selon laquelle le thread "a" reprend son activit, le problme ne se pose plus; en revanche, si le thread "b" attend de pouvoir supprimer un caractre, il va se produire une incohrence car, alors que le thread "a" attend une autre occasion de se remettre au travail, le thread "b" saute sur loccasion et le devance. Nous voil donc face une situation chaotique o les donnes inscrites ne sont pas le reet de la ralit. La mthode pop (), se met dcrmenter la valeur indicielle : buffer |p|q|r| | | | idx = 1 ^ Cette opration ignore le caractre "r" et renvoie ensuite le caractre "q". Il en rsulte que la lettre "r" na pas t pousse, ce qui empche de dtecter le problme. Mais regardons de plus prs ce qui arrive lorsque le thread dorigine "a" poursuit son travail.
Accs concurrents
6/78
6
Problme (suite)
Le thread "a" reprend sa tche o il lavait interrompue lors de lapplication de la mthode push(). Il incrmente la valeur indicielle, ce qui nous donne : buffer |p|q|r| | | | idx = 2 ^ Notez que cette conguration implique que "q" est valable et que la cellule contenant "r" est la cellule vide suivante. En dautres termes, "q" a t plac deux fois dans la pile, linsu de la lettre "r" qui ny apparat pas. Voici un exemple illustrant les problmes drivs de laccs de plusieurs threads des donnes partages. Pour prvenir tout problme, il faut un mcanisme protgeant les donnes contre ce genre daccs imprvu. Une des approches serait dempcher toute entrave lexcution du thread "a" jusqu ce que la partie fragile du code soit complte. Cependant, cette pratique nest concevable quavec des programmations de machines un bas niveau et incompatible sur des systmes complexes multi-utilisateurs. Pour palier cette incompatibilit, il existe un mcanisme, adopt par Java, qui traite les donnes fragiles avec grand soin.
Accs concurrents
6/79
6
Lindicateur de verrouillage de lobjet
Avec Java, une instance quelconque dun objet prsente un indicateur associ qui nest autre quun indicateur de verrouillage. Linteraction avec cet indicateur seffectue moyennant un mot-cl synchronized. Jetons un coup doeil au fragment de code modi : public void push(char c) { synchronized(this) { data[idx] = c; idx++; } } Lorsque le thread atteint linstruction synchronise, il tient lobjet envoy pour largument et tente den extraire lindicateur de verrouillage.
Objet this
thread, avant synchronisation (this) public void push(char c) { synchronized (this) { data[idx] = c; idx++; } }
Code ou comportement
Donnes ou tat
Accs concurrents
6/80
6
Objet indicateur de verrouillage (suite)
Objet this
thread, aprs synchronisation (this) public void push(char c) { synchronized (this) { data[idx] = c; idx++; } }
Code ou comportement
Donnes ou tat
Il faut bien garder lesprit que lobjet "this" na pas protg, en soi, les donnes qui lidentient. Si la mthode pop(), sans modication, est invoque par un autre thread, un risque de porter atteinte la cohrence de lobjet "this" nest pas exclus.
Accs concurrents
6/81
6
Objet indicateur de verrouillage (suite)
Pour viter ce risque, nous devons modier la mthode pop dans le mme sens. En loccurrence, nous ajoutons un appel synchronized(this) autour des parties fragiles de lopration pop(), comme nous nous y sommes pris avec la mthode push(). Voici ce qui se produit si un autre thread essaie dexcuter la mthode alors que le thread dorigine arbore lindicateur de verrouillage : Objet this Indicateur de verrouillage absent
zzz
thread sefforant dexcuter synchronized (this) public char pop() { synchronized (this) { idx--; return data[idx]; } }
Code ou comportement Donnes ou tat
Lorsque le thread tente dexcuter linstruction synchronized(this), il essaie denlever lindicateur de verrouillage de lobjet "this". Lindicateur tant absent, lexcution avorte et le thread vient se joindre une liste dattente dhomologues. Cette liste est associe avec les objets indicateur de verrouillage de manire ce que le premier thread soit lanc et puisse poursuivre son opration aussitt que lindicateur est restitu lobjet.
Accs concurrents
6/82
6
Restitution de lindicateur de verrouillage
Puisquun thread en attente de lindicateur de verrouillage dun objet ne poursuit pas son activit tant que cet indicateur na pas t restitu par le thread qui le dtient, il va sans dire quil faut restituer lindicateur lorsquil nest plus ncessaire. Lindicateur de verrouillage est restitu son objet ds que le thread qui le dtient envoie la n du bloc associ lappel synchronized() qui la obtenu en premier lieu. Java prend grand soin dassurer une restitution correcte de lindicateur, cest pourquoi, si le bloc synchronis gnre une exception ou si un arrt de boucle est issu du bloc, lindicateur sera convenablement rendu. En outre, si un thread lance deux fois lappel synchronis sur le mme objet, lindicateur sera libr sans ambages du bloc le plus lextrieur alors que le plus lintrieur est, en fait, ignor. Ces pratiques rendent lutilisation de blocs synchroniss beaucoup plus aise en comparaison avec des performances semblables dans dautres systmes tels que les smaphores binaires.
Accs concurrents
6/83
6
Pour assembler le tout
Comme nous lavons dj laiss entendre, le mcanisme synchronized() fonctionne uniquement condition que le programmeur place les appels au bon endroit. Il sagit, prsent, dassembler une classe correctement protge. Observons dabord laccessibilit des lments de donnes formant les parties fragiles de lobjet. Si elles ne sont pas prives, cela signie quelles peuvent tre accde via un code sans rapport avec la dnition de classe. Dans ce cas, on admet quaucun programmeur ne va omettre les protections de rigueur. Cette stratgie est loin dtre sre. Cest pourquoi les donnes devraient toujours prsenter la marque "priv". Nous venons dexpliquer pourquoi la privacit des donnes revt une importance toute spciale. Largument de linstruction synchronized() doit, en fait, tre this. Cette gnralisation permet au langage Java dutiliser un raccourci et au lieu dcrire : public void push(char c) { synchronized(this) { : : } } il suft dcrire simplement : public synchronized void push(char c) { : : } qui dbouche sur le mme rsultat.
Accs concurrents
6/84
6
Utilisation de synchronized
Pour assembler le tout (suite)
Pourquoi choisir une mthode au dtriment dune autre ? Lutilisation de synchronized en tant que modicateur de mthode convertit toute la mthode en un bloc synchronis, ce qui risque dentraner une dure de conservation de lindicateur de verrouillage sternisant au-del de ncessaire. Dautre part, en marquant la mthode de cette manire, les utilisateurs savent que la synchronisation a lieu et cette information peut savrer dune grande utilit lors de la conception lencontre de deadlock, sujet trait dans la section suivante. Notez que le gnrateur de documentation javadoc propage le modicateur synchronis dans les chiers de documentation, mais lutilisation de synchronized(this) nest pas documente.
Accs concurrents
6/85
6
Utilisation de synchronized
Thread a Acquisition du verrou A Acquisition du verrou B Acquisition du verrou A Deadlock Deadlock Temps Thread b
Acquisition du verrou B
Deadlock
Dans le cadre de programmes o de nombreux threads sont en lice pour accder aux multiples ressources, il peut se produire une situation que nous appellerons ici deadlock (treinte mortelle). Cette condition intervient lorsquun thread attend un verrou utilis par un autre thread qui, son tour, attend un verrou dj utilis par le premier thread. Dans cette spirale infernale, aucun des threads ne peut venir bout de son activit tant que lautre na pas mis n au processus de son bloc synchronis. Lenvoi du bloc synchronis est condamn chouer. Java est incapable de dtecter et encore moins de remdier ce cercle vicieux, il incombe donc au programmeur de se prmunir contre ce genre de situation. Voici une solution qui coule de source. Si vous avez affaire plusieurs threads prts accder diffrentes ressources, dterminez lordre prcis dobtention desdits verrous et respectez-le au doigt et loeil tout au long de la programmation. Nous reviendrons plus en dtail sur ce thme qui dpasse le simple objectif de ce cours.
Accs concurrents
6/86
6
Interaction de threads- wait() et notify()
Introduction
La plupart du temps, les threads sont spcialement conus pour accomplir des tches sans rapport entre elles. Dautres fois, en revanche, leur mission a un dnominateur commun. Cest pourquoi il convient, dans ce cas de gure, de programmer une interaction entre les threads. Pour y parvenir, vous avez le choix entre un large ventail de mthodes qui sont compatibles entre elles. Dans ce module sont prsents les mcanismes fournis dans Java.
Problme
Prenons un exemple tout simple pour expliquer les avantages qui se dgagent de linteraction entre deux threads. Deux personnes travaillent ensemble, lune lave la vaisselle et lautre lessuie. Ces deux personnes incarnent nos deux threads. Il existe entre elles un objet partag : lgouttoir. Admettons, en outre, quelles sont paresseuses et nhsitent pas une seconde sasseoir si elles nont pas de travail excuter. La personne qui essuie ne peut, manifestement, pas commencer sa tche tant que lgouttoir ne contient pas au moins une pice. Dans ce mme ordre dide, si lgouttoir est plein (celui qui lave va plus vite que son collgue), celui qui lave ne peut poursuivre tant quil ny a pas un peu de place dans lgouttoir. Voici comment Java sy prend pour mener bien cette opration.
Accs concurrents
6/87
6
Solution
Une des solutions serait de se servir des mthodes suspend() et resume(), mais pour quelle fonctionne, il faut que les deux threads soient crs en coopration, puisque chacun a besoin dun contrle sur lautre. Au vu de cet inconvnient, Java fournit un mcanisme de communication fond sur les instances dobjets. Avec Java, chaque instance dobjet possde deux les dattente de threads associes. La premire est utilise par les threads dsireux dobtenir lindicateur de verrouillage et est traite dans la section "Utilisation du mot-cl synchronized." La seconde le sert raliser les mcanismes de communication wait() et notify(). Trois mthodes sont dnies dans la classe de base java.lang.Object, savoir wait(), notify() et notifyAll(). Les mthodes wait() et notify() font lobjet de cette section. Revenons notre exemple de vaisselle. Le thread a lave et le thread b essuie. Tous deux ont accs lgouttoir. Supposons que le thread b veuille essuyer, mais que lgouttoir soit totalement vide. Le code est alors le suivant : if (drainingBoard.isEmpty()) drainingBoard.wait();
Le thread b fait appel la mthode wait(), ce qui entrane linterruption de son activit et il vient grossir la le dattente de lobjet gouttoir. Il reste inactif tant quil nest pas supprim de la liste dattente. La question qui nous occupe maintenant est de savoir comment relancer le thread b. Il suft dappeler la mthode notify() comme suit : drainingBoard.addItem(plate); drainingBoard.notify();
Accs concurrents
6/88
6
Solution (suite)
A ce stade, le premier thread bloqu dans la le dattente de lgouttoir est supprim de cette liste et entre en listee pour tre excut. Prcisons que lappel notify() est mis ici quel que soit ltat des threads (actif ou inactif). Cette approche ne fait pas lunanimit, car lappel est mis condition que ltat vide de lgouttoir passe non-vide lorsque lon y dpose une assiette. Mais il sagit dun dtail qui excde le cadre de ce module. Ce qui nous importe, en ralit, ce sont les conditions dutilisation de la mthode notify(), elle ne peut tre adopte que lorsque la le dattente bloque des threads. Les appels de notify() ne sont pas mmoriss. Par ailleurs, la mthode notify() libre au grand maximum le premier thread dans la le dattente. En consquence, si la liste dattente comporte plusieurs threads, seul le premier est libr. Pour librer en bloc tous les threads, utilisez la mthode notifyAll(). Par ce biais, nous pouvons coordonner nos threads qui lavent et essuient sans ambages et sans connatre leur identit. A chaque fois que nous effectuons une opration nentravant pas le travail de lautre thread, nous nous servons de la mthode notify() et lappliquons sur lgouttoir. Dautre part, chaque fois que nous essayons de travailler sans pouvoir aller de lavant parce que lgouttoir est vide ou plein, nous adoptons la mthode wait() et attendons que lgouttoir change dtat.
Accs concurrents
6/89
6
Mais en ralit...
Les stratgies proposes ci-dessus sont bonnes en thorie, mais la pratique se prsente sous un jour plus complexe. En loccurrence, la liste dattente est en soi une structure de donnes fragiles et doit, par consquent, tre protge laide du mcanisme synchronis. Ce quil nous faut retenir est quavant de lancer lune des mthodes wait(), notify() ou notifyAll(), il est ncessaire dobtenir lindicateur de verrouillage pour lobjet en question. En dautres termes, ces mthodes doivent tre invoques dans des blocs synchronized. Le code subit quelques modications comme suit : synchronized(drainingBoard) { if (drainingBoard.isEmpty()) drainingBoard.wait(); } puis : synchronized(drainingBoard) { drainingBoard.addItem(plate); drainingBoard.notify(); } De ce changement se dgage une remarque intressante. Comme linstruction synchronized ncessite que le thread obtienne lindicateur de verrouillage avant dtre excut, ceci implique limpossibilit pour le thread charg de laver la vaisselle datteindre linstruction notify() tant que le thread qui essuie la vaisselle est bloqu dans ltat wait(). Dans la pratique, cela ne se produit que trs rarement. En fait, lmission de lappel wait() renvoie dabord lindicateur de verrouillage lobjet. Nonobstant, an dviter toute dconvenue, lappel notify() rend le thread inactif et le dplace tout simplement de la le dattente vers la liste de lindicateur de verrouillage. Dans ce cas, il ne peut poursuivre son activit tant quil na pas rcupr lindicateur de verrouillage.
Accs concurrents
6/90
6
Mais en ralit... (suite)
Un autre aspect prendre en compte lors de la mise en service est que la mthode wait() peut tre arrte par les mthodes notify()interrupt() sur la classe Thread. Le cas chant, la mthode wait() envoie un avertissement InterruptedException, qui est cens tre plac dans une construction try/catch.
Accs concurrents
6/91
6
Prenons maintenant un exemple qui soit le reet de la ralit. Nous continuons avec lide de lavage et dessuyage, mais les caractres envoys sur une pile supplanterons les assiettes dposes dans lgouttoir. Dans le domaine de linformatique, lexemple le plus typique met en scne un rapport entre producteur et consommateur. Tout dabord, nous allons nous pencher sur la prsentation de la pile, puis observer avec attention les threads producteurs et consommateurs. Finalement, nous analyserons la pile et les mcanismes visant la protger et mettre en route la communication via les threads. La classe pile, appele SyncStack an de la distinguer de la classe de base du nom de java.util.Stack, offre lAPI publique suivante : public void push(char c); public char pop();
Accs concurrents
6/92
6
Producteur
Le thread producteur excute la mthode suivante : public void run() { char c; for (int i = 0; i < 20; i++) { c = (char)(Math.random() * 26 + 'A'); theStack.push(c); System.out.println("Produced: " + c); try { Thread.sleep((int(Math.random()* 100)); } catch (InterruptedException e) { // ignore it.. } } } Ceci gnre 20 majuscules quelconques et les pousse sur la pile avec un dlai alatoire entre chaque opration. Le dlai est compris dans une fourchette de 0 -> 100 millimes de seconde. Chaque caractre pouss est report sur la console.
Accs concurrents
6/93
6
Consommateur
Le thread consommateur excute la mthode dcrite ci-dessous : public void run() { char c; for (int i = 0; i < 20; i++) { c = theStack.pop(); System.out.println( "Consumed: "+ c); try { Thread.sleep((int)(Math.random() * 1000)); } catch (InterruptedException e) { // ignore it.. } } } Par ce biais, 20 caractres sont recueillis partir de la pile, accusant un retard entre 0 et 2 secondes entre chaque essai. Il en dcoule une lenteur plus marque lors du processus de vidage en comparaison avec le remplissage. Nous allons prsent nous pencher sur la construction de la classe pile. Il nous faut un index et une table tampon qui ne devrait pas tre trop grande, parce que le but de cet exercice est davoir une opration et une synchronisation correctes lors du remplissage. Nous allons prendre une table de 6 caractres.
Accs concurrents
6/94
6
Classe SyncStack
Une classe SyncStack nouvellement cre est normalement vide, ce qui peut aisment tre arrang au moyen de linitialisation par dfaut des valeurs, mais qui sera dtaill de faon explicite pour tre plus clair. Nous pouvons entamer la construction de notre classe : class SyncStack { private int index = 0; private char [] buffer = new char[6]; public synchronized char pop() { } public synchronized void push(char c) { } } Vous aurez remarqu labsence de tout constructeur. Il serait peut-tre prfrable dinclure this pour des raisons de style, mais, brivet oblige, nous nous sommes permis de lomettre.
Accs concurrents
6/95
6
Classe SyncStack (suite)
Analyse de push() et pop()
Au tour des mthodes push et pop dtre au coeur de notre analyse. Nous devons appliquer le mcanisme synchronized pour protger les donnes fragiles telles que les lments tampon et lindex. Par ailleurs, nous devons appeler wait() si la mthode ne fonctionne pas, puis notify() pendant la ralisation de notre travail. Voici laspect que revt la mthode push() : public synchronized void push(char c) { while (index == buffer.length) { try { this.wait(); } catch (InterruptedException e) { // ignore it.. } } this.notify(); buffer[index] = c; index++; }
Notez que lappel wait() est en fait this.wait(). La redondance nest pas vaine, elle permet de veiller ce que le rendez-vous ait bien lieu sur lobjet this. Lappel wait() est plac sur une construction try/catch. compte tenu de la suspension de lappel wait() par la mthode interrupt(), il faut boucler notre texte au cas o le thread serait activ prmaturment par lappel wait(). Examinons maintenant lappel notify() qui est en ralit this.notify(). Malgr la redondance, il a le mrite dtre univoque. Lappel notify() est lanc avant lavnement de la modication. Malgr les apparences, il ne sagit pas dune erreur. Tout thread en tat de sommeil ne peut poursuivre son activit tant quil nest pas sorti du bloc synchronis. Nous pouvons, par consquent, mettre lappel notify() aussitt que nous savons que nous allons pouvoir aller de lavant avec les changements que cela implique.
Accs concurrents
6/96
6
Classe SyncStack (suite)
Il ne nous reste plus qu voir comment il faut grer les erreurs. Vous aurez remarqu quil nexiste pas de code explicite pour viter le dbordement. Ceci nest pas ncessaire, puisque seule la mthode "this", qui entre dans ltat wait(), permet dinsrer un lment dans notre pile et provoquer un dbordement. Il est donc inutile de dtecter des erreurs. Par ailleurs, nous pouvons vouer une conance aveugle la mthode "this" dans le cadre dun systme dexploitation. Et pour cause, si notre logique savre dfectueuse, nous allons nous retrouver en manque daccs tables en dehors des limites autorises, ce qui entranera sur le champ lavertissement Exception et lerreur ne passera pas inaperue. Pour couvrir dautres cas, vous pouvez utiliser lexception Runtime pour placer vos propres contrles. Il en va de mme pour la mthode pop() : public synchronized char pop() { while (index == 0) { try { this.wait(); } catch (InterruptedException e) { // ignore it.. } } this.notify(); index--; return buffer[index]; } Il ne nous reste plus qu mettre ces fragments dans des classes compltes et ajouter un cadre pour les rendre excutables. Le code nal est illustr dans les pages suivantes.
Accs concurrents
6/97
6
Classe SyncStack
SyncTest.java
package mod13; public class SyncTest { public static void main(String args[]) { SyncStack stack = new SyncStack(); Runnable source = new Producer(stack); Runnable sink = new Consumer(stack); Thread t1 = new Thread(source); Thread t2 = new Thread(sink); t1.start(); t2.start(); } }
Producer.java
package mod13; public class Producer implements Runnable { SyncStack theStack; public Producer(SyncStack s) { theStack = s; } public void run() { char c; for (int i = 0; i < 20; i++) { c = (char)(Math.random() * 26 + 'A'); theStack.push(c); System.out.println("Produced: " + c); try { Thread.sleep((int)(Math.random() * 100)); } catch (InterruptedException e) { // ignore it.. } } } }
Accs concurrents
6/98
6
Classe SyncStack
Consumer.java
package mod13; public class Consumer implements Runnable { SyncStack theStack; public Consumer(SyncStack s) { theStack = s; } public void run() { char c; for (int i = 0; i < 20; i++) { c = theStack.pop(); System.out.println("Consumed: " + c); try { Thread.sleep((int)(Math.random() * 1000)); } catch (InterruptedException e) { // ignore it.. } } } }
Accs concurrents
6/99
6
Classe SyncStack
SyncStack.java
package mod13; public class SyncStack { private int index = 0; private char [] buffer = new char[6]; public synchronized char pop() { while (index == 0) { try { this.wait(); } catch (InterruptedException e) { // ignore it.. } } this.notify(); index--; return buffer[index]; } public synchronized void push(char c) { while (index == buffer.length) { try { this.wait(); } catch (InterruptedException e) { // ignore it.. } } this.notify(); buffer[index] = c; index++; } }
Accs concurrents
6/100
6
Etats dun Thread (rsum)
En Attente
n attente interruption
sleep()/join()
new
start()
Ordonnanceur Eligible yield() Actif
mort
le attente BLOC SYNCHRONIZED wait()
notify() notifyAll()
autre processus actif Remarques : 1) Dans un bloc synchronized le processus peut tre actif ou prempt par lordonnanceur . 2) Lorsque un processus reoit un notify() il nest pas forcment ractiv immdiatement: il peut avoir attendre quun autre processus relache le verrou sur lobjet synchronis courant.
Accs concurrents
6/101
6
Approfondissements
* Les mthodes de thread suspend() et resume() etant obsolete on peut chercher un moyen pour permettre un thread de rpondre une demande de suspension.
public class ControlledThread extends Thread { static final int SUSP = 1; static final int STOP = 2; static final int RUN = 0; private int state = RUN; public synchronized void setState(int s) { state = s; if ( s == RUN ) {//corriger si s==STOP et state==SUSP notify(); } } public synchronized boolean checkState() { while ( state == SUSP ) { try { wait(); } catch (InterruptedException e) { // ignore } } if ( state == STOP ) { return false; } return true; } public void run() { while ( true ) { doSomething(); // // // if } } } } Be sure shared data is in consistent state in case the thread is waited or marked for exiting from run() ( !checkState() ) { break;
Accs concurrents
6/102
Accs concurrents
6/103
Principes des Entres/Sorties

Points essentiels :
Java offre une vision des entre/sorties portables bases sur la notion de ot (Stream).
Il existe deux catgories de ots de base : les ots doctets (InputStream, OutputStream) et les ots de caractres (Reader, Writer). Certains ots sont associs des ressources qui fournissent des donnes (chiers, tableaux en mmoire, lignes de communications,...) Dautres types de ots transforment la manire dont on opre sur les donnes en transit (E/S bufferise, traduction de donnes, etc.) Cest en combinant les services de ces diffrents types de ot que lon contrle les oprations dentres/sorties.
7
Fots E/S avec Java
Dans ce module, nous allons examiner comment le langage Java gre les Entres/Sorties (y compris sur stdin, stdout et stderr) par le biais de ots (Stream). Par la suite, nous approfondirons le maniement des chiers et des donnes qui sy trouvent.
Les fondements de la notion de ot

Un ot est soit une source doctets, soit une destination pour les octets. Lordre est important. Par exemple, un programme souhaitant lire partir dun clavier peut se servir dun ot pour mener bien cette action. Il existe deux catgories fondamentales de ots, savoir les ots dentre, partir desquels on peut lire et les ots de sortie qui, au contraire, acceptent lcriture mais ne peuvent tre lus. Dans le package java.io, certains ots ont pour origine une ressource, ils peuvent lire ou crire dans ressource dtermine telle quun chier ou une zone mmoire. Dautres ots sont appels ltres. Un ltre dentre est cr moyennant une connexion un ot dentre existant, de sorte que, lorsque vous tentez de lire partir du ltre dentre, vous obteniez les donnes extraites, lorigine, sur cet autre ot dentre.
w o l l e
Sens du "ot" doctets
lecture() h
Ressource InputStream p. ex. du chier du disque
Filtre InputStream

7/105
7
Flots E/S avec Java
Mthodes InputStream
int read() int read(byte[]) int read(byte[], int, int) Ces trois mthodes fournissent des octets. La mthode read renvoie un argument int contenant un octet lu partir du ot ou la valeur -1 indiquant la n de chier. Les deux mthodes restantes remplissent une table doctets avec des octets lus et en renvoient le nombre. Les deux arguments int de la troisime mthode indiquent un sous-ensemble de la table cible.

Pour proter dune efcacit optimale, lisez toujours les donnes par blocs les plus grands possible.
void close() Il est recommand de fermer un ot lorsque vous avez ni de lutiliser. int available() Cette instruction signale le nombre doctets prts tre lus dans le ot. Une opration de lecture relle succdant cet appel peut ventuellement renvoyer plus doctets. skip(long) Cette mthode permet de sauter un nombre dtermin doctets provenant du ot.

7/106
7
Flots E/S avec Java
Mthodes InputStream (suite)
markSupported() mark(int) reset() Ces mthodes visent effectuer des oprations de "rejet" sur un ot condition que celui-ci les prenne en charge. La mthode markSupported() renvoie true si les mthodes mark() et reset() sont oprationnelles dans le cadre de ce ot spcique. La mthode mark(int) sert indiquer que le point courant dans le ot devrait tre not et quil faudrait affecter une quantit sufsante de mmoire tampon, dans le but dadmettre au moins le nombre de caractres de largument donn. A la suite doprations read()successives, la mthode reset() tend repositionner le ot dentre sur le premier point mmoris.

7/107
7
Flots E/S avec Java
Mthodes OutputStream
write(int) write(byte[]) write(byte[], int, int) Ces mthodes crivent dans le ot de sortie. A linstar des ots dentre, il est recommand dcrire les donnes par blocs les plus grands possibles. close() Il est prfrable de fermer les ots de sortie aprs avoir termin de les utiliser. flush() Il arrive parfois que le ot de sortie tamponne les critures avant de les crire rellement. La mthode flush() vous donne les moyens de purger les buffers..

7/108
7
Streams de base
De manire simplifie voici comment se prsente la hirarchie au sein du package java.io InputStream SequenceInputStream PipedInputStream FilterInputStream . . . FileInputStream ByteArrayInputStream
DataInputStream PushbackInputStream
. . . BufferedInputStream
FileInputStream et FileOutputStream
Il sagit de classes mettant en jeu des ots issus de ressources et, comme leur nom lindique, elles utilisent des chiers disque. Les constructeurs de ces classes vous permettent de prciser le chemin daccs du chier auquel elles sont connectes. La construction dune classe FileInputStream est conditionne par lexistence du chier associ et par son accs en lecture. Lors de la construction dune classe FileOutputStream, le chier de sortie, sil existe encore, est cras. FileInputStream infile = new FileInputStream("myfile.dat"); FileOutputStream outfile = new FileOutputStream("results.dat"); .

7/109
7
Classes Stream de base
BufferedInputStream et BufferedOuUtputStream
Ces ltres permettent de bufferiser les dE/S et donc de les optimiser.
DataInputStream et DataOutputStream
Ces ltres permettent la lecture et lcriture de types de base Java au moyen de ots. Voici une palette de mthodes spciales pour les types de base :
Mthodes DataInputStream
byte readByte() long readLong() double readDouble()
Mthodes DataOutputStream
void writeByte(byte) void writeLong(long) void writeDouble(double) Notez que les mthodes de DataInputStream vont de pair avec les mthodes de DataOutputStream.
PipedInputStream et PipedOutputStream
Les tubes de communication (piped streams) servent de pont de communication entre threads. Un objet PipedInputStream dans un thread reoit ses donnes en entre partir dun objet PipedOutputStream complmentaire situ dans un autre thread. .

7/110
7
Flots dentre sur URL
En sus de laccs de chiers de base, Java est munie dURL (Uniform Resource Locators) destines accder des objets via un rseau. Vous utilisez un objet URL lorsque vous accdez aux sons et images laide de la mthode getDocumentBase() pour des applets : String imageFile = new String ("images/Duke/T1.gif"); images[0] = getImage(getDocumentBase(), imageFile); Vous pouvez toutefois fournir un URL directement comme suit : java.net.URL imageSource; try { imageSource = new URL("http://mysite.com/~info"); } catch (MalformedURLException e) {} images[0] = getImage(imageSource, "Duke/T1.gif");
Pour ouvrir un ot dentre

En outre, vous pouvez ouvrir un ot dentre partir dune URL : InputStream is; String datafile = new String("Data/data.1-96"); byte buffer[] = new byte[24]; try { // new URL throws a MalformedURLException // URL.openStream() throws an IOException is = (new URL(getDocumentBase(), datafile)).openStream(); } catch (Exception e) {} A prsent, vous tes en mesure dutiliser is pour lire les informations, : try { is.read(buffer, 0, buffer.length); } catch (IOException e1) {}

Noubliez pas que la plupart des utilisateurs ont une politique de scurit visant empcher les applets daccder aux chiers.

7/111
7
Readers et Writers
Unicode
En interne Java utilise le format Unicode, comme ces caractres sont reprsents sur 16 bits on est oblig dutiliser des ots spciaux pour les manipuler: ce sont les Reader et les Writer. Les classes InputStreamReader et OutputStreamWriter font le pont avec les ots doctets en assurant de manire implicite ou explicite les conversions ncessaires.
Octet <-> Conversion de caractres

Par dfaut, si vous construisez simplement un Reader ou un Writer connect un ot, les rgles de conversion qui sappliquent sont celles entre le codage de la plateforme locale et Unicode. Dans la plupart des pays europens utilisant les caractres "latins", lencodage des caractres suit la norme ISO 8859-1.(Cp1252 sous Windows). Vous pouvez slectionner un autre type de codage doctets, laide dune des listes regroupant les formes de codage reconnues que vous trouverez dans la documentation pour loutil native2ascii. Pour lire une entre partir dun codage de caractre non local ou mme la lire partir dune connexion rseau avec un type diffrent de machine, vous pouvez construire un InputStreamReader par le biais dun codage de caractres explicite comme suit : ir = new InputStreamReader(flotentree, "ISO8859_1")

Si vous lisez les caractres dune connexion rseau, nous vous enjoignons dutiliser cette formulation, faute de quoi votre programme sera toujours tent de convertir les caractres quil lit comme sil sagissait dune reprsentation locale, ce qui ne serait pas le reet de la ralit .

7/112
7
Readers et Writers
BufferedReader et BufferedWriter
Il est prfrable denchaner un BufferedReader ou BufferedWriter, sur un InputStreamReader InputStreamWriter car la conversion entre formats donne rsultats plus probants lorsquelle est effectue par blocs. Noubliez dutiliser la mthode flush() sur un BufferedWriter. un ou des pas
Lecture de chane dentres

. public class CharInput { public static void main(String args[]) { String s; InputStreamReader ir; BufferedReader in; ir = new InputStreamReader(System.in); in = new BufferedReader(ir); while ((s = in.readLine()) != null) { System.out.println("Read: " + s); } } }

7/113
7
Fichiers
Avant de pouvoir appliquer E/S sur un chier, il vous faut obtenir linformation de base concernant ce chier. La classe File met disposition une srie dutilitaires permettant de travailler avec des chiers et dobtenir des informations leur sujet.
Pour crer un nouvel objet File

l l l
File myFile; myFile = new File("monfichier"); myFile = new File("repertoire", "monfichier"); // mieux si repertoire et/ou fichiers sont des vars File myDir = new File("repertoire"); myFile = new File(myDir, "monfichier");
Le constructeur que vous utilisez dpend souvent dautres objets chier auxquels vous accdez. Par exemple, si vous utilisez un chier dans votre application, utilisez le premier constructeur. En revanche, si vous utilisez plusieurs chiers provenant dun rpertoire commun, il est plus pratique de faire appel au second ou troisime constructeur. Un objet File peut faire ofce dargument de constructeur pour des objets FileInputStream et FileOutputStream. Vous prservez ainsi une indpendance vis--vis de la convention locale de notation de la hirarchie du systme de chiers.

7/114
7
Tests de chiers et utilitaires
Une fois un objet File cr, vous pouvez librement opter pour une des mthodes suivantes an de recueillir des information au sujet du chier :
Noms de chiers l l l l l
String getName() String getPath() String getAbsolutePath() String getParent() boolean renameTo(File newName)
Tests de chiers l l l l l l
boolean exists() boolean canWrite() boolean canRead() boolean isFile() boolean isDirectory() boolean isAbsolute();
Information gnrale axe sur les chiers et utilitaires l l l

long lastModified() long length() boolean delete()
Utilitaires en rapport avec les rpertoires l l

boolean mkdir() String[] list()

7/115
7
Fichiers accs direct
Le langage Java vous fournit une classe RandomAccessFile pour prendre en charge les chiers accs direct.
Pour crer un chier daccs direct

Vous avez le choix entre deux options pour ouvrir un chier accs direct:
Par le nom du chier
myRAFile = new RandomAccessFile(String name, String mode);
Par un objet File
myRAFile = new RandomAccessFile(File file, String mode); Largument mode dtermine si vous disposez dun accs en lecture seule ("r") ou en lecture/criture ("rw"). Voici comment procder, lors de louverture dun chier base de donnes, en vue dune mise jour : RandomAccessFile myRAFile; myRAFile = new RandomAccessFile("stock.dbf","rw");
Pour accder linformation

Les objets RandomAccessFile escomptent lire et crire les informations comme les ots dE/S donnes: vous pouvez accder toutes les oprations des classes DataInputStream et DataOutputStream.

7/116
7
Fichiers accs direct
Pour accder linformation (suite)
Le langage Java propose diverses mthodes permettant de parcourir le chier :
long getFilePointer();
Renvoie la position courante du pointeur de chier.
void seek(long pos);
Fixe le pointeur de chier sur la position absolue indique qui est prcise par un dcalage doctets partant du dbut du chier. La position 0 marque le dbut du chier.
long length();
Renvoie la longueur du chier. La position length() marque la n du chier.
Pour insrer des informations

: myRAFile = new RandomAccessFile("java.log","rw"); myRAFile.seek(myRAFile.length()); // Any subsequent write()s will be appended to the file

7/117
7
Approfondissements
* La lecture/criture dobjets sur les ots sera aborde dans un chapitre ultrieur (serialization) * Voir les packages java.util.zip et java.util.jar pour des utilitaires de compression ou daccs aux chiers Jar. * Voir galement dans java.io la classe StreamTokenizer (analyseur de texte)

7/118

7/119
La programmation rseau
Points essentiels :
Le package java.net offre des services permettant des connexions directes au travers du rseau. Le paradigme de socket est utilis pour tablir des connexions.
communications sur TCP (ots) communications via UDP (datagrammes). datagrammes avec diffusion multiple (multicast).
8
Modles de connexions rseau en Java
Accs programmatiques aux sockets (canaux de communication bidirectionnels) sur TCP/IP SERVEUR
port
demand
CLIENT
e de con nexion
SOCKET
Flots E/S
Programmation de Datagrammes UDP
Datagrammes avec MultiCast
8/121
8
Programmation rseau en Java
Sockets
Les Sockets sont des points dentre de communication bi-directionnelle entre deux applications sur un rseau. Les diffrents types de Socket conditionnent la faon dont les donnes vont tre transfres :
Stream sockets (TCP) Permettent dtablir une communication en mode connect. Un ot continu est tabli entre les deux correspondants : les donnes arrivent dans un ordre correct et sans tre corrompues. Datagram sockets (UDP) Permettent dtablir une connexion en mode non-connect, que lon appelle aussi mode Datagramme. Les donnes doivent tre assembles et envoyes sous la forme de paquets indpendants de toute connexion. Un service non connect est gnralement plus rapide quun servcie connect, mais il est aussi moins able : aucune garantie ne peut tre mise quand au fait que les paquets seront effectivement distribus correctement -ils peuvent tre perdus, dupliqus ou distribus dans le dsordre-.
8/122
8
Le modle rseau de Java.
Dans Java, les sockets TCP/IP sont implantes au travers de classes du package java.net. Voici la faon dont ces classes sont utilises. :
Serveur
ServerSocket (port #, nb_cnx) accept() retourne un objet Socket
Enregistrer ce service. Attendre une connexion du client. Utiliser la Socket
Client
Socket (host, port#)

(attempt to connect)
InputStream OutputStream
OutputStream InputStream
close ()
close ()
Dans ce modle, le fonctionnement est le suivant :
Le Serveur enregistre son service sous un numro de port, indiquant le nombre de client quil accepte de faire patienter un instant T. Puis, le serveur se met en attente sur ce service par la mthode accept() de son instance de ServerSocket. Le client peut alors tablir une connexion avec le serveur en demandant la cration dune socket destination du serveur pour le port sur lequel le service a t enregistr. Le serveur sort de son accept() et rcupre une Socket en communication avec le Client. Ils peuvent alors utiliser des InputStream et OutputStream pour changer des donnes.
La programmation rseau 8/123
8
Principe dun Serveur TCP/IP
Exemple de code de mise en oeuvre dun serveur TCP/IP
import java.net.*; import java.io.*; public class Serveur { ServerSocket srv ; public Serveur( int port) throws IOException{ srv = new ServerSocket(port) ; } public void go() { while (true) { try { Socket sck = srv.accept() ; dialogue(sck.getInputStream(), sck.getOutputStream()); sck.close() ; } catch (IOException exc) { } } } public void dialogue(InputStream is, OutputStream os) throws IOException { DataOutputStream dos = new DataOutputStream(os) ; dos.writeUTF ("Hello net World") ; } public static void main (String[] args) throws Exception { Serveur serv = new Serveur(Integer.parseInt(args[0])) ; serv.go() ; } }
8/124
8
Principe dun Client TCP/IP
Le client correspondant : import java.net.*; import java.io.*; public class Client { Socket sck ; public Client( String host, int port) throws IOException{ sck = new Socket(host, port) ; } public void go() { try{ dialogue(sck.getInputStream(), sck.getOutputStream()) ; } catch (IOException exc) { } } public void stop() { try { sck.close() ; } catch (IOException exc) { } } public void dialogue(InputStream is, OutputStream os) throws IOException { DataInputStream dis = new DataInputStream(is) ; System.out.println(dis.readUTF()) ; } public static void main (String[] args) throws Exception { Client cli = new Client( args[0], Integer.parseInt(args[1])) ; cli.go() ; cli.stop() ; } }
8/125
8
changes UDP
On na pas ici de connexion ouverte en permanence. Les paquets, autonomes, sont transfrs avec leur propres informations dadresse. Le service nest pas "able" car il y a des risques de perte, ou de duplication de paquets. Lordre darrive nest pas garanti. Pour limiter les incidents il vaut mieux limiter la taille des paquets envoys de manire ce quils noccupent quun seul paquet IP. Les objets fondamentaux :
DatagramSocket : dtermine un canal (socket) UDP. Pour un serveur on prcisera le port (pas ncessaire pour le client)
DatagramSocket serverSock = new DatagramSocket(9789); DatagramSocket clientSock= new DatagramSocket() ;
DatagramPacket : structure daccueil des donnes et des informations dadresse. Les methodes getData(), getAddress(), getPort() permettent de rcuprer ces informations.
// pour un envoi sendPack = new DatagramPacket(byteBuff, len, addr, port); socket.send(sendPack) ; // pour une reception revPack = new DatagramPacket(byteBuffer, len) ; socket.receive(recvPack);
InetAddress : permet de produire une adresse inet partir dune dsignation (mthode getByName()) ou de la machine locale (getLocalHost())
8/126
8
Exemple de Serveur UDP
Ce serveur reoit un message dun client et le renvoie prcd dun autre message. On utilise les donnes dadressage du paquet reu du client pour reexpdier les donnes
import java.io.* ; import java.net.* ; import java.sql.* ; public class DatagServer { public static final int DATA_MAX_SIZE = 512 ; DatagramSocket veille ; public DatagServer( int port) throws IOException { veille = new DatagramSocket(port) ; }// public void go() { byte[] recBuffer = new byte[DATA_MAX_SIZE] ; while (true) { try { // ************* on ecoute DatagramPacket recvPack = new DatagramPacket(recBuffer, recBuffer.length) ; veille.receive(recvPack) ; // ************* on prepare les streams et on dialogue ByteArrayInputStream biz = new ByteArrayInputStream(recvPack.getData()) ; ByteArrayOutputStream boz = new ByteArrayOutputStream(); lireEcrire(biz,boz) ; // ************* on renvoie DatagramPacket sendPack = new DatagramPacket(boz.toByteArray(), boz.size(), recvPack.getAddress(), recvPack.getPort()) ; veille.send(sendPack) ; } catch (IOException exc) { } } } // go
8/127
8
public void lireEcrire(InputStream is, OutputStream os) throws IOException { DataInputStream dis = new DataInputStream(is) ; String mess = dis.readUTF() ; System.out.println(mess) ; DataOutputStream dos = new DataOutputStream(os) ; dos.writeUTF("reu: " + mess ) ; }
public static void main (String[] args) throws Exception { DatagServer serv = new DatagServer(Integer.parseInt(args[0])) ; serv.go() ; }//End main }
8/128
8
Exemple de client UDP
Correspond au serveur prcdent : on envoie un message et on le reoit en echo prcd de celui du serveur. import java.io.* ; import java.net.* ; import java.sql.* ; public class DatagClient { public static final int DATA_MAX_SIZE = 512 ; DatagramSocket sock ; InetAddress inetServ ; int port ; public DatagClient( String server, int sport ) throws IOException { sock = new DatagramSocket() ; inetServ= InetAddress.getByName(server) ; port = sport ; }// public void go() { byte[] recBuffer = new byte[DATA_MAX_SIZE] ; try { ByteArrayOutputStream boz = new ByteArrayOutputStream(); ecrire(boz) ; DatagramPacket sendPack = new DatagramPacket(boz.toByteArray(), boz.size(), inetServ, port) ; sock.send(sendPack) ; // ************* on ecoute DatagramPacket recvPack = new DatagramPacket(recBuffer, recBuffer.length) ; sock.receive(recvPack) ; // ************* on prepare les streams et on dialogue ByteArrayInputStream biz = new ByteArrayInputStream(recvPack.getData()) ; lire(biz) ; // ************* on renvoie } catch (IOException exc) { } } // go
8/129
public void ecrire( OutputStream os) throws IOException { DataOutputStream dos = new DataOutputStream(os) ; dos.writeUTF("bonjour") ; }
public void lire(InputStream is) throws IOException { DataInputStream dis = new DataInputStream(is) ; String mess = dis.readUTF() ; System.out.println(mess) ; } public static void main (String[] args) throws Exception { DatagClient cli = new DatagClient(args[0], Integer.parseInt(args[1])) ; cli.go() ; }//End main }
8/130
8
UDP en diffusion (Multicast)
Une adresse de diffusion (multicast) est une adresse comprise entre 224.0.0.0 et 239.255.255.255. Des MulticastSocket permettent de diffuser des donnes simultanment un groupe dabonns. Sur une telle socket on peut sabonner une adresse multicast par joinGroup(InetAddress mcastaddr) ou se dsabonner par leaveGroup(InetAddress). Le paramtre TTL de ces sockets permet de xer le nombre maximum de routeurs traverss - si ces routeurs le permettent- (important si on veut limiter la diffusion lextrieur dune entreprise)
8/131
8
Exemple de Serveur Multicast
Diffuse un java.sql.TimeStamp toute les secondes. Les paquets ne se transmettent pas au travers des relais rseaux (TTL = 1).
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 import java.io.* ; import java.net.* ; import java.sql.* ; public class MultigServer { public static final int PORT = 9999 ; public static final String GROUP = "229.69.69.69" ; public static final byte TTL = 1 ; // pas de saut! public static final int DATA_MAX_SIZE = 512 ; public static void main (String[] tbArgs) { byte[] recBuffer = new byte[DATA_MAX_SIZE] ; try{ MulticastSocket veille = new MulticastSocket(PORT); InetAddress adrGroupe = InetAddress.getByName(GROUP) ; while (veille != null) { ByteArrayOutputStream boz = new ByteArrayOutputStream(); ObjectOutputStream oz = new ObjectOutputStream (boz) ; oz.writeObject(new Timestamp(System.currentTimeMillis())) ; // consommation excessive de donnes (deux byte buffers!) DatagramPacket sendPack = new DatagramPacket(boz.toByteArray(), boz.size(), adrgroupe, PORT) ; veille.send(sendPack, TTL) ; try{ Thread.sleep(1000) ; } catch (InterruptedException exc) {} } } catch (Exception exc ) { System.err.println(exc) ; } }//End main }
8/132
8
Exemple de client Multicast
Reoit 10 objets du serveur
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 import java.io.* ; import java.net.* ; import java.sql.* ; public class MultigClient { public static final int DATA_MAX_SIZE = 512 ; public static void main (String[] tbArgs) { MulticastSocket socket = null; InetAddress adrGroupe = null ; byte[] recBuffer = new byte[DATA_MAX_SIZE] ; try{ socket = new MulticastSocket(MultigServer.PORT) ; adrGroupe = InetAddress.getByName(MultigServer.GROUP) ; if (socket != null) { socket.joinGroup(adrGroupe) ; // danger! on reutilise le meme buffer? DatagramPacket recvPack = new DatagramPacket(recBuffer, recBuffer.length) ; for( int ix = 0 ; ix < 10 ; ix++) { socket.receive(recvPack) ; ObjectInputStream inz = new ObjectInputStream (new ByteArrayInputStream( recvPack.getData())) ; Object obj = inz.readObject() ; System.out.println(obj) ; inz.close() ; }// for } } catch (Exception exc ) { System.err.println(exc) ; } finally { if ( socket != null) { try{ socket.leaveGroup(adrGroupe) ; } catch (IOException exc) {} } } } }
8/133
8
Approfondissements
* Voir dans le package les classes permetttant de manipuler et dutiliser des URL et en particulier URLConnection et ses drivs (HttpURLConnection, JarURLconnection,..). Dans le cas dchanges http voir galement la pratique des ContentHandler. * Voir les classes lies la scurit avance sur rseau (NetPermision, Authenticator,..), lutilisation de javax.net.ssl et de https. * Voir galement les mcanismes de personnalisation des sockets (SocketImplFactory) en particulier avec RMI.
8/134
8/135
Linarisation des objets (Serialization)

Points essentiels :
Une catgorie particulire de classe dentre/sortie permet de lire ou dcrire des instance dobjets sur un ot :
ObjectInputStream et ObjectOutputStream particularits du comportement des Stream dobjets personnalisations des E/S dobjets.
9
Introduction
La majorit des applications requiert un outil de sauvegarde des donnes. La plupart de ces applications utilisent une base de donnes pour stocker ou conserver des donnes. Cependant, les bases de donnes ne servent pas uniquement stocker des objets, particulirement des objets Java. Pour les applications, le seul impratif est de conserver ltat dun objet Java an que cet objet puisse tre facilement stock et rcupr dans son tat initial . Dans cette optique, l API de linarisation dobjets Java fournit un moyen simple et transparent permettant de conserver les objets Java. Elle nest pas utilise uniquement pour sauvegarder ou restaurer des donnes mais sert aussi changer des objets sur des ots (par ex. changes dobjets entre JVM distantes)

9/137
9
Architecture de srialisation
Package java.io
LAPI de srialisation est base sur deux interfaces abstraites base de ots, java.io.ObjectOutput et java.io.ObjectInput, conues pour introduire ou extraire des objets dun ot dE/S.
java.io.DataOutput
java.io.OutputStream
ObjectOutput
ObjectOutputStream
ObjectStreamConstants
java.io.DataInput
java.io.InputStream
ObjectInput
ObjectInputStream
java.lang.Object
java.io.Serializable
Lgende Classe Classe abstraite Interface
java.io.Externalizable
Etend Implante

9/138
9
Interface ObjectOutput
Linterface ObjectOutput tend DataOutput an dcrire des primitives. La principale mthode de cette interface est writeObject() qui permet dcrire un objet. Des exceptions peuvent tre gnres lors de laccs lobjet ou ses champs, ou lors dune tentative dcriture dans le ot. package java.io; public interface ObjectOutput extends DataOutput { public void writeObject(Object obj) throws IOException; public void write(byte b[]) throws IOException; public void write(byte b[], int off, int len) throws IOException; public void flush() throws IOException; public void close() throws IOException; }

9/139
9
Interface ObjectInput
La mthode readObject permet de lire le ot et de retourner un objet. Des exceptions sont gnres lors dune tentative de lecture du ot , ou sil savre impossible de trouver le nom de classe pour lobjet srialis. package java.io; public interface ObjectInput extends DataInput { public Object readObject() throws ClassNotFoundException, IOException; public int read() throws IOException; public int read(byte b[]) throws IOException; public int read(byte b[], int off, int len) throws IOException; public long skip(long n) throws IOException; public int available() throws IOException; public void close() throws IOException; }

9/140
9
Interface Serializable
Linterface Serializable sert identier les classes pouvant tre srialises : package java.io; public interface Serializable {}; Toute classe peut tre srialise dans la mesure o elle satisfait aux critres suivants :
La classe (ou une classe de la hirarchie de cette classe) doit implmenter java.io.Serializable. Parmi les classes standard non-susceptibles dtre linarises citons java.io.FileInputStream, java.io.FileOutputStream et java.lang.Threads. Les champs ne pas srialiser doivent tre reprs laide du mot cl transient. Si le mot cl transient nest pas affect ces champs, une tentative dappel de la mthode writeObject() gnrera une exception NotSerializableException.
Elments srialisables
Tous les champs (donnes) dun objet Serializable sont crits dans le ot . Ils incluent les types de primitives, les tableaux et les rfrences dautres objets. A nouveau, seules les donnes (et le nom de classe) des objets rfrencs sont stockes. Les champs statiques ne sont pas srialiss. Il est noter que le mcanisme daccs aux champs (private, protected et public) na aucun effet sur le champ en cours de srialisation. .

9/141
9
Ecriture et lecture dun ot dobjets
Ecriture
Soit la classe : class Point implements java.io.Serializable { int x; int y; Point( int x, int y){ this.x = x; this.y = y; } }
Lcriture et la lecture dun objet dans un ot est un processus simple. Examinons le fragment de code suivant qui transmet une instance dun objet un chier :
Point myPoint = new Point(1,2); FileOutputStream fos = new FileOutputStream(myfile); ObjectOutputStream oos = new ObjectOutputStream(fos); oos.writeObject(myPoint); oos.close();

9/142
9
Ecriture et lecture dun ot dobjets
Lecture
La lecture de lobjet est aussi simple que lcriture, une exception prs la mthode readObject() retourne un rsultatde type Object, on doit donc transtyper (cast) le rsultat, avant que lexcution des mthodes sur cette classe soit possible : Point serialPoint; FileInputStream fis = new FileInputStream(myFile); ObjectInputStream ois = new ObjectInputStream(fis); serialPoint = (Point)ois.readObject();

9/143
9
Effets de la linarisation
Lorsquon linarise des objets avec des ObjectStreams on doit bien matriser les effets suivants :
Les instances rfrences par linstance en cours de linarisation sont leur tour linarises. Attention: les graphes de rfrences sont conservs (y compris sil y a des cycles!). haut proprio * gauche droite
haut transient proprio=X gauche droite
transfert Objet
bas1 proprio=X gauche * droite
bas2 proprio=X gauche * droite *
bas1 proprio * gauche * droite
bas2 proprio * gauche * droite *
Un mcanisme particulier (qui assure la proprit ci-dessus) fait que certaines mthodes ne sont appeles quune fois sur une instance donne. Pour que le Stream oublie les instances dej transfres utiliser la mthode reset(). La cration dun ObjectInputStream est un appel bloquant. On ne sortira de cet appel que lorsque le Stream aura reu un premier transfert qui lui permet de sassurer que le protocole avec lObjectOutputStream correspondant est correct. Lutilisation la plus simple du mcanisme de linariisation suppose que les JVM qui crivent et lisent les instances aient une connaissance a priori de la dnition des classes. Il peut se produire des cas o les versions de dnition de la classe ne sont pas tout fait les mmes entre les JVM : la spcication du langage Java (JLS) dnit prcisment les cas o ces versions sont considrs comme compatibles. Voir lutilitaire serialver pour connatre lidentiant de serialisation dune classe.

9/144
9
Personnalisation de la linarisation
personnalisation de la lecture/criture dobjet
On peut personnaliser la linarisation dune classe en dnissant deux mthodes prives writeObject and readObject. La mthode writeObject permet de contrler quelles informations sont sauvegardes. Typiquement on lutilise pour envoyer des informations complmentaires qui permettront de reconstituer correctement lobjet larrive : supposons par exemple quon ait des deux cots un mcanisme de dictionnaire (ou de base de donnes) qui permette de rechercher un objet en connaissant une clef; au lieu de transfrer cet objet (qui est rfrenc par lobjet courant) on peut transfrer sa clef et le reconstituer larrive en consultant le dictionnaire. private void writeObject(ObjectOutputStream s) throws IOException { s.defaultWriteObject(); // code spcifique : utiliser evt. les mthodes de // DataOutputStream pour les types scalaires et les chanes } La mthode readObject doit tre soigneusement conue pour lire exactement les donnes dans le mme ordre. private void readObject(ObjectInputStream s) throws IOException { s.defaultReadObject(); //lecture des donnes personnalises ... // code de mise jour de linstance courante } Les mthodes writeObject et readObjectne sont responsables que de la linarisation de la classe courante. Toute linarisation de super-classe est traite automatiquement. Si on a besoin de coordination explicite avec la super-classe il vaut mieux passer par le mcanisme de linterface Externalizable.

9/145
9
Personnalisation de la linarisation
Externalisable
Les classes implantant linterface Externalizable, prennent la responsabilit du stockage et de la rcupration de ltat de lobjet luimme. package java.io; public interface Externalizable extends Serializable { public void writeExternal (ObjectOutput out) throws IOException; public void readExternal (ObjectInput in) throws IOException, ClassNotFoundException; } Les objets externalisables doivent :
Implmenter linterface java.io.Externalizable. Implanter une mthode writeExternal pour enregistrer ltat de lobjet. La mthode doit explicitement correspondre au supertype pour conserver son tat. Implanter une mthode readExternal pour lire les donnes du ot et restaurer ltat de lobjet. La mthode doit explicitement correspondre au supertype pour conserver son tat. Etre responsables du format dni en externe. Les mthodes writeExternal et readExternal sont uniquement responsables de ce format.
Des classes externalisables impliquent que la classe soit Serializable, mais vous devez fournir les mthodes de lecture et dcriture dobjets. Aucune mthode nest fournie par dfaut. ATTENTION: les mcanismes dexternalisation sont une menace pour la scurit! Il est recommand de les utiliser avec une extrme prudence!

9/146

9/147
RMI (introduction technique)

Points essentiels
10
Jusqu lapparition de l API RMI, les sockets constituaient lunique fonction Java qui permettait dtablir une communication directe entre les machines. A linstar des appels de procdures distants (RPC), larchitecture RMI utilise la connexion avec les sockets et les E/S pour le transfert des informations, si bien que les appels de mthodes sur des objets distants sont effectus de faon identique aux appels de mthodes sur des objets locaux.
10
Bibliographie
Certaines parties de ce module sont extraites de :
The Java Remote Method Invocation Specication disponible sur http://chatsubo.javasoft.com/current/doc/rmi-spec/ rmi-spec.ps
Java RMI Tutorial disponible sur http://chatsubo.javasoft.com/current/doc/tutorial/ rmi-getstart.ps
Frequently Asked Questions, RMI and Object Serialization disponible sur http://chatsubo.javasoft.com/current/faq.html

10/149
10
Fonction de larchitecture RMI en Java
Ralisation
Client Application Stub rmic(compiler)
Class
Serveur Object Implementation Skeleton
Method call Method Results
L API RMI contient une srie de classes et dinterfaces permettant au dveloppeur dappeler des objets distants, dj existants dans une application sexcutant sur une autre machine virtuelle Java (JVM). Cette JVM distante ou serveur peut tre excute sur la mme machine ou sur une machine entirement diffrente du client RMI. Larchitecture RMI en Java est un mcanisme utilisant uniquement le langage Java.

10/150
10
Packages et hirarchies RMI
Package java.rmi
java.lang.SecurityManager java.lang.Object java.io.IOException
RMISecurityManager
Naming
RemoteException*
Lgende
Remote
Classe Classe extraite Interface
*Bien quil existe davantage dexceptions dans les packages java.rmi et java.rmi.server , RemoteException est lexception que vous rencontrerez le plus frquemment.
Etend Implante
Naming Cette classe nale est utilise par les clients et serveurs RMI pour communiquer avec un aiguilleur appel Registre des noms (Registry) et situ sur la machine serveur. Lapplication serveur utilise les mthodes bind et rebind pour enregistrer ses implantations dobjets auprs du Registre, alors que le programme client utilise la mthode lookup de cette classe pour obtenir une rfrence vers un objet distant. Remote Cette interface doit tre tendue par toutes les interfaces client qui seront utilises pour accder aux implantations dobjets distants. RemoteException Cette exception doit tre gnre par toute mthode dclare dans des interfaces et des classes de ralisation distantes. Tous les codes client doivent donc naturellement tre crits pour traiter cette exception. RMISecurityManager Cette classe permet aux applications locales et distantes daccder aux classes et aux interfaces RMI.

10/151
10
Package java.rmi.server
java.lang.Object
Operation
LoaderHandler
RMIClassLoader
ObjID
RMISocketFactory java.rmi.Remote RemoteObject
UID java.io.Serializable
RemoteStub
RemoteServer
java.io.PrintStream
UnicastRemoteObject RemoteCall RMIFailureHandler

Lgende
LogStream
Skeleton Unreferenced java.io.Externalizable RemoteRef
Classe Classe extraite Interface Etend
ServerRef
Implante

10/152
10
Package java.rmi.server (suite)
RMIClassLoader ClassLoader sert charger les stubs (talons) et les skeletons dobjets distants, ainsi que les classes des arguments et les valeurs retournes par les appels de mthodes distance. Lorsque RMIClassloader tente de charger des classes partir du rseau, une exception est gnre si aucun gestionnaire de scurit nest install. UnicastRemoteObject Classe parent de chaque classe distante en RMI

10/153
10
Cration dune application RMI
Server Open an account Account Manager Creates Account Instance Get current balance Deposit money Withdraw money Client
Exemple bancaire
Pour illustrer lutilisation de linvocation RMI, nous allons tudier lexemple simple dune banque dans laquelle on va ouvrir un compte. Les comptes sont contrls par un employ de banque : le gestionnaire de comptes. Aprs avoir ouvert un compte, on peut y dposer ou en retirer de largent et vrier le solde.

10/154
10
Interfaces bancaires
Si on tente de modliser ce problme en utilisant linvocation RMI, on peut crer deux interfaces Java du type suivant :
Account.java package rmi.bank; interface Account extends Remote { public float getBalance (); public void withdraw (float money); public void deposit (float money); }
AccountManager.java package rmi.bank; interface AccountManager extends Remote { public Account open (String name, float startingBalance); }

10/155
10
Interfaces bancaires (suite)
Il est noter que ces interfaces sont conues de sorte que lon utilise linterface AccountManager pour gnrer une instance dun objet Account. AccountManager est charg de retourner linstance courante dun objet Account si le compte existe dj. Cette approche de la cration dobjet est un type de conception dni dans la mthodologie de programmation par une mthode appele Gnrateur (Factory).1 Ce "Gnrateur" permet un objet de contrler la cration dautres objets et, dans le cas considr, il sagit de la solution idale car le gestionnaire de comptes (AccountManager) doit contrler la cration de nouveaux comptes. Si lon se rendait dans la banque et on tentait douvrir un autre compte, on rpondrait Vous possdez dj un compte dans notre tablissement. Utilisez-le.
1.
Design Patterns - Elements of Reusable Object-Oriented Software par Gamma, Helm, Johnson et Vlissides (Editions Addison-Wesley, 1995)

10/156
10
BankClient.java Account.java (interface) AccountManager.java (interface) %java BankClient BankServer.java AccountManagerImpl.java AccountImpl.java Account %rmi registry& Instance %java BankServer
Procdure
Le processus permettant de crer une application accessible distance dans RMI est le suivant : 1. 2. 3. 4. 5. 6. 7. 8. Dnir les objets distants utiliser sous forme dinterfaces Java. Crer des classes de ralisation pour les interfaces. Compiler linterface et les classes de ralisation. Crer des classes stubs et skeletons laide de la commande rmic sur les classes de ralisation. Crer une application serveur permettant de grer et de compiler les ralisations. Crer et compiler un client permettant daccder aux objets distants. Lancer rmiregistry et lapplication serveur. Tester le client.

10/157
10
Interface Account
Lexemple suivant prsente linterface Account complte : // The Account interface // Methods for getting the account balance, depositing, and // withdrawing money package rmi.bank; import java.rmi.*; public interface Account extends Remote { // Get the account balance public float getBalance () throws RemoteException; // Deposit money to the account // throw an exception if the value // is 0 or a negative number public void deposit (float balance) throws BadMoneyException, RemoteException; // Withdraw money from the account //but throw an exception if the // amount of the withdrawal will exceed the account balance public void withdraw (float balance) throws BadMoneyException, RemoteException; } Linterface Account doit tendre java.rmi.Remote et tre dclare public an dtre rendue accessible distance (aux clients utilisant dautres JVM). Il est noter que toutes les mthodes gnrent une exception java.rmi.RemoteException. Cette exception apparat lorsque survient un problme daccs la mthode dun objet distant. Les mthodes de dpt et de retrait gnrent galement une exception BadMoneyException indiquant quune valeur ngative a t transmise pour un dpt, ou quune tentative de retrait suprieur au solde du compte a t effectue.

10/158
10
Interface AccountManager
Linterface AccountManager complte inclut : // The Account Manager interface // Method for creating a new Account with the user's // name and initial account balance package rmi.bank; import java.rmi.*; public interface AccountManager extends Remote { public Account open (String name, float initialBalance) throws BadMoneyException, RemoteException; }

10/159
10
ralisation de linterface Account AccountImpl
Linterface Account est ralise par une classe devant son tour implanter toutes les mthodes dnies dans Account et tendre UnicastRemoteObject. Par convention, pour les classes ralisant des contrats d interface RMI, le sufxe Impl sera ajout au nom du chier dinterface : // // // // // AccountImpl - Implementation of the Account interface This class is an instance of an Account and implements the balance, deposit and withdraw methods specified by the Account interface.
package rmi.bank; import java.rmi.*; import java.rmi.server.UnicastRemoteObject; public class AccountImpl extends UnicastRemoteObject implements Account { // The current balance of the account private float balance = 0; // Create a new account implementation with a new account balance public AccountImpl (float newBalance) throws RemoteException { balance = newBalance; }

10/160
10
ralisation de linterface Account AccountImpl (suite)
// Methods implemented from Account // Return the current account balance public float getBalance () throws RemoteException { return balance; } // Deposit money into the account, // as long as it is a positive number public void deposit (float money) throws BadMoneyException, RemoteException { // Is the deposit amount a negative number? if (money < 0) { throw new BadMoneyException ("Attempt to deposit negative money!"); } else { balance += money; } } // Withdraw money from the account, up to the // value of the current account balance public void withdraw (float money) throws BadMoneyException, RemoteException { // Is the deposit amount a negative number? if (money < 0) { throw new BadMoneyException ("Attempt to deposit negative money!"); } else { // Is there sufficient money in the account? if ((balance - money) < 0) { throw new BadMoneyException ("Attempt to overdraw your account!"); } else { balance -= money; } } } }

10/161
10
AccountManagerImpl
La classe AccountManagerImpl est charge de crer et denregistrer de nouveaux comptes (sous forme dobjets AccountImpl). Cette classe utilise un vecteur (Vector) permettant denregistrer les objets Account dans une classe de conteneurs appele AccountInfo, associe au nom du compte String. Cette classe utilitaire facilite la recherche dun objet Account existant. // AccountManagerImpl - Implementation of the AccountManager // interface // // This version of the AccountManager class stores all // instances of the Account(s) it creates in a Vector // object - if an account requested exists, it will // return that account. package rmi.bank; import java.util.Vector; import java.rmi.*; import java.rmi.server.UnicastRemoteObject; public class AccountManagerImpl extends UnicastRemoteObject implements AccountManager { // Local storage of account names private static Vector accounts = new Vector (); // This empty constructor is required to create an // instance of this class in the server public AccountManagerImpl () throws RemoteException { }

10/162
10
AccountManagerImpl (suite)
// Implement method from AccountManager interface // Create an instance of an Account - if the account // name already exists, return that account instead // of creating a new one public Account open (String name, float initialBalance) throws BadMoneyException, RemoteException { AccountInfo a; // Check if this name is in the list already for (int i = 0; i < accounts.size(); i++) { a = (AccountInfo)accounts.elementAt(i); if (a.name.equals (name)) { return (a.account); } } // Check the initial account value... if (initialBalance < 0) { throw new BadMoneyException ("Negative initial balance!"); } // Store the new account a = new AccountInfo(); // Try to create a new account with the starting balance try { a.account = new AccountImpl (initialBalance); } catch (RemoteException e) { System.err.println ("Error opening account: " + e.getMessage()); throw (e); } a.name = name; accounts.addElement (a); // Return and instance of an AccountImpl object return (a.account); } }

10/163
10
AccountManagerImpl
Classe de conteneurs
La classe de conteneurs AccountInfo est utilise par la classe AccountManagerImpl. // A container class for instance of Accounts // that is stored in the Vector object class AccountInfo { String name; AccountImpl account = null; }

10/164
10
Compilation du code
Le chemin daccs aux classes est important pour la russite de lexcution du code RMI. Il est recommand denvisager lutilisation de loption -d du compilateur pour localiser les chiers de classes crs : %
javac -d classDirectory *.java
Dans lexemple de code ci-dessus, le rpertoire de package rmi/bank est cr dans le rpertoire courant.

10/165
10
Utilisation de la commande rmic
Aprs compilation des classes de ralisation , vous devez crer les codes stub et skeleton permettant daccder aux classes de ralisation. Vous rappellerez les classes stubs utilises par le code client pour communiquer avec le code skeleton du serveur. La commande rmic crera des codes stub et skeleton partir des dnitions des interfaces et des classes de ralisation. Cette tape doit tre excute aprs compilation des classes de ralisation et avant excution de lapplication serveur. La syntaxe de la commande est la suivante : rmic [options] package.interfaceImpl ...
Exemple :
%
rmic -d classDirectory rmi.bank.AccountManagerImpl \ rmi.bank.AccountImpl
Lexemple suivant crera quatre classes supplmentaires dans le rpertoire rmi/bank (package) : AccountImpl_Skel.class AccountImpl_Stub.class AccountManagerImpl_Skel.class AccountManagerImpl_Stub.class

10/166
10
Application BankServer
BankServer gre lobjet AccountManagerImpl. Son unique fonction consiste fournir une instance AccountManager tout client demandeur. // BankServer - This class is run on the RMI server // and is responsible for registering the AccountManager // implementation. package rmi.bank; import java.rmi.*; public class BankServer { public static void main(String args[]) { // Create and install the security manager System.setSecurityManager(new RMISecurityManager()); try { // Create the object instance for registration System.out.println ("BankServer.main: creating an AccountManagerImpl"); AccountManagerImpl acm = new AccountManagerImpl (); // Bind the object instance to the registry System.out.println ("BankServer.main: bind it to a name: bankManager"); Naming.rebind("bankManager", acm); System.out.println("bankManager Server ready."); } catch (Exception e) { System.out.println ("BankServer.main: an exception occurred: " + e.getMessage()); e.printStackTrace(); } } }

10/167
10
Application BankServer (suite)
Le serveur publie linstance de lobjet AccountManagerImpl en associant cet objet un nom stock dans une application daiguillage rmiregistry. Laffectation seffectue la ligne 23 du programme prcdent Naming.rebind("bankManager", acm); par le biais de la mthode rebind de la classe java.rmi.Naming. Cette mthode associe ou affecte le nom bankManager lobjet acm, en supprimant tout objet prcdemment affect ce nom dans le Registre. La classe Naming fournit deux mthodes permettant au dveloppeur denregistrer une ralisation, bind et rebind, la seule diffrence rsidant dans le fait que la mthode bind gnrera une exception java.rmi.AlreadyBoundException si un autre objet a dj t enregistr sur ce serveur, laide du nom transmis la mthode en tant que premier argument. Les arguments daffectation et de raffectation se prsentent sous forme de chane de type URL contenant le nom dinstance de ralisation dobjet. La chane URL doit respecter le format rmi://host:port/name o rmi dsigne le protocole, host est le nom du serveur RMI (qui devrait tre compatible DNS ou NIS+), port est le numro de port que le serveur doit couter pour les requtes, et name est le nom exact que les clients doivent utiliser dans les requtes Naming.lookup pour cet objet. Les valeurs par dfaut sont rmi pour le protocole, lhte local pour host 1099 pour port.

10/168
10
Application rmiregistry
rmiregistry est une application fournissant un simple service daiguillage sur un nom. Lapplication BankServer fournit lapplication rmiregistry la rfrence dobjet et un nom string par le biais de lappel de mthode rebind. Lapplication rmiregistry doit tre excute avant que lapplication BankServer ne tente laffectation : % %
rmiregistry & java rmi.bank.BankServer &
Les proprits peuvent tre dnies pour la machine JVM du serveur RMI dans la ligne de commande :
java.rmi.server.codebase Cet URL indique lemplacement o les clients peuvent tlcharger les classes. java.rmi.server.logCalls Si la valeur retourne est vraie, le serveur consigne les appels dans stderr. La valeur par dfaut est faux.
java -Djava.rmi.server.logCalls=true rmi.bank.BankServer &
Aprs exportation de la ralisation par le Registre, le client peut expdier une chane URL pour demander ce que lapplication rmiregistry fournisse une rfrence de lobjet distant. La recherche seffectue par le biais dun appel client de Naming.lookup, en transmettant une chane URL sous forme dargument : rmi://host:port/name La page suivante prsente la recherche utilise par lapplication client.

10/169
10
Application BankClient
Lapplication BankClient tente de localiser un objet AccountManager en effectuant une recherche laide dun aiguilleur (Registry). Cet aiguilleur se situe dans host:port dans la chane URL transmise la mthode Naming.lookup(). Lobjet retourn est vu (converti par cast) comme un gestionnaire de compte (AccountManager) et peut servir ouvrir un compte avec un nom et lancer le calcul du solde. // BankClient - the test program for the Bank RMI example // // This class simply attempts to locate the "bankManager" // RMI object reference, then binds to it and opens an // instance to an AccountManager implementation at the // <server> location. // // Then it requests an Account with <name> and optionally, // an initial balance (for a new account). // // The class then tests the account by depositing and // withdrawing money and looking at the account balance. package rmi.bank; import java.rmi.*; public class BankClient { public static void main(String args[]) { // Check the argument count if (args.length < 2) { System.err.println ("Usage:"); System.err.println ("java BankClient <server> <account name> [initial balance]"); System.exit (1); } // Create and install the security manager System.setSecurityManager(new RMISecurityManager());

10/170
10
Application BankClient (suite)
try { // Get the bank instance System.out.println ("BankClient: lookup bankManager"); String url = new String ("rmi://"+args[0]+"/bankManager"); AccountManager acm = (AccountManager)Naming.lookup(url); // Set the account balance, if passed as an argument float startBalance = 0.0f; if (args.length == 3) { Float F = Float.valueOf(args[2]); startBalance = F.floatValue(); } // Get an account (either new or existing) Account account = acm.open (args[1], startBalance); // Now do some stuff with the remote object implementation System.out.println ("BankClient: current balance is: " + account.getBalance ()); System.out.println ("BankClient: withdraw 50.00"); account.withdraw (50.00f); System.out.println ("BankClient: current balance is: " + account.getBalance ()); System.out.println ("BankClient: deposit 100.00"); account.deposit (100.00f); System.out.println ("BankClient: current balance is: " + account.getBalance ()); System.out.println ("BankClient: deposit 25.00"); account.deposit (25.00f); System.out.println ("BankClient: current balance is: " + account.getBalance ());
10/171
10
} catch (Exception e) { System.err.println("BankClient: an exception occurred: " + e.getMessage()); e.printStackTrace(); } System.exit(1); } }

10/172
10
Application BankClient (suite)
Aprs avoir ouvert un compte, lapplication BankClient excute les oprations simples de dpt et de retrait. Cette classe pourrait (et devrait probablement) possder une interface interactive qui permettrait au client de saisir le nom du compte, puis deffectuer un retrait ou un dpt.
Excution de lapplication BankClient

Lapplication BankClient peut tre excute partir de tout hte autoris accder au Registre et au package contenant les chiers de classes de lapplication client, des stubs et des interfaces.

10/173
10
Excution de lapplication BankClient
Syntaxe
java rmi.bank.BankClient hostname accountName initialBalance
Exemples
% java rmi.bank.BankClient mach1 fred 1000 BankClient: lookup bankManager BankClient: current balance is: 1000.0 BankClient: withdraw 50.00 BankClient: current balance is: 950.0 BankClient: deposit 100.00 BankClient: current balance is: 1050.0 BankClient: deposit 25.00 BankClient: current balance is: 1075.0 Il est noter que lobjet distant AccountManagerImpl situ sur le serveur, enregistre linstance du compte cr avec le nom fred. Par consquent, la rexcution de lapplication BankClient avec le mme nom de compte utilisera le mme objet : % java rmi.bank.BankClient mach1 fred BankClient: lookup bankManager BankClient: current balance is: BankClient: withdraw 50.00 BankClient: current balance is: BankClient: deposit 100.00 BankClient: current balance is: BankClient: deposit 25.00 BankClient: current balance is:
1075.0 1025.0 1125.0 1150.0

10/174
10
Scurit RMI
Chargement de classe
Pour utiliser RMIClassLoader, un gestionnaire de scurit doit dj exister an de sassurer que les classes charges partir du rseau satisfont aux critres standard de scurit Java. Si aucun gestionnaire nest en place, lapplication ne peut pas charger les classes partir dhtes distants.
Politique de scurit
De fait le RMISecurityManager nest strictement ncessaire que sil y a chargement de code. La prsence de ce gestionnaire de scurit rend obligatoire lutilisation dun chier policy : java -Djava.security.policy=myrmi.policy rmi.bank.Client ..... Ce chier policy contenant une entre de type : grant { permission java.net.SocketPermission host:1024-, connect ; } ; On peut galement tenter de rduire le nombre de ports admis en spciant : le port du rmiregistry, un port que les objets serveurs ont choisi (voir constructeur spcial de UnicastRemoteObject).

10/175
10
Scurit RMI
Chargement de classe
Ct client RMI
Si le programme client RMI est une applet, son gestionnaire de scurit (SecurityManager) et son chargeur de classe (ClassLoader) sont mandats par le browser ct client. Cependant, si le programme client est une application, les seules classes qui seraient tlcharges partir du serveur RMI seraient les dnitions dinterfaces distantes, les classes stubs , les classes darguments tendues et les valeurs retournes par les appels de mthodes distants. Si une application client tente de charger des classes supplmentaires partir du serveur, elle peut utiliser RMIClassLoader.loadClass, en fournissant comme paramtres les mmes URL et identicateur que ceux transmis dans Naming.lookup.
Invocation RMI au travers dun coupe-feu

La couche transport RMI tente normalement douvrir des sockets directs des clients aux serveurs. Nanmoins, sil est impossible dtablir une connexion directe au serveur par socket , la mthode createSocket de la classe java.rmi.server.RMISocketFactory retentera la requte sous forme de connexion par protocole de tranfert hypertexte (HTTP) en expdiant lappel RMI sous forme de requte HTTP POST. Si la mthode createServerSocket dtecte que la connexion rcemment accepte est une requte HTTP POST, les informations retournes seront rexpdies dans le corps dune rponse HTTP. Aucune conguration spciale nest requise pour permettre au client deffectuer des appels RMI au travers dun coupe-feu.

10/176
10
Approfondissements
* RMI et politiques de scurit; tlchargement des talons stubs, callback des clients, serveur Activatable et rmid, RMI et IIOP.

10/177
JDBC (introduction technique)

Points essentiels :
11
LAPI JDBC contient une srie dinterfaces conues pour permettre au dveloppeur dapplications qui travaillent sur des bases de donnes de le faire indpendamment du type de base utilis
Pilotes (drivers) JDBC. tablissement de connexion et contexte dexcution (Statement) requtes la base et rcupration des rsultats.
11
Introduction
La connectivit JDBC permet au dveloppeur de se concentrer sur lcriture de lapplication en sassurant que les interrogations de la base de donnes sont correctes et que les donnes sont manipules conformment leur conception. La connectivit JDBC permet au dveloppeur dcrire une application en utilisant les noms dinterfaces et les mthodes dcrites dans lAPI, sans tenir compte de leur ralisation dans le pilote (driver JDBC). Le dveloppeur utilise les interfaces dcrites dans lAPI comme sil sagissait de classes courantes. Le constructeur du pilote fournit une ralisation de classe pour chaque interface de lAPI. Lorsquune mthode dinterface est utilise, elle se rfre en fait une instance dobjet dune classe ayant ralis cette interface.
Bibliographie

Caractristiques JDBC : http://java.sun.com/products/jdbc The Practical SQL Handbook par Emerson, Darnovsky et Bowman (Editions Addison-Wesley, 1989)

11/179
11
Pilote JDBC
Chaque pilote de base de donnes doit fournir une classe ralisant linterface java.sql.Driver. Cette classe est alors utilise par la classe gnrique java.sql.DriverManager lorsquun pilote est requis pour assurer la connexion une base de donnes spcique. Cette connexion sopre laide dune URL (identicateur de ressources). Exemple de driver (utilis dans les exercices) : 1, un pilote JDBC crit pour une com.imaginary.sql.msql.MsqlDriver connexion une base de donnes Mini-SQL2. Le pilote Imaginary illustre la exibilit du langage Java.
1. 2.
API mSQL-JDBC fournie avec laimable autorisation de George Reese.http://www.imaginary.com/~borg Mini SQL fourni avec laimable autorisation de Hughes Technologies Pty Ltd, Australie.

11/180
11
Pilotes JDBC
Application Java (API JDBC)
Gestionnaire de pilotes JDBC
URL
URL
URL
URL
Pilote JDBC-NET
Pilote de liaison JDBC-ODBC
Pilote A
Pilote B
Pilotes ODBC et de bases de donnes
Possibilits dimplmentation JDBC

11/181
11
Organigramme JDBC
Lenchainement des appels
Du point de vue du programmeur JDBC les tches senchainent de la manire suivante :
Cration dune instance dun driver JDBC. dtermination de la base Ouverture dune connexion la base Allocation dun contexte de requte (Statement) Soumission dune requte Rcupration des rsultats
Package java.sql
Huit interfaces sont associes lAPI JDBC :
Driver Connection Statement PreparedStatement CallableStatement ResultSet ResultSetMetaData DatabaseMetaData

11/182
11
Organigramme JDBC
Chacune de ces interfaces permet un programmeur dapplication dtablir des connexions des bases de donnes spciques, dexcuter des instructions SQL et de traiter les rsultats.
DriverManager
Driver Connection Statement ResultSet
Driver Connection
Connection
Statement
Statement
Statement
ResultSet
ResultSet
Figure 0-1
Organigramme JDBC
Une chane dURL est transmise la mthode getConnection() du gestionnaire de pilotes (DriverManager) qui localise son tour un pilote (Driver). Un pilote vous permet dobtenir une connexion (Connection). Cette connexion vous permet de crer une requte (Statement). Lorsquune requte est excute avec une mthode executeQuery(), un rsultat (ResultSet) peut tre retourn.

11/183
11
Exemple JDBC
Cet exemple simple utilise la base de donnes Mini-SQL, ainsi que les lments dune application JDBC. Les oprations ralises seront les suivantes : cration dune instance Driver, obtention dun objet Connection, cration dun objet Statement et excution dune requte, puis traitement de lobjet retourn ResultSet. 1 import java.sql.*; 2 import com.imaginary.sql.msql.*; 3 4 public class JDBCExample { 5 6 public static void main (String args[]) { 7 8 if (args.length < 1) { 9 System.err.println ("Usage:"); 10 System.err.println (" java JDBCExample <db server hostname>"); 11 System.exit (1); 12 } 13 String serverName = args[0]; 14 try { 15 // Create the instance of the Msql Driver 16 new MsqlDriver (); 17 18 // Create the "url" 19 String url = "jdbc:msql://" + serverName + 20 ":1112/StockMarket"; 21 22 // Use the DriverManager to get a Connection 23 Connection mSQLcon = DriverManager.getConnection (url); 24 25 // Use the Connection to create a Statement object 26 Statement stmt = mSQLcon.createStatement (); 27 28 // Execute a query using the Statement and return a ResultSet 29 ResultSet rs = stmt.executeQuery ( 30 "SELECT ssn, cust_name FROM Customer" + 31 " order by cust_name");

11/184
11
Exemple JDBC
32 // Print the results, row by row 33 while (rs.next()) { 34 System.out.println (""); 35 System.out.println ("Customer: " + rs.getString (2)); 36 System.out.println ("Id: " + rs.getString (1)); 37 } 38 39 } catch (SQLException e) { 40 e.printStackTrace(); 41 } 42 } 43 } Rsultats: %
java JDBCExample serveur
Customer: Tom McGinn Id: 999-11-2222 Customer: Jennifer Sullivan Volpe Id: 999-22-3333 Customer: Georgianna DG Meagher Id: 999-33-4444 Customer: Priscilla Malcolm Id: 999-44-5555

11/185
11
Cration de pilotes JDBC
Il existe deux mthodes pour crer une instance de pilote JDBC : explicitement ou laide de la proprit jdbc.drivers.
Cration explicite dune instance de pilote JDBC

Pour communiquer avec un moteur de base de donnes particulier en JDBC, vous devez pralablement crer une instance pour le pilote JDBC. Ce pilote reste en arrire plan et traite toutes les requtes pour ce type de base de donnes. // Create an instance of Msqls JDBC Driver new MsqlDriver(); Il nest pas ncessaire dassocier ce pilote une variable car le pilote est rfrenc par un objet statique.

11/186
11
Cration de pilotes JDBC
Chargement des pilotes JDBC via jdbc.drivers
Il est tout fait possible que plusieurs pilotes de bases de donnes soient chargs en mmoire. Il peut galement arriver que plusieurs de ces pilotes, ODBC ou protocoles gnriques de rseau JDBC, soient en mesure de se connecter la mme base de donnes. Dans ce cas, linterface JDBC permet aux utilisateurs de dnir une liste de pilotes dans un ordre spcique. Cet ordre de slection est dni par un paramtre de proprits Java, jdbc.drivers. La proprit jdbc.drivers doit tre dnie sous forme de liste de noms de classes de pilotes, spars par le symbole deux points (:) : jdbc.drivers=com.imaginary.sql.msql.MsqlDriver:com.acme.wonder.driver Les proprits sont dnies par loption -D de linterprteur java (ou loption -J de lapplication appletviewer). Exemple : % java -Djdbc.drivers=com.imaginary.sql.msql.MsqlDriver:\ com.acme.wonder.driver Lors dune tentative de connexion une base de donnes, lAPI JDBC utilise le premier pilote trouv susceptible dtablir la connexion lURL dni. LAPI essaie tout dabord chaque pilote dni dans cette proprit, dans lordre de gauche droite. Elle essaie ensuite tous les pilotes dj chargs en mmoire en respectant lordre de chargement. Si le pilote a t charg par un code non scuris, il est alors ignor sauf sil a t charg partir de la mme source que le code tentant dtablir la connexion.

11/187
11
Pilotes JDBC
Dsignation dune base de donnes
Aprs avoir cr linstance du pilote JDBC, vous devez prsent indiquer la base de donnes laquelle vous souhaitez vous connecter. Dans JDBC, il vous suft de spcier un URL indiquant le type de base de donnes. La syntaxe des chanes dURL propose pour une base de donnes JDBC est : jdbc:sous_protocole:parametres sous_protocole dsigne un type spcique de mcanisme de connectivit des bases de donnes, pouvant tre support par un ou plusieurs pilotes. Le contenu et la syntaxe de parametres dpendent du sous-protocole. // Construct the URL for JDBC access String url = new String ("jdbc:msql://" + servername + ":1112/StockMarket"); Cet URL vous permettra daccder la base de donnes mSQL StockMarket . serverName est une variable dnissant le nom dhte du serveur de la base de donnes.

11/188
11
Connexion JDBC
Connexion une base de donnes
Aprs avoir cr un URL dnissant msql en tant que moteur de base de donnes, vous pouvez prsent tablir une connexion la base de donnes. A cet effet, on doit obtenir un objet java.sql.Connection en appelant la mthode java.sql.DriverManager.getConnection du pilote JDBC. // Establish a database connection through the msql // DriverManager Connection mSQLcon = DriverManager.getConnection(url); Le processus est le suivant :
Le gestionnaire de pilotes (DriverManager) appelle la mthode Driver.getConnection pour chaque pilote enregistr, en transmettant la chane dURL sous forme de paramtre. Si le pilote identie le nom du sous-protocole, il retourne alors une instance dobjet Connection ou une valeur nulle le cas chant.

11/189
11
Pilotes JDBC
Interrogation dune base de donnes
La gure 2-4 dcrit la mthode permettant un gestionnaire de pilotes (DriverManager) de traduire une chane URL transmise dans la mthode getConnection(). Lorsque le pilote retourne une valeur nulle, le gestionnaire appelle le pilote enregistr suivant jusqu la n de la liste ou jusqu ce quun objet Connection soit retourn.
Chane URL
Gestionnaire de pilotes Programme
getConnection (chane URL);
Pilote
Pilote
Pilote
jdbc:A
jdbc:B
jdbc:msql
Explication Le gestionnaire de pilotes appelle
Connexion la base de donnes StockMarket
getConnection(URL) qui appelle driver.connection(URL) pour les pilotes du

vecteur jusqu ce quune correspondance soit trouve. LURL est analys (jdbc:drivername). Lorsque le pilote du vecteur correspond au drivername analys, une connexion est tablie. Si le pilote ne correspond pas, la valeur NULL est retourne et le pilote suivant du vecteur est examin.
StockMarket

11/190
11
Instructions JDBC
Soumission dune requte
Pour soumettre une requte standard, crez tout dabord un objet Statement partir de la mthode Connection.createStatement. // Create a Statement object try { stmt = mSQLcon.createStatement(); } catch (SQLException e) { System.out.println (e.getMessage()); } Utilisez la mthode Statement.executeUpdate() pour soumettre un INSERT,un UPDATE ou un DELETE . // Pass a query via the Statement object int count = stmt.executeUpdate("DELETE from Customer WHERE ssn=999-55-6666"); La mthode Statement.executeUpdate() renvoie un entier qui reprsente le nombre denregistrements affects.
Utilisez la mthode Statement.executeQuery() pour soumettre linstruction SQL la base de donnes. Notez que JDBC transmet linstruction SQL la connexion de base de donnes sous-jacente sans modication. JDBC ne tente aucune interprtation des requtes. // Pass a query via the Statement object ResultSet rs = stmt.executeQuery("SELECT DISTINCT * from Customer order by ssn"); La mthode Statement.executeQuery() renvoie un rsultat de type ResultSet pour traitement ultrieur.

11/191
11
Instructions JDBC
requte prpare
En cas dexcution rptitive des mmes instructions SQL, lutilisation dun objet PreparedStatement savre intressante. Une requte prpare est une instruction SQL prcompile qui est plus efcace quune rptition dappels de la mme instruction SQL. La classe PreparedStatement hrite de la classe Statement pour permettre le paramtrage des instructions JDBC. Le code suivant prsente un exemple dutilisation dune instruction prformatte :
Exemple
public boolean prepStatement(Reservation obj){ PreparedStatement prepStmnt = msqlConn.prepareStatement( "UPDATE Flights SET numAvailFCSeats = ? WHERE flightNumber = ?" ); prepStmnt.setInt(1, (Integer.parseInt(obj.numAvailFCSeats) - 1)); prepStmnt.setLong(2, obj.FlightNo); int rowsUpdated = prepStmnt.executeUpdate(); return (rowsUpdated > 0) ; }
Les mthodes setXXX

Les mthodes setXXX de conguration des paramtres SQL IN doivent indiquer les types compatibles avec le type SQL de paramtre dentre dni. Ainsi, si un paramtre IN est du type SQL Integer, setInt doit tre utilis.

11/192
11
Mthodes setXXX
Table 2: Mthodes setXXX et types SQL Mthode setASCIIStream setBigDecimal setBinaryStream setBoolean setByte setBytes setDate setDouble setFloat setInt setLong setNull setObject setShort setString setTime setTimestamp setUnicodeStream Type(s) SQL Utilise une chane ASCII pour gnrer un LONGVARCHAR NUMERIC LONGVARBINARY BIT TINYINT VARBINARY ou LONGVARBINARY (selon la taille par rapport aux limites de VARBINARY) DATE DOUBLE FLOAT INTEGER BIGINT NULL Lobjet Java dni est converti en type SQL cible avant dtre envoy SMALLINT VARCHAR ou LONGVARCHAR (selon la taille par rapport aux limites du pilote sur VARCHAR) TIME TIMESTAMP UNICODE

11/193
11
Instructions JDBC
procdure stocke
Une procdure stocke permet lexcution dinstructions non SQL dans la base de donnes. La classe CallableStatement hrite de la classe PreparedStatement qui fournit les mthodes de conguration des paramtres IN. Etant donn que la classe PreparedStatement h rite de la classe Statement, la mthode de rcupration de rsultats multiples par une procdure enregistre est supporte par la mthode Statement.getMoreResults. Ainsi, vous pourriez utiliser une instruction CallableStatement pour enregistrer une instruction SQL prcompile, vous permettant dinterroger une base de donnes contenant les informations sur la disponibilit des siges pour un vol particulier. String planeID = "727"; CallableStatement querySeats = msqlConn.prepareCall("{call return_seats(?, ?, ?, ?)}"); try { querySeats.setString(1, planeID); querySeats.registerOutParameter(2, java.sql.Type.INTEGER); querySeats.registerOutParameter(3, java.sql.Type.INTEGER); querySeats.registerOutParameter(4, java.sql.Type.INTEGER); querySeats.execute(); int FCSeats = querySeats.getInt(2); int BCSeats = querySeats.getInt(3); int CCSeats = querySeats.getInt(4); } catch (SQLException SQLEx){ System.out.println("Query failed"); SQLEx.printStackTrace(); } Avant dexcuter un appel de procdure stocke, vous devez explicitement appeler registerOutParameter pour enregistrer le type java.sql.Type de tous les paramtres SQL OUT.

11/194
11
Instructions JDBC
Batch
Connection cnx = DriverManager.getConnection(url) ; cnx.setAutoCommit(false) ; Statement s = cnx.createStatement() ; s.addBatch(DELETE FROM personnes WHERE nom=Dupond) ; s.addBatch(DELETE FROM personnes WHERE nom=Dupont) ; s.addBatch(INSERT INTO personnes VALUES(tryphon,Tournesol); s.executeBatch(); .... cnx.commit() ;

11/195
11
Instructions JDBC
Rcupration de rsultats
Le rsultat de lexcution dune instruction peut se prsenter sous forme de table de donnes accessible via un objet java.sql.ResultSet. Cette table se compose dune srie de lignes et de colonnes. Les lignes sont rcupres dans lordre. Un objet ResultSet maintient un curseur sur la ligne de donnes courante et le positionne tout dabord sur la premire ligne. Le premier appel de linstruction next dnit la premire ligne en tant que ligne courante, le second appel dplace le curseur sur la seconde ligne, etc. A partir de la platerforme Java 2 les ResultSets offrent de nouveaux services :
regroupement de rsultats en blocs : rs.fetchsize(25) ; navigation dans les rsultats : rs.previous(), ...
Lobjet ResultSet fournit une srie de mthodes get permettant daccder aux nombreuses valeurs de colonne de la ligne courante. Ces valeurs peuvent tre rcupres partir du nom de la colonne ou dun indice. Il est gnralement plus pratique dutiliser un indice pour rfrencer une colonne. Les indices de colonne dbutent 1.

11/196
11
Instructions JDBC
Rception de rsultats (suite)
while (rs.next()) { System.out.println ("Customer: " + rs.getString(2)); System.out.println ("Id: " + rs.getString(1)); System.out.println (""); } Les diverses mthodes getXXX accdent aux colonnes dans la table de rsultats. Il est possible daccder aux colonnes dune ligne dans nimporte quel ordre. Nota: il est possible de dcouvir dynamiquement des informations sur la table comme le nombre de champs dans un enregistrement, le type de chaque champ, etc. Ce type dinformation est gr par lobjet ResultSetMetaData rendu par getMetaData() -service non accessible en mSQLPour rcuprer des donnes extraites de lobjet ResultSet, vous devez vous familiariser avec les colonnes retournes, ainsi quavec les types de donnes quelles contiennent. La table 2-3 tablit une correspondance entre les types de donnes Java et SQL.

11/197
11
Mthodes getXXX
Table 3: Mthodes getXXX et type de donnes Java retourn Mthode getASCIIStream getBigDecimal getBinaryStream getBoolean getByte getBytes getDate getDouble getFloat getInt getLong getObject getShort getString getTime getTimestamp getUnicodeStream Type de donnes Java retourn java.io.InputStream java.math.BigDecimal java.io.InputStream boolean byte byte[] java.sql.Date double float int long Object short java.lang.String java.sql.Time java.sql.Timestamp java.io.InputStream de caractres Unicode

11/198
11
Correspondance des types de donnes SQL en Java
La table 2-3 prsente les types Java standard pour la correspondance avec divers types SQL courants. Table 4: Correspondance de types SQL en Java Type SQL CHAR VARCHAR LONGVARCHAR NUMERIC DECIMAL BIT TINYINT SMALLINT INTEGER BIGINT REAL FLOAT DOUBLE BINARY VARBINARY LONGVARBINARY DATE TIME TIMESTAMP Type Java String String String (ou Stream) java.math.BigDecimal java.math.BigDecimal boolean byte short int long float double double byte[] byte[] byte[] java.sql.Date java.sql.Time java.sql.Timestamp

11/199
11
Utilisation de lAPI JDBC
En crant une srie gnrique dinterfaces permettant dtablir une connexion tout produit de base de donnes grce lAPI JDBC, vous ntes limit ni une base de donnes spcique, ni une architecture particulire daccs car plusieurs solutions peuvent tre envisages.
Types de conception des pilotes JDBC

La conception de larchitecture des accs base de donnes que vous choisissez dimplanter dpend en partie du pilote JDBC.
Conception en deux lments Utilisant le langage Java vers des bibliothques de mthodes natives ou Java vers un protocole de systme de gestion de base de donnes (SGBD) natif (tous les codes en Java mais protocole spcique) Conception en trois lments Utilisant tous les codes Java dans lesquels les appels JDBC sont convertis en protocole indpendant du systme SGBD. Conception en deux ou trois lments Spcialement conue pour fonctionner avec les pilotes de bases de donnes ODBC (connectivit ouverte aux bases de donnes Microsoft), dans lesquels les appels JDBC sont effectus par le biais dun pilote ODBC (gnralement une librairie spcique la plate-forme)
A ce jour, les principaux dveloppements de pilotes de bases de donnes ont t raliss par des constructeurs indpendants, non associs une socit de fourniture de bases de donnes. Cette situation est avantageuse pour le dveloppeur car elle implique que les solutions ne sont gnralement pas prives et que la concurrence rgule les prix.

11/200
11

11/201
Annexe : JNI
Contenu:
12
Cette annexe introduit lAPI Java Native Interface qui permet dtendre JAVA avec du code compil crit en C ou C++:
Pourquoi raliser du code natif? Les phases de gnration : un exemple simple Les caractristiques gnrales de JNI Exemples : emploi des types Java en C, accs aux attributs des objets JAVA, cration dinstances. Le problme de lintgrit des rfrences aux objets JAVA. Le traitement des exceptions JAVA Linvocation de JAVA lintrieur dun code C/C++.
12
Pourquoi raliser du code natif?
Il y a des situations dans laquelle le code ne peut pas tre compltement crit en JAVA :
Une grande quantit de code compil existe dja et fonctionne de manire satisfaisante. La fourniture dune interface avec JAVA peut tre plus intressante quune rcriture complte. Une application doit utiliser des services non fournis par JAVA (et en particulier pour exploiter des spcicits de la plateforme dexcution. Exemple : accs des cartes). Le systme JAVA nest pas assez rapide pour des applications critiques et la ralisation dans un code natif serait plus efciente.
Il est possible dimplanter en JAVA des mthodes natives ralises typiquement en C ou C++. Une classe comprenant des mthodes natives ne peut pas tre tlcharge au travers du rseau de manire standard: il faudrait que le serveur ait connaissance des spcicits de la plate-forme du client. De plus une telle classe ne peut faire appel aux services de scurit de JAVA (en 1.1) Bien entendu pour toute application JAVA qui sappuie sur des composants natifs on doit raliser un portage du code natif sur chaque plate-forme spcique. De plus cest un code potentiellement plus fragile puisque les contrles (pointeurs, taille, etc.) et la rcupration derreurs sont entirement sous la responsabilit du programmeur. Il existe diverses manires dassurer cette liaison code compil-Java. Depuis la version JAVA 1.1 le protocole JNI a t dni pour rendre cette adaptation plus facilement indpendante de la ralisation de la machine virtuelle sous-jacente. Dautre part il est galement possible dexcuter du code JAVA au sein dune application crite en C/C++ en appelant directement la machine virtuelle ( JAVA "enchass" dans C).
Annexe : JNI
12/203
12
un exemple : "Hello World" en C
rsum des phases :
Ecriture du code JAV : A
Cration dune classe "HelloWorld" qui dclare une mthode (statique) native.
Cration des binaires JAV de rfrence : A
Compilation du code ci-dessus par javac .
Gnration du chier dinclusion C/C++ :
Ce chier est gnr par lutilitaire javah . Il fournit une dnition dun en-tte de fonction C pour la ralisation de la mthode native getGreetings() dnie dans la classe Java "HelloWorld".
Ecriture du code natif :
Ecriture dun chier source C (".c") qui ralise en C le code de la mthode native. Ce code fait appel des fonctions et des types prdnis de JNI.
Cration dune librairie dynamique:
Utilisation du compilateur C pour gnrer une librairie dynamique partir des chiers .c et .h dnis ci-dessus. (sous Windows une librairie dynamique est une DLL)
Excution:
Excution du binaire JAVA (par java) avec chargement dynamique de la librairie.
Annexe : JNI
12/204
12
Ecriture du code JAV A
Le code de lexemple dnit une classe JAVA nomme "HelloWorld" et faisant partie du package "hi". package hi ; class HelloWorld { static { System.loadLibrary("hello"); } public static native String getGreetings(); public static void main (String[] tArgs) { for (int ix = 0 ; ix < tArgs.length; ix++) { System.out.println(getGreetings() + tArgs[ix]) ; } }// main } Cette classe pourrait contenir galement dautres dnitions plus classiques (champs, mthodes, etc.). On remarquera ici :
La prsence dun bloc de code static excut au moment du chargement de la classe. A ce moment il provoque alors le chargement dune bibliothque dynamique contenant le code excutable natif li la classe. Le systme utilise un moyen standard (mais spcique la plate-forme) pour faire correspondre le nom "hello" un nom de bibliothque ( "libhello.so" sur Solaris, "hello.dll" sur Windows,...) La dnition dun en-tte de mthode native. Une mthode marque native ne dispose pas de corps. Comme pour une mthode abstract le reste de la "signature" de la mthode (arguments, rsultat,...) doit tre spci. (ici la mthode est static mais on peut, bien sr, crer des mthodes dinstance qui soient natives).
Annexe : JNI
12/205
12
Cration des binaires JAV de rfrence A
La classe ainsi dnie se compile comme une autre classe : javac -d . HelloWorld.java (autre exemple sous UNIX : au lieu de "-d ." on peut faire par exemple "d $PROJECT/javaclasses") Le binaire JAVA gnr est exploit par les autres utilitaires employs dans la suite de ce processus. Dans lexemple on aura un chier "HelloWorld.class" situ dans le sousrpertoire "hi" du rpertoire cibl par loption "-d"
Annexe : JNI
12/206
12
Gnration du chier dinclusion C/C++
Lutilitaire javah va permettre de gnrer partir du binaire JAVA un chier dinclusion C/C++ ".h". Ce chier dnit les prototypes des fonctions qui permettront de raliser les mthodes natives de HelloWorld. javah -d . -jni hi.HelloWorld (autre exemple sous UNIX: javah -d $PROJECT/csources ....) On obtient ainsi un chier nomm hi_HelloWorld.h : /* DO NOT EDIT THIS FILE - it is machine generated */ #include <jni.h> /* Header for class hi_HelloWorld */ #ifndef _Included_hi_HelloWorld #define _Included_hi_HelloWorld #ifdef __cplusplus extern "C" { #endif /* * Class: hi_HelloWorld * Method: getGreetings * Signature: ()Ljava/lang/String; */ JNIEXPORT jstring JNICALL Java_hi_HelloWorld_getGreetings (JNIEnv *, jclass); #ifdef __cplusplus } #endif #endif Des rgles particulires rgissent la gnration du nom de chier dinclusion et des noms de fonctions ralisant des mthodes natives. On notera que la fonction rend lquivallent dun type JAVA (jstring) et, bien qutant dnie sans paramtres en JAVA, comporte deux paramtres en C. Le pointeur dinterface JNIEnv permet daccder aux objets JAVA, jclass rfrence la classe courante (on est ici dans une mthode statique: dans une mthode dinstance le paramtre de type jobject rfrencerait linstance courante).
Annexe : JNI
12/207
12
Ecriture du code natif
En reprenant les prototypes dnis dans le chier dinclusion on peut dnir un chier source C : "hi_HelloWorldImp.c" : #include <jni.h> #include "hi_HelloWorld.h" /* * Class: hi_HelloWorld * Method: getGreetings * Signature: ()Ljava/lang/String; * on a une methode statique et cest la classe * qui est passe en paramtre */ JNIEXPORT jstring JNICALL Java_hi_HelloWorld_getGreetings (JNIEnv * env , jclass curclass) { return (*env)->NewStringUTF(env, "Hello "); }
env nous fournit une fonction NewStringUTF qui nous permet de gnrer une chane JAVA partir dune chane C. NOTA : en C++ les fonctions JNI sont "inline" et le code scrirait : JNIEXPORT jstring JNICALL Java_hi_HelloWorld_getGreetings (JNIEnv * env , jclass curclass) { return env->NewStringUTF("Hello "); }
Annexe : JNI
12/208
12
Cration dune librairie dynamique
Exemple de gnration sous UNIX (le ".h" est dans le rpertoire courant) #!/bin/sh # changer DIR en fonction des besoins DIR=/usr/local/java cc -G -I$DIR/include -I$DIR/include/solaris \ hi_HelloWorldImp.c -o libhello.so Exemple de gnration sous Windows avec le compilateur VisualC++4.0: cl -Ic:\java\include -Ic:\java\include\win32 -LD hi_HelloWorldImp.c -Fehello.dll
Annexe : JNI
12/209
12
Excution
java hi.HelloWorld World underWorld Hello World Hello underWorld Si, par contre, vous obtenez une exception ou un message indiquant que le systme na pas pu charger la librairie dynamique il faut positionner correctement les chemins daccs aux librairies dynamiques (LD_LIBRARY_PATH sous UNIX)
Annexe : JNI
12/210
12
prsentation de JNI
JNI est une API de programmation apparue partir de la version 1.1 de JAVA. Il existait auparavant dautres manires de raliser des mthodes natives. Bien que ces autres APIs soient toujours accessibles elles prsentent quelques inconvnients en particulier parce quelles accdent aux champs des classes JAVA comme des membres de strcutures C (ce qui oblige recompiler le code quand on change de machine virtuelle) ou parcequelles posent quelques problmes aux glaneurs de mmoire (garbage collector). Les fonctions de JNI sont adressables au travers dun environnement (pointeur dinterface vers un tableau de fonctions) spcique un thread. Cest la machine virtuelle elle mme qui passe la ralisation concrte de ce tableau de fonctions et on assure ainsi la compatibilit binaire des codes natifs quel que soit la machine virtuelle effective. Les fonctions proposes permettent en particulier de :
Crer, consulter, mettre jour des objets JAVA, (et oprer sur leurs verrous). Oprer avec des types natifs JAVA. Appeler des mthodes JAVA Manipuler des exceptions Charger des classes et inspecter leur contenu
Le point le plus dlicat dans ce partage de donnes entre C et JAVA et celui du glaneur de mmoire (garbage collector): il faut se protger contre des drfrencements dobjets ou contre des effets de compactage en mmoire (dplacements dadresses provoqus par gc), mais il faut savoir aussi faciliter le travail du glaneur pour recuprer de la mmoire.
Annexe : JNI
12/211
12
JNI: types, accs aux membres, cration dobjets
Soit lexemple de classe : package hi ; class Uni { static { System.loadLibrary("uni"); } public String [] tb ;// champ "tb" public Uni(String[] arg) { tb = arg ; }// constructeur public native String [] getMess(int n, String mess); public static native Uni dup(Uni other); public String toString() { String res = super.toString() ; // pas efficient for (int ix = 0 ; ix < tb.length; ix ++) { res = res + \n + tb[ix] ; } return res ; } public static void main (String[] tArgs) { Uni you = new Uni(tArgs) ; System.out.println(you) ; String[] mess = you.getMess(tArgs.length, " Hello") ; for (int ix = 0 ; ix < mess.length; ix++) { System.out.println(mess[ix]) ; } Uni me = Uni.dup(you) ; System.out.println(me) ; }// main } Exemple dutilisation : java hi.Uni World hi.Uni@1dce0764 World Hello hi.Uni@1dce077f World
Annexe : JNI
12/212
12
La mthode native getMess(int nb, String mess) gnre un tableau de chanes contenant "nb" fois le mme message "mess" : /* Class: hi_Uni * Method: getMess * Signature: (ILjava/lang/String;)[Ljava/lang/String; */ JNIEXPORT jobjectArray JNICALL Java_hi_Uni_getMess (JNIEnv * env , jobject curInstance, jint nb , jstring chaine) { /* quelle est la classe de String ? */ jclass stringClass = (*env)->FindClass(env, "java/lang/String") ; /* un tableau de "nb" objet de type "stringClass" * chaque element est initialise a "chaine" */ return (*env)->NewObjectArray(env, (jsize)nb,stringClass,chaine) ; }
La fonction NewObjectArray est une des fonctions de cration dobjets JAVA. Elle doit connatre le type de ses composants (ici fourni par "stringClass"). Linitialisation de chaque membre dun tel tableau se fait par laccesseur SetObjectArrayElement() - mais ici on prote du paramtre dinitialisation par dfautJNI fournit des types C prdnis pour reprsenter des types primitifs JAVA (jint) ou pour des types objets (jobject, jstring,..) La fonction FindClass permet dinitialiser le bon paramtre dsignant la classe "java.lang.String" (la notation utilise le sparateur "/"!). Noter galement la reprsentation de la signature de la fonction "getMess": (ILjava/lang/String;) indique un premier paramtre de type int (symbolis par la lettre I) suivi dun objet (lettre L+ type + ; ) . De mme [Ljava/lang/String; dsigne un rsultat qui est un tableau une dimension (lettre [) contenant des chanes.
Annexe : JNI
12/213
12
La mthode statique "dup" clone linstance passe en paramtre : /* Class: hi_Uni; Method: dup * Signature: (Lhi/Uni;)Lhi/Uni; */ JNIEXPORT jobject JNICALL Java_hi_Uni_dup (JNIEnv * env, jclass curClass , jobject other) { jfieldID idTb ; jobjectArray tb ; jmethodID idConstr ; /* en fait inutile puisque cest curClass !*/ jclass uniClass = (*env)->GetObjectClass(env, other) ; if(! (idTb = (*env)->GetFieldID (env,uniClass, "tb","[Ljava/lang/String;"))) return NULL ; tb = (jobjectArray) (*env)->GetObjectField(env, other,idTb) ; /* on initialise un nouvel objet */ if(!(idConstr = (*env)->GetMethodID(env, curClass, "<init>", "([Ljava/lang/String;)V"))) return NULL ; return (*env)->NewObject(env, curClass,idConstr,tb) ; }
La rcupration du champ "tb" (de type tableau de chane) sur linstance passe en paramtre se fait par la fonction GetObjectField. On a besoin de la classe de linstance consulte et de lidenticateur du champ qui est calcul par GetFieldID. De la mme manire lappel dune mthode ncessite une classe et un identicateur de mthode calcul par GetMethodID. Ici ce nest pas une mthode qui est appele mais un constructeur et lidentiant est calcul de manire particulire ("<init>"), le type indique un paramtre de type tableau de chane et un "rsultat" qui est void (lettre V ) .
JNI fournit ainsi des accesseurs des champs (Get<static><type>Field, Set<static><type>Field) et des moyens dappeler des mthodes (Call<statut><type>Method : exemple CallStaticBooleanMethod). Il existe, en plus, des mthodes spciques aux tableaux et aux Strings
Annexe : JNI
12/214
12
rfrences sur des objets JAV A:
Le passage du glaneur de mmoire sur des objets JAVA pourrait avoir pour effet de rendre leur rfrence invalide ou de les dplacer en mmoire. Les refrences dobjet JAVA transmises dans les transitions vers le code natif sont protges contre les invalidations (elles redeviennent rcuprables la sortie du code natif). Toutefois JNI autorise le programmeur explicitement rendre une rfrence locale rcuprable. Inversement il peut aussi se livrer des oprations de "punaisage" (pinning) lorsque, pour des raisons de performances, il veut pouvoir accder directement une zone mmoire protge : const char * str = (*env)->GetStringUTFChars(env, javaString,0) ; .... /* oprations sur "str" */ (*env)->ReleaseStringUTFChars(env, javaString, str) ; Des techniques analogues existent pour les tableaux de scalaires primitifs (int, oat, etc.). Bien entendu il est essentiel que le programmeur C libre ensuite la mmoire ainsi gele. Si on veut viter de bloquer entirement un tableau alors quon veut oprer sur une portion de ce tableau , on peut utiliser des fonctions comme : void GetIntArrayRegion(JNIenv* env, jintArray tableau, jsize debut, jsize taille, jint * buffer) ; void SetIntArrayRegion(.... Le programmeur a aussi la possibilit de crer des refrences globales sur des objets JAVA. De telles rfrences ne sont pas rcuprables par le glaneur la sortie du code natif, elles peuvent tre utilises par plusieurs fonctions implantant des mthodes natives. Ici aussi il est de la responsabilit du programmeur de librer ces rfrences globales.
Annexe : JNI
12/215
12
exceptions
JNI permet de dclencher une exception quelconque ou de recuprer une exception JAVA provoque par un appel une fonction JNI. Une exception JAVA non rcupre par le code natif sera retransmise la machine virtuelle . .... jthrowable exc; (*env)->CallVoidMethod(env, instance , methodID) ; /* quelque chose sest-il produit? */ exc = (*env)->ExceptionOccurred(env); if (exc) { jclass NouvelleException ; ... /* diagnostic */ /* on fait le mnage */ (*env)->ExceptionClear(env) ; /* et on fait du neuf ! */ NouvelleException = (*env)->FindClass(env, "java/lang/IllegalArgumentException") ; (*env)->ThrowNew(env,NouvelleException, message); } ...
Annexe : JNI
12/216
12
invocation de JAV dans du C A
/*lanceur.c * usage : lanceur <classe_JAVA_en_format_/> <args> */ JavaVM *jvm ; JNIEnv * env; JDK1_1InitArgs vm_args ; /* 1.2 : JavaVMInitArgs */ main(argc, argv) int argc; char ** argv; { int cnt ; jint res ; jclass mainclass ; jmethodID methodID; jobjectArray jargs ; /* ici controles de lancement a faire */ .... /* initialisation des champs de vm_args ATTENTION*/ vm_args.version = 0x00010001 ; /* CHANGE en 1.2 ! */ /* appel obsolete en JAVA 1.2 */ res = JNI_GetDefaultJavaVMInitArgs(&vm_args) ; /* APPEL OBSOLETE (non portable). CHANGE en 1.2 */ vm_args.classpath = getenv("CLASSPATH"); if (0> JNI_CreateJavaVM(&jvm, &env, &vm_args))exit(1) ; if (!(mainclass= (*env)->FindClass(env,argv[1]))) exit(1); if(!(methodID= (*env)->GetStaticMethodID(env,mainclass, "main","([Ljava/lang/String;)V")))exit(2); .... jargs = (*env)->NewObjectArray(env,(jsize)(argc-2), (*env)->FindClass(env,"java/lang/String"), NULL) ; for (cnt = 0 ; cnt < (argc - 2) ; cnt++) { jobject stringObj = (*env)->NewStringUTF(env, argv[cnt+2]); (*env)->SetObjectArrayElement(env, jargs,(jsize)cnt,stringObj); } (*env)->CallStaticVoidMethod(env, mainclass, methodID, jargs) ; ..... (*jvm)->DestroyJavaVM(jvm) ; } Un tel code doit tre li la librairie binaire JAVA (libjava.so sous UNIX). La version de JAVA 2 introduit quelques modications (voir documentation).
Annexe : JNI
12/217
Annexe : collections
Points essentiels
Les collections permettent de stocker des objets htrognes.
13
Avant la version Java 2 il existait un certain nombre de classes rendant des services de stockage dobjets : Vector, Hashtable, etc. Java 2 dnit une architecture plus gnrale qui permet de mieux catgorier ces services. On dispose dinterfaces associes des smantiques (par exemple : ensemble, dictionnaire, etc.), de classes de base ralisant ces services et dalgorithmes gnraux oprant sur des collections (tris, recherche, etc.).
13
gnralits
Une Collection est un objet servant regrouper dautres objets. Les collections sont utilises comme moyen de stockage (un tableau dobjets Object[] est en quelque sorte une collection de bas niveau). Ce stockage est conu aussi pour faciliter des manipulations comme la recherche dun objet particulier. Dans les versions de Java antrieures la version 2 le package java.util proposait les services dun petit nombre de classes : Vector , Stack, Dictionary, Hashtable, Properties.
13/219
13
Vector (java 1.1)
Vector permet de disposer dun tableau extensible dobjets : la taille est ajuste automatiquement en fonction des besoins.
Cest une collection ordonne : On peut accder aux objets par leur index (lexception ArrayIndexOutofBounds est gnre en cas derreur) Cest une collection extensible : Les nouveaux lments sont automatiquement rajouts aprs le dernier lment du vecteur. Cest une collection contigu : La suppression dun lment entrane la compaction du vecteur (on ne laisse pas de "trou"). De mme linsertion dun lment un index donn peut donner lieu un dplacement des lments situs aprs cet index.
Les principaux services dun vecteur concernent :
l l
La gestion de la capacit (elle est normallement automatique mais le programmeur peut intervenir pour des raisons doptimisation) La recherche dobjets :
l l l
recherche par index recherche dun objet particulier (par sa rfrence) parcours de tous les objets
l l
La copie de la collection La modication du vecteur (accs par index ou accs par valeur)
Un Vector peut facilement tre utilis pour raliser des piles (FIFO, LIFO -voir Stack-).
13/220
13
Vector (java 1.1).
Vecteurs : optimisations de la capacit
La capacit dun vecteur exprime le nombre dlments quil peut recevoir sans avoir effectuer dopration dextension (opration coteuse). Cette information est donne par la mthode capacity() qui est distinguer de la mthode size() qui donne le nombre dlments effectivement prsents dans le vecteur.
Le constructeur Vector() rserve un nombre xe demplacements (actuellement 10) et double la capacit chaque fois quil doit stendre Le constructeur Vector(capacitInitiale) permet de xer la capacit initiale (lextension double la capacit). Le constructeur Vector(capacit, incrment) xe la capacit initiale et le nombre demplacements qui seront prpars au cours dune extension (un incrment infrieur ou gal zro permet de dterminer une extension par doublement de capacit) La mthode ensureCapacity(tailleMinimum) permet de dclencher ventuellement lextension pour garantir une capacit minimum.
l l
13/221
13
Vector (java 1.1)..
Vecteurs : recherche dobjets
l
par index :
l
elementAt(index) fournit llment situ lindex demand. Cette mthode est susceptible de dclencher lexception ArrayIndexOutOfBoundsException. Les mthodes firstElement() et lastElement() peuvent provoquer lexception NoSuchElementException.
par rfrence :
l
Les mthodes indexOf(objet), indexOf(objet, indexDpart), lastIndexOf(objet),... rendent lindex de lobjet dont la rfrence est passe en paramtre (ou -1 si lobjet nest pas trouv). Comme un objet peut tre rfrenc plusieurs fois dans un vecteur il existe plusieurs mthodes de recherche. contains(objet) indique si lobjet est prsent dans le vecteur.
oprations globales :
l
elements() permet dinitialiser un parcours (voir Enumeration) copyInto(Object[]) permet de recopier les lments du vecteur dans un tableau dobjets; lordre des objets est conserv.Le tableau doit avoir une taille sufsante pour contenir toutes les rfrences stockes dans le vecteur. clone() fournit un autre vecteur qui a les mmes caractristiques que le vecteur courant et qui rfrence les mmes objets.
13/222
13
Vector (java 1.1)...
Vecteurs : modications
l
par index :
l
insertElementAt(index), removeElementAt(index) sont susceptibles de provoquer une ArrayIndexOutOfBoundsException. Une insertion comme une destruction provoquent un glissement des index. addElement(objet) rajoute un lment en n de vecteur setSize(taille) peut avoir pour effet soit de dtruire des rfrences (si on rduit la taille) soit de crer des rfrences null (si on aggrandit la taille).
l l
par valeur :
l
removeElement(objet) dtruit la premire rfrence rencontre de lobjet pass en paramtre. Elle rend false si cette rfrence nest pas trouve
13/223
13
Hashtable (java 1.1)
Hashtable extends Dictionary ralise un dictionnaire dans lequel des "valeurs" peuvent tre recherches laide de "clefs". Les clefs et les valeurs peuvent tre nimporte quel objet (non null). Les performances des accs dpendent de plusieurs facteurs :
l l l
La taille initiale de la table de Hash (voir constructeurs) La manire dont cette table est amene saggrandir (voir galement les constructeurs) La pertinence des clefs de hash qui sont calcules partir de la mthode hashCode() de lobjet choisi comme clef daccs. La classe de cet objet doit aussi raliser la mthode equals(autreObjet) de manire adapte.
Les principaux services dune Hashtable concernent :
l l
La gestion de la conguration (optimisations) La recherche dobjets (la recherche se fait essentiellement par clef, mais la recherche par valeur est possible -bien que non performante-) la modication du contenu (enregistrement et suppression dune nouvelle paire clef/valeur)
13/224
13
Hashtable (java 1.1).
Hashtable : recherche dobjets
l
Par clef :
l
Object get(clef) rend lobjet associ "clef" (null si la clef nexiste pas) boolean containsKey(clef) indique si la clef est prsente dans la table
Par valeur :
l
boolean contains(Object valeur) indique si lobjet "valeur" est rfrenc dans la table (accs peu performant!)
oprations globales :
l
Enumeration keys() permet dinitialiser un parcours des clefs prsentes dans la table Enumeration elements() permet dinitialiser un parcours des valeurs prsentes dans la table.
Hashtable : modications
l
put(clef, valeur) permet dinsrer une nouvelle paire clef/valeur dans la table. Si une association ayant mme clef existait auparavant lancienne "valeur" est retourne (sinon rsultat null) remove(clef) supprime une association clef/valeur de la table. Ici aussi lancienne valeur est retourne (si la clef nexiste pas la mthode ne fait rien).
13/225
13
Properties
Properties extends Hashtable permet de raliser une "liste de proprits" cest dire un ensemble de champs ayant un nom (une chane de caractres) et une valeur exprime de manire standard sous forme de chane. Lavantage dune liste de proprits est de permettre de raliser une structure qui contient des champs variables : la prsence dun champ donn nest pas obligatoire et on peut tendre dynamiquement cette liste. On reprsente de cette manire :
Des informations venues du systme ou de ressources locales (toutes ne sont pas prsentes ou toutes ne sont pas accessibles pours des raisons de scurit) Des informations prsentant de nombreuses variantes qui amneraient dnir des classes avec un trs grand nombre de champs (dont la plupart resteraient inutiliss pour une instance donne) Des informations que lon trouve pratique de reprsenter et dinitialiser avec des chanes de caractres facilement "lisibles". Exemple initialisation dune instance de GridBagConstraints : gridx=3 gridy=5 gridwidth=2 anchor=WEST fill=VERTICAL .....
13/226
13
Properties.
Properties : initialisations
Lors de la construction dune liste de proprits on peut demander de disposer dune liste de valeurs par dfaut (une autre liste de proprits pralablement construite et initialise). Les mthodes load(InputStream) ou store(OutputStream, commentaire) permettent dinitialiser les valeurs depuis une ressource (chier, ot de communication,...) ou de sauvegarder ces valeurs dans une ressource (le champ "commentaire: sinscrit en entte du chier -sous forme de commentaire-) Le systme fournit des proprits qui peuvent tre consultes par System.getProperties(). Ces proprits sont calcules par le sytme (user.name, user.home,...), sont initialises par des ressources internes Java (java.vendor,...) ou extraites de paramtres de lancement. exemple (sous UNIX) : java -Dmyvar=$myvar -Dautrevar=$autrevar package.Maclasse Note Attention : pour des raisons de portabilit il ny a pas dautre mthode de rcupration de lenvironnement (System.getenv() est obsolete)
13/227
13
Properties..
Properties : mthodes spciques
String getProperty(prop)//retourne la proprit demande String getProperty(prop, defaut) //retourne "defaut" (au lieu de "null") // si la proprit nexiste pas Enumeration propertyNames() // liste des proprits accessibles String System.getProperty(prop) // SecurityException possible boolean Boolean.getBoolean(prop) // recherche proprit Systme avec valeur "true" Caractristiques dune recherche de proprit :
l l
Le rsultat est une chane (null si proprit inexistante) Si la proprit nest pas trouve on peut la rechercher dans une liste par dfaut (ex: propertyNames() explore rcursivment les listes par dfaut). on peut xer une valeur par dfaut si la proprit nexiste pas.
Dans le cas dune recherche dune proprit systme on peut dclencher un exception de scurit si la proprit existe et si la politique de scurit en empche laccs (ex: user.home pour une applet sans droits particuliers).
13/228
13
Enumeration (java 1.1)
Interface de parcours gnrique sur des collections : Enumeration enum ; ... // initialisations par ex. // collection.elements() while(enum.hasMoreElements()){ Object obj = enum.nextElement(); ... } Permet de raliser des parcours sur tous les lments dune collection dune manire indpendante de la nature mme de cette collection. On obtient ventuellement un dcouplage : la nature relle de la collection peut voluer sans quon ait modier les programmes qui la parcourent.
13/229
13
Collections en plateforme Java 2
Le package java.util a t profondment transform et propose une architecture unie pour servir de cadre des ralisations spciques. Les nouvelles classes (parfois trs proches des anciennes) ont des caractristiques minimum communes et sinscrivent chacune dans une hirarchie bien prcise des smantiques .
Listes
ArrayList est trs proche de Vector: cest un tableau extensible qui implante le contrat dni par linterface List . On retrouve des caractristiques de Vector (paramtres dinitialisation), mais la ralisation nest pas synchronise par dfaut. Les services daccs aux membres :
get (index) , indexOf(Object), (Object) : permettent de rechercher un objet
contains
add(index, Object), add (Object), set(index, Object), remove (index) : modient la liste (set remplace llment courant).
Ces mthodes font partie de linterface List qui exprime une squence dobjets dans laquelle laccs positionnel est privilgi. Par souci dharmonisation Vector a t dot des mmes mthodes.
LinkedList est galement une List base sur une ralisation de liste chane. ListIterator tend Iterator (qui lui mme remplace Enumeration) en permettant un parcours dune collection avec une smantique dordre positionnel (par ex. retour en arrire, ajout dun lment, etc.)
13/230
13
Collections : dictionnaires, ensembles
Linterface Map dnit un comportement de dictionnaire : les valeurs stockes sont associes une clef qui permet de les rechercher rapidement. Le contrat dinterface dnit en particulier :
les mthodes de modication : put( Object clef, Object val); Object remove(clef) ; les mthodes de recherche : Object get(clef) ; les mthodes permettant dobtenir lensemble du contenu : Collection values(); Set keySet() ;
La classe de ralisation HashMap est trs proche de Hashtable (sans synchronisation). La classe HashSet utilise une table de hash pour implanter un comportement de Set. Un Set est un ensemble : toute valeur contenue nexiste quune seule fois -y compris null-. Le contrat dinterface dnit en particulier :
modications : boolean add(Object) (rend faux si lobjet existe dej); remove(Object) ; recherche : contains(Object) ; parcours: Iterator iterator() ;
La classe TreeSet implante un Set particluier : SortedSet (ensemble tri). La ralisation sappuie sur la classe TreeMap (qui implante linterface SortedMap). La ralisation effective de ces arbres balancs suppose que lon ait le moyen de comparer deux lments quelconques contenus dans la collection.
13/231
13
Ordre naturel, comparateurs
Tout mcanisme interne aux collections sappuyant sur une relation dordre doit pouvoir sappuyer sur un des dispositifs suivants:
Un ordre naturel : tous les objets de la collection doivent raliser linterface java.lang.Comparable cest dire implanter ; public int compareTo(Object autreobjet) ; la mthode devant rendre 0 si les deux objets sont considrs comme gaux, un nombre ngatif si lobjet courant est plus petit que lautre et un nombre positif dans le cas contraire. En cas dincompatibilit la comparaison doit gnrer une ClassCastException.
Un objet comparateur : capable de comparer deux objets quelconques dans la collection et implantant linterface java.util.Comparator avec la mthode public int compare(Object lun, Object lautre) ; les conditions de comparaison tant les mmes que pour Comparable.
Ces mcanismes sont utiliss par les collections tries et par les mthodes de tri comme Collections.sort(List) ou Arrays.sort(Object[]). Si on utilise un objet comparateur celui-ci est pass en paramtre au constructeur de la collection trie ou en paramtre la mthode statique de tri. Arrays.sort(tableClients, new Comparator() { public int compare(Object lun, Object lautre) { return ((Client)lun).getNom().compareToIgnoreCase( ((Client)lautre).getNom()) ; } }) ;
13/232
13
Classes de service : Collections , Arrays
La classe Collections (et la classe Arrays) sont des classes de service offrant des mthodes statiques oprant sur des Collections ou des tableaux.
mise en ordre : Arrays : sort, binarySearch Collections : sort, binarySearch, reverseOrder, shuffle; copie : Arrays : fill, asList Collections : fill(list, Object), Set singleton(Object)
min,
max,
copy(List,
List),
gnrations de collections ayant des proprits particulires : unmodifiableXXXX(), synchronizedXXXX() (exemple : List synchronizedList(List)).
Attention : seuls les accs lmentaires ces objets sont synchroniss, une boucle de parcours de ces collections par un Iterator doit tre explicitement synchronis sur lobjet cible. Collection col = Collections.synchronizedCollection(maColl) ; synchronized (col) { Iterator iter = col.iterator() ; while( iter.hasNext()) { quelqueChose(iter.next()) ; } }
13/233
13
Itrateurs
Iterator permet un parcours abstrait dune collection, les principes sont plus sophistiqus que ceux de Enumeration : public interface Iterator { boolean hasNext() ; Object next() ; void remove() ;//facultatif!!!! } remove() retire le dernier lment rendu par next(). Cest le seul moyen de modier de manire sre une collection pendant le parcours dun itrateur. De la mme manire ListIterator permet dinsrer ou de remplacer un lment en cours de parcours. Ces modications peuvent dclencher diverses exceptions :
UnsupportedOperation : la collection sous jacente ne fournit pas le service demand IllegalState : par exemple deux demandes de remove() sur un mme next(). ConcurrentModification : sur certaines collections (en fait sur la plupart des implantations standard) les itrateurs sont capables de dtecter des modications opres ventuellement par un autre Thread.
13/234
13
13/235
Annexe : les composants AWT

Contenu :
14
Cette annexe donne un aperu sur les composants AWT courants et sur leur manipulation.
14
Les composants :
Button
Cest un composant dinterface utilisateur de base de type "appuyer pour activer". Il peut tre construit avec une tiquette de texte prcisant son rle . Button b = new Button(Sample); add(b); b.addActionListener(this);
Linterface ActionListener doit pouvoir traiter un clic dun bouton de souris. La mthode getActionCommand() de lvnement action (ActionEvent) activ lorsquon appuie sur le bouton rend par dfaut la chane de ltiquette.

14/237
14
Checkbox
La case cocher fournit un dispositif dentre "actif/inactif" accompagn dune tiquette de texte. Checkbox one = new Checkbox("One", false); Checkbox two = new Checkbox("Two", false); Checkbox three = new Checkbox("Three", true); add(one); add(two); add(three); one.addItemListener(new Handler()); two.addItemListener(new Handler()); three.addItemListener(new Handler());
La slection ou dslection dune case cocher est notie la ralisation de linterface ItemListener. Pour dtecter une opration de slection ou de dselection, il faut utiliser la mthode getStateChange() sur lobjet ItemEvent. Cette mthode renvoie lune des constantes ItemEvent.DESELECTED ou ItemEvent.SELECTED, selon le cas. La mthode getItem() renvoie un objet de type chane (String) qui reprsente la chane de ltiquette de la case cocher considre. class Handler implements ItemListener { public void itemStateChanged(ItemEvent ev) { String state = deselected; if (ev.getStateChange() == ItemEvent.SELECTED){ state = selected; } System.out.println(ev.getItem() + + state); } }

14/238
14
CheckboxGroup
On peut crer des cases cocher laide dun constructeur spcial qui utilise un argument supplmentaire CheckboxGroup. Si on procde ainsi, laspect des cases cocher est modi et toutes les cases cocher lies au mme groupe adoptent un comportement de "bouton radio". CheckboxGroup cbg = new CheckboxGroup(); Checkbox one = new Checkbox("One", cbg, false); Checkbox two = new Checkbox("Two", cbg, false); Checkbox three = new Checkbox("Three", cbg, true); add(one); add(two); add(three);

14/239
14
Choice
Le composant Choice fournit une outil simple de saisie de type "slectionner un lment dans cette liste". Choice c = new Choice(); c.addItem("First"); c.addItem("Second"); c.addItem("Third"); c.addItemListener(. . .);
Lorsquun composant Choice est activ il afche la liste des lments qui lui ont t ajouts. Notez que les lments ajouts sont des objets de type chane (String).
Linterface ItemListener sert observer les modications de ce choix. Les dtails sont les mmes que pour la case cocher. La mthode getSelectedIndex() de Choice permet de connatre lindex selectionn.

14/240
14
List
Une liste permet de prsenter lutilisateur des options de texte afches dans une zone o plusieurs lments peuvent tre visualiss simultanment. Il est possible de naviguer dans la liste et dy slectionner un ou plusieurs lments simultanment (mode de slection simple ou multiple). List l = new List(4, true);
Largument numrique transmis au constructeur dnit le nombre ditems visibles. Largument boolen indique si la liste doit permettre lutilisateur deffectuer des slections multiples.
Un ActionEvent, gr par lintermdiaire de linterface ActionListener, est gnr par la liste dans les modes de slection simple et multiple. Les lments sont slectionns dans la liste conformment aux conventions de la plate-forme. Pour un environnement Unix/Motif, cela signie quun simple clic met en valeur une entre dans la liste, mais quun double-clic dclenche laction correspondante. Rcupration: voir getSelectedItems() mthodes getSelectedObjects(),

14/241
14
Canvas
Un canvas fournit un espace vide (arrire-plan color). Sa taille par dfaut tant zro par zro, on doit gnralement sassurer que le gestionnaire de disposition lui affectera une taille non nulle. Cet espace peut tre utilis pour dessiner, recevoir du texte ou des saisies en provenance du clavier ou de la souris. Le canvas est gnralement utilis tel quel pour fournir un espace de dessin gnral.
Le canvas peut couter tous les vnements applicables un composant gnral. On peut, en particulier, lui associer des objets KeyListener, MouseMotionListener ou MouseListener pour lui permettre de rpondre dune faon ou dune autre une interaction utilisateur.

14/242
14
Label
Un label afche une seule ligne de texte. Le programme peut modier le texte. Aucune bordure ou autre dcoration particulire nest utilise pour dlimiter un label. Label lab = new Label(Hello); add(lab);
MaFrame
En gnral, on ne sattend pas ce que les Labels traitent des vnements, pourtant ils effectuent cette opration de la mme faon quun canvas. Dans ce cas, on ne peut capter les activations de touches de faon able quen faisant appel requestFocus().

14/243
14
TextArea
La zone de texte est un dispositif de saisie de texte multi-lignes, multicolonnes. On peut le rendre non ditable par lintermdiaire de la mthode setEditable(boolean). Il afche des barres de dlement horizontales et verticales. TextArea t = new TextArea(Hello!, 4, 30); add(t);
On peut ajouter des veilleurs dvnements de divers type dans une zone de texte. Le texte tant multi-lignes, le fait dappuyer sur <Entre> place seulement un autre caractre dans la mmoire tampon. Si on a besoin de savoir quel moment une saisie est termine, on peut placer un bouton de validation ct dune zone de texte pour permettre lutilisateur de fournir cette information. Un veilleur KeyListener permet de traiter chaque caractre entr en association avec la mthode getKeyChar(), getKeyCode() de la classe KeyEvent.

14/244
14
TextField
Le TextField est un dispositif de saisie de texte sur une seule ligne. TextField f = new TextField(Single line, 30); add(f);
Du fait quune seule ligne est possible, un couteur daction (ActionListener) peut tre inform, via actionPerformed(), lorsque la touche <Entre> ou <Retour> est active. Comme la zone de texte, le champ texte peut tre en lecture seule. Il nafche pas de barres de dlement dans lune ou lautre direction mais permet, si besoin est, un dlement de gauche droite dun texte trop long.
TextComponent
La classe TextComponent dont drivent TextField et TextArea fourni un grand nombre de mthodes. On a vu que les constructeurs des classes TextArea et TextField permettent de dnir un nombre de colonnes pour lafchage. Le nombre de colonnes est interprt en fonction de la largeur moyenne des caractres dans la police utilise. Le nombre de caractres effectivement afchs peut varier radicalement en cas dutilisation dune police chasse proportionnellel.

14/245
14
Frame
Cest la fentre gnrale de "plus haut niveau". Elle possde des attributs tels que : barre de titre et zones de contrle du redimensionnement. Frame f = new Frame(Frame);
La taille dun Frame peut tre dnie laide de la mthode setSize() ou avec la mthode pack(). Dans ce cas le gestionnaire de disposition calcule une taille englobant tous les composants du Frame et dnit la taille de ce dernier en consquence. Les vnements du Frame peuvent tre surveills laide de tous les gestionnaires dvnements applicables aux composants gnraux. WindowListener peut tre utilis pour ragir, via la mthode windowClosing(), lorsque le bouton Quit a t activ dans le menu du gestionnaire de fentres. Il nest pas conseill dcouter des vnements clavier directement partir dun Frame. Bien que la technique dcrite pour les composants de type Canvas et Label, savoir lappel de requestFocus(), fonctionne parfois, elle nest pas able. Si on a besoin de suivre des vnements clavier, il est plutt recommand dajouter au Frame un Canvas, Panel, etc., et dassocier le gestionnaire dvnement ce dernier.

14/246
14
Panel
Cest le conteneur de base. Il ne peut pas tre utilis de faon isole comme les Frames, les fentres et les botes de dialogue. Panel p = new Panel(); Les Panels peuvent grer les vnements (rappel : le focus clavier doit tre demand explicitement).

14/247
14
Dialog
Un Dialog est une fentre qui diffre toutefois dun Frame :
elle est destine afcher des messsages fugitifs elle peut tre modale: elle recevra systmatiquement toutes les saisies jusqu fermeture. elle ne peut-tre supprime ou icnie par les boutons du gestionnaire de fentre, on lui associe habituellement un bouton de validation.
Dialog d = new Dialog(f, "Dialog", false); d.add(new Label("Hello, I'm a Dialog"), BorderLayout.CENTER); d.pack();

14/248
14
Dialog
Un dialog dpend dune Frame : cette Frame apparait comme premier argument dans les constructeurs de la classe Dialog. Les botes de dialogue ne sont pas visibles lors de leur cration.Elles safchent plutt en rponse une autre action au sein de linterface utilisateur, comme le fait dappuyer sur un bouton. public void actionPerformed(ActionEvent ev) { d.setVisible(true); }

Il est recommand de considrer une bote de dialogue comme un dispositif rutilisable. Ainsi, vous ne devez pas dtruire lobjet individuel lorsquil est effac de lcran, mais le conserver pour une rutilisation ultrieure.
Pour masquer une bote de dialogue, appelez setVisible(false). Cette opration seffectue gnralement en ajoutant un WindowListener, et en attendant que la mthode windowClosing() soit appele dans ce gestionnaire dvnement.

14/249
14
FileDialog
Cest une implantation dun dispositif de slection de chier. Elle comporte sa propre fentre autonome et permet lutilisateur de parcourir le systme de chiers et de slectionner un chier spcique pour des oprations ultrieures. FileDialog d = new FileDialog(f, "FileDialog"); d.setVisible(true); String fname = d.getFile();
En gnral, il nest pas ncessaire de grer des vnements partir de la bote de dialogue de chiers. Lappel de setVisible(true) se bloque jusqu ce que lutilisateur slectionne OK. Le chier slectionn est renvoy sous forme de chane .Voir getDirectory(), getFile()

14/250
14
ScrollPane
Fournit un conteneur gnral ne pouvant pas tre utilis de faon autonome. Il fournit une vue sur une zone plus large et des barres de dlement pour manipuler cette vue. Frame f = new Frame("ScrollPane"); Panel p = new Panel(); ScrollPane sp = new ScrollPane(); p.setLayout(new GridLayout(3, 4)); sp.add(p); f.add(sp); f.setSize(200, 200); f.setVisible(true);
Le ScrollPane cre et gre les barres de dlement selon les besoins. Il contient un seul composant et on ne peut pas inuer sur le gestionnaire de disposition quil utilise. Au lieu de cela, on doit lui ajouter un Panel, congurer le gestionnaire de disposition de ce Panel et placer les composants lintrieur de ce dernier. En gnral, on ne gre pas dvnements dans un ScrollPane, mais on le fait dans les composants quil contient.

14/251
14
Menus
Les menus diffrent des autres composants par un aspect essentiel. En gnral, on ne peut pas ajouter de menus des conteneurs ordinaires et laisser le gestionnaire de disposition les grer. On peut seulement ajouter des menus des lments spciques appels conteneurs de menus. Gnralement, on ne peut dmarrer une "arborescence de menu" quen plaant une barre de menus dans un Frame via la mthode setMenuBar(). A partir de l, on peut ajouter des menus la barre de menus et incorporer des menus ou lments de menu ces menus. Lexception est le menu PopUpMenu qui peut tre ajout nimporte quel composant, mais dans ce cas prcis, il nest pas question de disposition proprement parler.
Menu Aide
Une caractristique particulire de la barre de menus est que lon peut dsigner un menu comme le menu Aide. Cette opration seffectue par lintermdiaire de la mthode setHelpMenu(Menu). Le menu considrer comme le menu Aide doit avoir t ajout la barre de menus, et il sera ensuite trait de la faon approprie pour un menu Aide sur la plateforme locale. Pour les systmes de type X/Motif, cela consiste dcaler lentre de menu lextrmit droite de la barre de menus.

14/252
14
MenuBar
Cest la barre de menu horizontale. Elle peut seulement tre ajout lobjet Frame et constitue la racine de toutes les arborescences de menus. Frame f = new Frame(MenuBar); MenuBar mb = new MenuBar(); f.setMenuBar(mb);
MenuBar
Menu
Menu
MenuItem
MenuItem

14/253
14
Menu
La classe Menu fournit le menu droulant de base. Elle peut tre ajoute une barre de menus ou un autre menu. MenuBar mb = new MenuBar(); Menu m1 = new Menu("File"); Menu m2 = new Menu("Edit"); Menu m3 = new Menu("Help"); mb.add(m1); mb.add(m2); mb.add(m3); mb.setHelpMenu(m3);

Les menus prsents ici sont vides ce qui explique laspect du menu File.
On peut ajouter un ActionListener un objet Menu, mais cest assez inhabituel. Normalement, les menus servent seulement disposer des MenuItem dcrits plus loin.

14/254
14
MenuItem
Les lments de menu MenuItem sont les feuilles dune arborescence de menu. Menu m1 = new Menu("File"); MenuItem mi1 = new MenuItem("Save"); MenuItem mi2 = new MenuItem("Load"); MenuItem mi3 = new MenuItem("Quit"); m1.add(mi1); m1.add(mi2); m1.addSeparator(); m1.add(mi3);
En rgle gnrale, on ajoute un ActionListener aux objets MenuItem an dassocier des comportements aux menus.

14/255
14
CheckboxMenuItem
Les lments de menu cocher permettent de proposer des slections (activ/dsactiv) dans les menus. Menu m1 = new Menu("File"); MenuItem mi1 = new MenuItem("Save"); CheckboxMenuItem mi2 = new CheckboxMenuItem("Persistent"); m1.add(mi1); m1.add(mi2);
Llment de menu cocher doit tre surveill via linterface ItemListener. Cest pourquoi la mthode itemStateChanged() est appele lorsque ltat de llment cocher est modi.

14/256
14
PopupMenu
Fournit un menu autonome pouvant safcher instantanment sur un autre composant. On peut ajouter des menus ou lments de menu un menu instantan. Frame f = new Frame("PopupMenu"); Button b = new Button("Press Me"); b.addActionListener(...); PopupMenu p = new PopupMenu("Popup"); MenuItem s = new MenuItem("Save"); MenuItem l = new MenuItem("Load"); s.addActionListener(...); l.addActionListener(...); f.add("Center", b); p.add(s); p.add(l); f.add(p);

14/257
14
PopupMenu (suite)

Le menu PopUp doit tre ajout un composant "parent". Cette opration diffre de lajout de composants ordinaires des conteneurs. Dans lexemple suivant, le menu instantan a t ajout au Frame englobant.
Pour provoquer lafchage du menu instantan, on doit appeler la mthode show. Lafchage ncessite quune rfrence un composant joue le rle dorigine pour les coordonnes x et y. Dans cet exemple cest le composant b qui sert de rfrence. public void actionPerformed(ActionEvent ev) { p.show(b, 10, 10); }
Composant de rfrence pour laffichage du popup menu
Coordonnes % composantes dorigines

Le composant dorigine doit tre sous (ou contenu dans) le composant parent dans la hirarchie des composants.

14/258
14
Contrle des aspects visuels
On peut contrler lapparence des composants AWT en matire de couleur de fond et de premier plan ainsi que de police utilise pour le texte.
Couleurs
Deux mthodes permettent de dnir les couleurs dun composant :
setForeground(...) setBackground(...)
Ces deux mthodes utilisent un argument qui est une instance de la classe java.awt.Color. On peut utiliser des couleurs de constante dsignes par Color.red Color.blue etc. La gamme complte de couleurs prdnies est documente dans la page relative la classe Color. Qui plus est, on peutcrer une couleur spcique de la faon suivante : int r = 255, g = 255, b = 0; Color c = new Color(r, g, b); Un tel constructeur cre une couleur daprs les intensits de rouge, vert et bleu spcies sur une chelle allant de 0 255 pour chacune.

14/259
14
Polices
La police utilise pour afcher du texte dans un composant peut tre dnie laide de la mthode setFont(). Largument utilis pour cette mthode doit tre une instance de la classe java.awt.Font. Aucune constante nest dnie pour les polices, mais on peut crer une police en indiquant son nom, son style et sa taille en points. Font f = new Font(TimesRoman, Font.PLAIN, 14); Si la portabilit est recherche il vaut mieux utiliser des noms de polices abstraites :
Dialog, DialogInput SansSerif (remplace Helvetica) Serif (remplace TimesRoman ) Monospaced (remplace Courier) Symbol
On peut obtenir la liste complte des polices en appelant la mthode getFontList() de la classe Toolkit. La bote outils (toolkit) peut tre obtenue partir du composant, une fois ce dernier afch on appelle la mthode getToolkit(). On peut aussi utiliser le ToolKit par dfaut obtenu par Toolkit.getDefaultToolkit().

ATTENTION!: la mthode getFontList de Toolkit est obsolete en Java2; voir plutt: GraphicsEnvironment.getAvailableFontFamilyNames().

14/260
14
Polices
Les constantes de style de police sont en ralit des valeurs entires (int), parmi celles cites ci-aprs :
Font.BOLD Font.ITALIC Font.PLAIN Font.BOLD + Font.ITALIC
Les tailles en points doivent tre dnies avec une valeur entire.

14/261
14
Impression
Limpression est gre dans Java 1.1 dune faon similaire lafchage sur cran. Grace une instance particulire de java.awt.Graphics toute instruction de dessin dans ce contexte est en fait destine limprimante. Le systme dimpression Java 1.1 permet dutiliser les conventions dimpression locales, de sorte que lutilisateur voit safcher une bote de dialogue de slection dimprimante lorsque lon lance une opration dimpression. Lutilisateur peut ensuite choisir dans cette boite de dialogue les options telles que la taille du papier, la qualit dimpression et limprimante utiliser. Frame f = new Frame("Print test"); Toolkit t = f.getToolkit(); PrintJob job = t.getPrintJob(f,"Mon impr.", null); if (job != null) { Graphics g = job.getGraphics(); ..... } Ces lignes crent un contexte graphique (Graphics) "connect" limprimante choisie par lutilisateur. Pour obtenir un nouveau contexte pour chaque page : f.printAll(g);// ou printComponents() On peut utiliser nimporte quelle mthode de dessin de la classe Graphics pour crire sur limprimante. Ou bien, comme indiqu ici, on peut simplement demander un composant de se tracer. La mthode print() demande un composant de se tracer , mais elle nest lie quau composant pour lequel elle a t appele. Dans le cas dun conteneur, comme ici, on peut utiliser la mthode printAll() pour que le conteneur et tous les composants quil contient soient tracs sur limprimante. Utiliser printComponents() si on utilise des composants 100% JAVA. g.dispose(); job.end(); Aprs avoir cr une page de sortie conforme ce que lon souhaite, on utilise la mthode dispose() pour que cette page soit soumise limprimante.

14/262
14
Impression
Une fois ce travail termin, on appele la mthode end() sur lobjet tche dimpression. Elle indique que la tche dimpression est termine et permet au systme de traitement en diffr dexcuter rellement la tche puis de librer limprimante pour dautres tches. Nota: Dans le contexte Solaris il nexiste pas dobjet standard de menu dimpression. On peut utiliser le 3me argument de getPrintJob() qui est un dictionnaire de proprits (qui peut aussi tre null) Frame f = new Frame("Print test"); Toolkit t = f.getToolkit(); Properties pprops = new Properties(); pprops.put("awt.print.paperSize","a4"); pprops.put("awt.print.orientation","landscape"); PrintJob job = t.getPrintJob(f,"Mon impr.", pprops); .....
Les proprits de ce dictionnaire sont : awt.print.destination awt.print.printer awt.print.fileName awt.print.options awt.print.orientation (portrait, landscape) awt.print.paperSize (letter,legal,executive,a4) awt.print.numCopies

Le systme dimpression change en Java 2 : voir package java.awt.print.

14/263
Annexe : lvolution des APIs JAV A

Points essentiels
15
Il existe de nombreux services associs Java. Ces extensions sont souvent mises au point par des consortiums dentreprises spcialises dans un domaine dapplication. Il faut faire la part de ce qui constitue des librairies de composants, des API daccs, des produits... Quelques exemples de domaine:
Graphique, Multimedia Rseau Utilitaires Accs donnes Echanges scuriss Embarqu lger Systme Produits divers exemple darchitecture : Java Enterprise
15
Graphique, Multimedia
Graphique
2 D : primitives sophistiques pour dessin, texte, images avec gestion des couleurs, des oprations gomtriques, de la composition. On peut utiliser texture, transparence, etc. Simplication de limpression. Support des niveaux de gris adapts limagerie mdicale (voir galement JAI). 3 D : programmation par description de scnes (graphe: objets gomtriques, attributs, informations de visualisation, mouvements,...). Li un excuteur optimis. Advanced Imaging API (JAI): chargement, traitement, composition et prsentation dimages.
MultiMedia
MediaFramework : dnit une architecture et une API pour le chargement et la prsentation de media sous coordination temporelle (MPEG, MIDI, etc.). LAPI Media Player supporte 3 niveaux : niveau client (contrle simple de lexcution), niveau personnalis (le programmeur peut rajouter ou enrichir des fonctionnalits), niveau design (adjonction de nouveaux media et formats). Sound : actuellement AudioClip de la plateforme Java2 fournit la possibilit dexcuter diffrents formats audio (AIFF, AU, WAV) et MIDI (type0, type1, RMF), lavenir possibilit de synthse de son. Speech : API pour reconnaissance et synthse de la parole. + Java Speech Grammar Format (JSGF) et Java Speech Markup Language (JSML).

15/265
15
Rseau
Dynamic management kit : Outil de dveloppement dagents lis ladministration systme/rseau. Permet de construire une administration hberge par un navigateur WEB. Contient des adaptateurs de nombreux protocoles, un systme de dploiement push, des composants beans gnriques, un compilateur de MIB ( passerelles SNMP-Java), outil daide la gnration dagents,... Naming and directory interface : API daccs des services de nommage et dannuaire. Permet de fdrer des services htrognes: LDAP, DNS, NIS, NIS+, NDS, RMI registry, COS Naming, etc. Java Mail: API daccs aux services du courrier lectronique. Contient galement une ralisation de rfrence pour laccs SMTP et IMAP. Java Message service: API daccs aux produits de communication par message (Message Oriented Middleware - IBM MQseries, TIBCO, etc.-). Java Shared Data Toolkit: permet de dvelopper des applications partageant interactivement des donnes sur un rseau. Exemples: outils de collaboration (tableau blanc partag, conversation de groupe,...), visualisations temps rel (cours de bourse, ...), etc. Java Spaces: partage de donnes, communications et coordination entre des objets Java situs sur un rseau. Paradigmes simples : write, read, take, notify,... . Facilits pour la persistence, pour des schmas divers de communication asynchrone (store & forward, ltres, etc.). Jini: rseau applicatif dynamique. On branche un agent (logiciel, matriel) sur le rseau et il sera capable de : rechercher (et se joindre ) un groupe dautres agents, publier ses capacits, rechercher des services, changer des services dans un environnement scuris. Accs aux couches JavaSpaces et Transaction.

15/266
15
Utilitaires, composants
Java Communications API : protocole standardis daccs des cartes de communication (port srie RS232, parallle IEEE1284). Telephony : API tablisssement et gestion dune communication tlphonique. (voir JavaPhone) Infobus : sur une seule JVM change de donnes entre des composants qui ne se connaissent pas a priori. Consommateurs et producteurs se reconnaissent par une tiquette commune et publient (ou recherchent) des donnes en indiquant la dsignation et le type de codage (avor) de ces donnes. JavaBeans Activation Framework (JAF) : dtermination dun type de donnes charges au runtime (depuis des ressources externes, depuis le rseau), accs transparent ces donnes, dcouverte des oprations possibles sur ces donnes, activation des composants beans appropris pour traiter ces donnes. Example : activation par un navigateur dun bean appropri pour prsenter/traiter un type de document reu par http. Enterprise JavaBeans: beans de niveau serveur (ou niveaux intermdiaires). Spcialisations des fonctions : sessions, communications, scurit, recherche de donnes, transactions, syntonisation (load balancing, etc.) sont grs par des composants diffrents de ceux qui grent la logique applicative associe au niveau courant. Les EJB. persistents ou non (session beans, entity beans), sont administrs par des Containers qui fournissent (souvent de manire transparente) les services de base et activent, dsactivent, sauvegardent les composants applicatifs. Dont rip and replace but wrap and embrace: politique recherche dadaptateurs pour des applications existantes

15/267
15
Utilitaires programmation
JavaHelp : systme de ralisation daide en ligne. Donnes et systme de recherche peuvent rsider cot client ou cot serveur. HotJava HTML components (produit) : Composants beans permettant dutiliser des fonctionnalits de navigateur WEB lintrieur dune application. Java project X (nom de code provisoire) : librairie daccs XML (analyseur, validation optionnelle, manipulation darbre en mmoire) Java Server Engine (produit): composant serveur JavaCC (Java compiler compiler) : permet de gnrer un analyseur partir de la description dune grammaire. La description comprend lanalyse lexicale et permet dutiliser des grammaires sophistiques. APIs annexes de dveloppement Java:
JBug : accs programmatique au debug. Comprend : Java Debug Interface (JDI), Java Debug Wire protocol (JDWP), Virtual machine Debug Interface (JVMDI). JDI est linterface de haut niveau 100%Java, JVMDI est linterface de bas niveau fournie par la JVM. Virtual Machine Proler Interface (JVMPI) : accs aux informations permettant de faire de lanalyse de performances. Heap Analysis Tool (HAT) : permet danalyser des chiers de dump gnrs la demande par une machine virtuelle JAVA (Xhprof) pour rechercher des refrences dobjets qui encombre la mmoire et ne sont par rcuprs par le glaneur de mmoire (prsence dans le code dune chane intempestive de rfrences fortes).
Ces Apis favorisent la ralisation dateliers de dveloppement Java voir galement paragraphe produits divers

15/268
15
Accs donnes
Java Transaction Service : Une API de bas niveau (selon la spcication CORBA OTS) pour laccs aux services transactionnels. Destine plutt aux dveloppeurs de serveurs ou de Containers dEJB. Java Transaction API : API de haut niveau pour la dnition, au sein des applications, desfrontires des transactions, des Commit deux phases, etc... Contient un niveau daccs aux services standard Xa de X/Open. Java Blend : produit Sun/Baan. Outil de dveloppement qui permet de gnrer des requtes aux bases de donnes directement partir des objets eux-mmes et code excutable qui optimise la gestion des requtes au runtime. StoreX (nom de code) : gestion des priphriques de stockage de donnes (storage managment).

15/269
15
Echanges scuriss
SSL : Secure Socket Layer permet douvrir des canaux de communication (socket voir java,net) scuriss. javax.net.ssl est une API qui permet daccder des produits (tierce partie) fournissant de tels services. La dsignation dURL https est directement comprise par la classe java.net.URL. Java Cryptographic Extension (JCE): fournit un accs des fonctions de cryptage/dcryptage. Cet acccs contient des aspects gnriques et des aspects spcialiss en fonction des algorithmes choisis. La ralisation effective de ces services est fournie par Sun aux Etats-Unis/Canada et nest pas exportable. voir : http://www.systemics.com Electronic Commerce Framework :
Java Wallet :
Java Commerce Client : solution SUN de Container personnalisable pour des beans specialiss. Charge des Cassettes (archives jar contenant des Commerce JavaBeans, des informations sur leur installation et des signatures identiant des Rles) Java Commerce API: API de dveloppement Commerce JavaBeans : Java Smart Card API : accs programmatique des drivers permettant dinterroger des cartes du commerce (dont javaring)
Java Card API (voir chapitre suivant)
Point Of Sale : volutions de la caisse enregistreuse.

15/270
15
Embarqu lger
PersonalJava : cibles : assistants personnels, tlphonie avec crans (y compris mobiles haut de gamme), internet TV, consoles. Plage : ROM ~2M, RAM 512k-1M, processeurs : 32bits, >50mhz. Importance de la connection au rseau pour les services mais aussi pour la maintenance/mise jour de la plate-forme. Sous-ensemble de Java, compact, interfaces graphiques simplies (evt. sans souris ni clavier). Ecriture dapplication lie un savoir-faire : outils de contrle -> PersonalJava Emulation Environment, JavaCheck. API spcialises: JavaPhone, JavaTV, AutoJava EmbeddedJava : cibles : pagers, instrumentation, tlphones bas de gamme,... Plage : ROM 256-512 K, RAM 256-512K, processeurs 16/32 bits > 25Mhz. Code Java moins gnraliste et plus spcialis. Code disponible spcialis et congurable. Adaptations de JVM : extensions temps rel, gestion des ressources et de la mmoire. Nota: les regroupements de spcications sont actuellement (n 98) spars en deux tendances une emmene par Sun Microsystems et lautre emmene par HP. JavaCard : cibles : cartes, Java Rings. processeurs java : SUN dveloppe un noyau de spcications et de maquettage pour permettre aux licencis de dvelopper des processeurs spcialiss adapts des besoins particuliers.

15/271
15
Systme
JavaOS : petits OS tirant directement partie du matriel
JavaOS for Business (Sun + IBM) Os pour client lger avec administration centralise. Le serveur gre les composants logiciels des applications ET du systme. Partie serveur : 100% Java, permet ladministration distante du systme et des applications. Chargement et reconguration dynamique (vnements).
System Database JSD Server
Applications JDK System database JSD
Partie client : 70% Java, trs modulaire techniques de modularit accessibles aux codes applicatifs support de JavaPOS
Service Loader JSL
Systme vnements
Device Interface JDI
Platform Interface JPI
Micronoyaux
Boot Interface JBI
JavaOS for Consumers : OS pour les machines de la catgorie PersonalJava

15/272
15
JavaOs for NC :
Le systme est compltement tlcharg au dmarrage. Linteraction utilisateur se fait dans un cadre Hotjava/HotJavaViews
adaptations temps rel : ChorusOS (Composants Systme modulaires )
JavaPC Comment transformer un vieux PC en plateforme JavaOS

15/273
15
Produits divers
Outils de dveloppement : Les Apis daccs la JVM facilitent le dveloppement de nombreux outils intgrs. La capacit de Java faire de lintgration dynamique permet de crer des combinaisons doutils. Un nouvelle catgorie doutil est amene prendre une place stratgique : les beans builder. Outils de tests : nombreux outils complmentaires de la lire de dveloppement : analyse de charge, gestion de version, tests de non regression, etc. (voir par ex. produits SunTest) Deploiement :
Java Plug-in : permet de remplacer la JVM dun navigateur par la dernire version de JRE. Plug-in HTML Converter : Eventuellement transformation dune applet pour tlchargement de cette nouvelle JVM. Outils de push : ces produits (Marimba Castanet, PointCast,...) permettent une autre stratgie de dploiement. Une application (par ex. application client) est localement rsidente; avant de dmarrer elle vrie avec le serveur si elle est conforme et, ventuellement, une mise jour diffrentielle ne est effectue.
Serveurs :
Java Embedded Server: petit serveur permettant des partenaires sur un rseau dhberger des services (par ex. dispositifs dans la gamme PersonalJava) Serveurs dapplications : fournissent un cadre intgr (administration, gestion des changes, scurit, sessions, accs donnes, transactions, etc.) des composants applicatifs.

15/274
15
Java Enterprise APIs
Exemple darchitecture : Java Enterprise APIs regroupe un ensemble cohrent dAPI pour la ralisation de serveurs dentreprise :
JAVABEANS HTML
RMI
IIOP
autres protocoles SERVLETS
ENTERPRISE JAVABEANS
SERVEUR
JTA*
JTS *
JDBC
JNDI
JAVA IDL
JMS

15/275

La couverture des agences de Sun France permet de rpondre lensemble des besoins de nos clients sur le territoire. Table 15.1 Liste des agences Sun Microsystems en france
Sun Microsystems France S.A 13, avenue Morane Saulnier BP 53 78142 VELIZY Cedex Tl : 01.30.67.50.00 Fax : 01.30.67.53.00 Agence de Issy les Moulineaux Le Lombard 143, avenue de Verdun 92442 ISSY-LES-MOULINEAUX Cedex Tl : 01.41.33.17.00 Fax : 01.41.33.17.20 Agence de Lille Tour Crdit Lyonnais 140 Boulevard de Turin 59777 EURALILLE Tl : 03.20.74.79.79 Fax : 03.20.74.79.80 Agence de Rennes Immeuble Atalis Z.A. du Vieux Pont 1, rue de Paris 35510 CESSON-SEVIGNE Tl : 02.99.83.46.46 Fax : 02.99.83.42.22 Bureau de Grenoble 32, chemin du Vieux Chne 38240 MEYLAN Tl : 04.76.41.42.43 Fax : 04.76.41.42.41 Agence dAix-en-Provence Parc Club du Golf Avenue G. de La Lauzire Zone Industrielle - Bt 22 13856 AIX-EN-PROVENCE Tl : 04.42.97.77.77 Fax : 04.42.39.71.52 Agence de Lyon Immeuble Lips 151, boulevard de Stalingrad 69100 VILLEURBANNE Tl : 04.72.43.53.53 Fax : 04.72.43.53.40 Agence de Toulouse Immeuble Les Triades Btiment C - B.P. 456 31315 LABEGE Cedex Tl : 05.61.39.80.05 Fax : 05.61.39.83.43 Agence de Strasbourg Parc des Tanneries 1, alle des Rossignols Btiment F - B.P. 20 67831 TANNERIES Cedex Tl : 03.88.10.47.00 Fax : 03.88.76.53.63

Programmation Java Avancee Francais

Hochgeladen von

Dokumentinformationen

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Programmation Java Avancee Francais

Hochgeladen von

Copyright:

Verfügbare Formate

Programmation JAV avance A Sun service formation

Programmation JAV avance A Sun service formation

Programmation JAV avance A Sun service formation

Programmation JAV avance A Sun service formation

Programmation JAV avance A Sun service formation

Programmation JAV avance A

Programmation JAV avance A

Programmation JAV avance A

Sun service formation

Sun service formation

Projet : avance Copyright Rf. Sun :

Programmation JAVA Sun Service Formation SL275

Projet : avance Copyright Rf. Sun :

Programmation JAVA Sun Service Formation SL275

Programmation JAVA Sun Service Formation SL275

Sun Microsystems France

Sun Microsystems France

Sun Microsystems France

Sun service formation

Programmation JAVA avance Sun service formation

Programmation JAVA avance Sun Service Formation SL275 F-beta 18/2/99

Sun Microsystems France

Applets (rappels), archives jar ...............................................12

Le package AWT (rappels), LayoutManagers .....................28

Le traitement des vnements AWT (rappels)....................40

Les composants SWING..........................................................54

Les Threads ................................................................................64

Accs concurrents .....................................................................76

Principes des Entres/Sorties ...............................................104

Linarisation des objets (Serialization)..............................136

RMI (introduction technique) ..............................................148

JDBC (introduction technique) ............................................178

Annexe : les composants AWT.............................................236

table des matires

Annexe : lvolution des APIs JAVA ..................................264

introduction a Java et au Java Computing

Applets (rappels), archives jar

Rvision : F-beta Date : 18/2/99

Applets (rappels), archives jar

Applets (rappels), archives jar

Les APIs entre lApplet et son environnement : ressource code Java

notications cycle de vie Applet chargement de code au travers du rseau

demandes de ressources rafraichissements graphiques

systme de fentrage local

Applets (rappels), archives jar

Applets (rappels), archives jar

Applets (rappels), archives jar

Applets (rappels), archives jar

Thread AWT (attente) Exposition

Applets (rappels), archives jar

Applets (rappels), archives jar

Pour connatre le contenu dun jar : jar tvf MesApplets.jar

Applets (rappels), archives jar

Applets (rappels), archives jar

Applets (rappels), archives jar

Applets (rappels), archives jar

Applets (rappels), archives jar

Applets (rappels), archives jar

Applets (rappels), archives jar

Le package AWT (rappels), LayoutManagers

Le package AWT concerne les services du terminal virtuel portable:

Rvision : F-beta Date : 18/2/99

Le package AWT (rappels), LayoutManagers

Le package AWT (rappels), LayoutManagers