Support de Cours Java2 PDF

Intitul Cours : Matrise de la programmation en langage Java
Date : 4/6/02
Matrisedelaprogrammationenlangage
J ava
2
Intutil Cours : Matrise de la programmation en langage Java
Rvision : J3
Date : 4/6/02
Protections Juridiques
Protections Juridiques
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 pralab
Intitul Cours: Matrise de la programmation en langage Java
Rvision : J3
Date : 4/6/02
Introduction
Objectifs
Ce cours a pour objectif de permettre des programmeurs Java
dapprofondir et dlargir leur pratique des aspects fondamentaux du
langage.
Les aspects conceptuels et techniques y sont abords en parallle.
Lobjectif est damener les professionnels vers une pratique mature de la
programmation Java.
Sortent du primtre de ce cours :
-Ltude dtaille de librairies trs spcialises comme sound,
CORBA etc..
- Les approches Java sortant du primtre Standard Edition
comme Java Entreprise Edition, Java Micro-Edition, etc.
- Les librairies dextension
Ces points sont abords dans dautres cours spcialiss
/4
Rvision : J3
Date : 4/6/02
Introduction
Prrequis
Pour pouvoir tirer un maximum de bnces de ce cours il est vivement
conseill:
Davoir une bonne pratique des aspects fondamentaux de Java
1
:
classes et interfaces, membres, constructeurs
hritage, polymorphisme
exceptions
Davoir de bonnes connaissances thoriques sur la programmation
en gnral et la programmation objet en particulier.
Davoir des notions sur les technologies du Web internet (usage
dun navigateur, adresses URL, langage HTML)
De connatre un minimum danglais (il faut pouvoir lire la
documentation)
1. Ces notions sont dveloppes dans notre cours SL-265
(Programmation en langage Java) et les cours drivs SL-110
(Langage Java pour programmeurs dbutants) et SL-010
(fondamentaux java pour programmeurs objet)
/5
Rvision : J3
Date : 4/6/02
Introduction
Phases
Le cours est dcompos en plusieurs parties :
1. Un bloc de chapitres revient sur les aspects fondamentaux de Java
Les interfaces graphiques Swing servent de support ces rappels
qui sont complts par un cours sur les processus lgers (threads).
2. Un bloc de chapitres introduit les relations avec lenvironnement
local dexcution: archives, ressources, internationalisation,
prfrences, rapports et journalisation.
3. Un bloc de chapitres traite des systmes dentres/sorties et
dchanges: diffrents systmes dE/S , programmation rseau,
rfrences distantes (RMI), accs aux bases relationelle(JDBC).
Chaque chapitre dispose dannexes qui ne font pas proprement parler
partie du cours, mais qui permettent de signaler des informations
complmentaires. Le support dispose galement dannexes globales qui
abordent des dispositifs avancs de programmation comme la
programmation dynamique, les rfrences faibles ou les codes natifs.
/6
Rvision : J3
Date : 4/6/02
Introduction
Rvision : J3
Date : 4/6/02
Table des Matires
Introduction............................................................................................................... 3
Introduction technique, composants Swing.......................................................... 15
Le code portable Java........................................................................................................... 16
Portabilit: exemple des applications graphiques................................................................ 18
Un premier programme Swing............................................................................................. 20
Disposer des composants dans un Container ....................................................................... 24
FlowLayout : synthse ......................................................................................................... 27
Gestionnaires de disposition :BorderLayout........................................................................ 28
BorderLayout : exemple dvelopp..................................................................................... 30
Quelques autres gestionnaires de disposition ...................................................................... 34
Introduction technique (suite), vnements .......................................................... 45
Les vnements.................................................................................................................... 46
Modle dvnements ......................................................................................................... 47
Les interfaces ....................................................................................................................... 49
Exemple de mise en place de traitement dvnement ........................................................ 50
Catgories dvnements ..................................................................................................... 52
Considrations architecturales: classes interdpendantes.................................................... 54
Processus lgers (threads)....................................................................................... 61
Multi-tches (rappel)............................................................................................................ 62
Processus lgers: principes .................................................................................................. 63
Conception dun Thread ...................................................................................................... 64
/8
Rvision : J3
Date : 4/6/02
Cycle de vie : dbut et fin de vie.......................................................................................... 65
Cycle de vie: retrait de ltat actif........................................................................................ 67
Cycle de vie: attente de la terminaison dune tche............................................................. 68
Autres techniques de cration.............................................................................................. 69
Etats dun Thread (rsum).................................................................................................. 71
Accs concurrents.................................................................................................... 77
Accs concurrents: problmatique....................................................................................... 78
Blocs synchronized.............................................................................................................. 80
Autres points sur lutilisation du moniteur .......................................................................... 82
Producteur/consommateur: problmatique .......................................................................... 86
Producteur/consommateur: mise en oeuvre......................................................................... 87
Etats dun Thread (rsum).................................................................................................. 91
Archives, ressources, scurit................................................................................. 97
Les ClassLoaders ................................................................................................................. 98
Archives jar.......................................................................................................................... 99
Archives jar: lancement dune application ........................................................................ 101
Ressources.......................................................................................................................... 103
Ressources applicatives ..................................................................................................... 104
Scurit .............................................................................................................................. 106
Scurit: politique configure............................................................................................ 107
Internationalisation............................................................................................... 117
Pourquoi internationaliser une application?................................................................... 118
Contextes culturels : Locale............................................................................................... 119
Contexte culturel: obtention, mise en place....................................................................... 120
Paramtrage de ressources: Resourcebundle ..................................................................... 121
ListResourceBundle........................................................................................................... 122
PropertyResourceBundle ................................................................................................... 123
Classes de mise en forme/analyse...................................................................................... 125
Prfrences ............................................................................................................. 131
Preferences: principes ........................................................................................................ 132
Preferences: contextes de nommage .................................................................................. 133
/9
Rvision : J3
Date : 4/6/02
Obtention dun contexte..................................................................................................... 134
Consultation dans un contexte ........................................................................................... 135
Enregistrement dune valeur .............................................................................................. 136
Harmonisation avec le systme de persistence .................................................................. 137
Rapports, journalisations, assertions .................................................................. 141
LA.P.I. de log................................................................................................................ 142
Contraintes architecturales des oprations de log .......................................................... 143
Qui dtermine un comportement effectif de Logger?........................................................ 145
Rglages dun Logger .................................................................................................... 146
Cheminement des rapports................................................................................................. 147
Mise en place des Loggers................................................................................................. 148
Mise en place explicite dun Handler ................................................................................ 150
Un code de Handler ........................................................................................................... 151
Un code de Formatter......................................................................................................... 152
Assertions........................................................................................................................... 154
Pourquoi utiliser des assertions.......................................................................................... 155
Assertions: syntaxe, activations......................................................................................... 157
Application dun pattern: les flots dE/S......................................................... 163
Modles structurels (design patterns) ................................................................................ 164
Un exemple dutilisation de pattern ............................................................................... 166
Application du modle structurel aux E/S flot en Java: ................................................. 170
Flots doctets (InputStream, OutputStream) ...................................................................... 172
Flots de caractres (Reader, Writer) .................................................................................. 173
Typologie par ressources................................................................................................ 174
Conversions octets-caractres............................................................................................ 175
Filtres ................................................................................................................................. 176
Filtres courants................................................................................................................... 177
Programmation rseau ......................................................................................... 181
Modles de connexions rseau en Java.............................................................................. 182
Sockets ............................................................................................................................... 183
Sockets TCP/IP. ................................................................................................................. 184
Serveur TCP/IP (exemple simple) ..................................................................................... 185
Client TCP/IP (exemple simple)........................................................................................ 186
Serveur TCP/IP (exemple avec threads) ............................................................................ 187
/10
Rvision : J3
Date : 4/6/02
Echanges U.D.P. ................................................................................................................ 189
Serveur U.D.P. (exemple).................................................................................................. 190
Client U.D.P. (exemple)..................................................................................................... 191
UDP en diffusion (Multicast)........................................................................................... 192
Diffuseur Multicast (exemple)........................................................................................... 193
Ecouteur Multicast (exemple)............................................................................................ 194
Dispositifs avancs dE/S ...................................................................................... 197
E/S dobjets........................................................................................................................ 198
Les objets dans un flot ....................................................................................................... 199
Objet adapt la linarisation (exemple)........................................................................... 200
Effets de la linarisation..................................................................................................... 201
Personnalisation de la linarisation.................................................................................... 202
Le package java.nio ........................................................................................................... 204
Mise en oeuvre de Buffers ................................................................................................. 205
Un exemple de mise en oeuvre de Buffers ........................................................................ 206
Ventilation des lectures/critures dans des Buffers ........................................................... 208
E/S asynchrones , slecteurs .............................................................................................. 210
Les rfrences distantes (R.M.I.).......................................................................... 215
La notion de service distant ............................................................................................... 216
Principe de la communication entre objets distants........................................................... 218
Exportation dun objet ....................................................................................................... 219
Les instances de Stub......................................................................................................... 221
Annuaire dobjets distants.................................................................................................. 222
Le serveur: enregistrement auprs du Registry.................................................................. 223
Le client: demande au Registry.......................................................................................... 224
Check-list pour une mise en oeuvre simple ....................................................................... 225
Laccs aux bases relationnelles (J.D.B.C).......................................................... 235
Le package java.sql ............................................................................................................ 236
Types de drivers JDBC...................................................................................................... 237
Modalits dune session JDBC.......................................................................................... 238
Enregistrement des pilotes ................................................................................................. 239
Dsignation de la ressource ............................................................................................... 240
Obtention de la connexion ................................................................................................. 241
Obtention dun contexte de requtes.................................................................................. 242
/11
Rvision : J3
Date : 4/6/02
Exploitation de resultats..................................................................................................... 243
Correspondance des types de donnes SQL en Java ......................................................... 244
Requte prpare................................................................................................................ 245
Procdure stocke .............................................................................................................. 246
Batch .................................................................................................................................. 247
ANNEXES.............................................................................................................. 249
Programmation dynamique ................................................................................. 251
Pourquoi une programmation sur des classes dcouvertes au runtime?............................ 252
La classe java.lang.Class.................................................................................................... 253
Obtention des informations sur la classe ........................................................................... 254
Le package java.lang.reflect .............................................................................................. 255
Les champs......................................................................................................................... 256
Les mthodes ..................................................................................................................... 257
Les constructeurs ............................................................................................................... 258
Les tableaux ....................................................................................................................... 259
Mandataires dynamiques ................................................................................................... 261
Notion de Bean............................................................................................................... 264
Les packages java.beans et java.beans.beancontext .......................................................... 265
XMLEncoder, XMLDecoder............................................................................................. 266
Rfrences faibles .................................................................................................. 269
Problmatiques de caches mmoire................................................................................... 270
Les objets rfrences.......................................................................................................... 271
SoftReference..................................................................................................................... 272
WeakReference.................................................................................................................. 274
Oprations lies labandon dun objet, finaliseurs, PhantomReferences........................ 276
Utilisation de code natif : J.N.I............................................................................. 281
Pourquoi raliser du code natif? ........................................................................................ 282
Un exemple : "Hello World" en C..................................................................................... 283
Prsentation de JNI ............................................................................................................ 290
JNI: types, accs aux membres, cration dobjets ............................................................. 291
Rfrences sur des objets JAVA:....................................................................................... 294
Exceptions.......................................................................................................................... 295
/12
Rvision : J3
Date : 4/6/02
Invocation de JAVA dans du C ......................................................................................... 296
Java et le Web: les applets .................................................................................... 297
Applets ............................................................................................................................... 298
Applets: restrictions de scurit......................................................................................... 300
Hirarchie de la classe Applet............................................................................................ 302
Applets: groupes de mthodes ........................................................................................... 303
H.T.M.L.: la balise Applet ................................................................................................. 304
Mthodes du systme graphique de bas niveau................................................................. 306
Mthodes daccs aux ressources de lenvironnement ...................................................... 307
Mthodes du cycle de vie................................................................................................... 309
Rappels: syntaxe, spcifications simplifies ....................................................... 311
Plan gnral dune classe................................................................................................... 312
Plan gnral dune interface............................................................................................... 313
Rappels syntaxiques (simplifis) ....................................................................................... 314
Variables ............................................................................................................................ 322
Mthodes............................................................................................................................ 329
Constructeurs ..................................................................................................................... 333
Blocs .................................................................................................................................. 335
Types primitifs scalaires, types objets ............................................................................... 339
Packages, rgles de responsabilit ..................................................................................... 340
Aide-mmoire........................................................................................................ 341
Le SDK.............................................................................................................................. 342
Les outils............................................................................................................................ 343
javadoc et HTML............................................................................................................... 344
Glossaire ............................................................................................................................ 347
Adresses utiles ................................................................................................................... 369
Rvision : J3
Date : 4/6/02
Premire partie: aspects fondamentaux du langage
.
/14
Rvision : J3
Date : 4/6/02
Rvision : J3
Date : 4/6/02
Introduction technique, composants Swing 1
Points essentiels
Premire revue des bases techniques de Java.
Si ncessaire un court prologue peut tre insr ici: Voir Java et le Web: les
applets, page 297.
Une prsentation des composants graphiques Swing sert de trame:
composants portables, philosophie dune disposition de composants
indpendante de la plate-forme.
1
1/16
Rvision : J3
Date : 4/6/02
Introduction technique, composants Swing
Le code portable Java
La lire de production du code Java :
On a donc ici deux phases :
Compilation du code source : javac Hello.java
Excution du pseudo-code gnr: java Hello (appel de
lexcuteur avec en paramtre le nom de classe qui sert de point
dentre) - on notera quil existe dautres manires dappeler
lexcuteur de code Java comme par exemple un excuteur
enchass dans le code dun navigateur. Dans ce cas on
tlcharge un code distant qui est dynamiquement pris en compte
par lexcuteur, le code doit rpondre un certain nombre de
contraintes (dans ce cas celles dcrites par la classe
java.applet.Applet).
chier source
chier binaire
compilation: javac excution
Hello.java Hello.class
1/17
Rvision : J3
Date : 4/6/02
1
Les machines virtuelles
Le pseudo-code Java (bytecode) obit des spcications prcises.
Portable, il est excut sur la plate-forme locale par un excuteur propre
cette plate-forme
Lexcuteur local est un code natif spcique au systme local.
La librairie systme de Java doit tre installe localement. Cette librairie
contient :
des classes compltement crites en Java
des classes contenant du code natif. Ces codes natifs permettent
en particulier de dlguer des services au systme dexploitation
local (ouverture de chiers, etc.) ou au systme de fentrage local
(cration dune fentre, etc.)
OS
systme de
JVM
(interprteur
spcique)
librairies
java
fentrage
OS
systme de
JVM
(interprteur
spcique)
librairies
java
fentrage
chier binaire (pseudo-code)
conforme aux spcications JVM
plate-forme de type A plate-forme de type B
1
1/18
Rvision : J3
Date : 4/6/02
Portabilit: exemple des applications graphiques
AWT
Le package java.awt dnit un ensemble de composants graphiques
standard que lon retrouve sur toutes les plateformes. Ces composant
dinteractions graphiques sont essentiellement raliss avec des
composants natifs du systme de fentrage local. Le mme code Java
connaitra sur des sytmes diffrents une ralisation sensiblement
diffrente (tout en conservant la mme logique):
Ici on a dispos deux boutons (classe java.awt.Button) lintrieur
dune fentre (classe java.awt.Frame).
AWT ne se contente pas de dnir un vocabulaire graphique, il dnit
galement une philosophie dassemblage de ses composants. Dans la
mesure o un code Java portable ne connait pas a priori la plateforme
cible, il est malvenu de raliser un positionnement absolu des composants
(Component) lintrieur des Containers (composants qui en
contiennent dautre).
La disposition des composants sappuie sur le principe des gestionnaires
de disposition (LayoutManager): un objet associ chaque container
calcule la position des composants en fonction de contraintes logiques
(nous allons en voir des exemples ultrieurement).
Motif Windows
(0,0)
x
y
Container (Frame)
Composant (TextField)
Bien que possible le positionnement en coordonnes absolues nest pas portable
1/19
Rvision : J3
Date : 4/6/02
1
Swing
Le package javax.swing dnit une autre catgorie de composants. Ces
composants ne sappuient pas sur des composants natifs mais sont
dessins partir des primitives graphiques de bas niveau (accessibles
en AWT).
On a ici un vocabulaire graphique plus riche (de par sa nature AWT a un
vocabulaire limit), et de nombreuses techniques qui compltent celles
dAWT. Ainsi lutilisation de gestionnaires de disposition est reprise et
enrichie.
Pour une dmonstration des capacits de la librairie voir le sous-
rpertoire demo/jfc/SwingSet2 de linstallation de votre kit de
dveloppement java (SDK). On remarquera, entre autres, la capacit de
changer de look and feel, cest dire de passer dune charte graphique
portable (appele Metal) au look and feel de la plateforme locale (voire
celui dune autre plateforme comme un look Motif sur Windows par
exemple).
1
1/20
Rvision : J3
Date : 4/6/02
Un premier programme Swing
Ici sur un systme de fentrage Motif, le rsultat de lexcution dun
programme montrant un message simple dans une fentre:
Le chier source Message.java
Un autre chier source (TestMessage.java) pour assurer le lancement
de lapplication :
public class TestMessage {
public static void main (String[] args) {//point dentre
Message messager = new Message(args[0]) ;
messager.dmarrer() ;
}
}
La compilation des 2 chiers donne les chiers de pseudo-code :
Messsage.class et TestMessage.class. Le lancement de
lapplication se fait par la commande (ici en syntaxe Shell Unix) :
java TestMessage Bien le bonjour de SWING!
import javax.swing.* ; //directive utilisation de librairie
public class Message {//dclaration classe
JFrame fentre ;
public Message (String mess) {
fentre = new JFrame("Message") ;
JLabel label = new JLabel(mess) ;
fentre.getContentPane().add(label);
}
public void dmarrer() {
fentre.pack();
fentre.show() ;
}
}// fin classe
var.membre instance
mthode dinstance
constructeur
1/21
Rvision : J3
Date : 4/6/02
1
Un premier programme Swing: contenu
Aspects fonctionnels
Dans une fentre Swing (JFrame: container racine partir duquel on
peut oprer en Swing) on dispose une tiquette Swing (JLabel: on ne
peut pas mlanger composants AWT et composants Swing).
Comme pour tous les containers racine cette disposition (application de
la mthode add) ne sapplique pas directement sur le JFrame mais sur
son Content Pane (tapisserie de fond) -dans ce cas il y a une petite
diffrence entre Swing et AWT qui, lui, dispose directement dans le
Container Frame-.
La mthode pack() de JFrame lui permet de tenter de prendre les
dimensions strictement ncessaires pour contenir les composants (effet
plus portable que lemploi de setSize(largeur, hauteur)).
Code java
La classe Message (dans le chier Message.java!) dnit une variable
dinstance (fentre) qui est initialise dans le constructeur et utilise
dans la mthode dinstance dmarrer (mthode dinstance sans
paramtre ni resultat).
La classe TestMessage contient juste un point dentre standard dont la
description doit tre :
public static void main(String[] parms)
Le tableau de chanes de caractres pass en argument du main
correspond aux arguments de lancement du programme. La premire
chane (index 0) est rcupre pour tre passe en argument au
constructeur de Message. Cette invocation du constructeur rend une
refrence vers un objet de type Message; la mthode dmarrer est
invoque sur cette instance.
1
1/22
Rvision : J3
Date : 4/6/02
Point intermdiaire :miseenplacedunprogramme
Mini-exercice :
En vous inspirant du modle prcdent raliser un code Java
Swing qui afche un message. Compiler, excuter.
Pour varier les plaisirs utiliser pour afcher un message un
autre composant que JLabel (par exemple un JButton, ou
un JTextField) -lire la documentation associe au SDK-
Pour les trs rapides ou ceux qui rvisent : changer la couleur
de fond, la couleur du texte, la fonte du texte (mthodes
setBackground, setForeground, setFont ,...)
1/23
Rvision : J3
Date : 4/6/02
1
1
1/24
Rvision : J3
Date : 4/6/02
Disposer des composants dans un Container
Voici un exemple plus complexe qui va nous permettre dobtenir ceci:
Le code du Container dans lequel on va disposer des boutons :
import javax.swing.* ;
import javax.swing.border.* ;
import java.awt.* ;
public class Barre extends JPanel {
/** Cre un barre horizontale de composants Swing
* <P>
* Les composant sont cadrs dans le sens naturel de lecture
*/
public Barre(JComponent[] tbComp) {
super(new FlowLayout(FlowLayout.LEADING)) ;
for(int ix = 0 ; ix < tbComp.length; ix++) {
this.add(tbComp[ix]) ;
}
}
/** Un cadre et un titre sont diposs autour des composants
*/
public Barre(String leTitre, JComponent[] tbComp) {
this(tbComp) ;
Border bordure = BorderFactory.createEtchedBorder() ;
Border titre = BorderFactory.createTitledBorder(
bordure, leTitre,TitledBorder.DEFAULT_JUSTIFICATION,
TitledBorder.TOP) ;
this.setBorder(titre) ;
}
}
1/25
Rvision : J3
Date : 4/6/02
1
Disposition : le code
La classe Barre dcrit un Panneau (JPanel) dans lequel les composants
sont disposs les uns la suite des autres.
Une telle disposition est assure par un gestionnaire de disposition appel
FlowLayout. Pour doter un container dun gestionaire de disposition
particulier, il faut faire appel sa mthode
setLayout(gestionnaire). La classe JPanel dispose galement dun
constructeur qui permet de passer le gestionnaire de disposition en
paramtre.
Dans le cadre dun FlowLayout on doit ajouter les composants au
container en employant la mthode add(composant) -lordre des ajouts
est important puisquil dtermine lordre de disposition des composants-
Il est possible de construire deux types de Barres: celles qui alignent
simplement des composants et celles qui entourent cet alignement avec
une bordure comprenant un titre (cas illustr dans limage). Cette
possibilit de placer une bordure autour dun composant est
caractristique de Swing (et nexiste pas en AWT classique).
Code java
Barre hrite de JPanel (dclaration extends). On dcrit deux
constructeurs dont lun se dnit par rapport lautre:
Le premier constructeur fait appel au constructeur de JPanel en
lui passant une instance de FlowLayout (argument dterminant
un cadrage gauche: constante de la classe FlowLayout).
On parcourt ensuite le tableau de composants pass en argument
et on les ajoute linstance courante (qui est un Container).
Le second contructeur fait dabord appel au premier, puis
construit une bordure compose.
Ces bordures sont fabriques par des mthodes de classe de la
classe BorderFactory (mthodes fabriques).
1
1/26
Rvision : J3
Date : 4/6/02
Disposer des composants dans un Container (suite)
Le code utilisant Barre pour crer limage en exemple:
public class TestBarre {
public static void main (String[] args) {
JComponent[] tb = {
new JButton("OUI"),
new JButton("NON"),
new JButton("Sans Opinion"),
} ;
Barre barre = new Barre(" Votre avis? ", tb) ;
JFrame fen = new JFrame("Sondage") ;
fen.getContentPane().add(barre) ;
fen.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE) ;
fen.pack();
fen.show() ;
}
}
Un tableau contenant 3 boutons est pass au constructeur de Barre et
cette Barre est mise directement dans le ContentPane de la fentre.
On notera que pour que lapplication sarrte quand on ferme la fentre,
on xe lopration dclencher (fonctionnalit spcique au JFrame: dans
le AWT classique il faudra suivre une procdure dcrite au chapitre
suivant).
Code java
Noter la cration dun tableau littral de JComponent (qui dailleurs ne
contient que des JButtons).
1/27
Rvision : J3
Date : 4/6/02
1
FlowLayout : synthse
Le gestionnaire de disposition FlowLayout positionne les composants les
uns la suite des autres. Au besoin il cre une nouvelle ligne pour
positionner les composants qui ne tiennent pas dans la ligne courante.
A la diffrence de beaucoup dautres gestionnaires de disposition, une
instance de FlowLayout ne modie pas la taille des composants (tous les
composants comportent une mthode getPreferredSize() qui est
appele par les gestionnaires de disposition pour demander quelle taille le
composant voudrait avoir).
FlowLayout est le gestionnaire par dfaut associ aux containers
de type Panel (AWT) et JPanel (Swing)
1
.
Il existe plusieurs manires de construire un FLowLayout ce qui
permet de faire varier lalignement ( gauche, droite, centr,..) ou
de faire varier la taille des gouttires sparant les composants.
Les composants sont ajouts au Container en employant la
mthode add(Component) , bien entendu lordre des add est
important puisquil dtermine lordre des composants dans la
disposition.
1. note: un autre gestionnaire par dfaut est associ au
ContentPane le add na pas ici le mme effet -voir suite de
lexpos-
redimensionnement
de la fentre
(exemple en AWT)
1
1/28
Rvision : J3
Date : 4/6/02
Gestionnaires de disposition :BorderLayout
BorderLayout divise son espace de travail en cinq zone nommes et les
composants sont ajouts explicitement une zone donne. On ne peut
placer quun composant par zone, mais toutes les zones ne sont pas
ncessairement occupes.
BorderLayout est le gestionnaire par dfaut des Containers de
type Window (AWT) et ContentPane des JFrame (Swing).
Les add sont qualis: il faut prciser dans quelle zone on met le
composant (par dfaut un add simple met le composant dans la
zone centrale).
En cas dlargissement du container le gestionnaire respecte les
hauteurs prfres des composants en NORTH et SOUTH, et les
largeurs prfres des composants en EAST et WEST. La zone
centrale tend occuper toute la place restante dans les deux
directions.
redimensionnement
de la fentre
(exemple AWT)
1/29
Rvision : J3
Date : 4/6/02
1
BorderLayout: exemple de code (simpli )
...;
import javax.swing.text.* ;
import java.awt.* ;
public class PresentationMessage extends JPanel {
... ;
protected JButton rep= new JButton("Rpondre") ;
protected JButton prec= new JButton("Prcdent") ;
protected JButton suiv= new JButton("Suivant") ;
public PresentationMessage() {
... ;
setLayout(new BorderLayout(5,5)) ;// gouttires de 5
// ---------- en-tte
String descr = ... ;
JLabel label = new JLabel(descr) ;
this.add(label, BorderLayout.NORTH) ;
// ---------- TEXTE
String message = ... ;
JTextArea jt = new JTextArea(message, 3, 50) ;
this.add(new JScrollPane(jt), BorderLayout.CENTER) ;
// ---------- boutons
JButton[] tbBout = {rep, prec, suiv};
Barre boutons = new Barre(tbBout) ;
this.add(boutons, BorderLayout.SOUTH) ;
}
....
}
On notera que le add prend ici une forme particulire (add quali).Par
ailleurs la combinaison JTextArea (texte multiligne), JScrollPane
est spcique Swing.
1
1/30
Rvision : J3
Date : 4/6/02
BorderLayout : exemple dvelopp
Voici laspect graphique de la prsentation recherche :
Cette prsentation graphique sert aux interactions sur un objet Message
dont voici la dnition:
package chat;// la class appartient au package chat
public class Message {// vrai nom : chat.Message
public static final int ORIGINAL = -1 ;
public final int numero ;
public final int repondA ;
public final String auteur ;
public final String message ;
public Message(String auteur,int num,int rep,String message){
this.auteur=auteur; numero = num;
repondA = rep; this.message = message;
}
public Message(String auteur,int num,String message) {
this(auteur, num, ORIGINAL, message) ;
}
}
Cette classe dnit en quelque sorte une structure de donnes simple
dont tous les champs sont immuables une fois linstance construite. Du
coup il ny a pas encapsulation des variables dinstance et celles-ci sont
publiques. (On notera galement la dnition de la constante de classe
ORIGINAL).
Toute classe Java qui sort du domaine de la petite dmonstration doit tre
dnie dans le cadre dun package(Voir Packages, rgles de responsabilit,
page 340..)
1/31
Rvision : J3
Date : 4/6/02
1
Exemple dvelopp de linterface graphique:
package chat;
import javax.swing.text.* ;
import java.awt.* ;
public class PresentationMessage extends JPanel {
private Message msg ;
protected JButton rep= new JButton("Rpondre") ;
protected JButton prec= new JButton("Prcdent") ;
protected JButton suiv= new JButton("Suivant") ;
public PresentationMessage(Message mess) {
msg = mess ;
setLayout(new BorderLayout(5,5)) ;// gouttires de 5
// ---------- en-tte
String descr = "De: " +msg.auteur +" ["+ msg.numero+ "] ";
if( msg.repondA != Message.ORIGINAL) {
descr += " rpond A: [" + msg.repondA +"]" ;
}
JLabel label = new JLabel(descr) ;
label.setFont(new Font("Monospaced",Font.BOLD,15)) ;
label.setForeground( Color.RED ) ;
this.add(label, BorderLayout.NORTH) ;
// ---------- TEXTE
JTextArea jt = new JTextArea(msg.message, 3, 50) ;
jt.setEditable(false) ;
this.add(new JScrollPane(jt), BorderLayout.CENTER) ;
// ---------- boutons
JButton[] tbBout = {rep, prec, suiv};
Barre boutons = new Barre(tbBout) ;
this.add(boutons, BorderLayout.SOUTH) ;
}
public Message getMessage() {// accesseur dun membre priv
return msg ;
}
}
1
1/32
Rvision : J3
Date : 4/6/02
Point intermdiaire :coder avecdes
LayoutManagers
Mini-exercice :
Raliser un code Java Swing qui soit lquivalent de cette
prsentation AWT:
Faites un code simple, mais les classes utilises doivent appartenir
un package. Si vous ne savez pas organiser un dveloppement
en package: Voir Dveloppement avec des packages, page 43..
Pour les trs rapides ou ceux qui rvisent : faites des expriences
avec des composants Swing (JLabel, JButton) en leur passant du
html comme texte.
Ci-aprs un exemple analogue au code prcdent mais qui utilise
un JEditorPane("text/html", texte) en remplacement
dun TextArea.
1/33
Rvision : J3
Date : 4/6/02
1
1
1/34
Rvision : J3
Date : 4/6/02
Quelques autres gestionnaires de disposition
GridLayout
Dispose un tableau dans lequel tous les composants ont la mme
hauteur et la mme largeur:
Utilise essentiellement des add(composant) -lordre des appels tant
important pour dterminer lordre de composants-
redimensionnement
de la fentre
disposition avec des lments manquants
1/35
Rvision : J3
Date : 4/6/02
1
BoxLayout
Cest un gestionnaire spcique Swing. A utiliser ventuellement avec la
classe Box pour permettre des alignements de composants dans une
direction avec des insertions despaces et de glue qui maintient des
lments ensembles.
1
1/36
Rvision : J3
Date : 4/6/02
GridBagLayout
Cest le plus complexe des gestionnaires standard. Les composants sont
disposs dans un tableau dans lequel chaque ligne et chaque colonne a
une dimension dicte par le plus grand composant qui loccupe
(dnissant ainsi un tartan irrgulier de cellules) :
1/37
Rvision : J3
Date : 4/6/02
1
On dispose par add(composant, contraintes) dans lequel
contraintes est une instance de GridBagConstraints (rutilisable), les
champs de cette instance comprennent:
gridx, gridy : donne les coordonnes x, y de lobjet dans la grille
(celle-ci dduit automatiquement son propre nombre de lignes et
de colonnes)
gridwidth, gridheight : nombre de cellules occupes par le
composant
ll : direction du remplissage (le composant tend alors occuper
toute sa cellule dans la direction donne). Valeurs: NONE, BOTH,
VERTICAL, HORIZONTAL
anchor: lorsquun composant est plus petit que sa cellule, bord
dancrage du composant (un point cardinal: EAST, NORTHEAST,
etc.)
insets: dtermination des "gouttires" (distance minimum entre le
composant et les frontires de sa cellule)
weightx,weighty : "poids" relatif de la cellule lorsque le container
dispose de plus de place que ncessaire pour les cellules et que
lon souhaite largir la disposition (valeur de type double
comprise entre 0 et 1)
Exemple de code :
GridBagConstraints gbc = new GridBagConstraints() ;
gbc.gridx = 0 ; gbc.gridy = 0 ;
add(new JButton ("<html><li>gridx=0;gridy=0"), gbc);// couteux!
gbc.gridx = 1 ; gbc.gridy = 1 ;
add(new JButton ("<html><li>gridx=1;gridy=1"), gbc) ;
1
1/38
Rvision : J3
Date : 4/6/02
Exercice: pratiquedesLayoutManagers
Exercice :
Raliser en Swing un formulaire comprenant un champ de saisie,
un bouton et une plage de texte (pour afcher la rponse la
question)
1/39
Rvision : J3
Date : 4/6/02
1
1
1/40
Rvision : J3
Date : 4/6/02
Complments
Les complments techniques suivants constituent une annexe de rfrence
Swing
La programmation Swing est un vaste sujet (voir notre cours SL-320).
Quelques remarques gnrales complmentaires sur les composants
Swing:
bordures :
En utilisant la mthode setBorder() 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 double-
buffering, 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 la charte
graphique (look and feel). La modication de laspect par
1/41
Rvision : J3
Date : 4/6/02
1
setLookAndFeel() est soumise des contrles de scurit.
Derrire chaque JComponent il y a un ComponentUI qui gre le
dessin, les vnements, la taille, etc.
utilisation de modles:
Swing comporte une trs grande varit de composants dont
certains sont trs complexes (voir JTree, JTable, etc.). Il est
pratique dutiliser des modles de programmation, cest dire
des structures de donnes qui grent en parallle des donnes et
leur reprsentation graphique (les modications de lune sont
rpercutes dans lautre).
1
1/42
Rvision : J3
Date : 4/6/02
Java: bases fondamentales
Pour amliorer vos connaissances sur les bases fondamentales de Java,
vous devez, ce stade, approfondir les points suivants :
Architecture des dclarations de classes -Voir Plan gnral dune
classe, page 312.-, packages, rgles de visibilit (modicateurs
public, private, protected) -Voir Packages, rgles de
responsabilit, page 340.-.
Utilisation des types: types primitifs (int, boolean, double,
etc.), types objets (rfrences vers des instances) et cas
particulier des objets qui sont des tableaux. -Voir Types primitifs
scalaires, types objets, page 339.
Dclaration des variables --Voir Dclarations de variable membre :,
page 314.; Voir Variables, page 322.-
Dclaration des mthodes (arguments, rsultats) -Voir Dclarations
de mthode membre, page 315.; Voir Mthodes, page 329.-, rgles de
rednition dans les sous-classes. Polymorphisme des rfrences.
Dclaration des constructeurs - Voir Dclarations de constructeur,
page 317.; Voir Constructeurs, page 333. -, appel des constructeurs,
rgles de dnition des constructeurs dans les sous-classes.
Membres de classe : variables partages -Voir variables de classe,
page 325.-, constantes, mthodes de classe -Voir Mthodes de classe,
page 332.-.
Structures du code -Voir Syntaxe simplifie des blocs de code,
page 318.; Voir Blocs, page 335.-, structures de contrle -Voir
Syntaxe simplifie des blocs de code, page 318.; Voir structures de
contrle:, page 319.
1/43
Rvision : J3
Date : 4/6/02
1
Dveloppement avec des packages
Exemple dorganisation pratique des rpertoires:
src
fr
gibis
utils p1 p2
Classe1.java C2.java
classes
fr
gibis
utils p1 p2
Classe1.class C2.class
javac -classpath classes -d classes -sourcepath src Classe1.java
variables
peut contenir une liste de chemins daccs
(spars par : -ou ; sous Win*-)
1
1/44
Rvision : J3
Date : 4/6/02
Rvision : J3
Date : 4/6/02
Introduction technique (suite), vnements 2
Points essentiels
La gestion des vnements dans une IHM va nous permettre de revenir
sur des dispositifs de programmation objet spciques Java: interfaces,
classes membres et classes locales.
Les mcanismes fondamentaux des vnements graphiques relvent de
AWT, mais sont repris et largis dans Swing.
2
2/46
Rvision : J3
Date : 4/6/02
Introduction technique (suite), vnements
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.
Sources dvnements
Un vnement (au niveau de linterface utilisateur) est le rsultat dune
action utilisateur sur un composant graphique source. A titre dexemple,
un clic de la souris sur un composant bouton gnre un ActionEvent.
LActionEvent est un objet contenant des informations sur le statut de
lvnement par exemple:
getActionCommand() : renvoie le nom de commande associ
laction.
getModifiers() : renvoie la combinaison des modicateurs,
cest dire la combinaison des touches que lon a maintenues
presses pendant le click (touche Shift par exemple).
getSource() : rend lobjet qui a gnr lvnement.
Gestionnaire dvnements
Un gestionnaire (handler) dvnement est une mthode qui reoit un
objet Event, lanalyse et traite les consquences de linteraction
utilisateur.
Pour certains types dvnements il peut y avoir plusieurs types de
gestionnaires qui seront respectivement appels en fonction de laction
qui sest produite au niveau du composant source. Ainsi pour un
vnement souris on pourra distinguer un gestionnaire correspondant
laction du clic ou un gestionnaire correspondant au fait que le curseur
soit pass sur le composant concern.
2/47
Rvision : J3
Date : 4/6/02
2
Modle dvnements
Modle par dlgation
Le JDK 1.1 a introduit dans Java un modle dvnement appel modle
dvnement par dlgation. Dans un modle dvnement par
dlgation, les vnements sont (indirectement) gnrs par un
composant graphique (quali de source de lvnement); on doit
associer ce composant un objet de traitement dvnement (appel
veilleur: Listener) pour recevoir lvnement et le traiter. De cette faon,
le traitement dvnement peut gurer dans une classe distincte du
composant impliqu.
Un veilleur est susceptible de traiter plusieurs actions lies un type
dvnement et donc de disposer de plusieurs gestionnaires : par exemple
un gestionnaire charg de veiller sur les clics souris et un charg de
veiller sur le passage de la souris sur le composant.
Applet
Panel
Bouton
action
....
}
handler daction
actionPerformed(ActionEvent e) {
instance de veilleur
gnration ActionEvent
2
2/48
Rvision : J3
Date : 4/6/02
Modle dvnements
Le type du veilleur
Les composants susceptibles de gnrer des vnements sont dots de
mthodes denregistrement des veilleurs spcialiss. On peut avoir
plusieurs mthodes denregistrement par exemple pour un bouton
JButton:
addActionListener(...) ; addMouseListener(...) ;...
Quelle est le type de largument qui permet de dsigner la nature du
veilleur?
Si ce type tait celui dune classe particulire on serait oblig au
niveau de la ralisation de crer une sous-classe pour implanter le
code de traitement.
Bien que possible, cette solution serait plus rigide: on pourrait
avoir besoin dinsrer ces codes de traitement dans des instances
qui drivent dautres classes (et, pourquoi pas, des instances qui
sont elles mmes des drivs de composants graphiques). De plus
si on voulait crer une classe de veille qui a plusieurs
comportement (ActionListener, MouseListener) lcriture du code
deviendrait difcile (pas dhritage multiple en Java).
On souhaiterait avoir ici la fois un contrle de type strict (lobjet
pass en paramtre doit savoir traiter lvnement considr) et
une grande souplesse au niveau du type effectif de lobjet qui rend
le service.
Le type du veilleur est dni par une interface Java
2/49
Rvision : J3
Date : 4/6/02
2
Les interfaces
Une interface est en Java une dclaration de type qui permet de dcrire
une capacit.
public interface ActionListener {
public void actionPerformed(ActionEvent evt) ;
}
-------------------// autre exemple dans un autre fichier .java
public interface FocusListener {
public void focusGained(FocusEvent evt) ;
public void focusLost(FocusEvent evt) ;
}
Une classe pourra dclarer adhrer au contrat dni par linterface. Elle
sera oblige dimplanter le code correspondant aux mthodes dclares
mais cela lui permettra dtre vue comme conforme au contrat de type
exig.
public class Veilleur extends X implements ActionListener {
... // codes divers
public void actionPerformed(ActionEvent act) {
// code spcifique
}
}
On pourra alors crire :
monBouton.addActionListener(monVeilleur) ;
puisquun Veilleur remplit les obligations dun ActionListener.
Pour un point sur les interfaces Voir Plan gnral dune interface, page 313.
et les dtails concernant les dclarations de mthodes et de constantes de
classe dans le chapitre Rappels: syntaxe, spcications simplies,
page 311
2
2/50
Rvision : J3
Date : 4/6/02
Exemple de mise en place de traitement dvnement
Les vnements sont des objets qui ne sont envoys quaux veilleurs
enregistrs. A chaque type dvnement est associ une interface dcoute
correspondante.
A titre dexemple, voici une fentre simple comportant un seul bouton :
import java.awt.*;
public class TestButton {
public static void main (String args[]){
JFrame fr = new JFrame ("Test");
JButton bt = new JButton("Appuyer!");
bt.addActionListener(new VeilleurBouton());
fr.getContentPane().add(bt,BorderLayout.CENTER);
fr.pack();
fr.show();
}
}
La classe VeilleurBouton dnit une instance de traitement de
lvnement .
import java.awt.event.*;
public class VeilleurBouton implements
ActionListener{
public void actionPerformed(ActionEvent evt) {
System.err.println("Ae!sur " + evt.getActionCommand());
/* faire System.err.println dans un interface graphique nest
* pas fondamentalement une bonne ide! ceci est un exemple
*/
}
}
2/51
Rvision : J3
Date : 4/6/02
2
Exemple de mise en place de traitement dvnement
La classe JButton hrite de AbstractButton une mthode
addActionListener(ActionListener).
Linterface ActionListener dnit une seule mthode ,
actionPerformed qui recevra un ActionEvent.
Lorsquun objet de la classe JButton est cr, on peut enregistrer
un objet veilleur pour les ActionEvent par lintermdiaire de la
mthode addActionListener, on passe en paramtre un objet
dune classe qui implante (implements) linterface
ActionListener.
Lorsque lon clique sur lobjet Bouton avec la souris, un
ActionEvent est envoy chaque ActionListener enregistr et
la mthode actionPerformed (ActionEvent)est invoque.
Remarquons que lon aurait pu enregistrer plusieurs veilleurs distincts
dvnements Action auprs du bouton. On aurait pu galement
enregistrer un veilleur qui sache traiter plusieurs types dvnement (par
exemple Action + Focus); dans ce cas la dclaration de la classe aurait t :
public class VeilleurBouton implements
ActionListener, FocusListener {
....
}
public void focusGained(FocusEvent evt) {
...
}
public void focusLost(FocusEvent evt) {
...
}
}
2
2/52
Rvision : J3
Date : 4/6/02
Catgories dvnements
Il existe de nombreux types dinterfaces de veille dans les packages
java.awt.event et javax.swing.event. Quelques exemples AWT:
Catgorie Interface Methodes
Action ActionListener actionPerformed(ActionEvent)
Item ItemListener itemStateChanged(ItemEvent)
Mouse MotionMouseMotionListener mouseDragged(MouseEvent)
mouseMoved(MouseEvent)
Mouse MouseListener mousePressed(MouseEvent)
mouseReleased(MouseEvent)
mouseEntered(MouseEvent)
mouseExited(MouseEvent)
mouseClicked(MouseEvent)
Key KeyListener keyPressed(KeyEvent)
keyReleased(KeyEvent)
keyTyped(KeyEvent)
Focus FocusListener focusGained(FocusEvent)
focusLost(FocusEvent)
Window WindowListener windowClosing(WindowEvent)
windowOpened(WindowEvent)
windowIconified(WindowEvent)
windowDeiconified(WindowEvent)
windowClosed(WindowEvent)
windowActivated(WindowEvent)
windowDeactivated(WindowEvent)
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>, ...)
Dans certains cas le package fournit une classe XXXAdapter qui
implante toutes les mthodes du contrat de veille mais sans
comportement associ. Cette facilit permet de dnir des classes de veille
simples par hritage de lAdapter et ainsi permet dviter dimplanter
toutes les mthodes du Listener -on ne dnit que celles dont on a
besoin-.
2/53
Rvision : J3
Date : 4/6/02
2
Point intermdiaire :Miseenplacedunveilleur
Mini-exercice :
Reprendre lexercice de mise en place dun formulaire question-
rponse (Exercice :, page 38).
Faire en sorte que lorsque lon a valid une question dans le
champ de saisie, on afche un cho de cette question dans le
composant rponse.
Prcision: la production de la rponse doit tre dclenche quand
on appuie sur le bouton JButton ET quand on valide le
champs de saisie JTextField (en appuyant sur la touche
<ENTER>). Quel est le type dvnement qui permet de grer ces
deux actions de la mme manire?
2
2/54
Rvision : J3
Date : 4/6/02
Considrations architecturales: classes interdpendantes
La mise en place dune interface utilisateur est particulirement
intressante par les problmes dorganisation qui sont poss. Il faut faire
collaborer des codes qui traitent la logique applicative avec les codes
chargs de la prsentation. De plus, il faut impliquer les codes qui grent
les vnements et permettent la mise jour des instances .
Dans le cadre de techniques dorganisation, on utilise souvent des
modles architecturaux (pattern) qui distinguent le Modle ( les donnes
qui vont tre manipules) de la Vue (la reprsentation graphique de ces
donnes) et mettent en place des automatismes de mise jour.
Sans entrer dans ces techniques nous allons nous poser un problme
dorganisation courant: imaginons un exemple trs simple dans lequel un
JFrame contient un bouton JButton et un JTextField dans lequel
nous afchons le nombre de clics sur le bouton.
Si nous crivons un code tel que :
bouton.addActionListener(new ControleurAction());
Comment linstance de contrle (de type ControleurAction) peut-elle
connatre le champ de type JTextField pour lui demander dafcher un
message?
2/55
Rvision : J3
Date : 4/6/02
2
Considrations architecturales
Le gestionnaire dvnement dans une classe externe
Le fait que le contrleur doive connatre un composant sur lequel il doit
agir nous amne raliser une classe qui garde en mmoire une rfrence
sur ce composant cible :
public class ControleurAction implements ActionListener {
private int compteur ;
private JTextField message ;
public ControleurAction (JTextField cible) {
message = cible ;
}
message.setText("nombre de clics =" + (++compteur));
}
}
et dans le code de disposition de composants graphiques :
bouton.addActionListener(new ControleurAction(leTextField));
Quelques remarques sur cette conception:
On crit un code de classe ad hoc : il nest pratiquement pas
rutilisable en dehors de ce besoin prcis. De plus la maintenance
nest pas facilite: dans le code de la classe dinteraction on na pas
le code de contrle dvnement sous les yeux, une modication
de la ralisation peut ncessiter une intervention sur deux chiers.
Que se passe-t-il si on dcide de remplacer le champ JTextField
par un JLabel?
Cette remarque devient dautant plus pertinente quon peut tre
amen ne crer quune seule instance de ControleurAction et
cibler de nombreux composants dans le code de gestion
dvnement.
2
2/56
Rvision : J3
Date : 4/6/02
Le gestionnaire dvnement intgr
Le gestionnaire dvnement peut tre intgr la classe de disposition
graphique:
public class Disposition extends JFrame implements ActionListener{
...
private JTextField leTextField ;
....
private int compteur ;
leTextField.setText("nombre de clics =" + (++compteur));
}
....
bouton.addActionListener(this) ;
...
}
Ici on a tout sous la main mais:
si on doit veiller sur plusieurs composants (par exemple faire de
cette manire des addActionListener sur plusieurs boutons) le
code du gestionnaire dvnement risque de devenir scabreux -il
devra implanter des comportements diffrents en fonction du
composant source: ce qui est criticable dans le cadre dune
programmation objets-
si, de plus, le code doit assurer simultanment la veille de
Listeners complexes comme MouseListener et
WindowListener, on risque daboutir un fouillis de
gestionnaires dvnements.
2/57
Rvision : J3
Date : 4/6/02
2
Le gestionnaire dvnement dans une classe interne
Une autre solution consiste dnir une classe de veille dans le contexte
de la classe de disposition. Ceci est rendu possible en Java par la
dnition dune classe interne.
public class Disposition extends JFrame {
...
....
private class ControleurAction implements ActionListener{
int compteur ;
leTextField.setText(
nombre de clics =" + (++compteur));
}
}// fin classe interne
....
bouton.addActionListener(new ControleurAction()) ;
...
}
On a ici une classe membre dinstance de la classe Disposition qui est
situe dans le contexte de la classe englobante. Du coup linstance du
veilleur a directement accs au champ leTextField.
2
2/58
Rvision : J3
Date : 4/6/02
Le gestionnaire dvnement dans une classe anonyme
Dans lexemple prcdent on a une classe interne qui est dnie alors
quil ny a quune seule instance utilisable. Il est donc possible dutiliser
une criture plus synthtique qui est celle dune classe anonyme :
public class Disposition extends JFrame {
...
....
bouton.addActionListener(new ActionListener() {
int compteur ;
leTextField.setText(
nombre de clics =" + (++compteur));
}
}) ;// fin classe anonyme
...
}
La syntaxe indique une dnition la vole dune classe aprs lappel du
new. Cette classe (sans nom) fait implicitement extends Object
implements ActionListener .
En voici un autre exemple (une fentre AWT qui ne dispose pas de lotion
DISPOSE_ON_CLOSE de JFrame)
fen.addWindowListener( new WindowAdapter() {
public void windowClosing(WindowEvent evt) {
dispose() ; //mthode de Frame
}
}) ;
Ici la classe anonyme fait implicitement extends WindowAdapter (on a
considr que lon tait dans le code dune classe drive de Frame,
sinon il aurait fallu crire fentre.dispose() )
2/59
Rvision : J3
Date : 4/6/02
2
Exercices :Miseenplacedunveilleur
Exercices :
Reprendre lexercice prcdent de mise en place dun formulaire
question-rponse et rorganiser le code de manire le rendre le
plus rutilisable possible.
Mise en application : faire en sorte que les saisies soient de la
forme:
cos 0.234
sin 0.254
....
(donc en gnral: fonction valeur_double) afcher le rsultat
du calcul (java.lang.Math).
Pour analyser la chane utiliser un
java.util.StringTokenizer. Pour raliser la transformation
chane->double voir classe java.lang.Double.
2
2/60
Rvision : J3
Date : 4/6/02
Rvision : J3
Date : 4/6/02
Processus lgers (threads) 3
Points essentiels:
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
3
3/62
Rvision : J3
Date : 4/6/02
Processus lgers (threads)
Multi-tches (rappel)
Comment un systme dexploitation permet-il davoir plusieurs tches
qui sexcutent en mme temps? Mme sil ne dispose que dun seul
processeur pour rellement excuter une tche, il est capable de donner
une illusion de paralllisme: pendant quil pilote une imprimante, il
continue dialoguer avec lutilisateur par exemple.
Dans un systme dexploitation multi-tches il y a plusieurs programmes
(processus) qui tournent en mme temps. Chacun excute un certain
code et dispose de ses donnes propres. Lillusion de lexcution en
parallle est obtenue en nexcutant une partie de code de chaque
processus que pendant un laps de temps trs court. Si chaque tche ne
voit son tour quune partie de son code excute on aura limpression
que plusieurs programmes sexcutent en parrallle.
A linterieur du systme lordonnanceur de tches a un rle essentiel :
cest lui qui dcide quel sera le processus actif un moment donn et
pour combien de temps.
Pour des raisons diverses il existe des algorithmes dordonnancement
diffrents selon les systmes : un algorithme de time-slicing alloue des
tranches de temps pratiquement quivalentes pour chaque processus,
dans dautres algorithmes un processus actif garde la main jusqu ce
quil se bloque sur un appel systme comme une opration dE/S.
Ces algorithmes sont complexes car ils tiennent compte de facteurs
supplmentaires comme des priorits entre processus.
3/63
Rvision : J3
Date : 4/6/02
3
Processus lgers: principes
Dans de nombreux systmes dexploitation modernes la notion de tche
est gre un niveau plus n. A lintrieur mme dun processus il existe
des processus lgers qui partagent les mmes donnes. Un mme
programme peut donc faire vivre plusieurs tches en son sein, et, le cas
chant, le systme est capable de ventiler ces tches sur plusieurs
processeurs.
Java intgre la notion de thread lintrieur mme du langage. Une fois
cre cette tche va disposer dune pile dexcution qui lui est propre et
partager des codes et des donnes des classes.
La J.V.M. dexcution pourra soit associer un thread Java un thread
systme soit elle-mme raliser un algorithme dordonnancement.
Pour permettre une grande souplesse dadaptation la spcication ne
place que trs peu de contraintes standard sur les comportements dun
thread. Le programmeur ne doit donc surtout pas faire dhypothses sur le
comportement de lalgorithme dordonnancement.
Voici un exemple de mauvaise conception:
// A PROSCRIRE !!!
Image img = getToolkit().getImage(urlImage) ;//dans un composant AWT
// mthode asynchrone: le chargement est ralis par une tche de fond
while(-1 == img.getHeight(this)) { /* rien : polling */ }
// tant que limage nest pas charge sa hauteur est -1
Ce programme ( proscrire!) est susceptible de tomber en marche sur
des systmes utilisant le time-slicing et ne fonctionne absolument pas sur
dautres (tout en touffant la C.P.U.!)
1
.
1. Lattente du chargement complet dune image (si elle est ncessaire) se fait
laide dun objet MediaTracker.
3
3/64
Rvision : J3
Date : 4/6/02
Conception dun Thread
On peut considrer que la classe Java Thread fournit un moteur qui
permet dexcuter une tche. Une instance de Thread va disposer de
caractristiques propres comme un nom permettant de lidentier ou une
priorit, mais surtout elle va fournir une pile dexcution pour drouler
un code.
Le code excut par le Thread est fourni par une autre classe qui ralise
le contrat dinterface Runnable au travers de sa mthode run().
import java.io.* ;
public class Compteur implements Runnable {
public final int max ;
public Compteur( int max){
this.max = max ;
}
public void run () {
for(int ix = 0 ; ix < max ; ix++) {
try {
File temp = File.createTempFile("cpt","");
System.out.println("#"+this+":"+temp);
temp.delete() ;
} catch (IOException exc){/*test */}
}
}// FIN DE TACHE
}
Ceci nous permet la dnition dune tche comme :
Thread tche = new Thread(new Compteur(33)) ;
Ici il sagit dune tche de dmonstration sans porte pratique (la
formule magique dans la boucle cre des chiers temporaires), mais le
fait de faire un appel systme lourd dans la boucle va probablement
mettre en lumire le comportement de lordonnanceur.
3/65
Rvision : J3
Date : 4/6/02
3
Cycle de vie : dbut et n de vie
Une fois cr le Thread est prt tre activ: ceci se fait par linvocation
de la mthode start()sur linstance
tche.start() ;
A partir de ce moment le code du run() est pris en charge par
lordonnanceur. En fonction des dcisions de lordonnanceur le Thread
passe par une srie dtats: par exemple actif (le code tourne) ou ligible
(le code ne tourne pas, mais lordonnanceur peut le ractiver tout
moment).
Quand le code du run() est puis (on arrive laccolade fermante de la
mthode) le Thread devient zombie: linstance du Thread existe
encore (jusqu ce quelle soit ventuellement rcupre par le garbage-
collector) mais on ne peut plus lui demander de re-excuter la tche
(IllegalThreadStateException).
Pour tester si un Thread est vivant :
if( tche.isAlive()) { ....
Cette mthode indique que start() a t excute et que linstance cible
nest pas devenue zombie.
Cette mthode nindique pas que le Thread tche est en tat actif (cest
le Thread demandeur qui excute le code qui est actif!).
Actif Eligible new mort
start()
Ordonnanceur
}//FIN DE TACHE
run() {
3
3/66
Rvision : J3
Date : 4/6/02
Point intermdiaire :lancement dethreads
Mini-exercice :
Reprendre le Thread Compteur dcrit prcdemment. Crer un
main qui lance plusieurs Compteurs en parallle et observer
lordonnancement (quel thread est actif quel moment).
3/67
Rvision : J3
Date : 4/6/02
3
Cycle de vie: retrait de ltat actif
Dans le code exctu par un thread il est possible de demander passer en
tat dinligibilit pendant un certain temps. Le code qui sexcute va
sinterrompre, et le thread est retir du pool des threads ligibles par
lordonnanceur:
public class Compteur2 implements Runnable {
public final int max ;
public Compteur2( int max){
this.max = max ;
}
System.out.println(#+this+:+ix);
try {
Thread.sleep(1000) ;
} catch (InterruptedException exc) {
...// message?
}
}
}// FIN DE TACHE
}
La mthode de classe Thread.sleep(long millis) rend le thread qui
lexcute inligible pendant au moins millis millisecondes.
On notera que cette mthode est susceptible de propager une exception si
on invoque sur linstance courante de ce thread la mthode interrupt().
La mthode de classe Thread.yield() permet au thread qui lexcute de
demander lordonnanceur de bien vouloir le faire passer ltat ligible.
Si il existe dautres threads de priorit au moins quivalente qui sont en
attente il est possible que lordonnanceur dcide de rendre un de ces
autres threads actif
2
.
2. Ceci ne garantit pas que le Thread qui excute yield ne sera pas
immdiatement reactiv par lordonnanceur. Ce dernier est matre de sa
stratgie, mme sil y a dautre threads ligibles il peut tout fait conserver le
Thread demandeur en activit puis nalement le dsactiver sur un appel
ultrieur de yield() (ou pour une autre raison).
3
3/68
Rvision : J3
Date : 4/6/02
Cycle de vie: attente de la terminaison dune tche
La mthode dinstance join() permet au Thread qui lexcute
dattendre la n de lexcution du Thread cible :
public class CompteurChaine extends Compteur{
private Thread autre ;
public CompteurChaine( int max, Thread autre){
super(max) ;
this.autre = autre ;// gag si on fait un cycle!
}
System.out.println(prt: + this ) ;
try {
autre.join() ;
} catch (InterruptedException exc) {/*test*/}
super.run() ; // mais oui! rien de magique
}// FIN DE TACHE
}
Le thread qui va excuter ce Runnable va attendre la n de lexcution du
Thread pass en paramtre pour excuter la suite du code.
3/69
Rvision : J3
Date : 4/6/02
3
Autres techniques de cration
On peut galement dnir une classe drive de Thread qui spcialise sa
propre mthode run().Ceci peut se produire lorsquon a besoin dun
thread avec un comportement spcique (ou aussi pour simplier
lcriture dun code):
public class UnThread extends Thread {
public void run() {
//qqch a excuter
}
}
Exemple:
Thread patience = new Thread() {
public void run() {
while(!isInterrupted()) {
System.out.print(.) ;
}
}
};
patience.start() ;
..... //on fait des tas de choses
patience.interrupt() ;
try {
patience.join() ;
} catch(InterrruptedException xc) { ...}
On notera galement deux mthodes intressantes en phase
dinitialisation:
setPriority(int prior): permet de xer la priorit du
Thread (une valeur comprise entre les constantes MIN_PRIORITY
et MAX_PRIORITY)
setDaemon(boolean b) : permet de spcier si le Thread est
un daemon ou un Thread utilisateur. La machine virtuelle
Java sarrte automatiquement quand les seuls threads actifs sont
des deamon.
3
3/70
Rvision : J3
Date : 4/6/02
Point intermdiaire :laviedesthreads
Mini-exercice :
Le Thread patience dans lexemple prcdent ne marche pas de
faon compltement satisfaisante. Le modier de faon ce quil
tente dalterner son excution avec le Thread principal qui la cr
(pour un test essayer par exemple que lun afche ping et lautre
pong -essayer dabord avec yield puis avec sleep -).
Vos conclusions?
3/71
Rvision : J3
Date : 4/6/02
3
Etats dun Thread (rsum)
Actif Eligible
En Attente
new mort
les dattente
(sera vu ultrieurement)
start()
Ordonnanceur
Thread.yield()
Thread.sleep() n attente
interruption autreThread.join()
3
3/72
Rvision : J3
Date : 4/6/02
Exercice :threads
Exercice:
Concevoir et raliser un composant Swing ImageAnimee :
un Thread permet de dclencher intervalles rguliers lafchage
successif des images dun tableau.
(Rechercher dabord le composant Swing qui va vous servir de
point de dpart, chercher dans la documentation comment
changer limage courante afche. Dans le main de test charger les
images depuis le systme de chier courant -nous verrons
ultrieurement une autre manire de recherhcer ces images-).
3/73
Rvision : J3
Date : 4/6/02
3
Complments
ThreadGroup
Les threads dune application peuvent directement interagir entre eux. En
pratique on peut limiter ces interactions en partitionnant lapplication en
groupes de Threads ThreadGroup.
Les ThreadGroups sont organiss de manire hirarchique. Un Thread
dans un ThreadGroup pourra obtenir des informations uniquement sur
son groupe (voir mthode checkAccess()).
Des mthodes comme setDaemon(bool) ou setMaxPriority(pri)
permettent de xer des caractristiques globales au groupe (et
eventuellement transmises aux sous-groupes crs ). De la mme manire
linvocation de interrupt() permet de diffuser une demande
dinterruption aux Threads et sous-groupes du groupe.
Une possibilit intressante est de crer une classe drive de
ThreadGroup et de rednir sa mthode
uncaughtException(Thread, Throwable): on peut ainsi mettre en
place un traitement par dfaut des exceptions qui remontent la pile et qui
nont pas t captures (pour un traitement dcent Voir Rapports,
journalisations, assertions, page 141. ).
3
3/74
Rvision : J3
Date : 4/6/02
Variables partages lies un Thread
Dans certaines situations on peut avoir besoin dune variable partage qui
ne soit pas lie une classe (membre static de classe) mais lie un
contexte de thread. Typiquement une telle variable pourrait tre un
identiant de session utilisateur sur un serveur: un ensemble de codes
pourraient avoir besoin dune variable partage qui soit spcique au
thread qui les excute.
Pour rpondre cette situation on peut mettre en place un objet partag
de type ThreadLocal.
public class Session {
public static ThreadLocal uid = new ThreadLocal() ;
...
}
public class TacheUtilisateur implements Runnable {
Utilisateur ut ;
public TacheUtilisateur(Utilisateur u) {
ut = u ;
}
public void run() {
Session.uid.set(ut) ;
....
}
}
et maintenant dans un code de lapplication:
utilisateurCourant= (Utilisateur) Session.uid.get();
Des threads crs par un Thread principal peuvent hriter des valeurs
partages de niveau Thread en utilisant un objet
InheritableThreadLocal.
3/75
Rvision : J3
Date : 4/6/02
3
Images de la mmoire
Le partage de donnes par plusieurs threads pose des problmes
compliqus (voir blocs synchronized dans la leon suivante). Il faut
savoir quen Java les variables sont stockes dans une mmoire principale
qui contient une copie de rfrence de la variable. Chaque Thread
dispose dune copie de travail des variables sur lesquelles il travaille. Les
mises jour rciproques de ces versions dune mme variable reposent
sur des mcanismes complexes qui sont dcrits dans le chapitre 17 de JLS
(spcication du langage). Il faut comprendre que ce modle permet des
ralisations trs performantes en laissant une grande libert aux
compilateurs/excuteurs et permet au maximum dutiliser des registres,
les instructions en tunnel des processeurs, etc.
Les blocs synchronized dcrits dans prochaine leon ont pour effet de
mettre en place des barrires qui forcent ces mises jour. En dehors de ces
blocs il est possible de forcer des rconciliations de valeurs en dclarant
des variables membres comme volatile .
public class Partage {
public volatile int valeurCourante;
}
Dans ce cas un Thread sait que lorsquil prend une copie de cette
variable sa valeur peut subir des modications et les compilateurs doivent
sinterdire certaines optimisations. Les lectures et critures de ces
variables suivent donc un protocole particulier.
3
3/76
Rvision : J3
Date : 4/6/02
Rvision : J3
Date : 4/6/02
Accs concurrents 4
Points essentiels
Dans la mesure o lon ne contrle pas compltement lordonnancement
des tches qui agissent en parallle, il peut savrer ncessaire de contrler
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 Threads 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 un le
dattente o il attendra une notication dun autre Thread qui
rend la ressource disponible (mcanisme wait/notify).
4
4/78
Rvision : J3
Date : 4/6/02
Accs concurrents
Accs concurrents: problmatique
Imaginons une classe grant une pile dobjets (ceci nest quun exemple: il
serait inutile dcrire un tel code puisquune classe existe
java.util.Stack!)
class MaPile {
... // code divers dont dfinition de MAX
private Object[] tb = new Object[MAX] ;
private int idx = 0 ;
public void push(Object obj) {
//on suppose que lon traite le pb de la taille
...
tb[idx] = obj ;
this.idx++ ;
}
public Object pop() {
// on suppose quon empche
// de dpiler une pile vide (exception)
....
this.idx-- ;
return tb[idx] ;
/* autre version avec mnage mmoire
* Object res = tb[idx] ;
* tb[idx] = null ;
* return res ;
*/
}
....// autre codes dont par ex. la taille de la pile
}
Notons quaprs chaque appel lindex idx indique le premier
emplacement disponible dans le tableau pour mettre un nouvel objet.
Et maintenant tudions ce qui se passerait si plusieurs threads pouvaient
faire des demandes la mme instance de MaPile (souvenons nous que
nous ne sommes pas matre de lordonnancement des threads).
4/79
Rvision : J3
Date : 4/6/02
4
Accs concurrents
Dans ce scnario (et bien dautres), on arrive un tat incohrent de
linstance!
Ici le problme vient du fait que les deux membres tb et idx de
linstance participent un tat cohrent : si lun est modi il doit tre
garanti que lautre est modi en consquence. On a ici des blocs de code
tels que : lorsquun thread a commenc une excution il faut garantir que
le mme thread sera seul autoris agir dans ce bloc.
Pour traiter ce problme on a mis en place en Java un mcanisme de
moniteur.
tat de linstance x ThreadA ThreadB autres Threads
idx== 3
x.push(obj1){
tb[3] = obj1 ;
tb[3] == obj1
x.push(obj2){
tb[3] = obj2 ;
this.idx++ ;
tb[3] == obj2
idx ==4
autres activits
this.idx++
tb[3]== obj2
//obj1 perdu
tb[4] == ?
idx == 5
}
4
4/80
Rvision : J3
Date : 4/6/02
Accs concurrents
Blocs synchronized
Reprenons partiellement le code prcdent et dotons une partie du code
dun bloc qui permette de protger une partie du code contre des accs
concurrents intempestifs:
class MaPile {
... // code divers dont dfinition de MAX
private Object[] tb = new Object[MAX] ;
private int idx = 0 ;
public void push(Object obj) {
//on suppose que lon traite le pb de la taille
...
synchronized(this){
tb[idx] = obj ;
this.idx++ ;
}
}
En Java tout objet est dot dun moniteur : cest un dispositif qui gre un
verrou et des les dattente daccs ce verrou.
Ici le bloc synchronized est rattach lobjet courant : tout thread qui va
chercher entrer dans le bloc devra tenter dacqurir le verrou ou restera
bloqu en le dattente en attendant son tour dacqurir le verrou
4/81
Copyright Sun Educational Services Rvision : J3
Rf. Sun : SL275+ Date : 4/6/02
4
Accs concurrents
Blocs synchronized
Dans ce scenario:
Le thread A demande le premier le verrou sur linstance courante
et lacquiert. Mme sil nest plus actif il conserve le verrou. Quand
il redevient actif il sort du bloc et relache le verrou.
Le thread B tente dacqurir le verrou, il passe en le dattente et
ne peut plus tre ligible tant quil nest pas sorti de la le. Quant
il est lu il acquiert automatiquement le verrou quil a demand.
tat de linstance x ThreadA ThreadB autres Threads
idx== 3
x.push(obj1){
tb[3] = obj1 ;
tb[3] == obj1
x.push(obj2){
tb[3] = obj2 ;
this.idx++ ;
autres activits
this.idx++
}
autres activits
synchronized(this)
synchronized(this)
bloqu! inligible
idx == 4
...//autre code
lu
tb[4] == obj2
idx == 5
}
ligible
4
4/82
Rvision : J3
Date : 4/6/02
Accs concurrents
Autres points sur lutilisation du moniteur
Tous les codes qui manipulent le mme ensemble de valeurs qui
doivent rester cohrentes doivent imprativement se synchroniser
sur le mme moniteur. Donc pour complter le code prcdent il
faut aussi:
public Object pop() {
....
synchronized(this) {
this.idx-- ;
return tb[idx] ;
}
}
Normallement les blocs synchronized doivent tre les plus
troits possible et se concentrer juste sur le code critique. Toutefois
lorsque toute une mthode est synchronise sur linstance
courante, il et possible dadopter la dclaration suivante :
public synchronized void push(Object obj) {
...
}
public synchronized Object pop() {
...
}
Il nest pas toujours possible de choisir linstance courante comme
support du moniteur:
Le code peut contenir plusieurs combinaisons de membres
solidaires:
class EtatsMultiples {
Truc objetX;
int entierX;
Object moniteurPourX = new Object() ;
Machin objetY ;
int entierY ;
Object moniteurPourY = new Object() ;
4/83
Rvision : J3
Date : 4/6/02
4
Accs concurrents
On peut, par exemple, utiliser un objet pass en paramtre
dune mthode (voir rserve ci-aprs)
static Comparable[] trier(Comparable[] tb) {
synchronized(tb) {
// suppose que tout utilisateur de ce tableau
// soit au courant! et fait lui mme appel
// au moniteur avant daccder
..... // re-arranger les lments du tableau
return tb; // sort du bloc synchronized
Java ne dtecte pas automatiquement les treintes mortelles
(deadlock). Si le code excut par un Thread A acquiert un moniteur
X, puis tente dacqurir un moniteur Y, si un Thread B a acquis Y et
tente dacqurir X tout est bloqu! A moins davoir une mauvaise
conception il est peu probable que ce code soit crit dans la classe
EtatsMuliples ci-dessus, mais pour un moniteur partag entre
plusieurs classes (pass en paramtre par exemple) le risque existe.
Une mthode de classe peut tre synchronized: le moniteur
utilis est le champ statique .class de la classe courante (objet
de type Class). Dans un code static il est bien sr possible de
se synchroniser sur une variable partage.
Classiquement un systme de verrou est source de problmes de
performance ( la fois pour des raisons lies au droulement de
lapplication et des raisons lies aux performances intrinsques
des moniteurs). Il faut donc faire attention. Typiquement les
classes de collection du package java.util ne sont pas
synchronises : on peut transformer une collection avec
Collections.synchronizedCollection(Collection),
mais on a aussi des stratgies optimistes qui permettent de
parcourir une collection non synchronise avec un iterateur et
dtre averti si une modication intempestive se produit
(ConcurrentModificationException).
Pour tester si le Thread courant a acquis le verrou sur un objet
donn :Thread.holdsLock(objet) ; (essentiellement utile pour
vrier des prconditions).
4
4/84
Rvision : J3
Date : 4/6/02
Accs concurrents
Point intermdiaire :blocssynchronized
Mini-exercice :
Reprendre lexercice pingPong prcdent (Mini-exercice :,
page 70) et faire en sorte que chaque fois quun des threads
commence afcher un Ping (ou un Pong) il soit garanti quil
puisse afcher 5 fois le mme message conscutivement.
(exemple : 5 Pings, 5 Pongs, 5 Pings, 5 Pings, etc...)
-bien choisir lobjet support de la synchronisation-
4/85
Rvision : J3
Date : 4/6/02
4
Accs concurrents
4
4/86
Rvision : J3
Date : 4/6/02
Accs concurrents
Producteur/consommateur: problmatique
Imaginons maintenant que nous crivions le code dune classe contenant
des objets et fonctionnant en le FIFO (First In First Out). Nous pourrions
ici faire usage dune des classes ArrayList ou LinkedList de
java.util. Ces collections ordonnes ont la particularit dassurer la
contiguit de leurs lments : on peut toujours rajouter un lment en n
et quand on prend le premier lment de la liste, le second devient le
premier, etc.
public class FIFO {
private ArrayList liste = new ArrayList();
public Object prendre() {
return liste.get(0) ;
}
public void poser(Object obj) {
liste.add(obj) ;
}
}
Maintenant un objet de cette classe va tre partag par plusieurs threads:
certains remettent dans la le des objets dont ils nont plus besoin,
dautres viennent chercher un objet pour lutiliser.
Le code de cette classe pose un problme pour le thread preneur: si le
stock dobjets est vide, dune part, la mthode get propage une exception
(quil va falloir traiter) et, dautre part, il va falloir attendre quun autre
thread veuille bien remettre un objet dans le stock. On ne peut pas
imaginer une boucle innie qui teste sans arrt la taille de la liste
(polling)!.
Il nous faut ici un mcanisme tel que le thread preneur affam (qui se
trouve face une ressource vide) puisse passer dans un tat dinligibilit
qui durera tant quun thread fournisseur na pas signal explicitement
quil a effectivement dpos un Objet.
Ici aussi le mcanisme du moniteur va tre mis contribution, un objet
(linstance courante) va servir de support un dispositif de coordination
entre threads.
4/87
Rvision : J3
Date : 4/6/02
4
Accs concurrents
Producteur/consommateur: mise en oeuvre
Reprenons le code prcdent pour quil assure une coordination entre
producteurs et consommateurs:
public class FIFO {
public synchronized Object prendre() {
while( 0 == liste.size()) {
try {
this.wait() ;
// on peut toujours logger!
}
}
}
public synchronized void poser(Object obj) {
this.notify() ;
liste.add(obj) ;
}
}
Le principe gnral est le suivant :
si la liste est vide les threads affams vont se mettre dans un pool
associ linstance courante. La mthode wait() met le thread qui
lexcute dans ce pool.
un thread qui vient dposer un objet signale que les threads en
attente peuvent redevenir ligibles pour aller rechercher un objet
dans le stock. Il excute sur lobjet support du moniteur la
mthode notify() .
Ce code appelle de nombreuses remarques :
4
4/88
Rvision : J3
Date : 4/6/02
Accs concurrents
Producteur/consommateur: mise en oeuvre (suite)
public class FIFO {
public synchronized Object prendre() {
while( 0 == liste.size()) {
try {
this.wait() ;
// loguer ou
//grer des interruptions
}
}
}
public synchronized void poser(Object obj) {
this.notify() ;
liste.add(obj) ;
}
}
Les mthodes wait et notify (de Object) ne peuvent tre
appeles que si le thread courant a acquis le moniteur sur lobjet
concern. Bien que le compilateur ne vrie pas cette condition au
runtime on verrait apparatre une
IllegalMonitorStateException (thread not owner).
Bien entendu le bloc synchronized doit englober tout le code
fragile (ici par exemple il faut tre sr au moment du get(0)
que la liste na pas t modie - et vide!-).
Pour cette raison faire, dans lexemple, notify avant le add nest
pas incorrect!
wait() peut etre interrompu (voir mthode interrupt() ) et
exige donc dtre plac dans un bloc try-catch.
Le thread qui excute wait() est mis dans un pool dattente, quand
il en sort il revient dans le bloc synchronized et entre en
comptition avec dautres threads pour acqurir le verrou courant.
Il nest donc pas certain que la condition qui a accompagne le
notify soit encore remplie au moment o le thread acquiert enn
le verrou: le test sous forme while est obligatoire!
4/89
Rvision : J3
Date : 4/6/02
4
Accs concurrents
notify existe sous deux formes : notify() (un thread est pris
dans le wait-pool ) et notifyAll() (tous les threads du wait-pool
vont chercher acqurir le verrou). Noter que le choix dun
Thread particulier dans le pool est dpendant dune stratgie de
ralisation de la JVM: le programmeur ne doit donc pas faire
dhypothses ce sujet.
Invoquer notify() ou notifyAll() alors quil ny a aucun
thread dans le wait-pool ne prte pas consquence, on peut donc le
faire sans risque.
Il existe une version de wait qui permet de limiter le temps
dattente: wait(long attenteEnMillisecondes) . Bien
entendu la sortie on nest vraiment pas sr que la condition
attendue soit remplie!
4
4/90
Rvision : J3
Date : 4/6/02
Accs concurrents
Point intermdiaire :producteur-consommateur
Mini-exercice :
Reprendre lexercice prcdent (squence de 5 messages) et
sassurer que les messages vont alterner ( 5 pings, 5 pongs, etc.).
Alternativement chaque processus se mettra en veille pour ensuite
attendre que lautre le rveille.
(la solution est trs simple, mais nest pas immdiatement
vidente!).
4/91
Copyright Sun Educational Services Rvision : J3
Rf. Sun : SL275+ Date : 4/6/02
4
Accs concurrents
Etats dun Thread (rsum)
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.
Actif
Eligible
En Attente
new mort
start()
Ordonnanceur
yield()
sleep()/join() n attente
interruption
wait()
BLOC SYNCHRONIZED
pool
attente
notify()
notifyAll()
autres processus actifs
interrupt()
4
4/92
Rvision : J3
Date : 4/6/02
Accs concurrents
Exercice :threads
Exercice (au choix):
En utilisant la classe Fifo (vue prcdemment) concevoir une le
spciale qui contient des Threads (appellons la ThreadPool).
Ces threads sont particuliers :
leur mthode run() est une boucle innie
en dbut de boucle le thread se met de lui-mme dans le
ThreadPool et se bloque en attente.
maintenant lorsquon soumet un Runnable au ThreadPool,
Ce dernier retire un thread, le ractive et lui fait excuter la
mthode run du Runnable. Quand cette tche est termine le
thread se replace en dbut de boucle. etc.
(question subsidiaire: quoi peut servir ce dispositif?)
Reprendre le composant ImageAnimee ( Exercice:, page 72) et
faire en sorte que lon puisse suspendre lanimation, la reprendre
et,ventuellement, larrter dnitivement.
Lire dabord suspend, resume, stop, page 93, on procdera alors
de la manire suivante :
dnir un type de Thread spcial appel Trame
Cette Trame dispose de mthodes qui sont appeles par
dautres threads : suspendRequest(), resumeRequest(),
stopRequest() . Ces mthodes ont des effets sur linstance
courante qui seront pris en compte par une mthode going()
qui permet au thread courant de savoir sil peut continuer
travailler, ou sil doit se bloquer en attente dune demande de
continuation (ou darrt).
Utiliser une instance de Trame pour animer ImageAnimee.
(question subsidiaire: cette conception prsente un dfaut majeur,
lequel?).
4/93
Rvision : J3
Date : 4/6/02
4
Accs concurrents
Complments
Excution des constructeurs
Le code dun constructeur ne peut pas tre synchronized : il nest
excut que par un seul thread pour la cration dun objet donn et,
normalement, une rfrence sur lobjet en construction ne devrait pas tre
rendue avant la n de lexcution du constructeur.
Il reste quil y a, potentiellement, quelques situations dangereuses: passer
une rfrence sur lobjet courant dans le code dun constructeur
(enregistrement dun callback par exemple) risque doffrir un accs
linstance avant que celle-ci ne soit dans un tat cohrent! Le danger vient
de lemploi dans le constructeur de mthodes qui cachent le fait quelles
passent this dautres objets: lexemple le plus courant se trouve dans
les constructions de hirarchies (exemple: hirarchies
Container/Component en AWT).
suspend, resume, stop
Dans des versions prcdentes de Java il existait des mthodes qui
permettait un Thread dagir de lextrieur sur un autre Thread.
Ces mthodes (suspend() pour suspendre lactivit, resume() pour
faire repartir le thread suspendu, stop() pour arrter le thread) ont t
rendues obsolete (deprecated) car le thread demandeur ignorait tout de
laction courante du thread cible et cela tait susceptible de provoquer des
catastrophes. Pour plus de dtails lire:
docs/guide/misc/threadPrimitiveDeprecation.html.
La mthode interrupt() reste, elle, intressante pour rveiller des
threads abusivement somnolents.
4
4/94
Rvision : J3
Date : 4/6/02
Accs concurrents
Rvision : J3
Date : 4/6/02
Deuxime partie: ressources
.
/96
Rvision : J3
Date : 4/6/02
Rvision : J3
Date : 4/6/02
Archives, ressources, scurit 5
Points essentiels
Le dploiement professionnel dune application ne saurait se rduire
une simple installation dun ensemble de rpertoires et de chiers
binaires. Nous allons voir quelques techniques simples de dploiement
archives Jar
ressources applicatives
contraintes de scurit
5
5/98
Rvision : J3
Date : 4/6/02
Archives, ressources, scurit
Les ClassLoaders
Un programme java a la particularit dtre un assemblage dynamique
de codes. O la machine virtuelle trouve-t-elle ces codes? :
Dans les librairies Java du runtime (JRE). Ce sont les librairies
bootstrap de Java qui font partie de linstallation de la machine
virtuelle.
Dans les extensions installes de Java. (a priori des librairies
standard installes dans le sous-rpertoire jre/lib/ext de
linstallation du SDK)
Dans les codes applicatifs qui sont les codes vus par le
CLASSPATH au moment du lancement de la machine virtuelle.
Dans certaines documentations ces codes sont improprement
qualis de codes systme.
Les codes java sont chargs par des ClassLoaders. Les ClassLoaders
ont une organisation hirarchique : une classe reconnue par le
ClassLoader pre est toujours charge en priorit ; comme le
ClassLoader primordial (bootstrap) est pre de tous les autres on ne peut
donc pas charger une classe qui porterait le mme nom quune classe Java
fondamentale.
En cours dexcution dautres ClassLoaders peuvent tre crs pour
mettre en oeuvre des techniques de chargement spciques (par exemple
pour charger des codes au travers du rseau), et pour crer des espaces de
gestion de classes lies une origine de code (scurit).
La mthode statique ClassLoader.getSystemClassLoader()

retourne le ClassLoader racine des applications.
ClassLoader bootstrap (null)
ClassLoader extensions
ClassLoader applicatif racine
5/99
Rvision : J3
Date : 4/6/02
5
Archives jar
Le ClassLoader applicatif sait retrouver des classes dans une arborescence
de chiers: dans une liste de rpertoires qui constituent le classpath il
cherche un sous-rpertoire fr.acme pour trouver la classe
fr.acme.Truc. Pour simplier notablement la mise en place des
librairies qui constituent une application les classes peuvent tre
dployes dans des archives JAR.
Le lancement dune application peut alors ressembler ceci :
java -cp /opt/gib/rt.jar:/opt/gib/graph.jar fr.gibis.MonAppli
// lapplication utilise 2 archives pour ses classes
Une archive Jar est un sur-ensemble des chiers ZIP et contient de
manire compresse une reprsentation dune arborescence de chiers.
Exemple de fabrication dune archive jar:
jar cvf appli.jar fr
Ici la commande a t lance dans le rpertoire classes, larchive jar a
cr en son sein un rpertoire supplmentaire (META-INF) qui contient
un chier manifeste contenant des meta-informations sur le contenu de
larchive.
classes\
fr\
gibis\
pack1\ pack2\ MonAppli.class
ClassX.class ClassY.class
fr\
gibis\
appli.jar
\
META-INF\
MANIFEST.MF
5
5/100
Rvision : J3
Date : 4/6/02
On peut aussi recomposer une archive partir des plusieurs parties
darborescence situes dans des rpertoires diffrents:
jar cvf appli.jar -C classes fr/gibis/pack1 -C media images/gif
Pour lister le contenu dun jar :
jar tvf appli.jar
Pour complter un jar existant (update):
jar uvf appli.jar images/jpeg
classes\
fr\
gibis\
media\
images\
gif\
sons\
jpeg\
img.gif
fr\
gibis\
pack1\
ClassX.class
\
META-INF\
MANIFEST.MF
images\
gif\
img.gif
appli.jar
5/101
Rvision : J3
Date : 4/6/02
5
Archives jar: lancement dune application
Lutilisation darchive jar simplie le dploiement, et permet aussi
damliorer les performances de chargement: si des codes de classes sont
distants -comme dans le cas dune applet- les classes sont charges en une
seule opration. Par ailleurs il est galement possible de mettre une
application autonome dans un chier jar. Il faut crer le chier jar en
initialisant lentre Main-Class du chier Manifest. Exemple : soit le
chier monManifeste :
(noter la ligne vide en n de chier -obligatoire-)
Cration du chier jar :
jar cvfm appli.jar monManifeste -C classes fr/gibis
Lancement de lapplication :
java -jar appli.jar
Dans de nombreux systmes de fentrage un simple double-click sur
licne dun chier jar permet de dmarrer lapplication ( condition que
le champ Main-Class ait t renseign)
Main-Class: fr.gibis.MonAppli
5
5/102
Rvision : J3
Date : 4/6/02
Point intermdiaire :pratiquedesarchivesJ ar
Mini-exercice :
Reprendre une des applications graphiques prcdentes utilisant
des packages et plusieurs classes. Fabriquer une archive Jar
Lancer lapplication depuis cette archive.
5/103
Rvision : J3
Date : 4/6/02
5
Ressources
A lexcution un programme Java peut avoir besoin dautres chiers que
des chiers .class, par exemple:
des chiers images (ou son!)
des chiers texte (messages, conguration, ...)
etc....
On qualie globalement ces chiers de ressources . Les ressources sont
ncessaires lexcution et sont lies des codes qui les exploitent. En
termes de dploiement il faut donc faire en sorte quelles soient prsentes
et que les codes sachent les rechercher.
Il faut savoir distinguer les ressources propres lenvironnement (lies
la JVM, au site local, lutilisateur) et les ressources lies au programme
lui-mme.
Ces distinctions ne sont pas videntes car un programme peut
avoir besoin de ressources de conguration, de paramtrisation
dont le principe est dni par un programme, mais qui sont
fournies par lenvironnement (par ex. gnres ou dcrites
localement et installes indpendament du Jar principal de
lapplication).
Voici par exemple un lancement dune application dans lequel on
passe des informations aux classes systme:
java -Djava.security.policy=sec.policy -jar appli.jar
(nous allons voir ultrieurement les chiers de conguration de
scurit qui sont utiliss dans cet exemple: ici le chier est situ
dans le rpertoire de lancement de lapplication).
Un autre exemple pourrait tre la paramtrisation dune Applet
au moyen des balises param et dune mthode comme
getDocumentBase().
5
5/104
Rvision : J3
Date : 4/6/02
Ressources applicatives
Dans leur principe les ClassLoaders peuvent accder aux classes par
des moyens trs divers (y compris au travers du rseau) il est donc
naturel quils aient emprunt au monde internet la notion dURL
(Uniform Resource Locator). Un ClassLoader standard
java.net.URLClassLoader fait trs spciquement rfrence ce
concept. Or le mcanisme qui sert rechercher une classe peut aussi tre
utilis pour des ressources applicatives lies aux classes qui les utilisent.
Do une notion importante : si une ressource est dploye avec une
classe on peut la rfrencer par une URL dduite de celle de la classe.
import java.net.URL;
import java.awt.* ;
public class PanelImage extends JPanel {
static Class maClasse = PanelImage.class ;
// au runtime : this.getClass()
public PanelImage(String nomImage) {
super(new BorderLayout()) ;
URL url = maClasse.getResource(nomImage) ;
if(null != url) {
add(new JLabel(new ImageIcon(url)),
BorderLayout.EAST);
}
}
}
Dautres mthodes ou constructeurs de Java utilisent des URLs:
getImage() (de Applet et de java.awt.Toolkit), mthodes
dAudioClip de Applet, de javax.imageio.ImageIO, ... La
technique la plus gnrale est celle des InputStreams (obtenus par
getResourceAsStream() -voir leon sur les ots dentre/sortie-.
On notera que lorsquune classe du bootstrap ClassLoader demande une

ressource elle va, en fait, faire appel au ClassLoader racine au travers
de ClassLoader.getSystemResource().
5/105
Rvision : J3
Date : 4/6/02
5
Point intermdiaire :ressourcesapplicatives
Mini-exercices :
Fabriquer un Jar comprenant un sous-rpertoire images la
racine (ce rpertoire contenant une image).
Utiliser une de ces images dans une des applications graphiques
prcdentes..
Attention: la formulation de largument de getResource() nest
pas triviale -bien lire la documentation-
Pour les trs rapides (ou ceux qui rvisent) :
Reprendre lexercice mais imaginer que les images ne sont pas
installes dans le jar des classes, mais sont dans un autre jar
fabriqu sur le site au moment du dploiement. Que feriez-
vous? Exprimentez. Quelles sont les limitations de scurit? (
voir aprs avoir suivi la suite du chapitre)
(pour ceux qui connaissent le principe des Properties) Mme
problmatique pour lire un chier de proprits par la
mthode load(InputStream) de
java.util.Properties.
5
5/106
Rvision : J3
Date : 4/6/02
Scurit
A partir dune application on peut mettre en place des ClassLoaders
chargeant des classes distance au travers du rseau
1
. Ces codes posent
toutefois un problme important: quelle conance peut-on leur faire? A
priori aucune:
Le ClassLoader doit vrier le pseudo-code
Les codes qui sexcutent ont des droits limits en ce qui concerne
leur interaction avec lenvironnement local, on leur applique une
politique de scurit par dfaut nomme Sandbox Security Policy.
Ces classes ne peuvent:
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 du code (ainsi une Applet peut ouvrir
une connexion avec son hte dorigine).
A partir de Java 2 on a dni un moyen standard de grer des politiques
personnalises en fonction de lURL dorigine des codes.
1. La technique dutilisation dun tel ClassLoader ne sera pas aborde ici. Nous
utiliserons de tels dispositifs de manire transparente(Applets, RMI,...)
5/107
Rvision : J3
Date : 4/6/02
5
Scurit: politique con gure
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 site dans chier
$JAVA_HOME/lib/security/java.policy :
grant codeBase "file:${java.home}/lib/ext/-" {
permission java.security.AllPermission;
};
//illustre les droits des extensions installes
Politique propre un utilisateur dans le chier .java.policy de son
rpertoire daccueil:
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)
5
5/108
Rvision : J3
Date : 4/6/02
Scurit: politique con gure
Il est possible de dclencher les contrles de scurit sur une application
autonome en la lanant avec un SecurityManager:
java -Djava.security.manager MonApplication
La scurit distingue les classes ables (proprit
java.sys.class.path) des autres classes soumises aux contrles de
scurit (proprit java.class.path).
Ds quune application met en oeuvre un SecurityManager
(directement ou travers la mise en place dun chargement distance) 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
5/109
Rvision : J3
Date : 4/6/02
5
Point intermdiaire :congurationscurit
Mini-exercices :
Sur les bases de linterface-graphique Question/Rponse
(Exercices :, page 59) raliser un code qui tente dafcher une
proprit systme (System.getProperty). Le tester sous
SecurityManager avec des proprits critiques comme la
proprit user.home de lutilisateur (capter la
SecurityException!). Mettre en place une conguration de
scurit qui permette cet afchage. Utiliser:
permission java.util.PropertyPermission "user.home", "read" ;
Dans le cas dune Applet pour passer un chier spcique de
conguration de scurit au logiciel de test appletviewer:
appletviewer -J-Djava.security.policy=my.policy MyApplet.html
5
5/110
Rvision : J3
Date : 4/6/02
Complments
Autres services sur les archives Jar
Voir la documentation <install_java>/docs/guide/jar/jar.html
et en particulier :
Description dans le Manifeste de packages complets (attribut
Sealed:): toute classe du package marqu Sealed sera alors
ncesssairement contenue dans le jar courant. Ceci permet de bien
grer la consistance dune distribution et de sa version et
damliorer les contraintes de scurit,
Description dans le Manifeste des informations de version du
package. Ces informations peuvent tre ventuellement exploites
par programme, pour sassurer des compatibilits de
comportement. (rappel: en Java le package est lunit indivisible
de livraison et de version des APIs -versions vues du point de vue
utilisateur de lAPI-).
Mise en place dun class-path auxiliaire des classes
dpendantes du jar courant et mise en place dun index
doptimisation (jarindex) pour optimiser le chargement des
archives jar dpendantes du jar courant.
5/111
Rvision : J3
Date : 4/6/02
5
Manipulations des certi cats de scurit
Voici un exemple simple de cration et de gestion des certicats de
scurit :
Soit une Applet nomme SnoopApplet.java et qui lit la proprit
user.home de lutilisateur de lApplet. Normalement la consultation de
cette valeur est interdite, on va donc crer une ressource de scurit
(chier .java.policy) qui autorise un serveur particulier (celui de la
socit acme.fr) raliser cette opration.
Le serveur va adresser un chier jar sign au client. Cette signature
sopre avec la clef priv de la socit ACME. Par ailleurs ACME met la
disposition du client sa Clef publique qui permettra au client
dauthentier larchive jar.
Le serveur met la disposition du client un Certicat qui contient les
informations ncessaires. Ce certicat est stock localement dans une
ressource (keystore). Lobtention du certicat peut se faire de diverses
manires (par ex. transaction avec une tierce partie qui se porte garante
du serveur).
5
5/112
Rvision : J3
Date : 4/6/02
Gnrationducerticat (cotserveur) :
Ici on supposera que cest le serveur lui-mme qui fabrique le certicat , il
va gnrer ses clefs publiques/clefs privs et va stocker le rsultat dans
une base locale (keystore), ce certicat est connu sous lalias
acmeserver:
$ keytool -genkey -alias acmeserver
Enter keyStore password : 14juillet
What is your first and last name?
[Unknown]: Jean Dupond
What is the name of your organizational unit?
[Unknown] : service informatique
What is the name of your organization?
[Unknown]: ACME France
What is the name of your City or Locality?
[Unknown]: Toulouse
What is the name of your State or Province?
[Unknown]: Midi-Pyrenees
What is the two-letter country code for this unit?
[Unknown]: FR
Is <CN=Jean Dupond, OU=service informatique, O=ACME France,
L=Toulouse,ST=Midi-Pyrenees, C=FR>
correct?
[no]: yes
Enter key password for <acmeserver>
(RETURN if same as keystore password) acme14
On notera que laccs la base et au certicat sont protgs par des mots
de passe.
5/113
Rvision : J3
Date : 4/6/02
5
Consultationdelabasedescerticats(cotserveur):
$ keytool -list
Enter keystore password: 14juillet
Keystore type: jks
Keystore provider: SUN
Your keystore contains 1 entry:
acmeserver, Tue Mar 09 17:21:07 CET 1999, keyEntry,
Certificate fingerprint (MD5):
ED:55:F3:0D:E4:A1:13:A3:BE:34:AB:7D:DE:BF:C8:B3
Signaturedelarchivejar (cotserveur) :
$ jarsigner snoop.jar acmeserver
Enter Passphrase for keystore: 14juillet
Enter key password for acmeserver: acme14
Contenudelarchivejar :
Dans le rpertoire META-INF de larchive on trouve les chiers :
MANIFEST.MF
ACMESERV.SF
ACMESERV.DSA (donnes)
Manifest-Version: 1.0
Created-By: 1.2 (Sun Microsystems Inc.)
Name: sl275/secur/SnoopApplet.class
SHA1-Digest: wrvJn8RFHRxB5RilIcYNdNRFCSM=
Signature-Version: 1.0
SHA1-Digest-Manifest: 1gAPmlinU6BRogZ5VF0smNXfAVg=
Created-By: 1.2 (Sun Microsystems Inc.)
Name: sl275/secur/SnoopApplet.class
SHA1-Digest: +QoJQIt14oTI8v+AmbD4X7q1BIE=
5
5/114
Rvision : J3
Date : 4/6/02
Exportationduncerticat dansunchier (fournisseur de
certicat) :
$ keytool -export -alias acmeserver -file acmeserver.certificate
Enter keystore password: 14juillet
Certificate stored in file <acmeserver.certificate>
I mportationduncerticat depuisunchier (cotclient) :
$ keytool -import -alias acme -file acmeserver.certificate
Enter keystore password: client14
Owner: CN=Jean Dupond, OU=Service informatique, O=ACME France,
L=Toulouse,ST=Midi-Pyrenees, C=FR
Issuer: CN=Jean Dupond, OU=Service informatique, O=ACME France,
L=Toulouse,ST=Midi-Pyrenees, C=FR
Serial number: 36e54a23
Valid from: Tue Mar 09 17:19:47 CET 1999
until: Mon Jun 07 18:19:47 CEST 1999
Certificate fingerprints:
MD5: ED:55:F3:0D:E4:A1:13:A3:BE:34:AB:7D:DE:BF:C8:B3
SHA1:
C8:E3:54:FD:2C:BA:76:12:27:97:90:FC:BE:47:90:20:59:82:7A:A5
Trust this certificate? [no]: yes
Certificate was added to keystore
Nota: lalias local du certicat peut tre diffrent de lalias original (acme au lieu de
acmeserver dans lexemple). La base et ses mots de passe est bien sr diffrente.
5/115
Rvision : J3
Date : 4/6/02
5
Contenudelabasedescerticats(Cotclient) :
$ keytool -list
Enter keystore password: client14
Keystore type: jks
Keystore provider: SUN
Your keystore contains 1 entry:
acme, Wed Mar 10 17:44:47 CET 1999, trustedCertEntry,
Certificate fingerprint (MD5):
ED:55:F3:0D:E4:A1:13:A3:BE:34:AB:7D:DE:BF:C8:B3
Politiquedescurit(cotclient) :
Fichier .java.policy
Lutilitaire policytool peut permettre de spcier cette politique de
scurit.
On notera que le chier dcrit lemplacement de la base des certicats
(avec une URL).
Toute classe authentie situe dans larchive jar dont la signature
correspond celle dsigne par lalias acme aura la possibilit de
provoquer une lecture de la proprit user.home.
keystore "file:/home/leclient/.keystore" ;
grant signedBy "acme" {
permission java.util.PropertyPermission "user.home","read";
} ;
5
5/116
Rvision : J3
Date : 4/6/02
Autres aspects de la scurit
De manire gnrale les aspects scurit sont approfondis dans notre
cours SL-303. Quelques points toutefois:
Les permissions accords un code au moment de lxcution
dpendent des permissions accords aux autres codes appels
dans la pile dexcution. Ainsi un code relativement privilgi ne
peut accder des services qui sont refuss son code appelant.
Dans certains cas ce code peut accorder au code appelant des
privilges qui lui sont attachs : voir documentation de java
docs/guide/security/doprivileged.html
Les conguration de scurit abords ici concernent les droits
accords des codes; pour des droits accords des utilisateurs
voir JAAS
(docs/guide/security/jaas/tutorials/index.html)
Rvision : J3
Date : 4/6/02
Internationalisation 6
Points essentiels
Linternationalisation est un cas particulier dexploitation des ressources.
Java dispose dun ensemble de mcanismes prdnis :
Dnition dun contexte culturel: java.util.Locale
Mise en place dun mcanisme abstrait de recherche de ressources:
ResourceBundle
Classe de formattage (mise en forme, analyse) dans le cadre de
conventions dpendantes de la culture locale.
6
6/118
Rvision : J3
Date : 4/6/02
Internationalisation
Pourquoi internationaliser une application?
Pourquoi internationaliser :
Traduire des messages/des interactions
(pouvoir dynamiquement dadapter la langue de lutilisateur)
Traduire des messages paramtrs ce rpertoire contient 1000
chier(s)
Analyser/ afcher selon des conventions locales : formats de
nombres, dates, formats valeurs montaires
Savoir sadapter des ordres alphabtiques diffrents,
comparaisons de chanes.
Adapter automatiquement lordre de disposition de composants
(exemple: formulaires en arabe TextField de saisie situ
gauche du Label dinvite -document lu de droite gauche-)
Une application doit pouvoir sadapter automatiquement la langue de
lutilisateur (ou mme permettre des crans multilingues)
6/119
Rvision : J3
Date : 4/6/02
6
Contextes culturels : Locale
Les mcanismes de localisation du language Java utilisent une
information de contexte culturel dnie au moyen de la classe
java.util.Locale.
Locale : constructeurs, constantes
Locale(langue, pays)
Locale(langue, pays,variant)
new Locale(fr, CA) ; //franais du Canada
new Locale (fr,CA, WINDOWS) ;
new Locale (fr,FR, EURO) ;
// monnaie euro et franais de France
Les arguments langue (chane en minuscule) et pays (chane en
majuscules) obissent des standard de dsignation (voir documentation
et mthodes statiques getISOLanguages, getISOCountries).
La classe fournit galement des constantes prdnies :
// constantes de classe
Locale.FRENCH ; // Locale(fr,)
Locale.FRANCE ; // Locale (fr, FR)
Les objets Locale (et les dsignations associes comme la chane fr_FR)
permettront de crer des hirarchies de ressources:
1. Le Francais
2. Le Franais de Belgique
3. La belgique francophone avec lEuro comme monnaie
6
6/120
Rvision : J3
Date : 4/6/02
Contexte culturel: obtention, mise en place
Au moment o une JVM dmarre elle met en place un Locale par dfaut
(en fonction de paramtres de lenvironnement)
Locale local = Locale.getDefault(); // local
System.out.println(local.toString()) ;
//-> fr_FR : chane clef
System.out.println(local.getDisplayName());
// Franais (France)
System.out.println(Locale.ENGLISH.getDisplayName());
// Anglais
// on a traduit en franais le nom!
On peut positionner globalement cette valeur
(Locale.setDefault(locale)), mais il est plus pertinent de la xer
pour chacun des objets qui utilisent ces contextes dinternationalisation:
NumberFormat nbf = NumberFormat.getInstance(local) ;
// sert mettre en forme des nombres
// on cre un formatteur propre au contexte
Comment demander une classe les Locales quelle sait grer:
Locale[] locs = NumberFormat.getAvailableLocales();
On peut agir sur le Locale par dfaut au moment du lancement de la JVM

en modiant les proprits user.language, user.country,
user.variant.
Exemple: java -Duser.language=fr monpackage.MonProgramme
6/121
Rvision : J3
Date : 4/6/02
6
Paramtrage de ressources: Resourcebundle
La traduction (dun message par exemple) doit sappuyer sur des
ressources extrieures de paramtrage des applications.
Un mcanisme gnral est defni pour rechercher ces ressources de
localisation: les ResourceBundle. Quand on recherche lquivalent
localis dun objet on sadresse un mcanisme de ResourceBundle
dni autour dun thme.
Pour un thme donn on a conceptuellement un dictionnaire qui
associe une clef (unique) une valeur correspondante
Le rsultat de la recherche est en fait obtenu par la consultation
dune hirarchie de dictionnaires sufxs par les chanes
caractristiques des Locales. Ainsi par exemple pour un thme
libell Erreurs on pourra avoir :
Erreurs_fr_CA_UNIX // locale demand
Erreurs_fr_CA
Erreurs_fr
Erreurs_<Locale_par_dfaut>// obtenu par getDefault()
Erreurs_<Locale_par_dfaut_simplifi>
Erreurs
Une hirachie ne doit jamais avoir de maillon manquant (si fr_CH existe fr
et <rien> doivent exister) - on peut aussi construire des chanages
explicites (setParent())-
Un dictionnaire abstrait est obtenu par spcication du thme et du
Locale.
ResourceBundle messagesErreur =
ResourceBundle.getBundle(Erreurs ,locale) ;
// -> Exception MissingResourceException
La clef de recherche est une chaine. Selon les circonstances on pourra
utiliser:
messagesErreur.getObject(clef) // pourquoi pas un glyphe?
messagesErreur.getStringArray(clef)// ou un ensemble de chaines
messagesErreur.getString(clef) ;// ou, bien sr, une chane
6
6/122
Rvision : J3
Date : 4/6/02
ListResourceBundle
ResourceBundle est une classe abstraite qui peut connatre des ralisations
diverses. Deux systmes de spcications de ressources sont livrs en
standard : ListResourceBundle et PropertyResourceBundle.
Ces deux classes sont une illustration des priorits de recherche de
getBundle() : un niveau de la hirarchie des Locale la mthode
recherche dabord une classe portant le nom du niveau par exemple
Erreurs_fr.class (cette classe peut tre de type
ListResourceBundle) et ensuite un chier
Erreurs_fr.properties (chier permettant de construire
dynamiquement une instance de PropertyResourceBundle). Ces
ressources doivent se trouver dans le chemin daccs aux classes
(classpath) associ un ClassLoader donn.
Exemple de ListResourceBundle :
public class Erreurs_fr extends ListResourceBundle {
public static final Object[][] tb = {
{ "err" , new ImageIcon("erreur.gif")} ,
{ "ERR" , new ImageIcon("terreur.gif")} ,
} ;
public Object[][] getContents() { return tb ;}
}
La ralisation doit implanter la mthode getContents() et le tableau
retourn doit associer une clef (chane de caractre) et un objet.
Dans lexemple ci-dessus seul getObject() devra tre utilis.

6/123
Rvision : J3
Date : 4/6/02
6
PropertyResourceBundle
Un PropertyResourceBundle est un Bundle cr automatiquement
par exploitation dun chier .properties
Le format dun tel chier est dni pour la classe
java.util.Properties (voir mthode store() ou load() ;
# Errors_fr.properties
#Supposed to be translated in French ;-)
you\ stupid\!=\ A\u00EDe\! une erreur malencontreuse est survenue
Ill\ scream\!=patience, impossible nest pas fran\u00E7ais
exploitation :
ResourceBundle errs = ResourceBundle.getBundle(Errors) ;
...
String message = errs.getString(you stupid!) ;
// et, heureusement, fr est le contexte par dfaut
6
6/124
Rvision : J3
Date : 4/6/02
Point intermdiaire :MiseenplacedunBundle
Mini-exercice :
Reprendre linterface graphique Question/Rponse (Exercices
:, page 59) et modier la de manire ce que le message qui
annonce une erreur tienne compte de la langue de lutilisateur (il
ne sagit pas de traduire le message gnr par lexception, mais
uniquement le message annonant quil y a une erreur).
Tester en modiant le Locale par des proprits passes au
lancement de la machine virtuelle. Mettre les ressources de
traduction dans un jar constitutif du CLASSPATH.
6/125
Rvision : J3
Date : 4/6/02
6
Classes de mise en forme/analyse
Les objets de mise en forme en fonction du contexte culturel drivent de la
classe java.text.Format et disposent de mthodes de mise en forme
du type : String format(Object) et de mthodes danalyse de
chanes de caractres du type: Object parseObject(String) (et
mthodes spcialises drives).
Classes principales de mise en forme : NumberFormat, DateFormat,
MessageFormat.
Utilisation de formats numriques prd nis :
NumberFormat formatteur =
NumberFormat.getNumberInstance(Locale.FRANCE);
System.out.println(formatteur.format(345987.246));
Donne:
345 987,246
NumberFormat permet aussi de se procurer des instances mettant en
forme des montants montaires (avec mention de la monnaie locale) et
des pourcentages (voir aussi la classe Currency).
Analyse:
NumberFormat formch =
NumberFormat.getNumberInstance(new Locale("fr","CH"));
try{
Number nb = formch.parse("345987.246");
} catch (ParseException exc) {
...
parse tente de retourner un Long ou sinon un Double
Attention le sparateur des milliers en Franais est vu comme un blanc

dur par Java, lanalyseur ne sait pas traiter une espace normale.
6
6/126
Rvision : J3
Date : 4/6/02
Numriques avec instructions de formatage
La classe DecimalFormat (sous-classe de NumberFormat) permet de
controler la mise en forme :
NumberFormat formatteur =
NumberFormat.getNumberInstance(Locale.FRANCE);
DecimalFormat df = (DecimalFormat)formatteur ;
df.applyPattern("000,000.00") ;
//sparateurs US + indicateurs chiffres (0 si manquant)
System.out.println(df.format(5987.246));
Donne:
005 987,25
Discussions: quel est lintrt dune mthode fabrique comme
NumberFormat.getNumberInstance() ?
Du coup quelle est lanomalie conceptuelle dans le code ci-dessus?
6/127
Rvision : J3
Date : 4/6/02
6
Autres formats
DateFormat permet dobtenir des objets de mise en
forme/analyse des Dates , SimpleDateFormat et
DateFormatSymbols permettent de fabriquer des formats de
mise en forme de Dates.
MessageFormat et ChoiceFormat permettent de fabriquer des
messages composs de plusieurs lments paramtrables:
int nbfichiers = 10 ;// obtenu en fait par calcul
String nomFic = "prmtc34x5f" ; //;-) idem
String param ="Le disque {1} contient {0} fichier(s)" ;
// obtenu par exploitation dun Bundle
MessageFormat fmt = new MessageFormat(param) ;
System.out.println( fmt.format(new Object[] {
new Integer(nbfichiers),
nomFic ,
})); // tableau anonyme (idiome)
Donne
Le disque prmtc34x5f contient 10 fichier(s)
Utilisation dun paramtrage par exploitation de plages de valeurs
(ChoiceFormat)
param = "Le disque {1} {0}" ; // obtenu par le Bundle
MessageFormat fmt2 = new MessageFormat(param) ;
double[] limites = {0,1,2} ;
// a chacune de ces limites est associ un format
//{0,number} analyse le parametre qui lui est pass
// (et qui contient seulement un lment de type nombre)
String[] associs =
{"est vide","contient 1 fichier","contient {0,number} fichiers"} ;
ChoiceFormat choix = new ChoiceFormat(limites, associs) ;
// argument 0 de param est trait par le ChoiceFormat
fmt2.setFormatByArgumentIndex(0, choix) ;
System.out.println( fmt2.format(new Object[] {
new Integer(nbfichiers),
nomFic }));
La mise en forme donne:
Le disque prmtc34x5f contient 10 fichiers
6
6/128
Rvision : J3
Date : 4/6/02
Point intermdiaire :saisies/afchagesparamtrs
mini-exercice :
Utilisation de linterface graphique Question/Rponse:
reprendre le code qui analyse une demande de calcul sin/cos.
Faire en sorte que ce code soit internationalis: lanalyse et
lafchage du format des doubles dpend des convention locales.
6/129
Rvision : J3
Date : 4/6/02
6
Complments
Autres point approfondir
De manire gnrale cest le package java.text qui traite les problmes
dinternationalisation:
* Pour les comparaisons textuelles voir la classe Collator
* Autres applications textuelles : pour les limites de lettres et de mots
BreakIterator (a utiliser pour phrases, lignes, mots, etc.)
* Un certain nombres de composants graphiques (gestionnaires de
disposition) peuvent automatiquement tenir compte dune prfrence
(voir : Component Orientation)
* Un outil trs utile pour internationaliser:
JavaTM Internationalization and Localization ToolKit
(http://java.sun.com/products/jilkit/)
A partir dun certain niveau il est conseill de faire appel des
spcialistes, car les problmes peuvent devenir trs complexes (exemple :
changement dorientation de lecture lintrieur dun formulaire,...)
Performances
Faire attention aux performances. La recherche dun ResourceBundle
par exemple est relativement couteuse: il est donc peu conseill daller en
chercher un chaque fois quon en a besoin; il est plus prudent dinitialiser
cette recherche dans une opration de niveau initialisation de classe qui
permette ensuite un accs partag depuis de nombreuses instances.
6
6/130
Rvision : J3
Date : 4/6/02
Organisation des Bundles
Pour permettre une meilleure gestion de Bundles essayer de lier
lexistence des Bundles celles des packages : par exemple un Bundle par
package, rarement plus , (et ventuellement regroupement des ressources
communes plusieurs sous-packages au package anctre commun).
Nous verrons dans un chapitre ultrieur que la politique de gestion des
Bundles doit tre cohrente avec celle des Loggers.
Rvision : J3
Date : 4/6/02
Prfrences 7
Points essentiels
Les prfrences sont un cas particulier de ressources: comment laisser
lutilisateur (ou ladministrateur systme du site) grer un contexte de
prfrences qui soit permanent et, ventuellement, commun un
ensemble dapplications.
7
7/132
Rvision : J3
Date : 4/6/02
Prfrences
Preferences: principes
Les prfrences dun utilisateur sont des donnes rmanentes qui sont
utilises dans des applications pour personnaliser un comportement.
Les applications peuvent permettre lutilisateur de les modier, et, bien
entendu, ces donnes constituent des paramtres comportementaux de
ces applications: taille prfre dune fonte, couleur , etc..
Ces paramtrages, tels quimplants par le package java.util.prefs,
ont des caractristiques particulires:
Ce sont des donnes non critiques : lapplication doit pouvoir
fonctionner si elle ne trouve pas le paramtre recherch.
Lorsquon demande une prfrence on doit toujours fournir
une valeur par dfaut (qui sera renvoye si la valeur recherche
nest pas trouve pour une raison quelconque).
Les types possibles pour ces donnes sont volontairement
limits: boolean, int, long, float, double,
String et byte[]. (voir ci-dessous contraintes du systme
de persistence).
Ce sont des donnes rmanentes qui peuvent aussi tre partages
par plusieurs applications:
Elles sont stockes de manire transparente lutilisateur et de
manire spcique au systme (par exemple par dfaut dans
des registres sous Windows, dans une arborescence de chiers
sous Unix).
Il y a une dsynchronisation entre les valeurs connues par une
instance de J.V.M et les valeurs connues par le systme de
persistence. Mme les modications sont asynchrones et ne
sont pas garanties (seule la demande explicite dharmonisation
avec le stockage sous-jacent est susceptible de propager une
erreur si ce stockage est indisponible).
Discussion: que verriez vous comme paramtrages dapplication
susceptibles dtre traits comme des prfrences?
7/133
Rvision : J3
Date : 4/6/02
7
Prfrences
Preferences: contextes de nommage
Spcier une prfrence cest associer une valeur une clef. Cette clef de
nommage est forcment une chane de caractre.
Pour un code il est important de grer ces associations dans un espace de
nommage quil contrle. A priori un espace naturel est li au nom du
package.
Les prfrences dun utilisateur sont organises dans un arbre de
contextes. Lorganisation hirarchique des contextes de prfrences est
associe un arborescence de nommage des noeuds (node)
Chaque noeud est reprsent par une instance de la classe Preferences.
Sa dsignation se faisant par un cheminom absolu (/org/gibis/ihm)
ou relatif au noeud courant (gibis/ihm dans /org).
Attention, pour des raisons de portabilit, il y a une limite la longueur
du nom dun noeud (80!) -comme dailleurs la longueur de la clef ou
de la valeur: voir les constantes de la classe Preferences-
Il existe deux arborescences de contextes:
les prfrences utilisateur
les prfrences systme
/
com org fr partages
gibis shadocks
ihm finance
utils
math
fontes
clef=valeur
cl2=val2
cl3=val3
clef=valeur
cl2=val2
cl3=val3
clef=valeur
cl2=val2
cl3=val3
clef=valeur
cl2=val2
cl3=val3
(exceptionnellement
nom indpendant
dun package)
7
7/134
Rvision : J3
Date : 4/6/02
Prfrences
Obtention dun contexte
Pour obtenir un contexte dans le cadre dun code donn:
Preferences curPrf= Preferences.userNodeForPackage(MyClass.class);
Si le noeud associ au nom du package nexiste pas il est cr (ainsi que
tous ses parents manquants), mais ce contexte ne deviendra persistant que
si une harmonisation avec le systme de stockage devient ncessaire (ou
est explicitement demande). De la mme manire il existe une mthode
systemNodeForPackage(Class).
On peut obtenir directement la racine dun des deux arbres de
prfrences:
Preferences racine = Preferences.userRoot();// par exemple
A partir dun noeud on peut obtenir un autre noeud en utilisant son
cheminom de dsignation:
Preferences petitFils = curPrf.node(fils/petitfils);
Preferences absolu = curPrf.node(/fr/shadocks);
Dans le premier cas on a obtenu un descendant direct du noeud courant
dans le second un noeud arbitrairement choisi dans larbre courant.
7/135
Rvision : J3
Date : 4/6/02
7
Prfrences
Consultation dans un contexte
A partir dun noeud donn on peut consulter une prfrence :
String imagePrfre = packNode.get(image, defaultimg.gif) ;
Comme pour toute les consultations de valeur on doit donner une valeur
par dfaut. Certaines implantations de la persistence sont autorises
conserver cette valeur par dfaut (mais ce nest pas un comportement sur
lequel il faut compter -de plus si une valeur par dfaut stocke existe
elle peut remplacer la valeur par dfaut propose!-).
On notera que, du fait de la dsynchronisation, la valeur obtenue nest pas
ncessairement celle prsente linstant t dans le systme de persistence:
la valeur peut-tre modie par une autre partie de lapplication courante
(bien entendu les codes des modications sont synchronized) ou alors
une autre JVM a concurrement modi cette valeur dans le systme de
persistence.
package org.gibis.ihm ;
import java.awt.* ;
import java.util.prefs.* ;
....
public class Fontes {
public static Preferences curPrefs =
Preferences.userNodeForPackage(Fontes.class);
public static final String CLEF_NOM_FONTE = nomfonte ;
public static final String NOM_FONTE_DEFAUT=monospaced;
.....
public Font fontePrfreUtilisateur() {
String nom = curPrefs.get(
CLEF_NOM_FONTE, NOM_FONTE_DEFAUT) ;
int style = curPrefs.getInt(
CLEF_STYLE_FONTE, Font.PLAIN);
int taille = curPrefs.getInt(
CLEF_TAILLE_FONTE, TAILLE_FONTE_DEF);
return new Font(nom, style, taille) ;
}
....
On aurait pu aussi stocker la reprsentation de la fonte sous forme dune
chane quon aurait ensuite analyse
(voir java.util.StringTokenizer ou package java.util.regex)
7
7/136
Rvision : J3
Date : 4/6/02
Prfrences
Enregistrement dune valeur
Dans le contexte dun noeud donn on peut enregistrer une prfrence:
// dans un interface graphique
String nomImage = myJTextField.getText() ;
packNode.put(image, monImage)
On dispose de mthodes pour enregistrer des valeurs ayant les types
simples admis pour les rfrences (putInt, putDouble,
putByteArray, etc.).
Ici aussi il faut veiller aux problmes de dsynchronisation avec le
systme de persistence. Il nest pas certain que la valeur soit
immdiatement enregistre. Pire elle peut ne jamais ltre: si un code na
pas le droit de modier un noeud systme lexcution risque de ne pas
voir passer dexception (voir ci-aprs les synchronisations explicites).
....
public static final String LOCALE = locale ;
.....
public void mmoriseContexteCulturel(Locale loc) {
curPrefs.put(LOCALE, loc.toString());
}
(ici, typiquement, si on enregistre fr_FR comme valeur il faudra lors
du get lanalyser pour reconstituer le Locale).
Une entre du dictionnaire local peut tre supprime par:
curPrefs.remove(nomProprit) ;
Une suppression radicale du dictionnaire par:
curPrefs.clear();
7/137
Rvision : J3
Date : 4/6/02
7
Prfrences
Harmonisation avec le systme de persistence
On peut explicitement demander des interactions avec le systme de
persistence sous-jacent.
Ici ces invocations sont susceptibles de propager des exceptions de type
BackingStoreException:
curPrefs.flush() ;
Sur cet appel le noeud courant et tous ses descendant sont sauvegards
par le systme de persistence (lappel est synchrone: au retour le systme
est jour). Si le noeud vient dtre cr le systme de persistence peut
crer tous les anctres ncessaires son existence.
curPrefs.sync() ;
Permet dassurer que les prochaines consultations de valeurs reterons
tous les changements survenus dans le systme sous-jacent (mises jour
par dautres JVM ). Comme effet de bord cette mthode assure que les
modications locales sont aussi harmonises (effet analogue un
flush() ).
Noter que lexception IllegalStateException punit tout appel sur
un noeud qui a t invalid ( par ex. par removeNode()).
Noter galement quun AccessControler qui na pas lautorisation
RuntimePermission(preferences) va dclencher une
SecurityException sur toute demande dobtention de noeud de
larbre des prfrences.
7
7/138
Rvision : J3
Date : 4/6/02
Prfrences
Point intermdiaire :prfrences
Mini-exercice :
1. Faire un programme qui xe un Locale de prfrence pour
lutilisateur.
2. Rcuprer cette prfrence dans votre programme
Question/Rponse internationalis
7/139
Rvision : J3
Date : 4/6/02
7
Prfrences
Complments
Personnalisation dun systme de Prfrences
Dans certaines situations on peut tre amen modier limplantation de
rfrence de la gestion de prfrences. Exemples:
architecture distribue pour les prfrences systmes qui
seraient obtenues partir dune ressource centralise.
codes destins un utilisateur mais qui sexcutent sur un serveur
(voir remarques dans la documentation de
AbstractPreferences).
Ici il faut fournir des implantations de services rpondant aux contrats
(SPI) dnis dans AbstractPreferences. Une PreferenceFactory
doit rendre les arbres utilisateur et systme et sa classe doit tre dsigne
dans la proprit java.util.prefs.PreferenceFactory .
- pour programmeurs experts uniquement! noter, de plus, que ce
dispositif est susceptible de changer dans des versions ultrieures-
Noter galement des possibilits dimport/export de prferences via des
descriptions XML.
Veille sur des modi cations de prfrenecs
A lintrieur dune JVM il est possible de mettre en place des mcanismes
qui permette de prvenir une partie de lapplication si ltat dun noeud a
chang de manire signicative dans une autre partie. Voir
PreferenceChangeListener et NodeChangeListener.
7
7/140
Rvision : J3
Date : 4/6/02
Prfrences
Rvision : J3
Date : 4/6/02
Rapports, journalisations, assertions 8
Points essentiels
La version 1.4 de Java a apport une harmonisation des oprations de
trace, rapports, etc.
Il fallait ici rsoudre une contradiction :
Il doit y avoir un dcouplage entre une demande de rapport faite
par un composant autonome et la classe qui rend effectivement le
sercice.
Il faut que ce service soit standard pour que des composants
indpendants y fassent rfrence.
Par ailleurs java1.4 a introduit un mcanisme standard dassertion qui
permet de spcier des vrications et de faire en sorte que ces
vrications soient activables au lancement dune JVM.
8
8/142
Rvision : J3
Date : 4/6/02
Rapports, journalisations, assertions
LA.P.I. de log
Notion de log
La notion de log recouvre tout ou partie des oprations de traces, mains
courantes et reconstitution doprations, historiques, signalement
derreur, monitorat divers, etc.
Dans ces oprations le programme envoie des informations qui
concernent des rles trs diffrents: utilisateur de lapplication,
administrateurs divers, dveloppeurs en phase de tests ou de
maintenance, autres applications (analyse, sauvegarde,....), etc.
Une conception saine des oprations de log doit suivre les contraintes
architecturales inhrentes aux applications Java (modularit, dynamicit):
Exemple: Si au moment de sa conception un composant ne connait
pas la nature du contexte dans lequel il va oprer, faire
System.err.println() dun rapport derreur nest pas une
bonne ide:
Il peut ne pas y avoir un System.err facilement lisible par le
destinataire (ex.: Applets, processus dmons systme)
Il peut tre intressant de diffrencier les interlocuteurs. Par
exemple sur un problme qui trouve sont origine dans le
systme dexploitation on pourrait envoyer: un message
lutilisateur, un message ladministrateur systme, voire un
message la maintenance logicielle.
Ces messages sont de nature diffrente selon le rle de
linterlocuteur: plus detaill pour ladministrateur, traces
dtailles de la pile (stackTrace) pour la maintenance etc.
Discussion: que faire dans le code dun bloc catch lorsquon a rcupr une
exception?
8/143
Rvision : J3
Date : 4/6/02
8
Contraintes architecturales des oprations de log
Certains codes ont besoin de poster des informations mais ne sont pas des
codes "terminaux" (directement la surface de lapplication comme les
codes dIHM).
Au moment de lcriture du code on doit :
pouvoir accder un dispositif de log quoiquon ne connaisse pas
son comportement effectif.
pouvoir simplement spcier les informations que lon loggue et
les catgoriser (niveau: trace, info, warning, error).
import java.util.logging.* ;
.....
// le package est lunit de base
Logger logger = Logger.getLogger("org.gibis.monpackage");
....
// Trace dans du code courant
logger.log(Level.INFO, "!", monObjet)
.....
try {
.....
} catch (ExceptionStock exc) {
logger.log(Level.SEVERE, "stock", exc)
// ne remplace pas necessairement toutes les actions a prendre
}
// nombreuses methodes drives commodes dacces
if (TRACE) {//code non compil si booln faux au compile time
logger.entering("CetteClasse", "cetteMthode") ;
}
....
logger.warning(
"ressource manquante..on continue avec valeur par defaut");
....
On a ici un dcouplage entre une demande de service et sa ralisation: le
code ne connait pas le comportement effectif du Logger li au module
applicatif reprsent ici par le package.
8
8/144
Rvision : J3
Date : 4/6/02
Point intermdiaire :Loggerspar dfaut
Mini-exercices :
Reprendre le code danalyse et dvaluation sin/cos (mini-
exercice :, page 128).
Ne pas renvoyer directement toutes les exceptions vers linterface
graphique mais mettre en place un Logger pour faire un rapport
sur certaines exceptions.
Excuter le code dans le cadre de linterface graphique:
ce comportement par dfaut vous satisfait-il? Comment pourrait-
on lamliorer?
8/145
Rvision : J3
Date : 4/6/02
8
Qui dtermine un comportement effectif de Logger?
Diffrentes situations et combinaisons sont possibles:
conguration de dploiement:
ressources dcrivant des comportements et/ou spciant des
classes impliquer; classes mises en oeuvre au dploiement.
outil de contexte :
ces outils permettent dexcuter des composants dans un contexte
particulier et grent de diverses manires le comportement des
loggers (y compris dynamiquement).
Ex.: containers E.J.B., Patrol, etc.
codes englobant les composants et ayant spciquement besoin de
mettre en place des comportements:
Ex.: interfaces graphiques reportant des messages lutilisateur
8
8/146
Rvision : J3
Date : 4/6/02
Rglages dun Logger
De manire gnrale on peut dire quil y a un Logger par domaine
fonctionnel (trs souvent associ la notion de package et portant le nom
de ce package).
Sur un Logger on peut effectuer des rglages programmatiques:
xer un certain niveau de log et rejeter tout message dimportance
infrieure:
ceLogger.setLevel(Level.FINE) ;
xer spciquement un ltre programmatique charg de rejeter
certains rapports (classe LogRecord).
ceLogger.setFilter(monFiltre) // implements Filter
Les rapports sont ensuite propags un ou plusieurs Handlers
qui vont transformer les LogRecords et les mettre en forme pour
le monde extrieur.
ceLogger.addHandler(monHandlerSurIHM) ;
Exemples de Handlers prdnis : FileHandler (log dans un
ou plusieurs chiers), OutputStreamHandler (dans un ot
dE/S), ConsoleHandler (sur System.err), SocketHandler
(sur des ports TCP distants).
Chaque Handler peut aussi dcider:
De ltrer ses messages :
monHandlerSurIHM.setFilter(filtre) ;
....
monHandlerSurIHM.setLevel(Level.OFF);// on arrte tout!
de mettre en forme les messages -ventuellement en fonction
de la langue (voir package java.text et ResourceBundle)-:
monHandlerSurIHM.setFormatter(new SimpleFormatter());//par dfaut
monHandlerSurFichier.setFormatter(new XMLFormatter());
8/147
Rvision : J3
Date : 4/6/02
8
Cheminement des rapports
Ce cycle de vie peut tre asynchrone (par ex. on sort de la mthode de
dpot avant que le message soit crit effectivement dans un chier)
Logger
Handler 1
Handler 2
dpot
Filter
FilterX
FilterY
Formatter1
Formatter2
rendu ext.
rendu ext.
8
8/148
Rvision : J3
Date : 4/6/02
Mise en place des Loggers
Il serait fastidieux de grer programmatiquement tous les Loggers
possibles! En fait il y a une organisation hirarchique des Loggers
partir du Logger racine (de nom ). La hrarchie des Loggers est
dtermine par leur nom (org.gibis est pre de org.gibis.util )
et, par convention, il y a aussi un domaine nomm global.
Les Loggers sont en gnral crs dynamiquement la demande et
hritent du comportement de leur parent:
Si le niveau de sensibilit (Level) dun Logger nest pas x
spciquement (valeur null) il prend automatiquement celui de
son anctre le plus proche pour lequel ce niveau est x.
Les ltres (Filter) sont spciques chaque Logger.
Lorsquun LogRecord est produit il est soumis tous les
Handlers associ spciquement au Logger et tous les
Handlers de ses parents (on peut donc ne pas avoir de Handler
en propre et hriter de ceux de sa hirarchie).
Pour contrer ce comportement:
ceLogger.setUseParentHandler(false) ;
Au titre dune conguration globale simplie on peut donc agir sur le
Logger racine (ou sur global) . Le systme de conguration statique
par dfaut agit essentiellement ce niveau (cest un chier texte en format
Properties: voir logging.properties et la documentation de la
classe LogManager).
8/149
Rvision : J3
Date : 4/6/02
8
Point intermdiaire :Congurationstatique
Mini-exercices :
Lire la documentation de java.util.logging.LogManager et
mettre en place une conguration statique simplie pour le
Logger racine dune application.
8
8/150
Rvision : J3
Date : 4/6/02
Mise en place explicite dun Handler
Il existe des situations dans lesquelles certains rapports doivent apparaitre
explicitement dans lapplication elle-mme: par exemple si nous voulons
faire apparatre dans lIHM des erreurs enfouies qui ne sont pas
rcupres dans le code IHM lui-mme.
Soit un tel code qui utilise alors pour afcher les rapports un code de
Handler spcique de nom IHMHandler:
Handler monHandlerSurIHM = new IHMHandler() ;
monHandlerSurIHM.setFormatter(new FormatSimple()) ;
Logger.getLogger("").addHandler(monHandlerSurIHM) ;
Par ailleurs le code qui met les rapports le fait en utilisant un
ResourceBundle particulier :
package fr.bankoo.calculs ;
interface PackCst {// porte package!
...
public static final String THEME_BUNDLE = "messages/Errors" ;
public static Logger CURLOG =
Logger.getLogger("fr.bankoo.calculs", THEME_BUNDLE);
...
A partir de ce moment les rapports mis partir des codes de ce package
seront mis en forme en utilisant le Bundle correspondant:
CURLOG.log(Level.SEVERE,errBackup,
new Object[] {deviceName, fileName});
Ressource correspondante dans Errors_fr_FR.properties :
errBackup : sauvegarde de {1} sur {0} impossible
8/151
Rvision : J3
Date : 4/6/02
8
Un code de Handler
Exemple de Handler simple dans le cadre dun IHM :
package xxx ;
....
public class IHMHandler extends Handler {
private static class IHMDialog extends JDialog {
// HIDE ON CLOSE par dfaut
private JTextArea jtxt = new JTextArea(10,60) ;
IHMDialog() {
// internationaliser
setTitle("Attention! message!") ;
getContentPane().add(new JScrollPane(jtxt)) ;
}
public synchronized void report(String rapport) {
jtxt.setText(rapport) ;//p.e. append(rapport)
pack() ;
show() ;
}
}
static IHMDialog ihm = new IHMDialog() ;
public void publish (LogRecord record) {
//normallement on doit demander une fois
// getHead(this) au formatter
if (isLoggable(record)) {
ihm.report(getFormatter().format(record));
}
}
public void flush() {
}
public void close() {
//normallement on doit demander une fois
// getTail(this) au formatter
}
}
8
8/152
Rvision : J3
Date : 4/6/02
Un code de Formatter
Exemple de Formatter trs simple qui pourra tre utilis avec le code
prcdent:
package xxxx;
public class FormatSimple extends Formatter {
public String format(LogRecord record) {
StringBuffer sb = new StringBuffer();
sb.append(record.getLevel().getLocalizedName())
.append(":\n\t)
// formattage localis + bundle li au rapport
.append(formatMessage(record));
// exception
Throwable th = record.getThrown() ;
if(th != null) {
sb.append(th) ;
}
return sb.toString() ;
}
}
8/153
Rvision : J3
Date : 4/6/02
8
Point intermdiaire :Loggersexplicites
Mini-exercices :
Reprendre le code danalyse et dvaluation sin/cos et son
interface graphique ( Mini-exercices :, page 144) . Mettre en
place les rapports sur interface graphique (en reprenant les codes
cits en exemple ici).
8
8/154
Rvision : J3
Date : 4/6/02
Assertions
Nous avons vu prcdemment des demandes de rapport loccasion de
traces, de signalement derreur etc. Nous abordons ici un thme
sensiblement diffrent qui est celui du dclenchement derreurs dans le
cadre de vrications non systmatiques.
Java 1.4 a introduit directement au niveau du langage un mcanisme
dassertion au moyen dun nouveau mot-clef: assert.
Une assertion permet de mettre en place un contrle ( par ex. telle valeur
est-elle valide?) et ceci de manire non-permanente. Bien souvent ce
contrle est rserv lusage exclusif du programmeur ou du metteur au
point.
Il est important de distinguer les assertions de lutilisation classique des
exceptions. Exemples :
package fr.banquoo.comptes;
....
public class Compte {
private double solde ;
....
public void retrait(double valeur) throws ExceptionDecouvert{
if(valeur <= 0) {
throw new IllegalArgumentException(retrait de + valeur);
}
if(valeur > solde) {
// plutot solde -valeur depasse decouvert autoris
throw new ExceptionDecouvert(this, valeur);
}
....
}
}
Discussion: pourquoi avoir ici une exception controle (ExceptionDecouvert) et
une RuntimeException (IllegalArgumentEception)?
8/155
Rvision : J3
Date : 4/6/02
8
Pourquoi utiliser des assertions
Dans lexemple prcdent nous avons un code public qui doit vrier un
certain nombres de prconditions. Le contrle de largument ngatif est
effectu, il doit tre signal dans la documentation, mais le programmeur
utilisateur nest pas oblig de traiter lexception correspondante (sil est
sr que la condition est remplie dans son code dappel). Soit maintenant
le code suivant :
package fr.banquoo.comptes;
....
public class Utils {
static double mensualit(double taux, int dure, double mnt){
// vrification des prconditions
....
}
On a ici affaire une mthode de porte package, qui ne sera utilise que
par les autre classes du mme package. Il peut tre raisonnable de penser
que ces contrles devront tre effectus dans des phases de mise au point,
mais quil est inutile de les lancer systmatiquement dans un code mature.
Il est alors possible dcrire le code suivant :
assert (taux > 0) && (dure > 0) && (mnt > 0) ;
....
On a ici un nouvel lment de syntaxe du langage Java: la compilation
doit se faire avec loption -source 1.4 (minimum).
Le point intressant: si lexcution est lance avec loption -ea
(enableassertions) le test sera excut et si le rsultat est faux une
AssertionError sera dclenche. Si les assertions ne sont pas actives
le test ne sera pas excut.
8
8/156
Rvision : J3
Date : 4/6/02
Pourquoi utiliser des assertions
Pourquoi utiliser des assertions? Pour permettre aux programmeurs de
renforcer la robustesse du code en introduisant des tests supplmentaires
lis aux phases de dveloppement, dploiement, tests, maintenance,...:
contrles de proprits sur des valeurs (trop souvent laisses
implicites).
switch(code) {
case 0 : ....; break;
case 1 : .... ; break ;
case 2 : .....; break
default : // ne doit pas se produire
assert false;
}
contrles sur des invariants de classe, post-conditions (et, dans
certains cas particuliers, de prconditions lies des codes
privs)
assert (taux > 0) && (dure > 0) && (mnt > 0);
//prcondition spciale lie un code de porte limite
....
assert (res >0) && (doublePrcis(res)) ;// postcondition
return res ;
}
Exemple dinvariant dans CompteJeune extends Compte:
assert decouvert == 0 ;//pas de decouvert autoris
erreurs de dploiement, dassemblage de composants, tests
particuliers certaines conditions dexploitation:
import java.util.Arrays;
.....
Locale loc = ..... ;
NumberFormat frm = NumberFormat.getNumberInstance(loc) ;
frm.format(montant) ;
assert
Arrays.asList(NumberFormat.getAvailableLocales()).contains(loc);
//ici format fonctionne toujours mais dans certains cas
// on voudrait pouvoir savoir pourquoi le format est surprenant
8/157
Rvision : J3
Date : 4/6/02
8
Assertions: syntaxe, activations
Syntaxe:
assert expressionBoolenne ;
assert expressionBoolenne : expression ;
Dans le second cas si les assertions sont actives et si
expressionBoolenne rend false, alors expression est
value et son rsultat est pass au constructeur dAssertionError (qui en
dduit un String).
static {
try {
bundle = ResourceBundle.getBundle(Erreurs, locale) ;
} catch (MissingResourceException exc) {
assert false : exc ;
// dploiement anormal! on arrte tout!!
}
}
Lactivation du contrle des assertions peut tre globale, ou spcique
un package, une classe :
java -ea fr.bankoo.Banque
active les assertions dans tous les packages (sauf packages bootstrap)
java -ea:fr.bankoo... fr.bankoo.Banque
java -ea:fr.bankoo.Banque fr.bankoo.Banque
dans un cas on active les assertions uniquement dans les packages et
sous-packages de fr.bankoo dans lautre uniquement dans la classe
dsigne.
On peut galement dsactiver les assertions pour certaines classes ou
packages et intervenir programmatiquement pour demander aux
ClassLoaders une activation.
8
8/158
Rvision : J3
Date : 4/6/02
Point intermdiaire :codesrobustes
Mini-exercice :
Reprendre vos codes (IHM Question/Rponse, lanceur, valuateur
dexpression mathmatiques) et les blinder : sassurer dune
mise en place pertinente dexceptions dune part et dassertions de
lautre.
Discussions: quenvisageriez-vous de faire pour mettre au point des protocoles de
tests systmatiques?
8/159
Rvision : J3
Date : 4/6/02
8
Complments
Autres point approfondir
Les rapports (LogRecord) peuvent contenir des objets et sont
donc une structure de donnes potentiellement riche; il faut
toutefois tre raisonnablement sr que ces objets seront
exploitables (se mer en particulier de la serialization des
LogRecord -Voir Dispositifs avancs dE/S, page 197.-).
Noter que la mthode getThrown() permet dexploiter un objet
Throwable et que depuis la version 1.4 cet objet dispose dune
mthode getStackTrace() qui permet dexploiter
programmatiquement les informations de la pile.
Internationalisation: penser ne passer par le Formatter que le
plus tard possible dans la chaine de transfert des rapports.
Imaginez ce qui se passerait si vous formattiez sur un serveur un
message lu par un utilisateur sur un poste client: il est fort possible
que le Locale ncessaire ne soit pas pris en compte!
Les erreurs dans les Handlers eux-mme ne doivent pas passer
par le systme de log (voir utilisation de ErrorManager).
Scurit : naturellement les codes non-ables ont un accs restreint
aux services locaux de log. Voir les autorisations de scurit et les
Loggers anonymes. Attention: les classes de conguration
statique doivent tre charges par le ClassLoader primordial.
8
8/160
Rvision : J3
Date : 4/6/02
Questions de performance
Il faut faire extrmement attention aux oprations de log dans un systme
critique.
Il faut dabord rchir la nature des rapports: sagit-il dune trace
simple ou cette trace est-elle elle mme critique pour reconstituer un
historique des oprations?. Dans le second cas on a affaire une opration
synchrone importante alors que dans le premier lopration peut tre
asynchrone et faire lobjet de mesures dabandon en cas de dtection de
problmes de performances graves. Il ne faut pas que les oprations de
log non-critiques deviennent un goulot dtranglement (imaginez la
tempte de logs si ceux-ci participent eux-mmes des dgradations du
service rendu par lapplication!).
Points surveiller pour les performances du systme de log:
Appels systmes, E/S non bufferises, (pour une technique
intressante: voir utilisation de MemoryHandler).
Trop-plein dinformations et problmes de place (XML
particulirement couteux, mais mme SimpleFormatter doit
tre surveill)
Recherches complexes (ResourceBundle, classes ou
programmation dynamiques)
Blocs synchronized (Voir Accs concurrents, page 77.)
Rvision : J3
Date : 4/6/02
Troisime partie: Entres/Sorties
/162
Rvision : J3
Date : 4/6/02
Rvision : J3
Date : 4/6/02
Application dun pattern: les ots dE/S 9
Points essentiels
Ce chapitre a un double objectif :
prsenter le notion de modle structurel (design pattern)
prsenter la technique des entres/sorties en mode ot en
montrant que sa ralisation en Java sappuie sur un modle de
programmation abstrait.
9
9/164
Rvision : J3
Date : 4/6/02
Application dun pattern: les ots dE/S
Modles structurels (design patterns)
Lexprience accumule par les programmeurs a permis de constater que
certaines classes, bien que traitant des problmes diffrents, avaient des
analogies structurelles. Do lide de reprer des modles
organisationnels qui permettent de rcuprer des mcanismes de
fonctionnement pour raliser des classes ayant des nalits diffrentes.
Lanalyse approfondie de la pertinence de ces mcanismes permet en fait
de rsoudre une classe de problmes apparents en ne sintressant
quaux proprits structurelles des objets mis en oeuvre.
Ces modles structurels (patterns) font lobjet de diverses publications et le
programmeur doit les connatre et savoir les adapter ses problmes. Un
exemple de petit pattern en Java est la prsence dans le package
java.util du couple Observer/Observable.
Le modle Observer/Observable
Ce modle (qui nest pas sans rappeler le mcanisme des veilleurs
dvenements) est adapt des situations o diffrents objets veulent tre
tenus au courant dvolutions survenues sur un objet surveill
(LObservable). Les objets qui implantent linterface Observer ont
pour obligation de senregistrer auprs de lObservable et de ragir aux
notications que ce dernier leur enverra en cas de modication de son
tat.
Une application typique serait davoir diverses interfaces graphiques qui
partagent un tableau de valeurs boursires. Chaque fois quune valeur
est modi dans le tableau de rfrence toutes les interfaces graphiques
doivent reter lvolution.
9/165
Rvision : J3
Date : 4/6/02
9
Observable
Observer
Observer
notification
modification
SUNW=9.7
(1)
(2)
SUNW 9.3
ACME 10.8
APEX 0.8
SMURF 11.8
buy
sell
public class CoursBourse extends Observable {
private HashMap cours ;
....
// p.e. synchronized
public void changeCote(String valeur, Money cote){
cours.put(valeur,cote) ;
setChanged();//rend notification possible
notifyObservers(valeur) ;
}
....
}
public class AfficheCours extends ... implements Observer {
// A la cration senregistre auprs de lObservabl
....
public void update(Observable cours, Object valeur)
// Met jour laffichage
}
}
9
9/166
Rvision : J3
Date : 4/6/02
Un exemple dutilisation de pattern
Nous allons prendre cet exemple dans le code de Java lui-mme. Les
dispositifs dentre/sortie en mode ot sont construits autour dune
interprtation dun modle structurel connu: le dcorateur.
Introduction: combinaison hritage/dlgation
Il nexiste pas dhritage multiple en Java. Si lon veut rcuprer des
comportements de deux classes diffrentes il faut explicitement lcrire
Ici le ClientSalarie hrite des mthodes de Client et dnit des
mthodes de Salarie en dlguant leur ralisation une instance locale
de Salarie.
Trs probablement on crera un constructeur :
public ClientSalarie(Salarie salarie, ....) {
super(...) ;
this.sal = salarie ;
....
}
Client
Salarie
ClientSalarie extends Client
private Salarie sal ;
getSolde()
getSolde()
getDept()
getDept()
9/167
Rvision : J3
Date : 4/6/02
9
Introduction: un cas particulier dhritage/dlgation
Ici chaque mthode de la super-classe est rednie pour tre dlgue ...
une instance de la super classe!
Tous les constructeurs prennent en paramtre une instance de la super-
classe!
class FilsPere extends Pere {
private Pere pere ;
public FilsPere(Pere pere) {
this.pere = pere ;
}
public void f() {
pere.f() ;
}
...
}
A quoi peut bien servir un dispositif aussi trange?
Pere
FilsPere extends Pere
private Pere pere;
f()
g()
f()
g()
9
9/168
Rvision : J3
Date : 4/6/02
Un arbre dhritage complexe...
Pere
f()
g()
FilsA
f()
g()
FilsB
f()
g()
f()
g()
FilsPere
Pere
f()
g()
FilsDcor
Pere
f()
g()
FilsEnrichi
FilsA
h()
Pere
FilsEnrichi
f()
g()
h()
FilsDcor
Les mthodes f() et g() sont red nies dans ces classes
filsDcorEnrichiA
9/169
Rvision : J3
Date : 4/6/02
9
Un arbre dhritage complexe
et mme trs complexe!:
Les classes FilsA et FilsB hritent de Pre en spcialisant ses
mthodes. Le comportement de ces mthodes est donc diffrent et
spcique aux classes FilsA et FilsB.
La classe FilsPere correspond au dispositif vu prcdemment,
noublions pas que son constructeur est FilsPere(Pre)
Les classes FilsEnrichi et FilsDcor hritent de FilsPere.
Leurs mthodes peuvent tre rednies mais sappuient in ne sur
les mthodes de mme nom de la classe Pre. Dans le cas de
FilsEnrichi on cre de nouvelles mthodes dont la ralisation
sappuie sur les mthodes fondamentales de la classe Pre.
Les constructeurs de ces classes utilisent toujours une instance de
Pre.
On peut alors construire une instance de FilsDcor qui
sappuie sur les comportements de FilsEnrichi et de FilsA:
new FilsDecore(new FilsEnrichi(new FilsA())) ;
On a ainsi compos des comportements en agissant de manire
transversale dans larbre dhritage.
Nous allons donner un exemple pratique de ce modle structurel.
9
9/170
Rvision : J3
Date : 4/6/02
Application du modle structurel aux E/S ot en Java:
InputStream
read()
close()
FileInputstream
read()
close()
PipeInputStream
read()
close()
read()
close()
FilterInputStream
I.S.
read()
readInt()
DataInputStream
I.S.
read()
close()
BufferedInputStream
FileIS
close()
I.S.
BufferedIS
read()
readInt()
close()
DataInputStream
Les mthodes read() et close(),etc. sont red nies dans ces classes
dataBufferedFileIS
9/171
Rvision : J3
Date : 4/6/02
9
Application du modle structurel aux E/S ot en Java:
Les ots (streams) dE/S sont bass sur un concept simple et unicateur.
Des octets coulent dans un ot et au point daccs du dispositif on
consomme des octets les uns aprs les autres (InputStream) ou on
fourni des octets les uns aprs les autres (OutputStream).
Le principe dutilisation est de programmer en sadressant un point
daccs qui dlgue la ralisation de lentre/sortie une combinaison de
dipositifs. Pour raliser ces combinaisons on dispose:
dune classe au sommet de la hirarchie. Ici il sagit de
InputStream (qui est dailleurs une classe abstraite).
de classes ralisant des E/S fondamentales: les ressources (node
streams). Ainsi ces classes permettent louverture dInputStream
sur des chiers, des sockets, des tableaux en mmoire, des pipes
(changes entre threads lintrieur dun processus JVM), etc. Ces
classes hritent de InputStream et implantent les
comportements fondamentaux qui sont la base du service.
dune classe FilterInputStream dont lobjectif est purement
structurel (on notera que son constructeur est protected).
de classes ltres qui transforment les comportements de ots
existant: BufferedInputStream (bufferisation utile pour les
performances), DataInputstream (permet de lire des primitifs
Java sur un ot), etc.
On peut alors raliser des instances ayant des comportement spciques:
new DataInputstream(new BufferedInputStream(
new FileInputStream(fichier))) ;
Si besoin est, on pourrait lire des objets Java de manire crypte,
compresse, bufferise au travers dune socket rseau ! (voir les packages
java.util.zip, java.security et javax.crypto)
9
9/172
Rvision : J3
Date : 4/6/02
Flots doctets (InputStream, OutputStream)
La dnition fondamentale des ots est de dcrire un dispositif pour
lire/crire des octets (byte).
Ces classes sont donc munies de mthodes de bas niveau comme :
java.io.InputStream
int read() throws IOException
// lit en fait un byte dans un int
// + dautres read(...) de bas niveau
java.io.OutputStream
void write(int octet) throws IOException
// criture dun byte pass comme int
// + autres write(...) de bas niveau
Les deux classes sont munies dune mthode de fermeture
void close() throws IOException
9/173
Rvision : J3
Date : 4/6/02
9
Flots de caractres (Reader, Writer)
Dans la mesure o Java utilise de manire interne des caractres
UNICODE cods sur 16 bits on a t amen dnir dautres types
fondamentaux de ots adapts aux caractres. Ce sont les Readers et les
Writers.
java.io.Reader
int read() throws IOException
// lit en fait un char dans un int
// + dautres read(...) de bas niveau
java.io.Writer
void write(int carac) throws IOException
// criture dun caractre pass comme int
// + autres write(...) de bas niveau
// dont write(string s)
Bien entendu ces classes disposent galement de close() .
9
9/174
Rvision : J3
Date : 4/6/02
Typologie par ressources
En prenant lexemple des seuls ots dentres comparons les
InputStreams et les Readers
Une classe permet de passer du domaine des InputStreams celui des
Readers : InputStreamReader
catgorie InputStream Reader
lecture dans tableau mmoire ByteArrayInputStream
CharArrayReader
StringReader
mcanisme
producteur/consommateur
entre Threads
PipedInputStream PipedReader
chiers FileInputStream
FileReader
InputStreamReader
ots fabriqus par dautres
classes
java.lang.Process getInputStream()
java.net.Socket getInputStream()
java.net.URL openStream()
...
9/175
Rvision : J3
Date : 4/6/02
9
Conversions octets-caractres
On utilise les caractres UNICODE lintrieur du monde Java, mais de
nombreuses ressources texte nutilisent pas ce mode de codage. On a ainsi
des chiers texte qui peuvent avoir t fabriqus par des systmes
divers qui emploient des jeux de caractres diffrents (le plus souvent
avec des caractres cods sur 8 bits).
Lorsquon change du texte entre le monde Java et le monde extrieur il
est essentiel de savoir quel est le mode de codage de texte adapt la
plateforme cible.
Deux classes InputStreamReader et OutputStreamWriter
permettent de passer dun ot doctets un ot de caractres on oprant
les conversions appropries.
try {
InputStream fis = new FileInputStream("fichier.txt") ;
Reader ir = new InputStreamReader(fis,"ISO-8859-1") ;
.....
} catch (UnsupportedEncodingException exc) {....// log
} catch (FileNotFoundException exc) {....// log
}
Le second argument du constructeur indique le mode de codage (ISO-
8859-1 ou ISO-8859-15 dans la plupart des pays europens, Cp1252
sous Windows). La liste des codages accepts se trouve dans la
documentation sous docs/guide/internat/encoding.doc.html -
voir aussi loutil native2ascii ou la documentation 1.4 de
java.nio.charset- On notera quil existe un codage nomm UTF8
qui permet de fabriquer un ot de caractres UNICODE cods sur 8 bits.
Il existe galement des constructeurs pour ces deux classes dans lesquels
on ne prcise pas le mode de codage: cest le mode de codage de la plate-
forme locale qui est pris par dfaut.
A partir de la version 1.4 on peut utiliser galement un argument de la
classe Charset (permet daccder un meilleur contrle sur le
mcanisme de conversion).
9
9/176
Rvision : J3
Date : 4/6/02
Filtres
Les ltres sont des dispositifs qui transforment la manire dont un ot
opre: bufferisation, conversion des octets en donnes Java, compressions,
etc.
Les ltres sont des ots dont les constructeurs utilisent toujours un
autre ot:
// exemple de dclarations des constructeurs
public BufferedInputStream(InputStream in) ...
public DataInputStream(InputStream in)...
On utilise les ltres en les associant avec un ot pass en
paramtre du constructeur. Ce ot peut lui mme tre un autre
ltre, on combine alors les comportements:
// dans des blocs try/catch ....
BufferedInputStream bis = new BufferedInputStream(
new FileInputStream (nomFichier)) ;
DataOutputStream dos = new DataOuputStream(
new BufferedOutputStream (
new FileOutputStream (nomFic))) ;
Chaque ltre dispose de mthodes spciques, certaines mthodes
ont la proprit de remonter la chane des ots :
try {
dos.writeInt(235);
dos.writeDouble(Math.PI);
dos.writeUTF(une chane accentue) ;
// chane crite en UTF8
dos.flush() ; //transmis au BufferedOutputStream
...
} catch (IOException exc) {
/*log */
} finally {
try {
dos.close() ; // ferme toute la chane
} catch (IOException exc) { /*ignore */}
}
9/177
Rvision : J3
Date : 4/6/02
9
Filtres courants
InputStream/OutputStream
Buffered* : la bufferisation permet de raliser des E/S plus
efcaces (en particulier sur le rseau).
Data* : permet de lire/crire des donnes primitives Java
Object* : permet de lire/crire des instances dobjets. Ce type de
ot est trs important (Voir Dispositifs avancs dE/S, page 197.).
PushBackInputStream: permet de remettre dans le ot des
donnes dj lues.
SequenceInputStream: permet de considrer une liste
ordonne de ots comme un seul ot.
Reader/Writer
Buffered* : bufferisation pour des caractres. Permet de lire un
texte ligne ligne.
LineNumberReader : BufferedReader avec numrotation des
lignes.
PrintWriter: pour disposer des mthodes print/println (voir
aussi PrintStream)
StreamTokenizer : permet de faire de lanalyse syntaxique de
texte.
Dans dautre packages on trouvera des ltres spcialiss :
java.util.zip.ZipInputStream, java.security.DigestInputStream,...
Il existe galement des dispositifs dentre/sortie qui ne sinscrivent pas
dans la logique des Streams : RandomAccessFile (chier accs direct)
et mcanismes de java.nio en java 1.4.
9
9/178
Rvision : J3
Date : 4/6/02
Exercice: pratiquedesE/Sot
Exercice :
Reprendre linterface graphique Question-Rponse et lui associer
le comportement suivant :
lutilisateur saisit une chane de caractre
si cette chaine est une URL (voir constructeur java.net.URL)
ouvrir un Stream avec la mthode openStream() et si cette
ouverture russit lire le contenu et lafcher
sinon on considrera que la chane saisie est celle dun chier
texte local, le lire et lafcher
Pour raliser correctement lexercice nous vous conseillons les
tapes suivantes:
Rechercher dans la documentation la mthode qui permet de
lire un texte ligne ligne.
Tenter douvrir un chier texte et lire la premire ligne
Lire toutes les lignes
Raliser lensemble de lexercice.
Suite de lexercice prcdent: comment modier le principe
gnral de linterface graphique pour la faire collaborer plus
efcacement avec des codes du type de celui que vous venez
dcrire?
9/179
Rvision : J3
Date : 4/6/02
9
Complments
RandomAccessFile
Exemple douverture :
RandomAcessFile raf ;
try {
raf = new RandomAccessFile(stock.raf,rw) ;
catch(Exception exc) {
....
}
Le premier argument donne le nom du chier impliqu, le second indique
le mode daccs (r pour lecture seule, rw pour lecture/criture -dans
ce cas si le chier nexiste pas il est cr-).
Les exceptions susceptibles dtre leves concernent le mode (chane
incorrecte), la dsignation ou les droits daccs au chier .
La lecture et criture de donnes peut soprer sur des donnes primitives
scalaires (int, byte, double, char,...) et sur des chanes de caractres
(capacits analogues aux DataStream) -toutefois dans ce dernier cas il
devient difcile de contrler correctement les accs directs en fonction
dune taille prdtermine-.
Pour grer laccs direct :
void seek (long position) ; //positionner dans le fichier
// commence en origine zero
long getFilePointer() ; // position actuelle
long length() ; // position fin de fichier
9
9/180
Rvision : J3
Date : 4/6/02
Les design patterns
Les design patterns sont un sujet la mode et il existe une abondante
littrature sur le sujet (le livre de rfrence est celui de Gamma, Helm,
Johnson, Vlissides).
Le problme principal de leur pratique est de comprendre la porte dun
pattern et de savoir ladapter un problme particulier. Pour sen
convaincre rechercher une description du modle dcorateur et le
comparer lutilisation qui en est faite dans les E/S Java. On peut aussi
analyser les limites du modle ou de son implantation (pour sen
convaincre regarder la nalit et la position dans le schma de la mthode
flush() ).
Rvision : J3
Date : 4/6/02
Programmation rseau 10
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).
10
10/182
Rvision : J3
Date : 4/6/02
Programmation rseau
Modles de connexions rseau en Java
Accs programmatiques aux sockets (points daccs aux interfaces de
communication) sur TCP/IP
Programmation de Datagrammes UDP
Datagrammes avec Multicast
SOCKET
SERVEUR
CLIENT
port
d
em
an
d
e d
e co
n
n
exio
n
Flots E/S
10/183
Rvision : J3
Date : 4/6/02
10
Programmation rseau
Sockets
Les Socket
1
s 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 service connect,
mais il est aussi moins able : aucune garantie ne peut tre donne
quand au fait que les paquets seront effectivement distribus
correctement -ils peuvent tre perdus, dupliqus ou distribus
dans le dsordre-.
1. En fait une Socket est une abstraction de plus haut niveau qui permet des
ralisations trs diverses. On associe: interface rseau (accs une liaison
physique), adresse rseau, type de protocole et numero de port.
10
10/184
Rvision : J3
Date : 4/6/02
Programmation rseau
Sockets TCP/IP.
Dans Java, les sockets TCP/IP sont implantes au travers de classes du
package java.net.
Diagramme dutilisation:
Dans ce modle, le fonctionnement est le suivant :
Le serveur enregistre son service sous un numro de port. 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.
Serveur
ServerSocket (port #)
accept()
OutputStream
InputStream
close ()
Client
Socket (host, port#)
OutputStream
InputStream
close ()
Enregistrer
ce service.
Attendre une
connexion du
(tentative de connexion)
(retourne un objet Socket)
client.
Utiliser la Socket
10/185
Rvision : J3
Date : 4/6/02
10
Programmation rseau
Serveur TCP/IP (exemple simple)
import java.net.* ;
import java.io.* ;
public class Serveur {
private ServerSocket srv ;
public Serveur(int port) throws IOException{
srv = new ServerSocket(port) ;
}
public void go() {
while(true) {
try {
Socket sck = srv.accept() ; //bloquant
OutputStream os = sck.getOutputStream() ;
DataOutputStream dos = new DataOutputStream(os) ;
dos.writeUTF("Hello Net World!") ;
sck.close() ;
} catch(IOException exc) {
Logger.global.log(Level.SEVERE,"serveur",exc) ;
}
}
}
public static void main (String[] args) throws Exception{
new Serveur(Integer.parseInt(args[0])).go() ;
}
}
Dans cet exemple lchange client/serveur est extrmement simple : la
connexion cest le serveur qui met et qui prend ensuite linitiative de
couper la connexion.
Bien entendu dautres possibilits sont ouvertes:
Le client pourrait tre le premier mettre (et donc le serveur
devrait commencer par lire)
La connexion pourrait rester ouverte pour un succession
dchanges entre client et serveur.
10
10/186
Rvision : J3
Date : 4/6/02
Programmation rseau
Client TCP/IP (exemple simple)
import java.net.* ;
import java.io.* ;
public class Client {
private Socket sck ;
public Client(String host, int port) throws IOException{
sck = new Socket(host, port) ;
}
public void go() {
try {
DataInputStream dis =
new DataInputStream(sck.getInputStream()) ;
String msg = dis.readUTF() ;
Logger.global.info("reu : " +msg) ;
Logger.global.log(Level.SEVERE,"serveur",exc) ;
}
}
public static void main (String[] args) throws Exception{
Client cli = new Client(args[0], Integer.parseInt(args[1]));
cli.go() ;
}
}
Ici le client ne se pose aucune question sur la dure de la communication
puisque cest le serveur qui prend linitiative de couper la connexion.
On notera dans les deux exemples que les constructeurs sont susceptible
dchouer (numero de port dej pris du cot du serveur, problme de
dsignation de lhte du serveur, accs cet hte, absence de processus
serveur, etc. du cot du client).
10/187
Rvision : J3
Date : 4/6/02
10
Programmation rseau
Serveur TCP/IP (exemple avec threads)
import java.net.* ;import java.io.* ;import java.util.logging.* ;
public abstract class ServeurThread {
protected ServerSocket srv ;
protected ServeurThread(int port) throws IOException{
srv = new ServerSocket(port) ;
}
public void go() throws IOException{
ThreadGroup thg = new ThreadGroup("serveur"){
public void uncaughtException(Thread t, Throwable e) {
Logger.global.log(Level.SEVERE,t.toString(), e) ;
}
} ;
while (true) {// mettre un systme darrt propre!
Socket sck = srv.accept() ;
new Thread(thg, fabriqueSession(sck)).start() ;
// crer un Pool de Threads rutilisables ne serait pas mal
}
}
public abstract Runnable fabriqueSession(Socket sck) ;
}
Exemple de dnition de la mthode fabrique dans une sous-classe:
public Runnable fabriqueSession(final Socket sck) {
return new Runnable () {
public void run() {
try {
DataInputStream dis =
new DataInputStream(sck.getInputStream()) ;
....// codes
sck.close() ;
Logger.global.log(Level.SEVERE,"thread serv",exc) ;
}
}// run
} ; // Runnable
}
10
10/188
Rvision : J3
Date : 4/6/02
Programmation rseau
Point intermdiaire :changesTCP
Mini-exercice:
Chaque stagiaire doit crire un client et un serveur utilisant les
communications sur Socket TCP:
Chaque serveur est un programme autonome qui coute sur le
port 6666 et qui envoie un message secret tout client qui se
connecte. Ce message secret est un tableau de String local au
serveur. Les envois se feront par writeUTF() (de
DataOutputStream).
Chaque client est un code li linterface graphique : lorsque
lutilisateur tape le nom dun hte sur le rseau, le code
contacte le serveur correspondant et afche le message secret.
10/189
Rvision : J3
Date : 4/6/02
10
Programmation rseau
Echanges U.D.P.
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 point daccs (socket) UDP.
Pour un serveur on prcisera le port (pas ncessaire pour le client
initiateur de lchange)
DatagramSocket serverSock = new DatagramSocket(9789);
DatagramSocket clientSock= new DatagramSocket() ;
InetAddress : permet de produire une adresse inet partir
dune dsignation (mthode getByName()) ou de la machine
locale (getLocalHost())
Ladressage dun datagramme ncessite de prciser une adresse
Inet + un numero de port cible. On peut aussi utiliser une classe
plus synthtique: InetSocketAddress (sous-classe de
SocketAddress)
DatagramPacket : structure daccueil des donnes et des
informations dadresse.
Les methodes getData(), getAddress(), getPort() (ou
getSocketAddress) permettent de rcuprer ces informations.
// pour un envoi
sendPack = new DatagramPacket(byteBuff, len, addr, port);
// ou sendPack = new DatagramPacket(byteBuff, len, socketAddress);
socket.send(sendPack) ;
// pour une reception
recvPack = new DatagramPacket(byteBuffer, len) ;
socket.receive(recvPack);
10
10/190
Rvision : J3
Date : 4/6/02
Programmation rseau
Serveur U.D.P. (exemple)
public abstract class ServeurUDP {
public static final int DATA_MAX_SIZE = 512 ;
protected DatagramSocket veille ;
public ServeurUDP(int port) throws IOException{
veille = new DatagramSocket(port) ;
}
public void go() {
byte[] recvBuff = new byte[DATA_MAX_SIZE] ;
while(true) { // prevoir arrt!
try {
/* on coute */
DatagramPacket recvPack =
new DatagramPacket(recvBuff, recvBuff.length) ;
veille.receive(recvPack) ; // bloquant
/* reu */
byte[] reponse = reponseA(recvPack.getData()) ;
/* on renvoie reponse a lexpditeur*/
DatagramPacket sendPack =
new DatagramPacket(reponse, reponse.length,
recvPack.getSocketAddress()) ;
veille.send(sendPack) ;
Logger.global.log(Level.SEVERE,"serveur udp",exc) ;
}
}
}
public abstract byte[] reponseA(byte[] question) ;
}
Les donnes changes sont ici stockes dans un tableau de byte. Si la
structure interne est un peu complique on peut utiliser des
ByteArrayInputStream ou des ByteArrayOutputStream pour
stocker/lire des donnes (voir aussi java.nio en 1.4).
10/191
Rvision : J3
Date : 4/6/02
10
Programmation rseau
Client U.D.P. (exemple)
import java.net.* ;import java.io.* ;
public class ClientUDP {
protected DatagramSocket dsk ;
protected InetSocketAddress cible ;
public ClientUDP(String host, int port)throws IOException {
dsk = new DatagramSocket();
cible = new InetSocketAddress (
InetAddress.getByName(host), port) ;
}
byte[] questionReponse(byte[] donnes) throws IOException {
new DatagramPacket(donnes, donnes.length, cible) ;
dsk.send(sendPack) ;
new DatagramPacket(new byte[DATA_MAX_SIZE],
DATA_MAX_SIZE) ;
dsk.receive(recvPack) ; //bloquant
return recvPack.getData() ;
}
}
On notera quici la constructeur de DatagramSocket peut choisir lui-
mme son numro de port. Linformation est contenue dans le
datagramme et peut-tre exploite par le serveur pour renvoyer un
datagramme la bonne adresse. Comme dans tous ces exemples on
notera que les refrences des SocketAddress nexistent pas dans des
versions antrieures la 1.4 .
10
10/192
Rvision : J3
Date : 4/6/02
Programmation rseau
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 TimeToLive 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)
10/193
Rvision : J3
Date : 4/6/02
10
Programmation rseau
Diffuseur Multicast (exemple)
import java.net.* ;
import java.io.* ;
public class Radio {
public static final int PORT = 6969 ;
public static final String GROUP = "229.69.69.69" ;
public static final int TTL = 1 ;
public static void main (String[] args) throws Exception {
int max = Integer.parseInt(args[0]) ;
MulticastSocket emetteur = new MulticastSocket();
//pas de port!
emetteur.setTimeToLive(TTL) ;
InetSocketAddress canal = new InetSocketAddress(
InetAddress.getByName(GROUP), PORT) ;
byte[] contenu = { (byte) ix} ;
new DatagramPacket( contenu,1, canal) ;
emetteur.send(sendPack) ;
}
}
}
10
10/194
Rvision : J3
Date : 4/6/02
Programmation rseau
Ecouteur Multicast (exemple)
public class Ecouteur {
public static void main (String[] args) {
int max = Integer.parseInt(args[0]) ;
MulticastSocket recepteur =null ;
InetAddress groupe = null ;
try {
recepteur = new MulticastSocket(Radio.PORT); // port!
byte[] vals = new byte[Radio.DATA_MAX_SIZE] ;
groupe = InetAddress.getByName(Radio.GROUP) ;
recepteur.joinGroup(groupe) ;
new DatagramPacket(vals, vals.length) ;
for(int ix = 0; ix <max; ix++) {
recepteur.receive(recvPack) ;
Logger.global.info(Byte.toString(vals[0])) ;
} //for
Logger.global.log(Level.SEVERE,"multicast", exc) ;
} finally {
if(null != recepteur && null != groupe) {
try {recepteur.leaveGroup(groupe) ;
}catch(IOException exc) {/*ignore*/}
}
}
}
}
10/195
Rvision : J3
Date : 4/6/02
10
Programmation rseau
Point intermdiaire :changesUDP-Multicast
Exercice ( faire chez soi : lexercice est long et cette partie du cours est
facultative)
Pour les amateurs de Loto traditionnel (appel aussi Rafe dans
certaines rgions) raliser un jeu de loto en rseau:
pour chaque poste de joueur on gnre une carte de loto (3
ranges de 9 cases), seules 15 cases portent un chiffre.
le maitre de jeu (un serveur multicast) publie intervalles
rguliers un numro au hasard compris entre 1 et 90.
le joueur qui gagne est celui qui a coch toutes ses cases et qui
ragit le plus vite (et qui ne triche pas!).
Voir class java.util.Random pour gnrer des nombres
alatoires.
10
10/196
Rvision : J3
Date : 4/6/02
Programmation rseau
Rvision : J3
Date : 4/6/02
Dispositifs avancs dE/S 11
Points essentiels
Deux aspects trs diffrents des systmes dentre/sortie disponibles en
Java:
Un dispositif de la famille des ots (streams) les entres/sorties
objet: ObjectInputStream, ObjectOutputStream
Une catgorie de systme dentre/sortie ne suivant pas le modle
des ots: la package java.nio
11
11/198
Rvision : J3
Date : 4/6/02
Dispositifs avancs dE/S
E/S dobjets
Les classes DataInputStream, DataOutputStream pemettent de
lire/crire des donnes java dans un ot: donnes scalaires
(readBoolean, readInt, readDouble, etc.) et chane de caractres
UNICODE codes en UTF-8 (readUTF).
Les classes ObjectInputStream et ObjectOutputStream disposent
des mmes fonctionnalit mais permettent en plus de lire ou crire des
instances dobjet :
try {
ObjectOutputStream oos =
new ObjectOutputStream(
new BufferedOutputStream(
new FileOutputStream(nomFichier)));
oos.writeObject(new BigDecimal(6.55957)) ;
oos.flush() ;
...
} catch(IOException exc) { /*log correct */}
Et inversement :
try {
ObjectInputStream ois =
new ObjectInputStream (
new BufferedInputStream(
new FileInputStream(nomFichier))) ;
BigDecimal taux = (BigDecimal) ois.readObject() ;
....//
}catch(ClassNotFoundException xc) { /* log */
}catch(IOException exc) { /* log*/
}
On notera que readObject() tant dclare avec un rsultat de type
Object on doit utiliser une opration de projection de type (cast) pour
pouvoir crire une affectation correcte. Dautre part il nest pas sr que la
JVM dispose du type effectif de lobjet transmis par le ot do la
ncessit de capter lexception correspondante (ClassNotFound); par
ailleurs la lecture dun objet dans le ot alors que cest un primitif qui sy
trouve provoquera un erreur dentre/sortie.
11/199
Rvision : J3
Date : 4/6/02
11
Les objets dans un ot
Tous les objets sont-ils susceptibles dtre envoys dans un ot (chier,
ligne de communication, etc.)?
Et dabord quelles sont les donnes qui sont concernes par le processus
de linarisation de linstance (serialization). Ici lobjectif est de transmettre
ltat de linstance pour pouvoir la reconsituer, outre le fait que lmetteur
et le rcepteur de lobjet doivent avoir un minimum daccord sur la classe
correspondante, il faut comprendre que:
Certains objets sont, par nature, non susceptibles dtre transmis
parce que leur tat rel nest pas reproductible, et/ou parce que
ces instances dpendent dlments de contexte qui ne sont pas
transmissibles entre JVM. Citons, par exemple, les threads ou les
disposititfs dentre-sortie eux-mmes.
Les dispositifs dentre/sortie dobjets ont donc besoin dune
information leur indiquant explicitement que la linarisation est
licite. Les objets concerns doivent donc implanter une des
interfaces Serializable (protocole control par le dispositif
dE/S) ou Externalizable (protocole spcique dni et
control par le programmeur).
Une tentative dcriture dun objet non-Serializable provoque
une NotSerializableException.
Il peut tre souhaitable de soustraire certaines variables membres
de linstance au processus de linarisation (par exemple parce que
ces variables ne sont pas Serializable!).
Un modicateur particulier: transient permet dindiquer que le
champ nest pas transmissible.
Les variables partages (membres static) ne sont pas
transfres.
Les autre modicateurs comme private, protected, etc. nont
aucun effet sur le mcanisme de linarisation.
11
11/200
Rvision : J3
Date : 4/6/02
Objet adapt la linarisation (exemple)
En supposant une classe Adresse marque Serializable:
import java.io.* ;
public class Salarie implements Serializable {
public final String id ;
private String nom ;
private Adresse adresse ;
private transient Salarie manager ;
....
public Salarie(String nom, String id) {
this.id = id ;
this.nom = nom ;
.....
}
public void associeManager(String managerId) {
...//
}
...
}
Discussion: Quelle raisons peut-on avoir pour associer le modi cateur
transient au champ manager?
11/201
Rvision : J3
Date : 4/6/02
11
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!).
Un mcanisme particulier (qui assure la proprit ci-dessus) fait
que le ot mmorise les instances. 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 ot aura reu des
informations qui lui permettent de sassurer que le protocole avec
lObjectOutputStream correspondant est correct. Ces
informations se trouvent dans les donnes initiales du ot (crites
par louverture de ObjectOutputStream correspondant).
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.
haut
proprio=X
gauche
droite
bas1
proprio=X
gauche *
droite
bas2
proprio=X
gauche *
droite *
haut
proprio *
gauche
droite
bas1
proprio *
gauche *
droite
bas2
proprio *
gauche *
droite *
transfert Objet
transient
11
11/202
Rvision : J3
Date : 4/6/02
Personnalisation de la linarisation
Modi cations des oprations lies aux objets Serializable
On peut personnaliser de diverses manires la faon dont la linarisation
opre en traitant une instance. Le mode opratoire principal consiste
dclarer dans la classe deux mthodes symtriques de responsabilit
private.
Reprenons lexemple prcdent de la classe Salarie:
public class Salarie implements Serializable {
public final String id ;
private String nom ;
private Adresse adresse ;
private transient Salarie manager ;
.... ;
private void writeObject(ObjectOutputStream oos)
throws IOException {
oos.defaultwriteObject() ;
if( null != manager ) {
oos.writeUTF(manager.id) ;
} else {oos.writeUTF() ;}
}
private void readObject(ObjectInputStream ois)
ois.defaultReadObject() ;
String idManager = ois.readUTF() ;
associeManager(idManager) ;
}
Par convention ces deux mthodes writeObject, readObject sont
prises en compte par le mcanisme de linarisation.
Ici les mthodes de ObjectStream defaultRead/Write permettent
doprer la lecture/criture normale de linstance, mais ensuite on
complte le protocole avec dautres donnes.
11/203
Rvision : J3
Date : 4/6/02
11
Point intermdiaire :changesdobjets
Mini-exercice :
Toujours un client graphique et un serveur autonome :
Le client qui veut se connecter au serveur, gnre un objet de
type java.sql.Timestamp par :
new Timestamp(System.currentTimeMillis()) ;
Lobjet est envoy au serveur qui le lit et le renvoie
accompagn dun autre Timestamp gnr sur le serveur.
Le code client lit les deux Timestamp, en gnre un troisime
et afche les 3 objets. (on pourra ainsi constater les drives
ventuelles des horloges!).
Pour les trs rapides: sur le serveur tracez les caractristiques de
votre interlocuteur (adresse IP).
11
11/204
Rvision : J3
Date : 4/6/02
Le package java.nio
Le package java.nio introduit un certain nombre de mcanismes
dentre/sortie qui ne se situent pas dans la philosophie des ots:
Les entres/sorties sont opres indirectement sur des Buffers.
Le type principal de Buffer est ByteBuffer, mais il existe aussi
des CharBuffer, IntBuffer, etc. Chacun a des oprations
spciques pour lire ou crire diffrents types de donnes.
Lectures et critures peuvent ventuellement se produire sur le
mme Buffer et il y a une position courante qui se dplace en
consquence.
Le package java.nio.channels dnit des channels c.a.d des
dispositifs dentre/sortie. Une srie dinterfaces dnissent par
exemple des Channels capable de lire ou dcrire partir de
ByteBuffers. Le point important est que ces oprations peuvent
tre asynchrones (mais atomiques du point de vue des threads: un
thread qui tente une opration dE/S sur un channel bloque tant
quune autre opration dE/S est en cours sur ce mme channel et
nest pas termine -ou interrompue-).
Chaque type effectif de Channel peut avoir des caractristiques
propres susceptibles dtre exploites.
Les FileChannels permettent, par exemple, davoir un
mapping direct entre le chier systme et un ByteBuffer
correspondant (technique performante uniquement sur de trs
gros chiers); ils permettent galement de mettre des verrous sur
des chiers ou des portions de chiers (toutefois il nest pas
garanti que ces verrous soient opposables dautre processus que
la JVM courante -ceci est dpendant du systme-).
Les SocketChannels et ServerSocketChannels sont des
exemples de channel selectable. Un seul thread peut tre bloqu sur
une opration select, au rveil il pourra obtenir la liste des
channels sur lesquels une opration dentre/sortie est demande.
Ce dispositif permet de raliser des serveurs performants qui
nont pas besoin de faire vivre autant de threads quil y a de
sockets disponibles.
11/205
Rvision : J3
Date : 4/6/02
11
Mise en oeuvre de Buffers
1. Allocation dun Buffer
int taille = 2 + 30 ;
ByteBuffer buff= ByteBuffer.allocate( taille ) ;
Il est galement possible davoir une allocation avec
corrrespondance directe avec un dispositif sous-jacent (mapping
avec dispositif de lecture/criture dun chier par ex.). Dans ce cas
les reads explicites et les rewinds des phases 2 et 3 ne sont pas
ncessaires.
2. Lecture (par exemple) partir dun Channel :
ReadableByteChannel chan =
new RandomAccessFile(nomFic,"rw").getChannel() ;
chan.read(buff) ;
3. Pour exploitation du Buffer il faut ramener le curseur:
buff.rewind() ;
4. On exploite maintenant le Buffer:
short num = buff.getShort() ;
position
courante
************************
position
courante
************************
position
courante
************************
position
courante
11
11/206
Rvision : J3
Date : 4/6/02
Un exemple de mise en oeuvre de Buffers
Exemple de codage de protocoles utilisant des donnes de taille xe: on
code ici une chaine de taille maximum 30 ; le protocole demande que lon
indique dabord la taille de la chane
public class ProtocolA {
public final int TAILLE_MAX = 30;
public static final String CODAGE = "US_ASCII";
ByteBuffer buff = ByteBuffer.allocate(2 + TAILLE_MAX) ;
public synchronized String decode(ReadableByteChannel chan)
throws IOException{
buff.clear() ;// Attention ne fait pas le mnage!
if( 0> chan.read(buff)) return null ;
buff.rewind() ;
short num = buff.getShort() ;
byte[] octets = new byte[num] ;
buff.get(octets) ;
return new String(octets, CODAGE) ;
}
public synchronized void code (
WritableByteChannel chan, String chaine)
buff.clear(); // ne fait pas le menage
byte[] octets = chaine.getBytes(CODAGE) ;
short num = (short) octets.length ;
if( num > TAILLE_MAX) {
throw new IllegalArgumentException(chaine+ ":too long");
}
buff.putShort(num) ;
buff.put(octets) ;
buff.rewind() ;
chan.write(buff) ;
}
Lexploitation de protocoles spciques dautres plate-formes non-java
est accessible du fait de lexistence de convertisseurs de caractres
(java.nio.charset-lutilisation des services de String employs ici
sont trs couteux-) et de Buffers spcialiss avec une autre convention
poids-fort/poids-faible (par ex. appel de:
buff.order(ByteOrder.LITTLE_ENDIAN) ;)
(on notera dans lexemple que le Buffer buff ntant pas nettoy on
trouvera dans le Channel des octets sans signication -la mthode
clear() nefface pas les octets dans le Buffer-).
11/207
Rvision : J3
Date : 4/6/02
11
Une mise en oeuvre de la classe prcdente :
public static void main(String[] args) throws Exception {
RandomAccessFile rfil = new RandomAccessFile(args[0],"rw") ;
FileChannel fc = rfil.getChannel() ;
ProtocolA proto = new ProtocolA() ;
String res;
while(null != (res = proto.decode(fc))) {
System.out.println(res) ;
}
rfil.close() ;
...
}
11
11/208
Rvision : J3
Date : 4/6/02
Ventilation des lectures/critures dans des Buffers
Les channels GatheringByteChannel et ScatteringByteChannel
acceptent des oprations sur un ensemble ordonn de ByteBuffers (on
dcoupe ainsi le traitement des diffrentes parties dun protocole).
Exemple:
Charset ascii = Charset.forName("US-ASCII") ; // exception possible
utilisation pour un protocole :
public void code (GatheringByteChannel gath,
short val, String chaine)
ByteBuffer myShort = ByteBuffer.allocate(2) ;
myShort.order(ByteOrder.LITTLE_ENDIAN) ;
CharBuffer myJavaString = CharBuffer.allocate(LG_CHAINE);
myJavaString.put(chaine) ;
myJavaString.rewind() ;
myShort.putShort(val) ;
myShort.rewind() ;
ByteBuffer buff = ascii.encode(myJavaString) ;
gath.write(new ByteBuffer[] {myShort, buff}) ;
}
Les channels associ des chiers (FileChannel), des Sockets
(SocketChannel), des datagrammes (DatagramChannel) et des
pipes java (Pipe.SinkChannel et Pipe.SourceChannel) ont des
capacits de ventilation.
Channel
ByteBuffer1
ByteBuffer2
ByteBuffer3
une seule opration read/write
ventile sur plusieurs Buffers
11/209
Rvision : J3
Date : 4/6/02
11
11
11/210
Rvision : J3
Date : 4/6/02
E/S asynchrones , slecteurs
Les SelectableChannels permettent des oprations dentre/sortie
non bloquantes. On enregistre chaque Channel en attente dune
opration auprs dun Selector. On peut ainsi raliser des serveurs
utilisant un nombre limit de threads.
Dans cet exemple cest un code client qui va tenter de contacter en
parallle un certain nombre de serveurs pour obtenir le service echo
(service standard sur le port 7).
public class Echo {
public static final int ECHO_PORT = 7 ;
public static final long TIME_OUT = 60000L ;
Selector veille = Selector.open() ;
ByteBuffer message =
ByteBuffer.wrap("hello".getBytes("US-ASCII")) ;
for(int ix = 0 ; ix < args.length ; ix++) {
try {
SocketChannel sckc = SocketChannel.open() ;
sckc.configureBlocking(false) ;
SelectionKey skey = sckc.register(veille,
SelectionKey.OP_READ| SelectionKey.OP_CONNECT);
skey.attach(args[ix]) ;// annotation libre!
sckc.connect(
new InetSocketAddress(args[ix], ECHO_PORT)) ;
} catch (Exception exc) {
Logger.global.log(Level.SEVERE,args[ix],exc) ;
}
}
Ici on cre un SocketChannel par nom de machine hte pass en
paramtre. Chaque SocketChannel est rendu asynchrone et est
enregistr auprs dun slecteur . Ce Selector permet une opration
bloquante select qui permet dobtenir un ensemble de channels sur
lesquels une opration dE/S est en attente (ici on sinscrit pour surveiller
les oprations de connection OP_CONNECT et les oprations de lecture
OP_READ).
11/211
Rvision : J3
Date : 4/6/02
11
while( veille.keys().size() >0 ) {
try {
// appel bloquant
int nbSelected = veille.select(TIME_OUT) ;
if(nbSelected == 0) {
System.out.println("pas de selection") ;
}
Iterator it = veille.selectedKeys().iterator() ;
while(it.hasNext()) {
SelectionKey skey = (SelectionKey) it.next() ;
SocketChannel sckc =(SocketChannel) skey.channel();
if( skey.isReadable()) {
System.out.println(
"response from "+skey.attachment()) ;
skey.cancel() ;// annulle clef
sckc.close() ; // ferme le channel
} else if (skey.isConnectable() ) {
sckc.finishConnect() ;// conclusions connx
System.out.println(
"connected to " +skey.attachment()) ;
message.rewind() ;
sckc.write(message) ;
}
}
Logger.global.log(Level.SEVERE,"",exc) ;
}
}
Ici on sort de chaque select avec un ensemble (Set) de clefs qui
permettent de retrouver le channel correspondant. On peut tester le type
dopration en cours.
pour une opration de lecture, on invalide la clef et on ferme le
channel.
pour une opration de connexion, on termine les oprations de
connexion (finishConnect) et on envoie le message pour le
service echo.
Le read de lecture nest pas utilis ici. Du fait de lasynchronisme il nest
pas garanti que toute lecture soit complte: il faut donc soigneusement
mettre au point tout protocole dchange.
11
11/212
Rvision : J3
Date : 4/6/02
Complments
Complments sur la linarisation
Comme un ObjectStream mmorise les instances il est possible de
forcer la lecture/criture dinstances sans conservation de refrence au
moyen des mthodes writeUnshared/readUnshared (attention les
champs objets dune instance unshared ne sont pas automatiquement
considrs comme unshared).
Dans le cadre dune personnalisation du mcanisme de linarisation noter
quon peut aussi mettre en place un mcanisme de remplacement qui
permette de rendre un objet diffrent de celui qui a t plac dans le ot
(voir personnalisation avec mthodes writeReplace/readResolve sur
lobjet linraris et autorisation de scurit correspondante, voir aussi la
mthode resolveObject spcique au Stream)
On peut aussi lire les champs comme dans defaultReadObject
(ventuellement sans connaitre a priori la classe cible) on rcupre
lensemble des valeurs de champs dans une instance de
ObjectInputField.GetField rendue par la mthode
dInputStream readFields.(voir technique symtrique putFields pour
les OutputStream)
La personnalisation de bas niveau pour les objets qui implantent
linterface Externalizable passe par la dnion des mthodes de cette
interface (writeExternal, readExternal).
11/213
Rvision : J3
Date : 4/6/02
11
Expressions rgulires
Le package java.util.regex permet de programmer des analyseurs
dexpressions rgulires:
public class IOProps {
private static Pattern clefValeur ;// thread safe
static {
try {
clefValeur = Pattern.compile(
"^\\s*(\\w*)\\s*:(.*)$", Pattern.MULTILINE) ;
} catch (PatternSyntaxException exc) {
assert false : exc ; //si code ci-dessus modifi!
}
}// static
public static Properties propsDepuis(CharSequence seq) {
Properties props = new Properties() ;
try {
Matcher match = clefValeur.matcher(seq) ;
while(match.find()) {
props.put(match.group(1), match.group(2).trim()) ;
}
} catch(Exception exc) {
Logger.global.log(Level.SEVERE, "", exc) ;
}
return props ;
}
}
Ici on permet danalyser une CharSequence (StringBuffer, String
ou CharBuffer). Chaque ligne est de la forme clef : valeur .
Lexpression regulire dcrit cette syntaxe (on notera les doubles \ du
fait des contraintes de la syntaxe des chanes Java).
Ici utilisation dune assertion . Le code doit se compiler avec loption:

javac -source 1.4 ....
et pour valider le contrle de lassertion:
java -ea ...
11
11/214
Rvision : J3
Date : 4/6/02
Utilisation avec une CharSequence obtenue partir dun Buffer de
java.nio:
public static void main(String[] args) throws Exception {
FileChannel fc = new
RandomAccessFile(args[0],"rw").getChannel() ;
MappedByteBuffer mbb=
fc.map(FileChannel.MapMode.READ_WRITE,0,1000) ;
CharBuffer cseq = mbb.asCharBuffer() ;
Properties props = IOProps.propsDepuis(cseq);
System.out.println(props) ;
}
(bien entendu la mthode load de java.util.Properties rend ce
service dune manire plus complte -ceci nest quun programme de
dmonstration-).
Rvision : J3
Date : 4/6/02
Les rfrences distantes (R.M.I.) 12
Points essentiels
Ce chapitre constitue une introduction technique R.M.I..
R.M.I. permet de demander des services des objets distants cest dire
des objets situs dans une autre J.V.M (ventuellement active sur une
autre machine). Bien que demandant un peu dintendance de mise en
place, R.M.I permet une architecture lgante et performante pour raliser
des changes client-serveur.
12
12/216
Rvision : J3
Date : 4/6/02
Les rfrences distantes (R.M.I.)
La notion de service distant
Imaginons une application bancaire trs simple qui gre des comptes.
Voici, par exemple, les grandes lignes de la classe Compte :
....
public synchronized void depot(BigDecimal val) {
....;
}
public synchronized void retrait(BigDecimal val)
throws ExceptionDecouvert{
...//
}
public BigDecimal getSolde() {
return ....;
}
}
et voici la ralisation du guichet qui nous permet dobtenir une
refrence sur une instance de Compte lorsquon connait le nom du client:
public class Banque {
.... //
public Compte compteClient (String client) {
return .....;
}
}
On voudrait maintenant accder aux services de cette application depuis
un poste distant. Ici une instance de Banque vit sur le serveur, et les
instances de Compte restent galement sur cette mme JVM. On voudrait
donc accder aux services rendus par ces instances depuis dautres
machines sur le rseau.
Comment le code rsident sur lapplication cliente va-t-il voir les objets
distants?
12/217
Rvision : J3
Date : 4/6/02
12
La d nition dun service distant
Le principe du dcouplage entre une demande de service et sa ralisation
prend ici tout sons sens. Le code demandeur du service du cot client na
pas connatre le type effectif de lobjet cot serveur: il va y avoir entre les
partenaires un accord de dnition dinterface de service.
Un autre principe important entre en jeu: la prsence du rseau nest pas
transparente. On ne dnit pas un service distant de la mme manire
quun service local (rendu dans la mme J.V.M): en effet tout appel de
mthode implique un transfert de donnes sur une ligne de
communication et cette opration peut chouer pour des raisons lies aux
entre/sortie distantes.
La dnition des services distant de Compte et de Banque passe par une
dnition dinterface particulire:
import java.rmi.* ;
public interface CompteDistant extends Remote{
public void depot(BigDecimal val) throws RemoteException ;
public void retrait(BigDecimal val)
throws ExceptionDecouvert, RemoteException ;
public BigDecimal getSolde() throws RemoteException ;
}
------------------------------
public interface BanqueDistante extends Remote{
public CompteDistant compteClient (String client)
throws RemoteException ;
}
chaque interface de service R.M.I (Remote Method Invocation)
doit hriter de linterface de marquage java.rmi.Remote.
1
chaque mthode du contrat doit imprativement dclarer la
propagation dun RemoteException (en plus des exceptions qui
leur sont propres).
1. une interface de marquage est une interface sans dnition de
mthode
12
12/218
Rvision : J3
Date : 4/6/02
Principe de la communication entre objets distants
Du cot serveur un objet vu de lextrieur doit tre export. Le
mcanisme correspondant va mettre en place un thread dcoute
pour traiter les demandes de services.
Sur les anciennes versions de RMI il existait explicitement des
classes dobjets chargs de grer RMI cot serveur: les Skeletons.
Du cot client un objet particulier appel talon (Stub) gre le
dialogue avec lobjet distant. Cest ce Stub qui est utilis par
lapplication cliente au travers de linterface de service
(CompteDistant dans lexemple).
Les deux codes chargs de grer les aspect rseaux vont collaborer
pour tablir des Sockets les maintenir, les rtablir, grer le
protocole dinvocation de mthode distante, et grer des changes
pour un garbage-collector distribu
Point important: tous les paramtres des mthodes, leur rsultat,
les exceptions susceptibles dtre propages sont tous linariss. Ils
doivent donc tous tre dun type primitif ou Serializable
unCompte
code client
interface
CompteDistant
talon
Stub
agent
dexportation
12/219
Rvision : J3
Date : 4/6/02
12
Exportation dun objet
Le package java.rmi.server traite de lexportation des objets RMI.
Une des solutions possibles consiste dnir lobjet export comme une
sous-classe de UnicastRemoteObject:
import java.rmi.* ;
import java.rmi.server.* ;
public class CompteExporte extends UnicastRemoteObject
implements CompteDistant {
private Compte compte ;
public CompteExporte (Compte cpt) throws RemoteException {
compte=cpt ;
}
public void depot(BigDecimal val)throws RemoteException {
compte.depot(val) ;
}
public void retrait(BigDecimal val) throws ExceptionDecouvert,
RemoteException {
compte.retrait(val) ;
}
public BigDecimal getSolde() throws RemoteException{
return compte.getSolde() ;
}
}
Lobjet export implante linterface de service distante
Tout constructeur dobjet export doit explicitement propager
lexception RemoteException (ne serait-ce parce que tous les
constructeurs de UnicastRemoteObject le font!)
12
12/220
Rvision : J3
Date : 4/6/02
Sur le mme principe le code de lobjet Banque :
import java.rmi.* ;
import java.rmi.server.* ;
public class BanqueExportee extends UnicastRemoteObject
implements BanqueDistante {
private Banque bank ;
public BanqueExportee()throws RemoteException {
bank = new Banque() ;
}
public CompteDistant compteClient (String client)
throws RemoteException{
// on peut faire partager le mme Compte
// plusieurs code clients! (bien entendu le programmeur
// doit grer cette concurrence daccs)
return new CompteExporte(bank.compteClient(client)) ;
}
}
Gnration des classes de Stub
Pour dialoguer avec ces objets exports il faut disposer dinstance de
Stub. Les classes correspondantes sont automatiquement gnres par
lutilitaire rmic partir des chiers .class des objets serveurs.
Exemple (script UNIX):
rmic -v1.2 -classpath $CLASSES -d $CLASSES pack.CompteExporte
On trouvera ainsi dans le rpertoire des classes du package (dans
larborescence situe sous le rpertoire dsign par $CLASSES) un chier
automatiquement gnr et de nom CompteExporte_Stub.class.
(de la mme manire on gnrera BanqueExportee_Stub.class ).
12/221
Rvision : J3
Date : 4/6/02
12
Les instances de Stub
Prenons par exemple un code client qui ralise les oprations suivantes:
BanqueDistante banqueDistante ;
..... // codes divers
CompteDistant cpt = banqueDistante.compteClient(client);
La rfrence banqueDistante est type par linterface de service, mais
lobjet qui va rendre le service est de type effectif
BanqueExportee_Stub.
Ce talon va appeler lobjet serveur, lui signier lappel de la mthode et
lui passer largument linaris.
Lobjet serveur va renvoyer en rsultat une instance de
CompteExporte_Stub qui reprsente la rfrence distante.
Cette rfrence distante est vue par le code client comme de type
CompteDistant et cest sur cette rfrence que seront invoques les
mthodes correspondantes:
cpt.depot(mnt);//le talon communique avec lobjet correspondant
Mais comment a-t-on amorc ce processus, comment a-t-on obtenu la
premire refrence distante sur un objet BanqueExportee ?
CompteDistant cpt =
banqueDistante
.compteClient(client);
cpt.depot(mnt) ;
CLIENT instance de
BanqueExportee_Stub
co
m
p
te
C
lie
n
t(clie
n
t)
rsultat
instance de
CompteExporte_Stub
BanqueExportee
instance de
CompteExporte
instance de
d
e
p
o
t
(
m
n
t
)
12
12/222
Rvision : J3
Date : 4/6/02
Annuaire dobjets distants
Pour obtenir une rfrence sur un objet distant lapplication cliente doit
sadresser un agent bien connu, pour lui demander un objet rfrenc
par un nom. Inversement une application serveur qui souhaite rendre un
service distant doit appeler cet annuaire pour enregistrer une rfrence
sous ce nom (dans lexemple nous avons choisi le mot-clef banque).
En RMI cette application dintermdiation est appele registry.
Lapplication de rfrence fournie avec le SDK est rmiregistry :
Elle doit tre lance sur le mme hte rseau que le serveur.
Elle coute par dfaut sur le port 1099
On peut la lancer avec la commande:
rmiregistry [num_port]
SERVEUR
REGISTRY
CLIENT
instance de
BanqueExportee_Stub
e
n
r
e
g
i
s
t
r
e

l
e

S
t
u
b
s
o
u
s

l
e

n
o
m

b
a
n
q
u
e
d
e
m
a
n
d
e
d
e
r
f
re
n
c
e
so
u
s le
n
o
m

b
a
n
q
u
e
cre un objet
BanqueExportee
12/223
Rvision : J3
Date : 4/6/02
12
Le serveur: enregistrement auprs du Registry
Voici un code de serveur trs simple:
...
import java.rmi.* ;
public class Serveur {
BanqueExportee bank = new BanqueExportee() ;
Naming.rebind("banque", bank) ;
}
}
On cr un objet Banque serveur
On lenregistre auprs du registry sous le nom banque
Cet appel a pour effet denvoyer une instance de
BanqueExportee_Stub au registry.
Il y a deux mthodes statiques possibles dans la classe Naming :
bind(..) pour un enregistrement dnitif, rebind(..) pour
des re-enregistrements successifs.
On notera que le programme ne sarrte pas: il y a en effet maintenant un
thread dcoute lattente des demandes de services sur lobjet export.
Utiliser UnicastRemoteObject.unexportObject() pour retirer un
objet du runtime RMI.
Pour une forme plus dvelope de largument du bind voir page
suivante.
12
12/224
Rvision : J3
Date : 4/6/02
Le client: demande au Registry
Un code de client trs simple :
...
import java.rmi.* ;
public static void main (String[] arg) throws Exception {
........
BanqueDistante bk =
(BanqueDistante) Naming.lookup("rmi://"+hote+"/banque") ;
CompteDistant cpt = bk.compteClient(nomClient) ;
cpt.depot(depot) ;
cpt.retrait(retrait) ;
........;
}
}
La demande de refrence distante initiale au registry se fait au
moyen de la mthode Naming.lookup() .
Comme cette mthode rend un rsultat de type Object noter la
ncessiter doprer une projection de type (cast).
Largument de dsignation est une chane en format URL de la
forme:
rmi://hote:port/clef
hote est la dsignation de la machine hte sur laquelle tourne
le registry
la dsignation du port est optionnelle (si le registry coute sur
un port diffrent du port par dfaut 1099)
clef est le mot-clef sous lequel est enregistr le service.
on notera que cette dsignation est aussi valable pour le bind
//code cot serveur
Naming.rebind(rmi://localhost:6666/banque, bank );
// ici registry coute sur port 6666
12/225
Rvision : J3
Date : 4/6/02
12
Check-list pour une mise en oeuvre simple
Le cadre de notre exemple suppose que les classes suivantes soient
accessibles dans le classpath des applications:
SERVEUR:
Banque.class CompteDistant.class
BanqueDistante.class CompteExporte.class
BanqueExportee.class CompteExporte_Stub.class
BanqueExportee_Stub.class ExceptionDecouvert.class
Compte.class Serveur.class
Remarquer la ncessit de disposer des classes de Stub : le bind envoie
au registry une instance de ce type.
RMIREGISTRY:
BanqueDistante.class CompteDistant.class
BanqueExportee_Stub.class CompteExporte_Stub.class
Le cas est ici particulier pour deux raisons:
rmiregistry dcode les objets qui lui sont passs et donc a
besoin des classes et interfaces correspondantes au type des
Stubs. Ce comportement est particulier cette implantation de
rfrence du service de registry.
Dans le cas de chargement dynamique des classes de Stub (voir
annexe) il faut, au contraire, viter davoir de telles classes
accessibles dans le classpath de rmiregistry.
CLIENT:
BanqueDistante.class CompteDistant.class
BanqueExportee_Stub.class CompteExporte_Stub.class
Client.class ExceptionDecouvert.class
Ici cest la prsence des classes de Stub qui peut surprendre. Dans de
nombreux cas de dploiement, comme pour les Applets, ceci ne pose
aucun problme puisque cest le serveur qui dploie le code client. Dans
dautres cas on pourra sorienter vers un chargement dynamique de ces
classes (voir annexe).
12
12/226
Rvision : J3
Date : 4/6/02
Exercice:miseenplacedeR.M.I .
Exercice :
On dnira un service distant de la manire suivante :
package rmi ;
import java.rmi.* ;
import java.sql.* ;
public interface TimeService extends Remote {
Timestamp[] echo(Timestamp arg) throws RemoteException;
}
Ici le service demand est analogue celui vu dans Mini-
exercice:, page 188. On envoie un Timestamp et on en rcupre
deux. Le nom du service (tel quil sera index par le Registry)
sera timestamp.
Faire lexercice en plusieurs phases :
dabord en lanant le test en local et en partageant toutes les
classes entre client, serveur et registry
ensuite en sparant soigneusement les classes visibles par le
client, le serveur, le registry (toujours en local).
Pour les trs rapides (ou ceux qui rvisent) : faire fonctionner le
service entre plusieurs machines avec tlchargement
dynamique des classes.
12/227
Rvision : J3
Date : 4/6/02
12
Complments
Telechargement dynamique des codes de classe
Un partenaire dun change RMI peut se trouver dans une situation o il
ne dispose pas dun code de classe:
parcequune classe de Stub na pas t installe localement
parceque le type effectif dun objet accompagnant un appel de
mthode nest pas connu localement. Du fait du polymorphisme
on peut avoir en effet un type runtime diffrent du type dclar
dans le contrat de linterface Remote.
On notera que cette incertitude peut exister pour chacun des partenaires
(client ou serveur -de fait la distinction traditionelle entre client et serveur
peut devenir peu pertinente: un serveur pouvant prendre linitiative
dun change vers un objet export par le client-).
Contexte de scurit
Le premier point est que toute J.V.M qui tlcharge dynamiquement du
code doit mettre en place un SecurityManager (sil nest pas dj
prsent -cas des Applets par ex.-):
System.setSecurityManager(new SecurityManager());
//ou par option lancement de la J.V.M.
La prsence dun environnement de scurit ncessite une mise en place
dune politique de scurit:
java -Djava.security.policy=myrmi.policy pack.Client .....
Ce chier policy contenant une entre de type :
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).
12
12/228
Rvision : J3
Date : 4/6/02
Mise en place du tlchargement des classes
Les objets impliqus dans des changes R.M.I. contiennent une annotation
qui permet dindiquer une URL dorigine de la classe correspondante. Le
ClassLoader local qui dsrialize lobjet peut prendre en compte cette
URL pour charger la classe en fonction du protocole indiqu dans lURL.
De manire pratique le protocole le plus utilis est http. Ce qui suppose la
mise en place dun serveur http pour exporter le code des classes.
Pour annoter correctement les objets et Stubs impliqus :
Soit xer la proprit java.rmi.server.codebase dans le
contexte de la JVM exportatrice.
Soit xer un ensemble dURL accessibles et les passer un
URLClassLoader. Exemple :
public static void main(String args[]) throws Exception {......
URL[] tbURL = new URL[args.length] ;
for (int ix = 0 ; ix < args.length; ix++) {
tbURL[ix] = new URL(args[ix]) ;
}
URLClassLoader classLoad = new URLClassLoader( tbURL) ;
Remote ss = (Remote) classLoad.loadClass(nomClasseRacine).
newInstance();
// ici la classe racine a un constructeur sans paramtre
//attention les classes dpendantes ne doivent pas tre vue du classpath local
Naming.rebind("Server", ss) ;
}
}
Dans les deux cas il est souhaitable dorganiser un dploiement dans des
jars et dutiliser des URLs comme:
jar:http://server:8080/mesclasses.jar!/
Attention: dans ce cas si on utilise rmiregistry comme registry prendre
soin de lui retirer toute visibilit directe sur les classes concernes (sinon il
reconstituera des annotations errones au moment o il envoie le Stub au
client).
12/229
Rvision : J3
Date : 4/6/02
12
Personnalisation des mcanismes sous-jacents RMI
La classe java.rmi.server.UnicastRemoteObject dispose de
constructeurs ou de mthode de classe qui permettent :
de xer le numero de port utilis pour exporter lobjet (utile
dans un contexte sous SecurityManager).
de personnaliser les Sockets sous-jacentes (via
RMIServerSocketFactory et RMIClientSocketFactory).
On peut ainsi par exemple mettre en place des sockets UDP, des
Sockets SSL -voir package javax.net.ssl-), ou des Sockets
avec compression des donnes, etc. voir:
docs/guide/rmi/socketfactory/index.html
Pour une liste des Properties de conguration voir :
docs/guide/rmi/spec/rmi-properties.html.
Par ailleurs RMI est automatiquement capable de transformer une requte
bloque par un pare-feu en appel HTTP POST.
12
12/230
Rvision : J3
Date : 4/6/02
Serveurs dormants, serveurs rsilients
Les objets exports ne sont pas ncessairement des instances situes dans
un serveur actif. On peut tout fait dclarer un objet pour lexportation
et ensuite arrter la JVM serveur.
Lorsquun client demande une rfrence lobjet est resuscit au sein dune
JVM active.
Ces objet particuliers sont Activatable et un dmon systme particulier
rmid sert enregistrer ces objets et les activer (notons que rmid joue
aussi le rle de registry).
Voir docs/guide/rmi/activation.html
12/231
Rvision : J3
Date : 4/6/02
12
JINI
(voir http://www.jini.org)
JINI permet lorganisation de services spontans sur un rseau.
Cest un ensemble de protocoles et de rgles de programmation qui
permettent de rechercher un service (ou de le publier), de tlcharger
un mandataire (proxy) de service (code java qui gre un dialogue avec le
service, ou partie de service qui sexcute sur le client).
Lutilisation de ces services par des codes clients est soumis des rgles
de comportement (bail de ressource sur le serveur, vnements distribus,
transactions distribues).
Protocoles de recherche et dcouverte
Unicast Discovery Protocol : on se connecte un
ServiceRegistrar connu (URL Jini, messages TCP): pour
enregistrement dun service, recherche dun service,
enregistrement dune consigne (vt. distribu).
Multicast Request: demande de recherche de ServiceRegistrar
diffuse en multicast.
Multicast Announcement: un ServiceRegistrar annonce son
existence sur le rseau.
12
12/232
Rvision : J3
Date : 4/6/02
Utilisation des Services
RMI Classique
Code sur client + talon de communication
Code sur client
talon
client
telechargement talon
service (Java)
RMI, ....
mandataire service
client
telechargement proxy (+talons)
service (Java)
RMI, ....
+talon
service autonome
client
telechargement code service
12/233
Rvision : J3
Date : 4/6/02
12
Talon daccs un service non-Java
Codes Java servant de frontaux des dispositifs matriels
mandataire
client
telechargement proxy
(non Java)
protocole priv
mandataire
mandataire
telechargement proxy
(Java?)
mandataire
device
code substitut
device
device
service
12
12/234
Rvision : J3
Date : 4/6/02
Rvision : J3
Date : 4/6/02
Laccs aux bases relationnelles (J.D.B.C) 13
Points essentiels
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
Ce chapitre constitue une introduction technique JDBC:
Pilotes (drivers) JDBC.
tablissement de connexion et contexte dexcution (Statement)
requtes la base et rcupration des rsultats.
13
13/236
Rvision : J3
Date : 4/6/02
Laccs aux bases relationnelles (J.D.B.C)
Le package java.sql
Le package java.sql permet de raliser des applications qui exploitent
des bases de donnes relationnelles. Laccs aux bases se fait en SQL au
travers de modalits standardises (JDBC). En ce sens JDBC est typique
des API daccs: java.sql dnit essentiellement des interfaces daccs qui
sont ralises par des pilote (drivers).
Une application Java qui fait appel JDBC sappuiera sur un petit nombre
de classes standard (comme le DriverManager) qui permettront
lutilisation de classes complmentaires livres avec les pilotes spciques
une base..
Liste indicative des pilotes :
http://java.sun.com/products/jdbc/jdbc.drivers.html
APPLICATION JAVA
JDBC DriverManager (java.sql)
Driver JDBC (fournisseur A) Driver JDBC (fournisseur B)
S.G.B.D. A
S.G.B.D. B
13/237
Rvision : J3
Date : 4/6/02
13
Types de drivers JDBC
Le choix des pilotes dpend des caractristiques de la base et du type
darchitecture systme retenue :
architecture deux parties : lapplication communique
directement avec le systme de gestion de base de donnes.
architecture trois parties : lapplication cliente fait traiter ses
requtes par une application serveur qui gre les modalits et la
cohrence des appels la base de donnes.
Le protocole client/serveur peut trs bien ne contenir aucune
rfrence SQL.
On classe habituellement les pilotes en 4 catgories:
1. Pont JDBC-ODBC : permet de transcrire les appels JDBC en appels
un driver ODBC (les deux modles sont assez proches). Les
driver ODBC sont raliss en code natif.
2. Accs direct lAPI de la base: le pilote est ralis en code natif sur
lAPI daccs la base de donnes.
3. Driver deux parties JDBC-Net: le pilote est en pur Java et
communique avec un correspondant capable de dialoguer
directement avec la (ou les) base(s).
4. Driver pur Java sur protocole spcique: le pilote retranscrit les
appels JDBC en appels du protocole distant spcique la base.
13
13/238
Rvision : J3
Date : 4/6/02
Modalits dune session JDBC
La ralisation dun accs JDBC aux bases de donnes suit toujours le
mme schema :
Dsignation de la ressource cible. Cette dsignation se fait au
travers dune chane de description dune URL et permet dactiver
un pilote particulier. Le DriverManager permet cette activation
condition que le programmeur ait veill lui faire connatre un
pilote adapt.
Obtention dun objet de type Connection.
Permet de grer une session de consultation de la base.
Obtention dun objet de type Statement.
Dans le cadre dune Connection on obtient des objets de ce type
pour formuler des requtes SQL la base.
Exploitation des rsultats : si la requte est de type SELECT, les
objets ResultSet permettent de recuprer les donnes
rsultantes.
13/239
Rvision : J3
Date : 4/6/02
13
Enregistrement des pilotes
Il y a deux mthodes principales pour faire connatre un pilote JDBC
lobjet DriverManager:
Chargement explicite de la classe principale du pilote.
Les spcications JDBC prcisent que lorsque le ClassLoader
charge une classe qui ralise lAPI dcrite par java.sql.Driver,
celle ci doit crer un objet du type correspondant et lenregistrer
auprs du DriverManager.
Dans ce cas il faut:
Connatre le nom complet de la classe Driver: par ex.
com.imaginary.sql.msql.MsqlDriver
Faire en sorte que cette classe (ou une archive .jar la contenant)
soit dans le CLASSPATH de lapplication.
public class LanceurJDBC {
public static void main(String[] args) throws Exception{
Class.forName(args[0]);
// nom de la classe passe en paramtre dappel
// ou de tout autre manire
....
}
}
Communication dune liste de classes Driver au travers des
arguments dappels de Java:
java -Djdbc.drivers=com.acme.ThatDriver:fr.gibi.MonPilote
Le DriverManager peut interroger le systme pour connatre la
liste des pilotes disponibles et les charger.
13
13/240
Rvision : J3
Date : 4/6/02
Dsignation de la ressource
Pour tablir une connexion une base on va adresser au
DriverManager une chane didentication de la ressource recherche.
Cette chane doit suivre une syntaxe standard qui suit la syntaxe des URL:
jdbc:sous_protocole:parametres
sous_protocole dsigne un type spcique de mcanisme pouvant tre
ralis par un ou plusieurs pilotes. Le contenu des paramtres dpendent
de ce sous_protocole. Il convient donc de suivre le mode demploi
indiqu par les pilotes pour savoir dsigner une ressource dune manire
adapte: cest la rdaction correcte de cette url qui permettra au pilote de
se reconnatre.
En effet le DriverManager essaie, dans lordre, tous les pilotes
enregistrs en leur passant lurl demande. Le premier pilote qui sait
tablir la connexion emporte la dcision.
Voici, par exemple, une chane de caractres reprsentant une url pour un
pilote de nom msql qui tablit une connexion rseau sur une machine
serveur sur un numro de port donn:
jdbc:msql://monserveur:6666/MaBase
ceci tant fabriqu par exemple par linstruction:
String url = jdbc:msql:// +nomserveur + : + port +/ + base ;
13/241
Rvision : J3
Date : 4/6/02
13
Obtention de la connexion
Pour obtenir une instance daccs la base conforme
java.sql.Connection on doit appeler:
Connection conx = DriverManager.getConnection(chaineUrl) ;
Cet objet permet dobtenir des informations sur la base et, surtout, permet
dtablir des contextes de requtes.
Dautres formes de getConnection existent; si aucun pilote nest trouv
le rsultat sera null, si une anomalie sest produite au regard des
exigences de la base une SQLException sera propage.
13
13/242
Rvision : J3
Date : 4/6/02
Obtention dun contexte de requtes
Des objets contexte de requte (Statement) peuvent tre obtenus dans
le cadre dune connexion. Un objet Statement permet de traiter une seule
requte SQL statique en mme temps. Si lon veut traiter plusieurs
requtes en parallle il faut ouvrir plusieurs Statement.
// cration dun contexte de requte
Statement stmt = null ;
try {
stmt = conx.createStatement() ;
} catch (SQLException exc) {
// traiter exception
}
Lobjet Statement permet dexcuter divers type de requtes, ainsi , par
exemple, pour une requte modicative de la base (INSERT, UPDATE,
DELETE):
//
int nombre = stmt.executeUpdate(
DELETE from Clients WHERE id = 16899023455);
La mthode executeUpdate(sqlString) renvoie un entier qui
reprsente le nombre denregistrements affects.
13/243
Rvision : J3
Date : 4/6/02
13
Exploitation de resultats
Dans un contexte Statement la mthode executeQuery permet de lancer
une requte rendant des enregistrements (SELECT):
ResultSet res = stmt.executeQuery(SELECT * from Clients) ;
Lobjet de type ResultSet permet dobtenir des informations sur le rsultat
et de parcourir les enregistrements:
while (res.next()) {
String nomClient = res.getString(2) ;
String id = res.getString(1) ;
table[ix++] = new Client(id, nomClient) ;
}
Les colonnes de lenregistrement sont numrotes partir de 1. Pour
chaque colonne on peut rcuprer le rsultat dans un type Java appropri
en utilisant une des mthodes getXXX() -voir table page suivante-. Il est
galement possible de rechercher une colonne par son nom plutot que par
son numro dordre.
Les ResultSets permettent galement des rcuprations par blocs de N
enregistrements:
regroupement de rsultats en blocs : stmt.setFetchSize(25);
navigation dans les rsultats : rs.previous(), ...
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() -si le service est
accessible pour le driver considr-
13
13/244
Rvision : J3
Date : 4/6/02
Correspondance des types de donnes SQL en Java
Quelques types Java standard pour la correspondance avec divers types
SQL courants.
Table 1: Correspondance de types SQL en Java
Type SQL Type Java
CHAR String
VARCHAR String
LONGVARCHAR String (ou Stream)
NUMERIC java.math.BigDecimal
DECIMAL java.math.BigDecimal
BIT boolean
TINYINT byte
SMALLINT short
INTEGER int
BIGINT long
REAL float
FLOAT double
DOUBLE double
BINARY byte[]
VARBINARY byte[]
LONGVARBINARY byte[]
DATE java.sql.Date
TIME java.sql.Time
TIMESTAMP java.sql.Timestamp
13/245
Rvision : J3
Date : 4/6/02
13
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. :
Exemple
public void prepStatement(ListeReservations liste){
PreparedStatement prepStmnt = msqlConn.prepareStatement(
"UPDATE Flights SET numAvailFCSeats = ? WHERE flightNumber = ?" );
for ( .... ) { //parcours de la liste
Reservation rsv = .... ;
prepStmnt.setInt(1,
(Integer.parseInt(rsv.numAvailFCSeats) - 1));
prepStmnt.setLong(2, rsv.FlightNo);
int rowsUpdated = prepStmnt.executeUpdate();
...
}
}
Si la requte prpare avait t base sur un SELECT cest un
executeQuery quil aurait fallu appeler.
13
13/246
Rvision : J3
Date : 4/6/02
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. .
Exemple de requte 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.execute();
int FCSeats = querySeats.getInt(2);
int BCSeats = querySeats.getInt(3);
int CCSeats = querySeats.getInt(4);
} catch (SQLException SQLEx){
Logger.global.log(Level.SEVERE,return_seats, SQLEx);
}
On notera la syntaxe de dsignation de la procdure (type ODBC)
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.
13/247
Rvision : J3
Date : 4/6/02
13
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() ;
13
13/248
Rvision : J3
Date : 4/6/02
Exercice:miseenplacedeJ .D.B.C
Exercice :
Lanimateur mettra votre disposition une base de donnes, son
driver et vous donnera une description des tables disponibles.
Raliser une interface graphique qui vous permette de taper une
requte SELECT et de consulter les rsultats de votre requte.
Rvision : J3
Date : 4/6/02
ANNEXES 14
14
14/250
Rvision : J3
Date : 4/6/02
ANNEXES
Rvision : J3
Date : 4/6/02
Programmation dynamique 15
Points essentiels
La classe Class et le package java.lang.reflect : les bases de la
programmation dynamique.
La dcouverte et lutilisation au runtime dobjets dun type inconnu.
La dnition de protocoles auquels doivent adhrer ces objets inconnus
(convention de Bean) permet de crer des outils capables de manipuler
dynamiquement des catgories dobjets.
15
15/252
Rvision : J3
Date : 4/6/02
Programmation dynamique
Pourquoi une programmation sur des classes dcouvertes au
runtime?
Java tant un langage compil, les codes que lon crit oprent sur des
classes connues au compile-time. Il est pourtant possible dcrire des
programmes qui oprent sur des classes inconnues du compilateur:
Du fait du polymorphisme des oprations dnies par des types
connus du compilateur (classes ou interfaces) peuvent en ralit
oprer sur des objets ayant un type effectif non apparent. Les
classes correspondantes peuvent mme avoir t dcouvertes et
charges dynamiquement au run-time .
Au del de lutilisation dune API connue il peut savrer utile
de dcouvrir lAPI dune classe au run-time et, mieux encore, de
lutiliser. Cest en particulier le cas doutils crits en Java et chargs
de mettre en oeuvre des codes Java crits par ailleurs:
compilateurs (vrication de la compatibilit dune A.P.I.),
gnration de protocoles (comme la linarisation des objets), outils
de dploiement, assemblages interactifs de composants,
composants graphiques gnriques sadaptant des modles
prdnis, etc.
15/253
Rvision : J3
Date : 4/6/02
15
La classe java.lang.Class
Pour pouvoir oprer un niveau interprtatif sur un objet on a besoin
dune instance de la classe java.lang.Class reprsentant la classe de
lobjet. Une telle instance peut sobtenir par :
chargement dynamique dune classe au travers dun ClassLoader.
On doit alors fournir une chane donnant le nom complet de la
classe (hirarchie de package + nom de classe). Par ex.:
Class laClasse = Class.forName(nom) ;
obtention de la classe dune instance (obtenue par diffrents
moyens, par exemple un transfert distant):
Class laClasse = instance.getClass() ;
consultation dun champ statique connu au compile-time:
Class maClasse = MaClasse.class ;
Class tabCharClass = char[].class ;
cas particulier des scalaires primitifs :
Class typeInt = int.class ;
Class typeInt = Integer.TYPE ;
(ces classes reprsentant des primitifs servent reprer par ex. les
types des arguments dune mthode: on ne peut pas faire des
oprations objet avec)
15
15/254
Rvision : J3
Date : 4/6/02
Obtention des informations sur la classe
A partir dune instance de Class (qui ne rpond pas la condition
isPrimitive()) on peut obtenir des informations sur les constituants.
Par exemple :
quels sont les champs dclars dans la classe? :
Field[] champs = maClasse.getDeclaredFields() ;
si la classe reprsente une tableau (isArray() rpond true), il
est possible de connatre le type des composants :
Class typeComposants = classeTableau.getComponentType();
quelles sont les mthodes dnies dans la classe?
Method[] mthodes = maClasse.getDeclaredMethods() ;
quels sont les constructeurs dnis dans la classe?
Constructor[] constructeurs = maClasse.getDeclaredConstructors();
Lutilisation des classes correspondantes (Field, Method,
Constructor,...) relve du package java.lang.reflect.
15/255
Rvision : J3
Date : 4/6/02
15
Le package java.lang.reflect
La manipulation des champs, mthodes, constructeurs peut poser des
problmes de droit daccs. Pourtant certains mcanismes (voir par
exemple la linarisation) doivent pouvoir agir indpendament des
privilges de responsabilit (private, protected, etc.):
Membres et constructeurs de la classe drivent tous de
java.lang.reflect.AccessibleObject qui dispose dune
mthode setAccessible(boolean) qui permet de passer outre
aux privilges de responsabilit.
Bien entendu nimporte quel code ne peut raliser ces oprations
sans disposer dune autorisation de scurit adequate:
java.lang.reflect.ReflectPermission
suppressAccessChecks
15
15/256
Rvision : J3
Date : 4/6/02
Les champs
A partir dune instance de Field on peut obtenir :
son nom:
String nom = champs[ix].getName() ;
son type
Class type = champs[ix].getType() ;
dautres informations comme les modicateurs utiliss.
On peut galement consulter la valeur de ce membre (ou la modier). Les
mthodes get/setXXX permettent de lire ou modier une valeur sur une
instance passe en paramtre :
Field leChamp0 = laClasse.getDeclaredFields() [0] ;
.... // obtention informations de type
.... // fixation evt. des droits daccs
.....// cration dun objet de ce type: valeurObjet
leChamp0.set(instance, valeurObjet) ;
Si le champ est statique le premier argument est ignor (il peut tre null).
15/257
Rvision : J3
Date : 4/6/02
15
Les mthodes
A partir dune instance de Method on peut obtenir :
son nom:
String nomMeth = mthodes[ix].getName() ;
le type de son rsultat
Class typeRes = mthodes[ix].getReturnType() ;
les types des paramtres
Class[] typeparms = mthodes[ix].getParameterTypes() ;
dautres informations comme les modicateurs utiliss ou les
exceptions dclares.
On peut galement invoquer la mthode dynamiquement sur cet objet en
lui passant les arguments appropris (et ventuellement en rcuprant
une InvocationTargetException qui chane une Exception
provoque par linvocation sous-jacente).
Method laMeth0 = laClasse.getDeclaredmethods() [0] ;
.... // fixation evt. des droits daccs
.... // obtention informations des type des paramtres
.....// cration dun tableau darguments
//** pour chaque type primitif on passe une instance
//** de la classe dencapsulation correspondante
//** par ex. un Integer pour int.TYPE
try {
laMeth0.invoke(instance, tableauArguments) ;
} catch (Exception xc) {}
Si la mthode est statique le premier argument est ignor (il peut tre
null).
15
15/258
Rvision : J3
Date : 4/6/02
Les constructeurs
A partir dune instance de Constructor on peut obtenir :
les types des paramtres
Class[] typeparms = constructeurs[ix].getParameterTypes() ;
dautres informations comme les modicateurs utiliss ou les
exceptions dclares.
La cretion dynamique dune instance peut se faire par
maClasse.newInstance() (sil ya un constructeur sans paramtres) ou
par linvocation de newInstance :
try {
constructeur.newInstance(tableauArguments) ;
} catch (Exception xc) {}
15/259
Rvision : J3
Date : 4/6/02
15
Les tableaux
La classe java.lang.reflect.Array permet des accs particuliers aux
objets qui sont des tableaux (elle permet galement la cration de tableaux
une ou plusieurs dimensions).
Pour accder en lecture ou en criture les mthodes set/getXXX sont
dots dun argument reprsentant lindex dans le tableau. Les mthode
statiques newInstance permettent de crer des tableaux dun type
donn:
public static Object[] subArray(Object[] el, int idx, int size) {
...// verification validit paramtres
Object[] res =
(Object[])java.lang.reflect.Array.newInstance(
el.getClass().getComponentType(), size);
System.arraycopy(el, idx, res, 0, size);
return res;
}
15
15/260
Rvision : J3
Date : 4/6/02
Point intermdiaire :programmationdynamique
Mini-exercice (pour ceux qui rvisent):
Reprendre linterface graphique Question/Rponse et sur le
modle du code qui analysait les demandes de calcul sin/cos faire
un code qui utilise les services statiques dune classe (comme
Math ou StrictMath) pour leur demander lexcution dun calcul:
atan 3.45 // calcule arc-tangente de 3,45
essayer de perfectionner en permettant des arguments en nombre
et types varis et en internationalisant :
racinecarre 6,5859
15/261
Rvision : J3
Date : 4/6/02
15
Mandataires dynamiques
Un mandataire (proxy) est un objet qui sinterpose devant un autre objet
pour intercepter les messages et modier la faon dont un service est
rendu. En Java cette interposition peut se raliser :
soit avec un objet dun type qui sous-classe le type de la rfrence
demande et qui spcialise ses mthodes (pour evt. dlguer un
objet du type demand: Voir Introduction: un cas particulier
dhritage/dlgation, page 167.)
soit avec un objet qui implante une interface correspondante au
type demand et qui dlgue ventuellement une instance de
lobjet initial.
Dans ce dernier cas les mandataires dynamiques (dynamic proxy)
permettent de gnrer dynamiquement des objets dun type dont la classe
effective est dnie au runtime. Il peut y avoir plusieurs raisons pour
oprer dynamiquement dont, en particulier, le fait que linterposition ne
sadresse pas forcment un objet dun type effectivement connu au
compile-time, ou le fait que le comportement rajout dans linterposition
soit relativement gnrique (c.a.d sapplique des ensembles de
mthodes).
f()
g()
rfrence X
f()
g()
rfrence X
f()
g()
class X
Interposition extends X
f()
g()
rfrence T
f()
g()
rfrence T
f()
g()
class X implements T
Interposition implements T
15
15/262
Rvision : J3
Date : 4/6/02
On pourrait, par exemple, faire de linterposition dynamique pour faire
des appels de mthodes sur des objets distants implantant une certaine
interface (une sorte de R.M.I. simpli sans Stub), ou encore pour
interposer des controles avant et aprs tous les appels de mthodes
destins un objet (vrication dinvariant de classe, mise en place de
transactions,...).
Schma simpli dutilisation pour des appels distants:
Une ralisation correcte tant trs complexe nous allons esquisser un
mcanisme de mise en place dappels distants :
public interface RemoteService extends Remote {
Clef remoteGet(Object support, DescripteurMethode factory,
Object[] arguments) throws RemoteException ;
Object remoteInvoke(Clef support, DescripteurMethode meth,
Object[] arguments) throws RemoteException ;
}
et maintenant un mcanisme rendant un objet dynamique et bas sur les
mcanismes dnis par java.lang.reflect.Proxy :
public class RemoteFacts {
private RemoteService server ;
private class Invoker implements InvocationHandler {
Clef key ;
public Object invoke(Object proxy, Method method,
Object[] args) throws Throwable {
// le service demand sur lobjet
// est repass au serveur
//pour simplier on na pas tenu compte des exceptions
Object res = server.remoteInvoke(key,
new DescripteurMethode(method, key), args) ;
return res ;
}
Invoker(Clef key) {
this.key = key ;
}
}
15/263
Rvision : J3
Date : 4/6/02
15
// sert gnrer un objet sur le serveur en spcifiant
// une mthode factory sur un objet
// le serveur renvoie une clef qui lui permettra
// de retrouver lobjet effectif
public Object remoteObjectAs(Class interf,
Object factorySupport, Method factory,Object[] args)
throws Exception{
Clef key = server.remoteGet( factorySupport,
new DescripteurMethode(factory), args) ;
// on gnre le Stub dynamique!
// (manque les exceptions,etc....
return Proxy.newProxyInstance (interf.getClassLoader(),
new Class[] {interf}, new Invoker(key)) ;
}
...
Ici lobjet gnr par newProxyInstance sera conforme au contrat
dni par linterface demande, et dlguera des appels de mthodes un
object correspondant connu uniquement sur le serveur. Dans lexemple
cest linstance de Invoker qui est charg doprer la dlgation.
Utilisation :
// on ne prcise pas ici la nature de lobjet banque
// ni le fonctionnement des Classes Clef et
// DescripteurMethode
CompteDistant cpt = (CompteDistant) rmFact.remoteObjectAs(
CompteDistant.class,banque, getCompteMeth,
new Object[]{nomClient});
// et maintenant on peut appeler les mthodes de CompteDistant
// sur lobjet rsultant : cest un objet de plein droit
// qui implante linterface demande
15
15/264
Rvision : J3
Date : 4/6/02
Notion de Bean
Le dveloppement bas sur des composants ne se limite pas deux
phases : dveloppement/gneration de code et excution. Dautres phases
intermdiaires sont possibles puisque les codes dvelopps dans la
premire phase peuvent tre rutiliss pour dautres dveloppements,
assembls dans le cadre de dploiement, etc.
Les capacits de rexion/introspection de Java permettent danalyser un
code binaire existant pour rechercher certaines proprits qui pourront
tre exploites dans ces phases intermdiaires dassemblage de
composants. Si entre le producteur primaire de code et lutilisateur de
composant on met en place des conventions sur ces proprits des codes
on pourra ainsi faciliter laction doutils permettant dassembler des
composants, de gnrer des codes de dploiement, etc.
On appelle ces conventions des conventions de Bean. La convention de
Bean initiale a surtout t orient vers lutilisation de composants
graphiques mais il existe maintenant dautres conventions
complmentaires comme Entreprise Java Bean (composants
dentreprise dploys dans un serveur dapplication) ou Federated
Management Bean (composants de services dadministration
dynamique sur le rseau -voir JIRO: une extension de JINI consacre
ladministration rpartie-).
15/265
Rvision : J3
Date : 4/6/02
15
Les packages java.beans et
java.beans.beancontext
Ces packages fournissent les interfaces, les classes fondamentales pour
exploiter la convention Bean initiale. Quelques points :
Dans un objet bean sont nomms proprit des attributs
particulirement visibles, leur modication peut ventuellement
permettre de paramtrer la mise en oeuvre de lobjet. Par
convention on a une proprit si on a une paire de mthodes
accesseur/mutateur de la forme setXXX(typeX) et typeX
getXXX() (XXX devient le nom de la proprit)
On peut mettre en place un systme de gestion dvnements lis
la modication de proprits. Certains beans pourront par
exemple apporter leur veto des modications sur un autre bean.
Un objet Introspector permet de consulter de manires souple
les caractristiques bean dun objet. Il opre par
reexion/introspection classique mais aussi en recherchant un
objet BeanInfo qui a pour rle de documenter un autre objet. La
fourniture dun tel objet dinformation permet de modier les
rsultats de lintrospection classique (par exemple en ltrant et en
limitant lexposition de certaines mthodes), mais aussi en
fournissant des informations complmentaires qui sont
susceptibles dtre exploit par programme (ou de manire
lisible par un tre humain).
On peut mettre en place des mcanismes simplis de persistance
pour sauvegarder une instance . La restauration dun bean depuis
un bean cont est un moyen de crer une instance comportant
un tat dja (partiellement) paramtr.
Les services de beancontext permettent dorganiser le
dploiement dynamique de beans au sein dun conteneur qui
leur fournit des informations sur les services disponibles dans le
contexte et sur les vnements dajout et de suppression dautres
beans au sein du conteneur.
15
15/266
Rvision : J3
Date : 4/6/02
XMLEncoder, XMLDecoder
Ces deux classes du package java.beans sont la fois une application
typique du mcanisme de beans et une partie intgrante des systmes de
persistance/change de composants.
Les objets sont mis dans un format qui sappuie sur les connaissances de
lAPI publique et ceci permet de ne pas tenir compte dvolutions de
dtails de limplantation effective du code (au contraire de la linarisation
classique). De plus cette sauvegarde se fait en XML ce qui rend ce format
trs pratique pour gnrer des tests (que lon peut crire ou modier la
main).
On peut sauvegarder en XML des objets qui ne sont pas des beans
classiques mais pour lesquels le processus de reconstitution est
document dans une meta-classe BeanInfo :
public final int id ;
public final String nom ;
private String adresse ;
private long nimporteQuoi ;
public Client (int id, String nom, String adr) {
this.id = id ;
this.nom = nom ;
adresse = adr ;
}
public String getAdresse() {
return adresse ;
}
public void setAdresse(String adr) {
adresse = adr ;
}
....
}
15/267
Rvision : J3
Date : 4/6/02
15
Le BeanInfo ( titre dexemple: le processus complet nest pas ici
explicit)
public class ClientBeanInfo extends SimpleBeanInfo{
private PersistenceDelegate persD =
new DefaultPersistenceDelegate(
new String[] { "id" , "nom", "adresse"});
public BeanDescriptor getBeanDescriptor() {
return new BeanDescriptor(Client.class) {
{setValue("persistenceDelegate", persD);}
} ;
}
}
Un programme de sauvegarde
Client cli1 = new Client(133, "dupond" , "rue des lois") ;
XMLEncoder enc = new XMLEncoder(new FileOutputStream(nomFic)) ;
enc.writeObject(cli1) ;
...
Le contenu du chier XML :
<?xml version="1.0" encoding="UTF-8"?>
<java version="1.4.0" class="java.beans.XMLDecoder">
<object class="dyn.Client">
<int>133</int>
<string>dupond</string>
<string>rue des lois</string>
</object>
</java>
En lecture par XMLDecoder lobjet sera reconstitu par appel du
constructeur avec les paramtres corrects (issus de la sauvegarde des
attributs signicatifs).
Pour plus de dtails lire :
http://java.sun.com/products/jfc/tsc/articles/persisten
ce4
15
15/268
Rvision : J3
Date : 4/6/02
Rvision : J3
Date : 4/6/02
Rfrences faibles 16
Points essentiels
Les techniques dites de rfrences faibles permettent dinteragir avec le
glaneur de mmoire (Garbage Collector) pour lui permettre de recuprer
certaines rfrences dobjets non-critiques, ou pour tre averti si certains
objets sont dsallous en mmoire (ou en passe de ltre).
Les rfrences java.lang.ref.Reference sont des objets qui
encapsulent une autre rfrence qui est gre dune manire particulire.
Seront abords les References de type :
SoftReference
WeakReference (ainsi que WeakHashMap)
PhantomReference
Dans ce chapitre nous utiliserons le terme gnrique rfrence faible
pour recouvrir ces diffrentes catgories.
16
16/270
Rvision : J3
Date : 4/6/02
Rfrences faibles
Problmatiques de caches mmoire
Un des caractristiques de Java est que la dsallocaiton des objets en
mmoire nest pas sous le contrle du programmeur. Une tche de fond
de basse priorit le glaneur de mmoire (Garbage Collector) soccupe de
rechercher les objets qui ne sont plus rfrencs, dsalloue leur empreinte
dans le tas et tasse la mmoire pour mieux la grer. Pour permettre des
volutions des algorithmes de nettoyage mmoire la norme ne xe que
trs peu de contraintes sur le comportement des garbage-collectors. Le
programmeur sait quil peut aider une meilleure gestion de la mmoire
en mettant explicitement certaines rfrences null et aprs certaines
oprations de nettoyage il peut explicitement faire appel
System.gc() (dans ce dernier cas il ne lui est mme pas garanti que le
garbage-collector rpondra sa requte!)
Or il existe des situations o un certain degr de collaboration avec le
glaneur de mmoire est souhaitable. Un de ces cas est lorsque lon
souhaite grer des caches mmoire cest dire que pour des raisons
doptimisation on cherche conserver des objets en mmoire mais de
manire raisonne et compatible avec les autres exigences de demande de
place. Deux exemples:
Soit un programme qui afche des images (reprsentation en
mmoire couteuse); selon les interactions de lutilisateur certaines
images sont afches souvent, dautres non. Pour optimiser la
gestion de la mmoire on souhaite adopter le comportement
suivant: lorsquune image est demande elle est charge depuis
une URL (oprations couteuse en temps!), les images sont
conserves en mmoire mais lorsquon a besoin de place les
images les moins rcemment accdes seront elimines: si
lutilisateur re-demande une image limine elle sera recharge
depuis son URL dorigine.
Soit un programme qui ralise un calcul trs couteux en temps et
en ressources. Des statistiques font apparatre quil nest pas rare
que ce calcul soit appel avec les mmes paramtres. On dcide
alors de mmoriser les rsultats des prcdents calculs: si le calcul
a dj t effectu on sera en mesure de rendre directment le
rsultat sans oprer un nouveau calcul couteux. La mmoire
ntant pas indniment extensible un moment donn il faudra
se rsoudre abandonner tout ou partie des stocks de rsultats.
16/271
Rvision : J3
Date : 4/6/02
16
Rfrences faibles
Les objets rfrences
La package java.lang.ref introduit des objets References. Ce sont des
objets qui encapsulent une refrence vers un autre objet.
Lide est que le programmeur puisse conserver une refrence forte vers
un objet Reference, mais la rfrence contenue (referent object) fait lobjet
dune convention avec le garbage-collector. Ce dernier peut ventuellement
rcuprer lobjet contenu qui devient inaccessible au programmeur.
Laccs indirect lobjet cible se fait par la mthode get() :
monObjet = (TypeMOnObjet) maReference.get() ;
if(monObjet == null) { // ah tiens! GC est pass!
Bien entendu on ne doit pas conserver de rfrence forte sur lobjet cible
point par la rfrence faible (lobjet ne serait pas rcupr par le glaneur
et la stratgie serait mise en echec).
Il existe diffrent types standard de rfrences faibles en fonction de la
stratgie attendue du glaneur de mmoire.
Il est possible dassocier un objet Reference une le
ReferenceQueue dans laquelle le glaneur mettra lobjet Reference
aprs avoir recupr lobjet cible. De cette manire le glaneur dcide de
signaler au programme son action sur la Reference : on peut donc
mettre en place une surveillance de cette le (bloquante: mthode
remove(), ou non bloquante: mthode poll()) et dcider dactions
correspondantes (par exemple dtruire la rfrence forte sur lobjet
Reference lui-mme).
Reference
objet
symbole (rfrence forte)
rfrence destructible
16
16/272
Rvision : J3
Date : 4/6/02
Rfrences faibles
SoftReference
Voici, par exemple, le code simpli dune Applet qui met en place la
stratgie de cache dimages expose prcdemment.
import java.applet.* ;
import java.awt.* ;
import java.net.* ;
import java.lang.ref.* ;
public class WeakApplet extends Applet {
SoftReference ref ;
URL base ;
String nom ;
public void init() {
base = getDocumentBase() ;
nom = getParameter("image");//se proteger contre erreur ici!
ref = new SoftReference(getImage(base,nom)) ;
}
public void paint(Graphics gr) {
Image img = null ;
if ( null == (img = (Image) ref.get())) {
img = getImage(base, nom) ;
ref = new SoftReference(img) ;
}
gr.drawImage(img, 50, 50, this) ;
}
}
16/273
Rvision : J3
Date : 4/6/02
16
Rfrences faibles
SoftReference
Les objets cibles refrencs au travers de rfrences faibles de type
SoftReference sont rcupres la discrtion du glaneur de mmoire.
Celui-ci est toutefois encourag essayer de les liminer en pargnant en
priorit les objets les plus rcemment crs ou accds. En ce sens ces
refrences sont moins faibles que les objets WeakReference.
On utlisera des SoftReferences pour suivre des stratgies bases sur
lhistorique des accs et dune manire analogue on pourra utiliser des
WeakReferences pour avoir des stratgies moins discriminantes (et
probablement plus performantes).
On notera, dans le code dillustration, quune fois quon a constat que
lobjet cible a disparu, il faut crer une nouvelle rfrence pour contenir
un objet reconstitu.
16
16/274
Rvision : J3
Date : 4/6/02
Rfrences faibles
WeakReference
Les refrences WeakReference contiennent des objets cibles qui sont
rcupres librement par le glaneur de mmoire.
Souvent ces objets servent de reprsentant canonique pour un autre
objet cest dire de clef caractristique par laquelle on peut,
potentiellement, retrouver un objet donn. Pour pousser cette analogie
nous alllons reprendre lexemple du cache de calcul expos
prcdemment et utiliser comme table de recherche un objet de type
java.util.WeakHashMap.
Lobjet caractristique dun calcul est sa combinaison de paramtres. Dans
notre exemple le calcul couteux prendra deux paramtres entiers et
nous allons dcrire un objet reprsentant cette paire:
public class Parm2 {
int x,y ;
public Parm2 (int a, int b) {
x = a; y = b ;
}
public boolean equals(Object autre) {
Parm2 oth = (Parm2) autre ;
return (x == oth.x) && ( y == oth.y) ;
}
public int hashCode() {
return x ^ y ;
}
}
On notera que, cet objet servant de clef pour une table de hash, il faut
soigneusement dnir la combinaison des mthodes equals() et
hashCode().
Dans la WeakHashMap les clefs sont automatiquement gnres comme
refrences faibles et doivent tre le seul point daccs possibles pour les
valeurs quelles reprsentent. Le glaneur de mmoire va pouvoir recuprer
ces valeurs selon ses besoins.
16/275
Rvision : J3
Date : 4/6/02
16
Rfrences faibles
import java.util.* ;
public class CalculEnStock {
WeakHashMap dict = new WeakHashMap() ;
Long grosCalcul(int x, int y) {
.....// gros calcul: (si vous ntes pas convaincu
// essayez la fonction dackermann!)
return new Long(res) ;
}
long calculStock(int x, int y) {
Parm2 parms = new Parm2(x,y) ;
Long res = (Long) dict.get(parms) ;
if( res == null) {
res = grosCalcul(x,y) ;
dict.put(parms, res) ;
}
return res.longValue() ;
}
Ici le dictionnaire des rsultats grossit au fur et mesure des besoins, mais
le glaneur a la facult de mettre le hol cette croissance et dliminer des
rsultats.
Cet exemple est de porte pdagogique : llimination des rsultats
stocks est radicale et peu discriminante (Il ny a pas ici de stratgie
particulire pour choisir les candidats llimination)
1
.
1. Une ralisation plus satisfaisante pourrait par ex. faire appel
java.util.LinkedHashMap utilisant un paramtre spciant
un ordre bas sur laccs et une taille limite controle par
removeEldestEntry
16
16/276
Rvision : J3
Date : 4/6/02
Rfrences faibles
Oprations lies labandon dun objet, naliseurs,
PhantomReferences
Avant de rcuprer lempreinte mmoire dun objet le garbage-collector
appelle sa mthode finalize() (qui doit tre rednie si on veut un
comportment associ cette phase de la vie de lobjet).
Lutilisation de finalize() est dlicate : lappel survient des moments
imprvus, peut tre excut dans des threads diffrents et il nest pas
garanti que tous les objets aient t rcuprs au moment de larrt de la
machine virtuelle (la mthode System.runFinalizersOnExit() a t
rendue obsolete du fait de ces risques).
Les PhantomReferences permettent dassocier, de manire plus souple,
des mthodes cette phase de n de vie .
Exemple. Soit la dnition dune interface:
public interface DerniereVolonte {
public void adieu() ;
}
et maintenant la dnition
public class PresqueFantome extends PhantomReference {
private DerniereVolonte vol ;
public PresqueFantome(
DerniereVolonte vl, Object obj, ReferenceQueue queue){
super(obj,queue) ;
vol = vl ;
}
public void preMortem() {
vol.adieu() ; // se proteger des exceptions
clear() ;
}
}
16/277
Rvision : J3
Date : 4/6/02
16
Rfrences faibles
Les PhantomReferences sont obligatoirement associes une
ReferenceQueue. Quand le glaneur de mmoire va recuprer lobjet cible
de la refrence, son naliseur est appel et la rfrence est mise dans la
le. A partir de ce moment, bien que lempreinte de lobjet naie pas t
recupre, il est impossible dobtenir lobjet (de toute faon get() rend
toujours null sur une telle rfrence) - par contre au cours du traitement
de la refrence il faudra explicitement annuler la rfrence vers lobjet
cible (clear()).
Utilisations possibles de nos refrence PresqueFantomes: admettons
quelles aient t toutes construites avec la le suivante :
final ReferenceQueue ref = new ReferenceQueue() ;
Recupration par un thread en cours dexcution:
Thread th = new Thread(fantomes) {
{setDaemon(true) ;}
public void run() {
while(true) {
try {
Reference curRef = ref.remove();// bloquant!
((PresqueFantome)curRef).preMortem() ;
// suite du mnage .....
} catch(Exception exc) {
curlogger.warning(exc.getMessage()) ;
}
}
}
} ;
th.start() ;
Notons que dans dans ce cas on ne dclenche la mthode associe au
dcs que si le glaneur est pass pour lobjet cible. Il peut tre utile de
prvoir de faire quelque chose pour les autres.
16
16/278
Rvision : J3
Date : 4/6/02
Rfrences faibles
Point intermdiaire :nalisation
Les oprations dclenches au moment du passage du garbage-collector et
les oprations de fermeture de lapplication (shutdown hook) sont
particulirement sensibles car on ne contrle pas compltement ltat de
lapplication au moment o elles se dclenchent. Il faut particulirement
veiller aux dclenchements intempestifs dexceptions et aux problmes de
concurrence daccs.
exercice :
En rutilisant linterface DerniereVolonte de lexemple
prcdent crire une classe Notariat disposant des mthodes de
classe :
public static Reference fabriqueVoeu(Object o, DerniereVolonte v)
public static void executeVoeu(Reference r)
Telles que : si un objet enregistre ses dernires volonts celles-ci
sont obligatoirement excutes:
soit par appel explicite de executeVoeu
soit au moment de la recupration de lobjet par le glaneur de
mmoire .
soit la n de lapplication (si, par exemple, on a conserv
jusquau bout une rfrence forte sur lobjet, ou si le glaneur
nest pas pass).Rcupration au moment de larrt de la
machine virtuelle: Exemple:
Runtime.getRuntime().addShutdownHook(new Thread(notaire) {
public void run() {
// poll() sur la file de references
// + executer voeu sur refs survivantes
}
}) ;
16/279
Rvision : J3
Date : 4/6/02
16
Rfrences faibles
Discussion: quelles utilisations pratiques verriez-vous ce mcanisme?
Par ailleurs si vous ralisiez de cette manire un code fondamental susceptible de
nombreuses r-utilisations dans le temps comment le rendriez-vous paramtrable
ou red nissable?
16
16/280
Rvision : J3
Date : 4/6/02
Rfrences faibles
Complments
Autres techniques dabandon dobjets
Il existe dautres techniques pour dcider dabandon dobjets -
particulirement sur des serveurs -. Ainsi les techniques de bail
(lease) permettent daccorder un client un contexte de service de
dure limite.
Du point de vue du code client cela veut dire que le contexte sur le
serveur nest pas forcment garanti et quil faut renouveler le
bail rgulirement. Dans certaines stratgies le bail nest mme
pas garanti pour une dure donne (voir service de lease sur
JINI). Effectivement dans une situation qui devient tendue un
serveur peut dcider de raccourcir les dlais. On peut donc
facilement imaginer que la ralisation de stratgies fasse appel
des combinaisons de techniques qui tiennent la fois compte de la
qualit du service et des contraintes technique du serveur. Ces
techniques de syntonisation peuvent devenir trs complexes et il
peut devenir intressant de les dlguer des outils spciques.
Rvision : J3
Date : 4/6/02
Utilisation de code natif : J.N.I 17
Points essentiels
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++.
17
17/282
Rvision : J3
Date : 4/6/02
Utilisation de code natif : J.N.I
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 plate-
forme dexcution. Exemple : accs des cartes).
Le systme JAVA nest pas adapt une partie critique de
lapplication 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).
17/283
Rvision : J3
Date : 4/6/02
17
Un exemple : "Hello World" en C
rsum des phases :
Ecriture du code JAVA:
Cration dune classe "HelloWorld" qui dclare une mthode
(statique) native.
Cration des binaires JAVA de rfrence :
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.
17
17/284
Rvision : J3
Date : 4/6/02
Ecriture du code JAVA
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).
17/285
Rvision : J3
Date : 4/6/02
17
Cration des binaires JAVAde rfrence
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 sous-
rpertoire "hi" du rpertoire cibl par loption "-d"
17
17/286
Rvision : J3
Date : 4/6/02
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).
17/287
Rvision : J3
Date : 4/6/02
17
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
*/
(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 :
(JNIEnv * env , jclass curclass) {
return env->NewStringUTF("Hello ");
}
17
17/288
Rvision : J3
Date : 4/6/02
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
17/289
Rvision : J3
Date : 4/6/02
17
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)
17
17/290
Rvision : J3
Date : 4/6/02
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 structures 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.
17/291
Rvision : J3
Date : 4/6/02
17
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
17
17/292
Rvision : J3
Date : 4/6/02
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 dfaut-
JNI 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 dunobjet (lettre L+type +;) .
De mme [Ljava/lang/String; dsigne un rsultat qui est un
tableau une dimension (lettre [) contenant des chanes.
17/293
Rvision : J3
Date : 4/6/02
17
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
17
17/294
Rvision : J3
Date : 4/6/02
Rfrences sur des objets JAVA:
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.
17/295
Rvision : J3
Date : 4/6/02
17
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);
}
...
17
17/296
Rvision : J3
Date : 4/6/02
Invocation de JAVAdans du C
Pour un exemple dvelopp voir dans le rpertoire src/launcher de
linstallation du SDK.
Un tel code doit tre li la librairie binaire JAVA (libjava.so sous
UNIX).
Rvision : J3
Date : 4/6/02
Java et le Web: les applets 18
Points essentiels
Les Applets constituents 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 la lie au navigateur qui la met en oeuvre (cycle de vie
de lApplet).
Les codes qui sexcutent au sein dune Applet sont soumis des
restrictions de scurit.
18
18/298
Rvision : J3
Date : 4/6/02
Java et le Web: les applets
Applets
Une Appliquette (Applet) est une portion de code Java qui sexcute dans
lenvironnement dun navigateur au sein dune page HTML. Elle diffre
dune application par son mode de lancement et son contexte dexcution.
Une application autonome est associe au lancement dun processus JVM
qui invoque la mthode main dune classe de dmarrage.
Une JVM associe un navigateur peut grer plusieurs Applets, grer
leur contexte (ventuellement diffrents) et grer leur cycle de vie
(initialisation, phases dactivit, n de vie).
Lancement dune Applet
Une applet sexcutant dans le cadre dune page HTML, la requte de
lancement et les paramtres associs sont en fait contenus dans le chier
source dcrivant la page.
Le langage HTML (voir http://www.w3.org/MarkUp) permet de
dnir une prsentation partir dun texte contenant des balises (qui sont
des instructions de mise en page). Certaines de ces balises demandent le
chargement de donnes non-textuelles comme des images ou des Applets
Java.
Le lancement dune Applet suppose donc :
La dsignation dun document au navigateur au travers dune
adresse URL (voir http://www.w3.org/Adressing)
Le chargement et la mise en page du document HTML associ
Le chargement du code de lApplet spci dans le document (et
ventuellement le chargement des codes des classes distantes
appeles par lApplet).
La gestion, par la JVM du navigateur, du cycle de vie de lApplet
au sein du document mis en page.
18/299
Rvision : J3
Date : 4/6/02
18
Applets: lancement
Exemple dutilisation de la balise APPLET :
<P> et maintenant notre Applet :
<APPLET code=fr.gibis.applets.MonApplet.class
width=100 height=100>
</APPLET>
classe de lApplet (et dpendants)
http://unserveur/page.html
1. le navigateur demande une URL.
Loading...
Location:
2. charge un document HTML.
<HTML>
<APPLET CODE = ...>
</APPLET>
:
http://unserveur/page.html
3. charge les classes de lApplet.
Navigateur
4.la JVM excute le code.
fichier HTML:
18
18/300
Rvision : J3
Date : 4/6/02
Applets: restrictions de scurit
Dans ce contexte on va excuter des codes de classe : classses distantes
et classes systme de la librairie java locale. Pour viter quun code
distant puisse raliser des oprations contraires une politique de
scurit lmentaire, des rgles par dfaut sappliquent (sandbox security
policy):
LApplet ne peut obtenir des informations sur le systme courant
(hormis quelques informations lmentaires comme la nature du
systme dexploitation, le type de J.V.M., etc.).
LApplet ne peut connatre le systme de chiers local (et donc ne
peut raliser dentre/sortie sur des chiers).
LApplet ne peut pas lancer de processus
Les communications sur rseau (par socket) ne peuvent tre
tablies quavec le site dorigine du code de lApplet.
Bien entendu un code dApplet ne peut pas contenir de code natif (par
essence non portable).
A partir de la version 2 de Java un systme standard de mise en place de
domaines de scurit (Protection Domain) permet dassouplir ces rgles
pour permettre certaines oprations des codes dment authentis
venus de sites connus. On peut ainsi imaginer que lApplet qui vous
permet de consulter votre compte en banque vous permet aussi de
rapatrier des donnes un endroit du systme de chier dni par vous.
18/301
Rvision : J3
Date : 4/6/02
18
Applets: restrictions de scurit
Le modle de scurit Java 2 sapplique ds quun SecurityManager est

prsent et ce aussi bien pour du code tlcharg que pour du code local
18
18/302
Rvision : J3
Date : 4/6/02
Hirarchie de la classe Applet
De par lincorporation dune Applet une prsentation graphique ( la
page du navigateur) toute Applet est, de manire inhrente, une classe
graphique (mme si on peut crer des Applets qui nont aucune action de
nature graphique). A la base lincorporation dune Applet dans une page
HTML revient signaler au navigateur quune zone de dimensions
donnes nest plus gre directement par linterprteur de HTML mais
par un programme autonome qui prend le contrle de la reprsentation
graphique de cette zone.
Toute classe qui est une Applet doit driver de java.applet.Applet
qui est elle-mme une classe drive de java.awt.Panel qui
reprsente un panneau graphique dans la librairie graphique AWT.
18/303
Rvision : J3
Date : 4/6/02
18
Applets: groupes de mthodes
Une Applet tant un Container graphique, elle hrite des mthodes qui
permettent de disposer des composants graphiques dans la zone gre
par la classe. Ce point est trait du point de vue de la programmation
AWT classique, et, dun autre cot , nous allons nous attacher trois
groupes de mthodes:
Mthodes qui sont appeles par le systme graphique pour la
notication dune demande de rafrachissement dune zone de
lcran:
repaint(), update(graphics), paint(Graphics)
Dans le cas o lApplet souhaite grer le graphique de bas niveau
(au lieu de laisser agir le systme automatique attachs des
composant AWT de haut niveau) elle doit conserver un modle
logique des lments graphiques quelle gre et tre capable de les
redessiner la demande.
Mthodes spciques aux Applets et qui leur permettent de
demander au navigateur des informations ou des actions lies au
contexte: informations sur la page HTML courante, chargement
dune ressource sur le site dorigine de la page, etc.
Mthodes spciques aux Applets et leur cycle de vie : le
navigateur doit pouvoir notier lApplet quil veut linitialiser
(init()), quil veut la rendre active ou inactive (start(),
stop()), ou quil veut la dtruire (destroy()).
Par dfaut ces mthodes ne font rien et il faut en rednir
certaines dentre elles pour obtenir un comportement signicatif
de lApplet.
18
18/304
Rvision : J3
Date : 4/6/02
H.T.M.L.: la balise Applet
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=valeur>]
[<PARAM name=Attribut2 value=valeur>]
. . . . .
[HTMLalternatif]
</APPLET>
Exemple :
<APPLET
code=fr.acme.MonApplet.class
width=300 height=400
>
</APPLET>
Evolutions (HTML 4) :
<OBJECT codetype=application/java
classid="fr.acme.MonApplet.class"
width=300 height=400>
>
</OBJECT>
18/305
Rvision : J3
Date : 4/6/02
18
HTML: la balise Applet
. La balise HTML APPLET comporte les attributs suivants :
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. Ce point ne sera pas abord dans ce cours.
object=objectFile.ser permet de spcier une instance dobjet
charger. Ce point ne sera pas abord dans ce cours.
<param name=appletAttribute1 value=value> -- Ces lments permettent
de spcier un paramtre lapplet. Les applets accdent leurs
paramtres par la mthode getParameter().
18
18/306
Rvision : J3
Date : 4/6/02
Mthodes du systme graphique de bas niveau
Applet hritant de Panel il est possible de modier laspect en utilisant les
mthodes graphiques des composants.
Voici un exemple minimal dApplet qui crit du texte de manire
graphique:
import java.awt.* ;
import java.applet.Applet ;
public class HelloWorld extends Applet {
gr.drawString(Hello World?, 25 ,25) ;
}
}
Les arguments numriques de la mthode drawString() sont les

coordonnes x et y du dbut du texte. Ces coordonnes font rfrence la
ligne de base de la police. Mettre la coordonne y zero aurait fait
disparatre la majeure partie du texte en haut de lafchage ( lexception
des parties descendantes des lettres comme p, q etc.)
18/307
Rvision : J3
Date : 4/6/02
18
Mthodes daccs aux ressources de lenvironnement
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 : certaines congurations 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 ressources 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.
18
18/308
Rvision : J3
Date : 4/6/02
Mthodes daccs aux ressources de lenvironnement
Utilisation de la rcupration de paramtres. Exemple de source HTML:
<APPLET code=Dessin.class width=200 height=200>
<PARAM name=image value=duke.gif>
</APPLET>
Le code Java correspondant :
import java.awt.*;
import java.applet.Applet;
public class Dessin extends Applet {
Image img ;
public void init() {// redef. mthode standard cycle vie
String nomImage = getParameter(image) ;
if ( null != nomImage) {
img = getImage(getDocumentBase(),
nomImage);
}
}
public void paint (Graphics gr) {
if( img != null) {
gr.drawImage(img,50,50, this) ;
} else {
gr.drawString(image non charge,
25,25) ;
}
}
}
Les mthodes de chargement de media comme getImage() sont des

mthodes asynchrones. On revient de lappel de la mthode alors que le
chargement est en cours (et, possiblement, non termin). Il est possible
que paint() soit appel plusieurs fois au fur et mesure que limage
devient compltement disponible.
18/309
Rvision : J3
Date : 4/6/02
18
Mthodes du 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 la fentre
courante du navigateur est restaure aprs avoir t iconise ou lorsque la
page qui hberge lapplet 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 dtre en phase
active. 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.
18
18/310
Rvision : J3
Date : 4/6/02
Mthodes du cycle de vie
// Suppose lexistence du fichier son cuckoo.au"
// dans le rpertoire sounds situ dans
// le 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");
// attention syntaxe dURL!!!
}
// mthode de dessin de java.awt.Graphics
gr.drawString("Audio Test", 25, 25);
}
public void start () {
sound.loop();
}
public void stop() {
sound.stop();
}
}
Rvision : J3
Date : 4/6/02
Rappels: syntaxe, spci cations simpli es 19
Contenu:
Rappels sur la syntaxe (simplie)
Condens des spcications dutilisation des variables, mthodes,
constructeurs.
Pour des descriptions plus compltes voir le document de spcication du
langage (J.L.S.) voir:
http://java.sun.com/docs/books/jls/
19
19/312
Rvision : J3
Date : 4/6/02
Rappels: syntaxe, spci cations simpli es
Plan gnral dune classe
Plan gnral des dclarations de classe premier niveau:
package yyy;
import z.UneCLasse ; // A prfrer
import w.* ;
public class XX extends YY implements AA, BB {
// public ou visibilit package
// une classe publique par fichier
// si mthode abstract la classe doit etre abstract
// ordre indiffrent sauf pour les blocs et expressions
// dinitialisation de premier niveau
//MEMBRES STATIQUES
variables statiques
var. statiques initialises
var. statiques final/constantes de classe
mthodes statiques
classes ou interfaces statiques
classes statiques avec accs privilgi
avec la classe englobante.
//MEMBRES DINSTANCE
variables dinstance
var.dinstance initialises
var dinstance blank final
mthodes dinstance
patrons de mthodes dinstance (abstract,...)
classes dinstance
classes avec accs instance englobante
//BLOCS DE PREMIER NIVEAU
blocs statiques
/* valus au moment du chargement de la classe */
blocs dinstance
/* valus au moment de la cration de linstance */
// CONSTRUCTEURS
constructeurs
}
19/313
Rvision : J3
Date : 4/6/02
19
Plan gnral dune interface
public interface JJ extends BB, CC {
var. statiques final/constantes de classe
classes ou interfaces statiques
patrons de mthodes publiques
}
19
19/314
Rvision : J3
Date : 4/6/02
Rappels syntaxiques (simpli s)
Nota: pour une description complte en format B.N.F. voir les documents
de spcication du langage (le formalisme adopt ici est trs simpli).
Dclarations de premier niveau
Dclarations de variable membre :
Descriptions simplies :
<modificateurs> <Type> <nom> ;
<modificateurs> <Type> <nom> = <expression> ;
Exemples :
private int x;
java.math.BigDecimal solde ;
public static final int MAX = 5 ;
exemples dautres cas:
protected Truc[] tb ;
protected Truc[] tb2 = {new Truc(), new Truc()} ;
int x, y, z;
19/315
Rvision : J3
Date : 4/6/02
19
Dclarations de mthode membre
Descriptions simplies:
<modif.> <Type_res> <nom> (<liste type-nom>) <bloc methode>
<modif.> <Type_res> <nom> (<liste type-nom>)
throws <liste_exception> <bloc methode>
Exemples :
public BigDecimal getSolde() { return this.solde ;}
public final void deStocker( int nb) throws ExceptionStock {
if (nb > this.stock) {
throw new ExceptionStock(this) ;
}
stock -= nb ;
}
public static void main(String[] args) {
System.out.println(test) ;w
}
exemples dautres cas :
int compareTo(Object autre) ; // dans une interface
public abstract void paint(Graphics gr) ; //abstrait
public MonObjet fabrique(final int num, String s) {
.... // code
}
Si la mthode ne renvoie pas un type void, <bloc_mthode> doit contenir
au moins une expression return <expression du type demand>;
19
19/316
Rvision : J3
Date : 4/6/02
Dclarations de classes ou interfaces membres
<modif.> class <nom> <extends et implements decl.> <bloc classe>
<modif.> static interface <nom> <extends list> <bloc interface>
Exemples :
public static class Exception extends java.lang.Exception {
double solde, dpassement;
private Exception(String mess, double x, double y) {
super(mess) ;
solde =x ; dpassement = y ;
}
}// dans classe Compte donne classe Compte.Exception
private class Accesseur implements Enumeration {
...// code de Accesseur
}
public static interface Taxeur {
double getTaux(Sucrerie sucr) ;
}
19/317
Rvision : J3
Date : 4/6/02
19
Dclarations de constructeur
<modif.> <nom classe> (<liste type-nom>) <bloc construct.>
<modif.> <nom classe> (<liste type-nom>)
throws <liste_exception> <bloc construct.>
Exemples :
public Point( int x, int y) {
this.x =x;
this.y = y;
}
public SousTruc(String nom)throws IllegalArgumentException {
super(nom) ;// le constructeur de Truc
// qui , lui meme peut declencher une exc.
}
19
19/318
Rvision : J3
Date : 4/6/02
Syntaxe simpli e des blocs de code
Dans un bloc de code on peut trouver :
<declaration variable locale>
<dclaration de classe locale>
<instruction>
<structure de contrle>
<rupture>
<bloc ou structure etiquete>
dclaration variable locale
<Type> <nom> ;
<Type> <nom> = <expression> ;
Exemples:
double dx ;
double dy = 3.14 ;
Exemples dautres cas:
final int ix = 7 ;
double dx, dy ;
int[][] tb = {{ 1,2,3} , {4,ix}} ;
instruction :
Les instructions pouvant prendre des formes dtailles trs diverses une
simple liste pour rappel:
<affectations>
<pre/post incrmentation/decrmentation>
<appel de mthode>
<invocation de constructeur>
<assertions> //java 1.4
19/319
Rvision : J3
Date : 4/6/02
19
structures de contrle:
IF :
if (<expression boolenne>) <instruction ou bloc>
if (<expression bool>) <instr. ou bloc> else <instr. ou bloc>
Exemples:
if (estceVrai) {// prfrer toujours avec accolades
if( x == 0) return ;// ici encore lisible
.....// code
} else {
...// code
}
SWITCH
switch (<expression entire>) {
case <constante> : <liste instructions>
case <constante> : <liste instructions> break;
....
default: <liste instructions> [break] ;
}
Exemples:
switch(random.nextInt()%2) {
case -1 : mess = "pas daccord" ; break;
case 1 : mess = "daccord" ; break;
default: mess = "ni pour, ni contre(bien au contraire!)";
}
WHILE:
while(<test_boolen>) <instruction ou bloc>
Exemples:
bonneRponse = teste() ;
while(!bonneRponse) {
affiche(essaye encore!) ;
bonneRponse = reTeste() ;
}
19
19/320
Rvision : J3
Date : 4/6/02
DO...WHILE :
do <instruction ou bloc> while (<test boolen>) ;
Exemples:
do {
bonneRponse = teste() ;
affiche(bonneRponse?bravo!:essaye encore!) ;
} while (!bonneRponse) ;
FOR:
for ( <initalisations> ; <test haut> ; <oprations bas de boucle>)
<instruction ou bloc>
Exemples;
for(int ix = 0 ; ix <tb.length ; ix++) System.out.println(tb[ix]);
for(int ix=0, iy = tb.length;ix<tb.length; ix++, y--) {
tb[ix] = iy ;
}
for(;;) {// forever
sam.playItAgain() ;
}
19/321
Rvision : J3
Date : 4/6/02
19
TRY..CATCH..FINALLY
try {
// code
}catch (<exception1> <nom>) {
// code
}catch (<exception2> <nom2>) {
// code
}....
try { //code
} catch (<exceptiom> <nom>) { // evt plusieurs catch
// code
} finally { // code
}
try {
// code avec droutement ou propagation exception
}finally {
// code garanti sauf arrt machine virtuelle
}
droutements:
RETURN:
return ; // dans mthode void ou constructeur
return <expression> ;// dans une mthode rendant un rsultat
// du mme type que <expression>
BREAK:
break; // dans un bloc de code
break <tiquette> ;// dans bloc tiquet
CONTINUE:
continue ; // dans une boucle
continue <tiquette> ; //saut bas de boucle tiquete
THROW:
throw <throwable> ;
19
19/322
Rvision : J3
Date : 4/6/02
Variables
Deux aspects : dclaration , utilisation.
On ne peut utiliser une variable qui na pas t dclare. Dans de
nombreux cas on ne peut pas utiliser une variable qui na pas t
initialise (vrication de compile-time).
Critres controler :
Nom : un symbole (un nom) va dsigner la variable. Il faut que ce
nom ne soit pas un mot rserv, que ce mot ne constitue pas une
gne pour une variable dclare avec le mme nom (conit de
porte). Suivre les rgles de nommage pour rendre votre code plus
lisible.
Type : toute dclaration dun nouveau symbole doit
saccompagner dune dclaration de type qui dnit les droits et
obligations lis lusage du nom. Attention les types scalaires
primitifs et les types objets nont pas les mmes comportements, ni
les mmes contraintes.
Initialisation : vrier soigneusement. Le compilateur fait une
vrication dinitialisation sur les variables automatiques
(variables de bloc).
Forme gnrale des dclarations:
Type nomSymbole
// exemples
int ix // un scalaire
Integer iix // un objet
double[] tbd // un tableau de scalaires
UneClasse[] tbo // un tableau dobjets
UneClasse[][] tb2 // un tableau de tableaux
19/323
Rvision : J3
Date : 4/6/02
19
variables dinstance
Variables membres de linstance. Chaque objet cr sur le modle de la
classe gre sa propre combinaison de valeurs associes ces variables.
int numero ;
BigDecimal solde ;
}
Les objets crs sur ce modle: compteDupond, compteDurand ont des
valeurs diffrentes pour numero ou solde.
Dclaration : sous la forme Type nom ;
(autres formes possibles : Type nom1, nom2, etc. et dclaration
+initialisations)
Ordre et emplacement des dclarations indiffrent (sauf si
initialisations)
Modicateurs daccs possibles: public, private,
protected
Initialisations : par dfaut les variables dinstance sont initialises
zro au moment de la cration de linstance. Selon les types des
variables cette initialisation peut avoir des signications diffrentes
(false pour les booleans, null pour les rfrences, etc.).
En gnral il est conseill de raliser linitialisation dune variable
dinstance soit dans un constructeur (valeur passe en paramtre
du constructeur), soit dans une dclaration avec initialisation (par
exemple pour lallocation de structures de donnes):
int numero ;
BigDecimal solde ;
// structure de donne initialise
Arraylist listOprations = new ArrayList() ; \
public Compte( int num, String depotInitial) {
numero = num ;
solde = new BigDecimal(depotInitial) ;
}
}
19
19/324
Rvision : J3
Date : 4/6/02
Dans le cas o la variable dinstance est dclare et initialise
lordre de dclaration des initialisations est important. Par ailleurs
ces initialisations sont excutes avant la partie du code du
constructeur ne faisant pas appel un autre constructeur (appel de
this(...) ou super(...) ).
Attention: aucune de ces oprations dinitialisation hors
constructeur ne doit tre susceptible de propager une exception
controle (voir galement bloc dinitialisation dinstance).
Une variable dinstance peut tre marque final (blank nal):
dans ce cas elle doit tre initialise dans le constructeur (ou par
une initialisation immdiate); dans un constructeur on ne peut
initialiser une variable final hrite (puisque celle-ci a dej t
initialise dans la construction dune super-classe).
Accs : on ne peut consulter une variable dinstance que si lon
dispose dune instance :
compteDupond.numero ;
Dans le code de la classe on a implicitement une rfrence
linstance courante (this) :
double getSolde() {// dans classe Compte
return solde.doubleValue() ;
// implicitement this.solde
}
Attention: ceci nest pas vrai dans le code dune mthode statique
(comme main).
Autres cas : dsignation dune instance dune classe englobante :
ClasseEnglobante.this.champ et dsignation dun champ
cach de la super-classe : super.champ (conseil: ne pas se
mettre dans cette situation qui consiste rednir un champ
dinstance dans une sous-classe).
Autres modicateurs : transient, volatile
19/325
Rvision : J3
Date : 4/6/02
19
variables de classe
Variables membres de la classe. Dans le contexte dun ClassLoader toutes
les instances ont accs ces variables partages.
static int compteurDInstances ; // partag
int numero ;
BigDecimal solde ;
}
Dclaration : sous la forme Type nom ;
(autres formes possibles : Type nom1, nom2, etc. et dclaration
+initialisations)
Ordre et emplacement des dclarations indiffrent (sauf si
initialisations)
Modicateurs daccs possibles: public, private,
protected
initialisations : par dfaut les variables de classe sont initialises
zro . Selon les types des variables cette initialisation peut avoir
des signications diffrentes (false pour les booleans, null pour les
rfrences, etc.).
Pour raliser linitialisation dune variable de classe il faut soit
utiliser un bloc statique de premier niveau , soit une dclaration
avec initialisation -ces initialisations sont effectues au moment de
l'initialisation de la classe (premier accs aux services de la classe
aprs chargement par le ClassLoader)-:
public class Contexte {
public static String osName =
System.getProperty(os.name);
public static URL urlDoc ;
static { // bloc statique
try { urlDoc = new URL(http://java.sun.com)
} catch(MalformedURLException exc){}
}//ATTENTION si urlDoc est final : problmes possibles
}
Les variables membres dune interface sont implicitement public
static final.
19
19/326
Rvision : J3
Date : 4/6/02
Dans le cas o la variable de classe est dclare et initialise lordre
de dclaration des initialisations et des blocs statiques est
important: les valuations se font dans lordre au moment de
linitialisation de la classe.
Attention : les oprations dinitialisation ne peuvent faire appel
des mthodes dinstance de la classe courante (sans cration dune
telle instance) et ne doivent pas tre susceptibles de propager des
exceptions controles.
Une variable de classe peut tre marque final et initialise (ce
qui ne veut pas ncessairement dire que ce sont des constantes
valuables au moment de la compilation).
Accs : on peut accder une variable de classe de 3 manires:
en la qualiant par le nom de la classe
MaClasse.maVariableDeClasse
MaClasse.CONSTANTE_DE_CLASSE
ce sont les notations prfrer.
en la qualiant par une rfrence de la classe
instanceDeMaClasse.maVariableDeClasse
(ou en utilisant implicitement ou explicitement this)
Cette notation est viter car elle ne facilite pas la
comprhension du code.
en la qualiant par dsignation de la super-classe :
super.variableDeClasse
ceci correspond une situation de rednition dune variable
de classe dans une sous-classe (data hiding): viter
Autre modicateur : volatile
19/327
Rvision : J3
Date : 4/6/02
19
variables de bloc
Il sagit de variables temporaires: elles sont cres au moment o
lexcution atteint cette partie du code et dtruites quand on sort de la
porte du bloc courant (variables ou rfrences alloues dans la pile).
Dclarations :
instruction de dclaration dans un bloc
{
int ix ;// nimporte o dans le bloc
String s1, s2, s3 ;
double dz = 3.14 ;
cas particuliers assimils aux prcdents :
for(int ix = 0, iy = tb.length; ix<tb.length; ix++, iy--) {
// ix et iy nexistent que dans la porte du bloc for
paramtres
void methode(int ix, String nom) {
// ix et nom en porte dans le bloc
....
Maclasse(String parm) { // paramtre constructeur
...
try {....
} catch (IOException exc){//exc en porte dans bloc catch
}
Attention: un symbole local dans un bloc peut cacher une
variable dinstance ou une variable de classe, le compilateur ne le
signale pas mais le code devient illisible. Par contre il ne peut pas
porter le mme nom quun symbole du bloc local ou dun bloc
englobant.
Modicateurs :
possibles : final,
impossibles : static, public, private, protected,
volatile, transient (attention: erreur de syntaxe difcile
comprendre, certains compilateurs donnent un message obscur!)
19
19/328
Rvision : J3
Date : 4/6/02
Initialisations :
Les paramtres sont automatiquement initialiss (par lappel
de la mthode, ou la rcupration dune exception).
La modication de la valeur dun paramtre dans le bloc est
sans effet sur le code appelant (voir cas particulier des effets
de bord).
Les autres variables de bloc dovient imprativement tre
initialiss avant dtre utilises (condition vrie par le
compilateur)
19/329
Rvision : J3
Date : 4/6/02
19
Mthodes
Deux aspects: dnition dun cot, utilisation de lautre.
Lutilisation dune mthode fait partie du contrat dun type donn. Sauf
dans le cas trs particulier de lexcution dynamique par introspection
(package java.lang.reflect), le compilateur va sefforcer de vrier
que lappel est conforme la dnition (il consulte le chier binaire
.class pour cela).
Critres controler :
Nom : un symbole (un nom) va dsigner la mthode. Plusieurs
mthodes peuvent porter le mme nom -avec des paramtres
diffrents-(surcharge): il est prfrable dans ce cas que lintention
smantique soit la mme.
Pour viter toute confusion ne pas utiliser le mme nom quune
variable ou quune classe (cest possible!)
Suivre les rgles de nommage pour rendre votre code plus lisible.
Signature : cest la combinaison caractristique dune mthode
comprenant le nom et la liste ordonne des types des paramtres.
Une classe ne peut pas avoir deux mthodes avec la mme
signature.
Rsultats : les mthodes de Java sont fonctionnelles par nature,
elles prennent des paramtres en entre et rendent un seul rsultat
pour lexcution normale. Si il ny a pas de rsultat on dclare
un type void.
Ds quune mthode dclare un rsultat non-void on ne doit
sortir normallement de la mthode que par lappel dun ou
plusieurs return accompagn dune valeur du type de retour
demand.
Les rsultats anormaux sont ceux qui dcoulent dune erreur
dexcution: leur dclaration fait partie du contrat de la
mthode.
Object[] tableauTri(Object[] tb)
throws ClassCastException {
Object[] res = (Object[]) Array.newInstance(
tb.getClass().getComponentType(), tb.length);
...// copier dans res et trier
return res ;
}
19
19/330
Rvision : J3
Date : 4/6/02
Mthodes dinstance
Mthodes membres de linstance. Les instructions dans le corps de
dnition peuvent agir sur les variables propres la mthode, les
variables membres de linstance courante, les variable de classe de la
classe courante.
Dnition : sous la forme
TypeRsultat nom(liste_paramtres) throws liste_exceptions {
//corps de dfinition
}
Les mthodes marques abstract (et celles dnies dans les
interfaces) ou marques native nont pas de corps de dnition.
Des rgles strictes gouvernent la dclaration dune mthode
comme rednition dune mthode de la super-classe:
on ne peut rednir une mthode de classe en mthode
dinstance.
on ne peut aggraver le contrat : rendre la mthode plus
prive que la mthode originale, dclarer propager plus
dexceptions (ou des super-classes des exceptions dclares).
on ne peut modier le type de rsultat dune mthode de
mme signature.
Nota: la dnition dun paramtre peut tre dune des formes:
Type nom
final Type nom
Modicateurs :
public, private, protected, final, abstract
et native, strictfp, synchronized
(abstract est incompatible avec final et native)
Les en-ttes de mthodes de dclaration des interfaces sont
implicitement public abstract.
19/331
Rvision : J3
Date : 4/6/02
19
Appels : on ne peut appeler une mthode dinstance que si lon
dispose dune instance (on envoie un message linstance):
monInstance.mthode(arg1, arg2, argn) ;
Dans le code de la classe on a implicitement une refrence
linstance courante :
public class MaClasse {
public void meth1() {
....
}
public void meth2() {
...
meth1() ;
// implicitement this.meth1()
}
}
Autres cas :
dsignation dune instance englobante :
ClasseEnglobante.this.methode() ;
//utile si methode est aussi definie dans classe locale
dsignation de la mthode de la super-classe (en cas de
rednition locale)
super.toString() + champ local: + champlocal ;
// redefinition de toString() dans la classe fille
Les paramtres sont passs par valeur: cest dire quils ont valus, puis
copis dans la pile et cest cette copie qui est rcupre par le code de la
mthode. Les rgles de promotion de type sont appliques.
19
19/332
Rvision : J3
Date : 4/6/02
Mthodes de classe
Mthodes membres de la classe. Les instructions dans le corps de
dnition peuvent agir sur les variables propres la mthode et les
variable de classe de la classe courante. Elles ne peuvent agir sur des
variables dinstance si ces variables ne sont pas qualies par rapport
une instance dment cre.
Dnition : sous la forme
static TypeRes nom(liste_paramtres) throws liste_exceptions {
//corps de dfinition
}
On peut rednir ainsi dans une classe une mthode statique de la
super-classe (rupture du lien statique : hiding) -dispositif rare et
peu conseill-
Modicateurs :
public, private, protected, final
et native, strictfp, synchronized .
Appels : on peut appeler une mthode de classe:
en la qualiant par le nom de la classe
MaClasse.maMthodeDeClasse()
cest la notation prfrer.
en la qualiant par une rfrence de la classe
instanceDeMaClasse.maMthodeDeClasse()
(ou en utilisant implicitement ou explicitement this)
Cette notation est viter car elle ne facilite pas la
comprhension du code (+ valuation non polymorphique).
en la qualiant par dsignation de la super-classe :
super.maMthodeDeClasse()
((SuperClasse)instance).mthodeDeClasse()
ceci correspond une situation de rednition dune mthode
de classe dans une sous-classe ( hiding): viter
Les paramtres sont passs par valeur: cest dire quils ont valus, puis
copis dans la pile et cest cette copie qui est rcupre par le code de la
mthode. Un paramtre peut tre marqu final. Les rgles de promotion
de type sont appliques.
19/333
Rvision : J3
Date : 4/6/02
19
Constructeurs
Ce ne sont pas des membres de la classe (on ne qualie pas un
constructeur par rapport une instance ou par rapport une classe: on
lappelle par new).
Critres controler lors de la dnition :
Nom : obligatoirement le nom de la classe.
Noter que les constructeurs ntant pas hrits on est oblig de les
dnir pour chaque niveau de la hirarchie de classes: on a bien
une correspondance nomClasse-nomConstructeur.
Paramtres : mmes principes de dnition des paramtres que
pour les mthodes.
Les constructeurs peuvent tre surchargs (plusieurs contructeurs
possibles avec des paramtres diffrents).
Une classe dpourvue de dnition est dote automatiquement
dun constructeur par dfaut (constructeur sans paramtres)
condition que sa super-classe lui rende accessible un constructeur
sans paramtres (implicite ou non).
Ds quun constructeur est dni la classe perd son consturcteur
implicite (on peut alors dnir explicitement un constructeur sans
paramtres).
Structure interne : le bloc de dnition a une architecture
particulire:
une premire instruction doit concerner lappel dun autre
constructeur : soit de la mme classe (par this) soit de la
super-classe (par super). Si le constructeur appeler est le
constructeur sans paramtres de la super-classe cette
instruction peut tre implicite.
aprs cette premire instruction le systme value (dans lordre
dni par le code source) toutes les initialisations explicites de
variables dinstance (ou de blocs dinstance) -sauf si la
premire instruction est un appel au constructeur this-
Les autres instructions dinitialisation viennent ensuite. Si une
variable membre de linstance est marque nal sans avoir t
initialise, son initialisation doit tre ralise au travers du code
de tous les constructeurs.
19
19/334
Rvision : J3
Date : 4/6/02
(par ailleurs viter dappeler dans le code du constructeur des
mthodes de linstance courante qui ne soient pas marques
final ou private).
Rsultats: Un constructeur ne doit dclarer aucun rsultat (mme
pas void). Son rle est dallouer et initialiser une instance.
Par contre un constructeur peut propager des exceptions et donc
refuser de construire/initialiser une instance.
Modicateurs : public, protected, private
( pas de static, nal, native, strictfp, synchronized)
Cas particuliers :
On ne peut pas crer une instance dune classe marque
abstract mais celle-ci peut tout de mme disposer de
constructeurs qui seront utilises par les sous-classes par
linvocation de super() (ou au travers de la
dnition/invocation dune classe anonyme)
classes internes :
- on ne peut pas dnir de constructeur dans une classe
anonyme mais on peut invoquer le constructeur de la super-
classe de la classe anonyme en lui passant des paramtres.
- les constructeurs de classes membres dinstance on besoin
dtre invoqu partir dune rfrence du type de la classe
englobante dont la classe est membre.
- cas extrme : il est possible dans la dnition du constructeur
dune classe interne dinstance dappeler this ou super
comme membre dun paramtre du type de la classe
englobante:
class Interne2 extends Interne1 {
....
public Interne2(Englobante inst, int x){
inst.super(x) ; //dans le contexte
// de linstance paramtre
19/335
Rvision : J3
Date : 4/6/02
19
Blocs
Les blocs permettent de regrouper un ensemble dinstructions. Ils
dterminent galement des zones hirarchises de porte des variables:
{// bloc englobant
int nombre ;
.....
{ // bloc interne
int autreNombre ;
....
nombre = 10 ; // correct
} // fin bloc interne
...
autreNombre = 7 ; // ERREUR ! IMPOSSIBLE
nombre = 20 ; // possible
}
Certains dispositifs syntaxiques permettent de dclarer galement des
variables dans la porte du bloc associ : paramtre de mthode ou de
constructeur, paramtre dun bloc catch, dclaration de variable dans la
partie initialisation dune boucle for...
En dehors des blocs associs aux dclarations de classe, aux corps des
mthodes ou des constructeurs, aux structures de controles, aux blocs
try/catch/finally, et aux blocs synchronized (hors primtre du
cours) il existe des blocs isols : blocs dinitialisations statiques, blocs
dinitialisations dinstance et blocs isols dans un autre bloc.
19
19/336
Rvision : J3
Date : 4/6/02
Blocs statiques
Un bloc de premier niveau marqu static est valu au moment de
l'initialisation de la classe.
Il peut y avoir plusieurs blocs dinitialisation de classe: ils sont valus
dans lordre dapparition dans le code.
public class Maintenance{
static URL urlMaintenance ;
static {
String url = System.getProperty("produitX.url") ;
URL secours = null ;
try {
secours = new URL ("http://java.sun.com") ;//test
urlMaintenance = new URL(url) ;
} catch (Exception exc) {
urlMaintenance = secours;
}
}
....
19/337
Rvision : J3
Date : 4/6/02
19
Blocs dinstance
Un bloc de premier niveau non marqu static est valu au moment de
la cration de linstance (aprs initialisation de la super-classe et avant
lexcution du reste du code du constructeur).
Il peut y avoir plusieurs blocs dinitialisation dinstance: ils sont valus
dans lordre dapparition dans le code. Ces blocs, rares, peuvent tre
utiliss soit pour raliser des initialisations ncessitant des blocs
try/catch, soit pour remplacer des oprations dinitialisation dinstance
dans une classe anonyme (qui ne dispose pas de systme de dnition de
constructeur).
19
19/338
Rvision : J3
Date : 4/6/02
Blocs non associs une structure
Dans un bloc il est possible douvrir un nouveau bloc de contexte. ceci
permet disoler des dclarations de variables, damliorer la lisibilit et la
structure du code.
...
{ // PANEL HAUT (nouveau bloc)
panelHaut = new Panel(new FlowLayout(
FlowLayout.LEFT));
Button button1 = new Button(1) ;
panelHaut.add(button1 ;
}
add(panelHaut, BorderLayout.NORTH) ;
Un tel bloc de code peut aussi tre tiquet :
__PANEL_HAUT__: {
....
if(...) break __PANEL_HAUT__ ;
//
....
}
Ces dispositifs (peu usits) peuvent tre utiles pour attirer lattention du
lecteur du code sur des structures implicites :
19/339
Rvision : J3
Date : 4/6/02
19
Types primitifs scalaires, types objets
Il y a en Java deux grandes catgories de types qui se distinguent
nettement par leur utilisation et leur allocation en mmoire:
Les types primitifs : ce sont des types prdnis qui reprsentent
des valeurs scalaires (boolens, caractres, types numriques
entiers et ottants). Leur reprsentation interne est standardise et
portable (exemple : int signs sur 32 bits en ordre poids fort-
poids faible, char sur 16 bits non signs avec codes UTF16
Unicode).
Ces types sont: boolean, char, byte, short, int,
float, double.
Dans le code dune mthode ou dun constructeur ces types sont
allous sur la pile dexcution (avec une valeur indtermine tant
quils ne sont pas initialiss). Une variable de type primitif dsigne
toujours une valeur.
Les types objets : quils soient dnis par Java ou par lutilisateur
ils hritent de la classe java.lang.Object.
Les instances sont cres par lappel de new Constructeur() et
sont systmatiquement alloues dans le tas. Les champs primitifs
sont initialiss zero par dfaut.
Une variable de type objet dsigne toujours une refrence vers
une instance en mmoire. Il nest pas garanti que le type effectif de
linstance soit celle du type dclar de la variable
(polymorphisme).
Un cas particulier dobjets sont les tableaux. Ce sont de vrais objets
qui ne disposent que dun seul membre immuable (length), mais
qui permettent daccder un ensemble de valeurs qui sont soit
des scalaires (tableau de primitifs), soit des rfrences (tableau
dobjets -y compris tableau de tableaux-).
19
19/340
Rvision : J3
Date : 4/6/02
Packages, rgles de responsabilit
Toute classe Java doit appartenir un package. Un package est un
regroupement de classes qui concourent des objectifs communs ou
analogues. Il est de bonne pratique dorganiser les packages selon une
hirarchie :
<nom InterNic > <units organisationelles> <hierarchie thmes>
Donc par exemple :
fr.financesoft.backoffice.utils.swap
Les packages structurent les responsabilits des codes: chaque code a des
possibilits dinteragir ou non avec dautres codes en fonction des droits
daccs qui lui sont accords:
Un membre ou un constructeur marqu private est sous la
responsabilit du code courant (on pourrait dire: sous la
responsabilit du programmeur en charge du source courant). Il
nest accessible que dans le source courant.
Un membre ou un constructeur sans modicateur (package friendly)
nest accessible que depuis les codes du mme package (on
pourrait dire: accessible par les programmeurs qui font partie de la
mme quipe de dveloppement).
Un membre ou un constructeur marqu protected est accessible
depuis les codes du mme package, de plus:
un membre protected est accessible comme membre hrit
(c.a.d membre de linstance courante) dans les classes qui
hritent de la classe courante et qui sont situs dans dautres
packages.
un constructeur protected ne peut tre invoqu quau travers
de super(..) dans les classes qui hritent de la classe courante
et qui sont situs dans dautres packages.
Un membre ou un constructeur marqu public est accessible
dans tout code.
Les classes de premier niveau ne peuvent tre que public ou de niveau
package.
Rvision : J3
Date : 4/6/02
Aide-mmoire 20
Contenu:
les outils du SDK
aide-mmoire HTML pour javadoc
glossaire
adresses utiles
20
20/342
Rvision : J3
Date : 4/6/02
Aide-mmoire
Le SDK
Divers sites permettent de tlcharger un SDK (voir
http://java.sun.com/j2se/)
Le SDK sinstalle en deux phases :
Linstallation de la machine virtuelle spcique votre
machine/systme
Linstallation de la documentation (commune toutes les plate-
formes)
Une installation typique du rpertoire racine de Java contient les
rpertoires ou chiers:
bin : excutables de lancement des utilitaires lis Java : java,
javac, etc.
jre : linstallation de la machine virtuelle proprement dite.
Excutables, librairies dynamiques, librairies systme ou
librairies dextension de Java, ressources gnrales de
conguration de lexcution.
lib : librairies utilitaires spciques limplantation (par ex.
librairies Java des utilitaires comme le compilateur, javadoc, etc.)
include : les ressources pour compiler du code natif li Java.
demo : ressources pour des dmonstrations de programmes et leur
code source.
docs: le rpertoire de la documentation gnrale en HTML
(chier index.html)
src.jar : les sources des librairies standard de Java dans une
archive Jar. Pour consulter ces sources faire
jar xvf src.jar
qui cre un rpertoire src contenant les chiers source.
20/343
Rvision : J3
Date : 4/6/02
20
Aide-mmoire
Les outils
La documentation des outils est lie la livraison du SDK.
voir docs/tooldocs/tools.html
outre java, javac, javadoc quelques autres outils utiles pour dbuter:
jar : permet darchiver un ensemble de binaires java (et dautres
chiers associs). Cest une archive dans un format compress
(ZIP) qui peut tre passe comme lment de CLASSPATH. Cest
de cette manire que des librairies ou des applications Java sont
livres. Ce point est developp dans notre cours maitrise de la
programmation java.
javap : dcompile un binaire Java en assembleur JVM. Pratique
pour vrier rapidement le vritable contenu dun chier .class.
Pour un vrai dcompilateur (binaire->source) il existe des logiciels
domaine public.
jdb : debuggueur rustique en mode commande.
appletviewer: permet de tester rapidement la prsentation dune
applet.
native2ascii : utilitaire de conversion de chiers texte (selon le
mode de codage des caractres)
rmic : Compilateur de stub RMI(fonctionne par introspection sur
les classes dobjets serveur).
rmiregistry : registry RMI de refrence.
rmid : daemon systme permettant lactivation dynamique
dobjets serveurs RMI (sert galement de registry).
20
20/344
Rvision : J3
Date : 4/6/02
Aide-mmoire
javadoc et HTML
Voir usage de javadoc dans la documentation spcique :
docs/tooldocs/plate-forme/javadoc.html.
Point particulier pour les auteurs francophones: le source Java de la
documentation doit tre lisible ce qui pose un problme pour les
caractres accentus qui peuvent tre diffrents selon les plate-formes de
codage. On veillera ce que le HTML gnr soit portable (option -
charset).
Pour HTML voir les descriptions de rfrence
http://www.w3.org/MarkUp et http://www.w3.org/TR/html4
Aide mmoire HTML
Structures principales
Elments principaux de la structuration du chier html : nont que peu ou
pas dintrt pour la documentation javadoc puisque le programme
gnre automatiquement les grandes structures de prsentation du
document HTML.
Structure gnrale :
<HTML>
<HEAD>
titre interne
<TITLE> titre externe </TITLE>
</HEAD>
<BODY>
corps du document (texte balises)
</BODY>
</HMTL>
Hirarchie des sections:
<H1> premier niveau de titre de paragraphe </H1>
<H2> second niveau </H2>
<H3> niveau suivant </H3>
<H1> encore premier niveau </H1>
20/345
Rvision : J3
Date : 4/6/02
20
Aide-mmoire
Paragraphes et listes

<P> un paragraphe
</P>
<P> un autre paragraphe
<BR> un retour la ligne forc
</P>
<BR>
<HR> 
Liste simple :
<UL>
<LI> un lment de la liste </LI>
<LI> un autre lment </LI>
</UL>
Liste numrote:
<OL>
<LI> premier item </LI>
<LI> deuxime item, etc. </LI>
</OL>
Liste descriptive:
<DL COMPACT>
<DT> entre dans la liste </DT>
<DD> description de lentre </DD>
<DT> un autre terme </DT>
<DD> sa description </DD>
</DL>
Citation de texte :
<BLOCKQUOTE>
La culture cest ce qui reste quand on a tout oubli
</BLOCKQUOTE>
Texte prformat :
<PRE>
for( int ix = 0; ix < tb.length; ix++) {
System.out.println(tb[ix]);
}
</PRE>
20
20/346
Rvision : J3
Date : 4/6/02
Aide-mmoire
Tableaux
<TABLE >
<TR> 
<TH> cellule de titre
<TD> cellule normale
<TD> cellule suivante
<TR> 
voir aussi <A HREF=http://www.truc.fr/doc.html#cible> l </A>
Images
voici une image : <IMG SRC=image.gif>
ou <OBJECT data=image.gif type=image/gif>
Styles physiques
dans le texte lui mme <B>ceci est en caractres gras</>
et <I>ceci en italiques</I>
<U>ceci est soulign</U>
et <TT> ceci en caractres chasse fixe (comme fonte
courier)</TT>
20/347
Rvision : J3
Date : 4/6/02
20
Aide-mmoire
Glossaire
voir aussi : http://java.sun.com/docs/glossary.html
pour la version franaise des termes voir
http://www.granddictionnaire.com
Quelques dnitions dans ce glossaire sont marques terminologie non-

standard car il ny a pas un large accord sur la pratique terminologique
en Franais. Le terme dcrit a toutefois t choisi pour tre utilis dans ce
support de cours.
accesseur
(accessor) mthode permettant dinterroger une instance sur la valeur dun
attribut encapsul. Par convention les accesseurs sont de la forme : type
getXXX() . o XXX est le nom du champ. Voir mutateur et la
convention correspondante.
adaptateur
(adapter) Dans le contexte particulier du traitement des vnements en
Java: une classe qui ralise toutes les mthodes dune interface avec un
code vide. On doit crer une classe qui hrite de ladaptateur et qui
rednit une ou plusieurs de ces mthodes.
agregation
En terme danalyse : relation qui possde ou ensemble/lment.
Relation de longue dure entre deux objets, mais relation non exclusive; le
cycle de vie des deux objets nest pas ncessairement li.
allocation
Rservation dun emplacement en mmoire. (par exemple pour contenir
les donnes lies un objet). En java on distingue les allocations
automatiques (sur la pile: variables scalaires ou rfrences), les
allocations dans le tas (par new), le pool de constantes, et les allocations
20
20/348
Rvision : J3
Date : 4/6/02
Aide-mmoire
des classes elle-mmes par les ClassLoaders. Contrairement dautres
langages on na, en Java, aucun accs la gestion de ces emplacements
mmoire.
analyse
Phase de dnition de ce qui doit tre fait en terme de mtier.
API
(Application Programming Interface) la liste des accs programmatiques un
objet dune classe donne. En pratique on a tendance restreindre cette
description aux membres et constructeurs public ou protected qui
constituent le contrat de type dni par la classe vis vis des
utilisateurs externes lquipe de dveloppement.
applet
(Littralement Appliquette -petite application-). Code Java tlcharg et
excut par un navigateur WEB.
architecture trois parties
(three tiers architecture) Application(s) clate en trois parties distinctes
(chaque partie tant ventuellement accessible au travers du rseau). Une
partie est charge de linteraction utilisateur (avec parfois un peu de
logique dporte), une partie centrale est charge de rgler la logique
applicative et une autre est constitue du fond de donnes de lentreprise.
association
En terme danalyse : relation qui utilise . Relation entre deux objets lis
par la ralisation dun service.
attribut
Variable membre vue dun point de vue conceptuel. On a ici une vue plus
large puisquun attribut peut, par exemple, tre en ralit driv par
calcul (exemple surface sera calcul partir dautres informations
gres par lobjet)
20/349
Rvision : J3
Date : 4/6/02
20
Aide-mmoire
automatique
Variables propres un bloc de code -comme une mthode-(paramtres,
variables locales). Ces variables (scalaires, rfrences vers des objets) sont
alloues sur la pile et ont une dure de vie qui ne dpasse pas le temps
dexcution du bloc de code (exception: les variables automatiques
marques nal et copies dans le cadre de classes locales).
bean
Composant rutilisable. Un bean est une classe Java sur laquelle on peut
obtenir des informations par programme: on utilise pour cel les
mcanismes standard de reexion/introspection de Java, des classes de
documentation (comme BeanInfo) et des conventions de nommage. Les
informations ainsi obtenues permettent par exemple de personnaliser la
mise en oeuvre du composant dans un contexte dexcution , de gnrer
du code de mise en oeuvre, etc. Il existe diffrentes conventions de Beans
selon le type denvironnement de mise en oeuvre (Entreprise Java Beans
pour les serveurs dentreprise, Federated Beans pour ladministration de
Systmes, etc.)
bus logiciel
Systme de propagation de messages par lequel un objet metteur peut
sadresser plusieurs objets recepteurs sans les connatre. Les objets
recepteurs sabonnent un bus et lmetteur sadresse au bus (un peu
comme une frquence radio).
champ
voir variable dinstance
chargeur de classe
(ClassLoader) Une classe java qui permet de charger le code dautres
classes java . A chaque ClassLoader est associ un espace de noms et une
politique de scurit particulire aux URLs dorigine des codes quil gre.
On peut donc retrouver la mme classe dans des ClassLoaders
diffrents ce qui peux donner des effets surprenants comme des variables
partages (statiques) ayant des valeurs diffrentes.
20
20/350
Rvision : J3
Date : 4/6/02
Aide-mmoire
classe
Unit de regroupement de donnes et de codes (agissant ventuellement
sur ces donnes). Certaines classes servent de matrices pour la fabrication
dinstances sur ce modle (de regroupement de donnes et de code )
dautres sont un simple regroupement de services (classe nayant que des
mthodes de classe).
classe abstraite
Une classe qui est utilise pour reprsenter un concept abstrait, et
partir de laquelle on ne peut pas crer dobjets. Les mthodes qui sont
dclares sans fournir de dnition sont appeles mthodes abstraites .
Ces classes sont souvent le rsultat dune dcision de mutualisation de
services entre des classes analogues : les mthodes concrtes sont
partages et les services gnriques sont dcrits par des mthodes
abstraites.
classe anonyme
Classe sans nom dnie et utilise la vole dans le code. On cre de
cette manire une instance ayant des proprits ad hoc et pour laquelle on
nenvisage pas de rutilisation.
classe dencapsulation
(terminologie non-standard pour wrapper class) Classes lies des types
scalaires primitifs et permettant :
de crer des objets immuables qui contiennent un scalaire du
type correspondant (par exemple de type int pour la classe
Integer);
dobtenir des services (mthodes de classe) lis ces types
scalaires (par exemple conversion). Si une mthode prend un
argument de type gnerique Object et quon veut lutiliser
avec des types primitifs on met alors en place une convention
qui permet de passer une instance du type dencapsulation
correspondant. Le champ TYPE de ces classes est un objet de
type Class qui dcrit le type scalaire associ.
classe interne
(terminologie non-standard: englobe ici les termes inner class et embedded
class) classe dnie dans la porte syntaxique du code dune autre classe.
On distingue les classes membres et les classes locales.
20/351
Rvision : J3
Date : 4/6/02
20
Aide-mmoire
classe locale
Classe dnie dans la porte syntaxique dun code excutable. La classe
peut utiliser des variables automatiques de ce code condition quelles
soient marques final.
classe membre
Classe dnie au niveau des dclarations lintrieur dune classe. Elle
devient un membre dinstance ou de classe avec les obligations et
proprits qui en dcoulent. Contrairement aux classes de premier
niveau elles peuvent tre private ou protected. Elles ont, a priori,
accs aux champs et aux services qui sont dans la mme unit de
compilation.
CLASSPATH
Liste des chemins daccs aux classes. Peut contenir des rpertoires, des
archives Jar .
code natif
Une classe java peut faire rfrence du code compil pour un systme et
un processeur particulier. Il y a bien sr des conventions particulires
pour assurer la liaison avec ce code (voir J.N.I) et la classe perd sa
portabilit inter-plateformes.
compilation conditionnelle
Dans certains langages le code source peut contenir des directives
permettant de ne compiler certaines parties que sous condition (par
exemple paramtre pass au compilateur). Ceci permet de fabriquer
diffrentes version dun logiciel: par exemple une avec des informations
de trace et lautre , plus performante, sans ces traces. Le code source de
Java vite les systmes de macro-commandes (pour des raisons de
lisibilit) mais on peut raliser des blocs de code qui ne sont pas compils;
la version 1.4 contient aussi des facilits dassertions.
composition
En termes danalyse : relation est compos de.Relation de longue dure
entre deux objets, relation exclusive; le cycle de vie des deux objets est li
au sens o si on supprime lobjet contenant on supprime lobjet contenu.
Ex. La description du Client contient son Adresse.
20
20/352
Rvision : J3
Date : 4/6/02
Aide-mmoire
conception
Phase permettant de dnir, partir de lanalyse, une architecture, des
objets techniques qui conduiront au programme rel.
constante
Une valeur quon ne peut pas modier. En Java la notion est relativement
complexe, en effet on distingue :
les constantes de compile-time (des primitifs scalaires
essentiellement)
les constantes values au run-time (soit au moment de
linitialisation de la classe, soit au moment de la cration de
linstance)
Il nest pas garanti que les champs dune constante objet soient eux-
mmes constants.
constructeur
Code dinitialisation qui accompagne lallocation dune instance.
container
Plusieurs sens possibles en Java :
Composant graphique qui en contient dautres. Un
gestionnaire de disposition associ permet de disposer des
composants lintrieur dun container.
Environnement de dploiement de Beans
conversion
(cast) Transformation effective dune valeur scalaire dun type donn dans
un autre type . Conversions implicites (par exemple short->int),
conversions explicites (par exemple int-> short); certaines conversions
sont impossibles (par exemple int -> boolean). Dans ce document ce terme
nest pas utilis pour les rfrences dobjet car il ny a pas de
transformation de la valeur.
20/353
Rvision : J3
Date : 4/6/02
20
Aide-mmoire
dlgation
En termes danalyse : agrgation permettant un objet contenant de
rendre un service en dlguant sa ralisation lobjet contenu.
directive
Mot reserv servant donner des indications de comportement au
compilateur. Par exemple package, import. Les directives ne sont pas
des instructions excutables.
doclet
Code java dynamiquement associable lutilitaire javadoc. Ce code
permettra de personnaliser les traitements associs certaines structures
de la documentation (par exemple mise en forme spciale ou dtection
dabsence)
dynamicit
Capacit de Java de choisir du code excutable au run-time : par
polymorphisme , par chargement dynamique de classe.
encapsulation
Rendre inaccessible du code des donnes ou des services situs dans un
autre code.
espace de nom
(terminologie non-standard : dcalque de namespace) En gnral un
dictionnaire qui associe un symbole, un nom une entit du langage.
En Java il sagit dun dictionnaire de noms de classes et il en existe un par
ClassLoader.
vnement
Un objet qui rend compte du fait que quelque chose sest produit au
niveau dun autre objet. Un autre aspect est li aux conditions de
propagation : idalement lvnement nest gnr que sil y a quelquun
qui sest inscrit pour le rcuprer, implicitement le code de traitement ne
doit pas bloquer le thread qui la dclench et des mcanismes spciaux
peuvent permettre de fusionner des vnements proches dans une srie
donne pour viter des engorgements. Pour dautres types de
propagation dobjets voir exception et bus logiciel.
20
20/354
Rvision : J3
Date : 4/6/02
Aide-mmoire
exception
Un objet qui rend compte dune condition errone. La propagation de ces
objets a un mode particulier: lmetteur ne connait pas le rcepteur. Il doit
y avoir en amont dans la pile courante un bloc de code charg de ltrer
les exceptions qui remontent la pile. On a ainsi une indpendance entre
le code charg de signaler lexception et le code charg de ragir. Un des
aspects intressant de Java est que les exceptions peuvent faire partie du
contrat dune mthode ou dun constructeur et que ce contrat oblige les
codes utilisateurs rcuprer les exceptions potentielles.
expression
Partie dune instruction qui svalue lexcution (opration, appel de
mthode, ...). Lvaluation dune expression peut avoir des effets de bord
(tel quune affectation une variable), un rsultat qui peut tre utilis
son tour comme oprande ou comme argument dans une autre
expression, ou mme avoir un effet sur lenchainement des instructions.
Comme en C/C++ laffectation (oprateur =) est une expression qui rend
un rsultat (do les notations : y =x =z; ou o.m(x=y) )
filtre
En Java terme utilis dans les mcanismes dentre/sortie. Un ltre est
incorpor dans un enchainement de ots: il prend ses donnes dans un
ot, transforme les donnes ou le fonctionnement du ot et rend ces
donnes un autre ot. Exemples : BufferedInputStream transforme
lcoulement du ot en bufferisant; InputStreamReader transforme
un Inputstream en Reader (cest un ltre bien quil ne drive pas dune
classe ltre comme FilterInputStream)
Autre sens: mcanisme qui permet de slectionner des objets parmi un
ensemble dobjets en fonctions dattributs, de proprits, de nom, etc..
Exemple: FileNameFilter.
flot
Modle abstrait dentre/sortie reprsentant les dispositifs de
lecture/criture comme une suite ordone de donnes. On lit par exemple
successivement des donnes et le ot continue de fournir ces donnes au
point daccs. Le modle est puissant car il permet de reprsenter des
lectures dans des situation trs diffrentes : lecture dans un chier, dans
un tableau en mmoire, etc...
20/355
Rvision : J3
Date : 4/6/02
20
Aide-mmoire
fonction
Java ne dispose pas de fonctions (ni de procdures) mais ses mthodes
suivent un modle fonctionnel cest dire elles dnissent une expression
de la forme: res f(listeargs). Les arguments ventuels sont des
paramtres en entre et le rsultat ventuel est constitu dune seule
valeur. Java adhre un modle avanc qui dclare galement les
rsultats errons potentiels (clauses throws).
forage de type
(galement utilis: projection de type; terminologies non-standard:
rendent un des sens de loprateur cast) Opration par laquelle on
demande de considrer une rfrence dun type donn comme une
rfrence vers un type compatible. Lopration a des effets au compile-time
(on peut drfrencer par rapport au type demand) et au run-time
(dclenchement dune ClassCastException si le type effectif nest pas
compatible).
garbage collector
Tche de fond (thread) de basse priorit qui recherche dans le tas des
objets qui ne sont plus refrencs (mme indirectement) par les piles
dexcution. La mmoire est alors rcupre et, ventuellement tasse.
gestionnaire dvnement
(event handler) Mthode spcialise dans le traitement dun objet
vnement et correspondant une circonstance particulire (par exemple:
keyPressed pour un KeyEvent)
gestionnaire de disposition
(LayoutManager) Classe charge de la disposition graphique de
composants lintrieur dun Container.
gestionnaire de scurit
(SecurityManager) Classe charge de mettre en oeuvre les contrles daccs
correspondant une politique de scurit. Il sagit ici des controles lies
lorigine des classes et des droits des instances lies ces classes.
glaneur de mmoire
(terminologie non-standard: extension du glaneur de cellules de Lisp.
Autre terme: ramasse-miettes) voir garbage collector.
20
20/356
Rvision : J3
Date : 4/6/02
Aide-mmoire
hritage
Deux aspects : conceptuel ou oprationnel.
Aspect conceptuel : relation est un ou est une sorte de. Peut dcouler
dune dmarche de spcialisation (rutilisation par extension) ou de
gnralisation (on tente de capturer les points communs entre plusieurs
classes)
Aspect oprationnel : les mcanismes dhritage permettent de mettre en
place des dnitions diffrentielles (telle classe est dnie par ses
diffrences avec une autre classe, une partie est commune). Une nouvelle
classe hrite des caractristiques de sa classe mre (mme si elle na
pas toujours accs tous les lments -ceux qui sont privs par ex.-), elle
peut rednir certains comportements ou en rajouter.
hritage multiple
Aspect conceptuel : une classe hrite de plusieurs autres classes distinctes.
Aspect oprationnel : nexiste pas en Java (permet ainsi de ne pas avoir de
rgles implicites complexes sur des comportements hrits: tout doit tre
cod explicitement).
Hotspot
(marque dpose) Compilateur auto-adaptatif couplant un compilateur
JIT et un interprte sous le contrle de rgles doptimisation. On obtient
ainsi des performances remarquables conditions dtre sous le contrle
de rgles adaptes au type dapplication (ex. les rgles ne sont pas les
mmes pour un serveur ou pour un poste client graphique).
Ieee754
(IEEE = Institute of Electrical and Electronics Engineers) Standard de
reprsentation et de fonctionnement pour les processeurs de calcul en
virgule ottante.
implmenter
(terminologie non-standard: le mot nexiste pas en franais mais il est
retenu ici dans le sens trs troit de la dclaration du mot-clef implements)
Dispositif par lequel une classe Java dclare connatre la smantique
dune interface Java et sengage raliser le contrat de type ainsi dni.
20/357
Rvision : J3
Date : 4/6/02
20
Aide-mmoire
instance
Un objet: entit autonome cre sur le modle de la classe auquel il
appartient. Lobjet est responsable de la ralisation de services quil rend
en grant son tat interne de manire cohrente, ventuellement en
collaboration avec dautres objets.
interface
Le terme a de trs nombreux sens en informatique (partout o se trouve
une frontire conventionnelle sur laquelle se situent des changes). En
Java le terme un sens particulier lorsquil dsigne un type abstrait pur
cest dire un type qui est dni par ce quil fait (une liste den-ttes de
mthodes dinstance) et non par sa ralisation.
interface homme/machine
(I.H.M. ou en anglais GUI -Graphic User Interface- prononcer gouw)Tout
ce qui permet la communication utilisateur-ordinateur: plus
particulirement la prsentation graphique et ses modes dinteraction.
introspection
voir rexion/introspection
JIT
Just In Time: excuteur de pseudo-code qui compile la vole ce code
en code natif de la machine.
JVM
Java Virtual Machine: norme dcrivant le comportement dun excuteur
du pseudo-code Java (et par extension tout excuteur conforme cette
norme). Il sagit en fait dun processeur virtuel qui excute un code
binaire spcique (le pseudo-code), la prsence dun tel mulateur sur
une machine permet dassurer la portabilit du code binaire Java.
liaison dynamique
(quivalent de virtual method invocation en argot C++) Mcanisme qui
permet lexcution (au runtime) de choisir le bon code dune mthode
en fonction du type effectif de lobjet. En java le type effectif dune
rfrence peut tre diffrent du type dclar : soit lobjet est dune sous-
classe de la classe demande soit il est dune classe qui implmente le
type dinterface dclar. Le compilateur ne peut tablir au compile-time
quel est le code de mthode qui va tre rellement excut
20
20/358
Rvision : J3
Date : 4/6/02
Aide-mmoire
liaison statique
Le compilateur sait tablir au compile-time quel est le code ou la donne
qui va tre consult (voir liaison dynamique). La rednition dans une
sous-classe dun membre qui est en liaison statique (rupture du lien
statique ou hiding) rend parfois le code obscur.
linearisation
voir serialization
litteral
Notation qui permet de dcrire une valeur. Pour les primitifs scalaires et
les chanes de caractres une notation qui dcrit une constante : 12 12.3
c chaine sont des littraux. La dclaration
Object[] tb = {new Object(), new Object()} ;
utilise un tableau littral.
mandataire
(proxy) code ou application qui reoit des demandes adresses un autre
objet ou application pour les lui transmettre, les ltrer, etc.
membre
Ce qui est directement joignable en passant par une rfrence d instance
ou une dsignation de classe (cet accs se faisant par loprateur .).
Les champs, les mthodes, les classes dnies au niveau des dclarations
sont des membres : soit des membres de classe (static) soit des
membres dinstance (il en va de mme pour les membres hrits des
super-classes). Les constructeurs et les blocs de premier niveau ne sont
pas des membres. Le terme est galement valable pour les membres dun
package qui sont des classes ou des sous-package. Pour les tableaux sont
membres : les membres hrits de Object et le champ length.
20/359
Rvision : J3
Date : 4/6/02
20
Aide-mmoire
message
Le terme sert exprimer le dcouplage entre une demande de service et
sa ralisation: cest dire que celui qui demande un service ne sait pas a
priori comment il va tre rendu. Cela permet la fois du contrle de type
(celui qui on demande le service sait effectivement le rendre) et
abstraction, dynamicit et maintenabilit (le code ralisant peut voluer, le
code ralisant peut ne pas tre connu au compile-time).
Historiquement le terme vient du caractre interprtatif de certains
langages Objet: la requte tait interprt et dans ces langages le
polymorphisme recouvrait la fois possibilit de rednition et de
surcharge; en Java les deux concepts sont distincts et le polymorphisme
nimplique que la rednition.mthode dinstance
Mthode appele comme membre dune instance (c.a.d
objet.methode() ou this.methode()) et qui sert modier ou
tirer partie de ltat de linstance et/ou permettre davoir un
comportement polymorphique.
mthode de classe
Mthode membre dune classe ( appeler de prfrence par
Classe.methode()) qui est un service gnral li la classe mais qui
na pas de raison dtre une mthode dinstance (pas de liaison logique
avec une instance particulire, pas de recherche de polymorphisme).
modle structurel
(terminologie non-standard pour rendre pattern) Dispositif abstrait
dcrivant un modle dassemblage de classes permettant dobtenir une
mcanique comportementale particulire. Exemple: le modle
Observer/Observable de Java dcrit un classe observe pour
laquelle des modications seront signales aux observateurs.
modle/vue/controleur
Un modle structurel qui propose de grer en parallle des donnes
applicatives susceptibles dtre modies et leur(s) reprsentation (en
gnral graphique). Imaginons, par exemple, un tableau de donnes qui
sont la fois modies par un processus externe (par ex. dautres
interfaces graphiques qui partagent les mmes donnes distance) et
modies par une interface graphique locale: le modle sera le tableau de
donnes, la vue linterface graphique et le controleur assurera les
changes et la cohrence entre les deux,
20
20/360
Rvision : J3
Date : 4/6/02
Aide-mmoire
mutateur
(terminologie non-standard : dcalque de mutator) Mthode permettant de
modier globalement sur une instance la valeur dun champ dont laccs
est protg. Par convention les mutateurs sont de la forme : void
setXXX(Type) . o XXX est le nom du champ etType le type du
champ. Voir accesseur et la convention correspondanteNaN
(Not A Number) Dans les processeurs de calcul en virgule ottante des
congurations de bits spciales qui permettent de grer des compte-
rendus ou des rsultats doprations particulires comme 0/0. Un NaN
est absorbant pour toutes les oprations et toute comparaison (y compris
avec lui mme) rend faux. En Java voir les constantes Double.NaN et
Float.NaN et mthodes isNaN.
objet
voir instance
obsolescence
(deprecation) Entre deux versions dun programme Java une partie dune
A.P.I. peut tre abandonne (il apparat, par ex., qu lusage les
spcications sont fautives). Dans ce cas les mthodes (ou constructeurs)
abandonnes peuvent faire toujours partie de lA.P.I mais tre marque
par la balise spciale javadoc @deprecated . Le compilateur signale alors
tout usage obsolete dune A.P.I.
package
En Java regroupement de classes agissant dans un domaine particulier
(les classes dentre/sortie, les classes graphiques, etc.). Les codes ainsi
regroups ont entre eux des responsabilits que nont pas les codes
extrieurs au package.
En dehors de tout petits codes de dmonstration il est exclu davoir des
codes hors-package.
Pour viter des conits potentiels de nom il est dusage de prxer les
packages avec le nom internet des organisations (com.sun, org.omg,
etc.)
20/361
Rvision : J3
Date : 4/6/02
20
Aide-mmoire
passage par rfrence
Dans certains langages de programmation on a la possibilit de passer un
paramtre (par ex. une fonction) qui reste dans lespace du code
appelant. Le code de la fonction peut alors ventuellement modier la
valeur et cette valeur est donc modie pour le code appelant. Ce type
deffet de bord nest pas recommand dun point de vue thorique mais
reste possible.
Java ne connait que le passage par valeur (ceci dit il est possible
lorsquon passe une rfrence comme paramtre de pouvoir modier un
membre rattach cette rfrence et donc de produire un effet de bord).
Il arrive que lon utilise le terme passage par refrence en Java lorsquon
utilise R.M.I (invocation de mthodes distantes) et que lon veut signier
que le paramtre reste un objet distant (RemoteRef).
passage par valeur
Le fait que les paramtres dune mthode sont copies sur la pile ( partir
de valeurs connues dans le code appelant) et que toute modication de
ces valeurs survenue dans le code de la mthode est sans effet sur le code
appelant (en principe : voir passage par rference).
Il arrive que lon utilise le terme passage par valeur en Java lorsquon
utilise R.M.I (invocation de mthodes distantes) et que lon veut signier
que le paramtre est un objet qui va tre linaris et va tre copi dans
la JVM qui excute le code.
pattern
voir modle structurel
persistence
Capacit de conserver ltat interne dun objet y compris entre diffrentes
instances de processus JVM. Un programme pourra par exemple
sarrter et retrouver ltat dun objet persistant au redmarrage de
lapplication.
petit-boutien
(rfrence aux voyages de Gulliver: voir poids fort/poids faible, utilis
galement pour les formats de date jj/mm/aa)
20
20/362
Rvision : J3
Date : 4/6/02
Aide-mmoire
pile
Partie(s) de la mmoire dans laquelle sont stockes les donnes
ncessaires lexcution des mthodes (paramtres, variables locales). Ces
donnes sont temporaires et sont gres en pile cest dire quon les
alloue au moment o lon rentre dans lexcution et quelles perdent toute
signication au moment o lon sort de lexcution de la mthode
courante.
poids fort/poids faible
Organisation de blocs de bits dans un processeur (par ex. pour la
reprsentation dun nombre entier). Dans de nombreuses architecture le
mot mmoire est organis de droite gauche regulirement (le bit le
plus droite a le poids le moins fort, et plus on va vers la gauche plus
on reprsente des poids fort -hormis le bit de signe). Une telle
architecture (processeurs Motorola, Sparc, entiers portables Java) est dite
en ordre poids-fort/poids-faible (ou gros-boutienne). Dautres
architectures (processeurs VAX, Intel) ont des blocs de bits qui sont
regroups de manire non homogne (de droite gauche lintrieur du
bloc mais de gauche droite entre blocs) : elles sont poids-faible/poids-
fort (ou petit-boutienne).
pointeur
Dans certains langages type permettant de reprsenter une adresse en
mmoire. Il ny a pas de pointeurs en Java.
polymorphisme
Le terme a eu plusieurs acceptations selon le contexte informatique:
gnralement il sagit dun comportement gnrique qui sadapte
automatiquement au type effectif des variables.
En Java cette gnricit concerne le point vue de lexcution dune
mthode dinstance: pour une API donne dnissant un type: lappel sur
une rfrence dune mthode (repre par sa signature) peut correspondre
des codes diffrents en fonction du type effectif de lobjet (qui peut tre
diffrent du type dclar soit par hritage, soit par implmentation
dinterface).
Un tel dcouplage entre une demande de service et sa ralisation amliore
la gnricit, la maintenabilit et la dynamicit des programmes.
pool
Ensemble de ressources mises en commun. ex. pool de constantes mises
en commun entre les classes.
20/363
Rvision : J3
Date : 4/6/02
20
Aide-mmoire
porte
Capacit dun code accder une donne rfrence par un symbole. En
Java la porte est lie la porte syntaxique : dans un bloc on naccde
quaux variables du bloc local, celles du bloc englobant (y compris de
variables associes au bloc comme des paramtres). On accde aussi aux
membres et constructeurs de la classe courante (ainsi quaux aux membres
et constructeurs accessibles dans les autres classes) et lespace de nom
des classes. Les modicateurs daccs (public, private, etc..) sont, eux, lis
la notion dunit de compilation.
primitif
En java type scalaire (c.a.d non-objet) cabl dans le langage. Certains
langages objet nutilisent pas de tels types et ne connaissent que des
objets mme pour reprsenter des donnes simples comme des entiers. De
tels types existent en java (voir classes dencapsulation), mais des soucis
de performance (en particulier dans les calculs) ont fait prfrer
limplantation de types primitifs.
proprit
Une association nom-valeur. Peut avoir plusieurs interprtations en Java:
Une association de deux chaines dans un dictionnaire de type
java.util.Property (lune est la clef, lautre la valeur). A
de nombreuses utilisations comme recuprer des valeurs de
conguration (System.getProperties()) ou des donnes
paramtres (PropertyResourceBundle).
Dans un bean: une association symbole-valeur dcouverte
dynamiquement grce aux conventions de notation et aux
mcanismes de rexion/introspection
pseudocode
(bytecode) Code binaire destin la machine virtuelle Java (voir JVM).
Comme cette machine est, prcisment, virtuelle il sagit dun pseudo
code binaire.
20
20/364
Rvision : J3
Date : 4/6/02
Aide-mmoire
rcursivit
Possibilit pour une mthode de se rappeler elle-mme dans sa dnition.
Pour les amateurs :
public static long ackerman(long mx, long ny) {
// parametres doivent etre positifs
if( mx ==0L) {return ny+1; }
if(ny==0L) { return ackerman(mx-1,1) ;}
return ackerman(mx-1, ackerman(mx, ny-1)) ;
}
redfinition
(overriding) Reprise dans une sous-classe de la dnition dune mthode
hrite de la super-classe. Cette rednition peux ventuellement faire
appel lexcution de la mthode rednie (appel de
super.methode()).
Avec la dnition de mthodes abstraites (hritage de classes abstraites,
ralisation de contrat dinterface) cette technique accompagne la liaison
dynamique et le polymorphisme.
Ne pas confondre avec surcharge (overloading) et avec rupture du lien
statique (hiding).
rfrence
En Java on naccde un objet quindirectement au travers dune
refrence: cest dire quelque chose qui permet de retrouver lobjet
dans le tas. Contrairement aux apparences il y a peu de chances quune
rfrence soit implante comme un pointeur en mmoire (tel que ce
type est utilis dans certains langages comme Pascal ou C).
rfrence distante
Technique permettant davoir une rfrence sur un objet situ dans une
autre J.V.M (voir R.M.I.)
rfrence faible
Technique permettant de grer des caches mmoire. Certains objets que
lon sait reconstituer sont rfrencs faiblement cest dire que lon
autorise explicitement le glaneur de mmoire les rcuprer si on a
besoin de mmoire, lobjet sera reconstitu si on en a besoin
ultrieurement. (voir package java.lang.ref)
20/365
Rvision : J3
Date : 4/6/02
20
Aide-mmoire
reflexion/introspection
Ensemble de mcanismes qui permettent dinspecter une instance dun
type a priori inconnu et den connatre la classe, les membres et les
constructeurs. On peut , par exemple, appeler dynamiquement une
mthode inconnue au compile-time .
rupture du lien statique
(terminologie non-standard pour rendre le terme hiding dans son
acceptation par JLS) rednition dans une sous classe dun membre qui
nest pas soumis valuation dynamique. Exemple: rednition dun
champ ou dune mthode statique.
sandbox security model
(pas de traduction connue: la plus approprie nous semble tre celle de
larne -que ce soit pour des gladiateurs, des politiciens ou des toros on
peut jouer dedans mais les occasions de sortie doivent tre limites-
correspond dailleurs au sens tymologique de larne = sable ). Modle
de scurit du code appliqu par un gestionnaire de scurit en labsence
dune politique de scurit congure. En gros un code soumis politique
de scurit ne peut consulter que quelques informations sur
lenvironnement (voir chier jre/lib/security/java.policy), ne
peut pas connatre ni accder au systme de chier, ne peut pas
dclencher un processus systme local et ne peut pas faire un accs rseau
(sauf avec le site dont le code est originaire).
scalaire
(terminologie non-standard emprunte dautres langages comme APL).
Un type non-objet reprsentant une valeur atomique.
(En toute rigueur les types long et double ne sont pas strictement
atomiques au regard de certaines oprations, voir chapitre de JLS
NonAtomic treatment of double and long).
serialization
mise plat dun objet pour envoi dans un ot spcial (ObjectStream).
Utilis pour la persistence ou pour la communication dobjets au travers
du rseau.
20
20/366
Rvision : J3
Date : 4/6/02
Aide-mmoire
spcification
Dnition du comportement dune entit informatique (objet, oprateur,
structure de contrle, ...). Pour prendre lexemple des interfaces Java les
spcications sont rendues la fois par des moyens formels analysables
par informatique (les en-ttes de mthodes abstraites) et par la
documentation javadoc qui dcrit de manire informelle le contrat de
comportement de ces mthodes.
statique
(abus de langage venant de la reprise -malheureuse- du mot clef static
de C/C++) Qui appartient une classe et non une instance. Les
membres de classes sont prxs du modicateur static (il en est de
mme des blocs de classe).
Aspect avanc: lallocation mmoire correspondante nest en rien
lallocation statique prsente dans dautres langages: lallocation est lie
au chargeur de classe et donc il peut y avoir plusieurs fois la mme
classe en mmoire (et donc par exemple plusieurs versions dune variable
partage statique).
structure de contrle
Elment du langage permettant de modier le droulement successif des
instructions et de les regrouper par blocs: aiguillages (if, switch),
boucles (while, do-while, for), captures (try-catch-finally),
sections sous contrle de concurrence (synchronized).
surcharge
(overloading) capacit de dnir plusieurs mthodes avec la mme
intention smantique et des paramtres diffrents (ex. println de
PrintStream qui peut grer des entiers, des ottants, des objets, etc.).
Existe aussi pour des constructeurs.
Ne pas confondre avec rednition (voir aussi message).
tas
Partie de la mmoire dun processus qui sert lallocation dynamique de
donnes dont le nombre nest pas a priori connu.
En Java tout est pratiquement allou dans le tas et le glaneur de
mmoire gre la dsallocation des objets qui ne sont plus refrencs.
20/367
Rvision : J3
Date : 4/6/02
20
Aide-mmoire
thread
(pas daccord gnral sur la traduction du terme en franais) Tche
lmentaire lintrieur dune JVM. Ces processus lgers peuvent tre
grs par le systme dexploitation ou par lexcuteur Java lui-mme. Un
ordonnanceur de tches passe la main une tche particulire en fonction
de priorits et aussi de stratgies qui ne sont pas spcies par le
standard. La gestion cohrente de donnes qui sont accdes par
plusieurs threads concurrents est un des aspects les plus difcile de la
programmation en Java.
transtypage
(terminologie non-standard: rend les diffrents sens de cast) Terme
gnrique regroupant conversion et forage de type.
UML
Formalisme de reprsentation de modles (en principe indpendant des
langages et des mthodologies). Utilis ici essentiellement pour montrer
des diagrammes de classes.
variable dinstance
Variable membre dune instance. Dclare au premier niveau de la
classe elle est accessible essentiellement par les mthodes de linstance
courante (mais pas par les mthodes de classe), La combinaison des
valeurs des variables dinstance constitue ltat de linstance.
variable de classe
voir variable partage.
variable partage
Variable membre dune classe. Dclare au premier niveau de la classe
(avec modicateur static) elle est accessible au travers de la dsignation
de la classe (et,mais cest moins courant, au travers de rfrence une
instance de la classe).
veilleur
(terminologie non-standard: ide de Listener) Objet qui sabonne pour
recevoir des vnements et dont la classe implante des gestionnaires
dvnements.
20
20/368
Rvision : J3
Date : 4/6/02
Aide-mmoire
XML
Formalisme permettant de reprsenter des donnes sous forme textuelle.
Il sagit dun langage balises (les balises tant du texte spcial qui
documente et structure le texte lui-mme). Ces donnes sont ainsi
portables et aussi bien lisibles par une application que par un tre
humain.
20/369
Rvision : J3
Date : 4/6/02
20
Aide-mmoire
Adresses utiles
Java
site fondamental: http://java.sun.com ;
+ http://www.ibm.com/java
spcications : http://java.sun.com/docs/books/jls/
spcications JVM : http://java.sun.com/docs/books/vmspec/
Un livre: Le langage Java (Arnold, Gosling, etc. ed. Vuibert ISBN 2-7117-
8671-4)
Approche objet
Un livre: Object-Oriented Software Construction, Second Edition (Bertrand
Meyer - ed. Prentice-Hall-)
UML
http://uml.free.fr (en franais!)
Unicode
http://www.unicode.org
HTML et XML
http://www.w3.org
20
20/370
Rvision : J3
Date : 4/6/02
Aide-mmoire
Rvision : J3
Date : 4/6/02
INDEX
A
AbstractPreferences ............................................................................................................. 139
AccessControler ................................................................................................................... 107
accesseur .............................................................................................................................. 347
AccessibleObject .................................................................................................................. 255
ActionEvent ........................................................................................................................... 51
ActionListener .................................................................................................................. 51, 52
actionPerformed ..................................................................................................................... 51
Activatable ........................................................................................................................... 230
adaptateur ............................................................................................................................. 347
add .................................................................................................................................... 27, 28
addActionListener .................................................................................................................. 51
Adresses utiles ..................................................................................................................... 369
agregation ............................................................................................................................. 347
allocation .............................................................................................................................. 347
analyse .................................................................................................................................. 348
Annuaire dobjets distants .................................................................................................... 222
API ....................................................................................................................................... 348
Applet
balise HTML .......................................................................................................... 304
classe ....................................................................................................................... 302
applet .................................................................................................................................... 348
appletviewer ......................................................................................................................... 343
appliquette ............................................................................................................................ 298
architecture trois parties .................................................................................................... 348
Archives jar ............................................................................................................................ 99
Array
java.lang.reflect.Array .......................................................................................... 259
assert
mot-clef ................................................................................................................... 155
mot-clef (1.4) .......................................................................................................... 213
assertion ............................................................................................................................... 213
AssertionError ...................................................................................................................... 155
/372
Rvision : J3
Date : 4/6/02
Assertions ............................................................................................................................. 154
assertions .............................................................................................................................. 141
association ............................................................................................................................ 348
attente de la terminaison dune tche ..................................................................................... 68
attribut .................................................................................................................................. 348
AudioClip ............................................................................................................................. 307
automatique .......................................................................................................................... 349
awt .......................................................................................................................................... 18
B
BackingStoreException ........................................................................................................ 137
Batch .................................................................................................................................... 247
bean ...................................................................................................................................... 349
beancontext .......................................................................................................................... 265
BeanDescriptor .................................................................................................................... 267
BeanInfo ............................................................................................................................... 265
bloc ....................................................................................................................................... 335
dinitialisation dinstance ..................................................................................... 337
non associe a une structure .................................................................................. 338
statique ................................................................................................................... 336
Blocs synchronized ................................................................................................................ 80
bootstrap
classes de .................................................................................................................. 98
BorderFactory ........................................................................................................................ 25
BorderLayout ......................................................................................................................... 28
bordures .................................................................................................................................. 40
BoxLayout .............................................................................................................................. 35
break
description simple de la syntaxe ......................................................................... 321
BreakIterator ........................................................................................................................ 129
Buffer
dans java.nio .......................................................................................................... 204
BufferedInputStream ............................................................................................................ 176
bus logiciel ........................................................................................................................... 349
ByteArrayInputStream ......................................................................................................... 174
ByteBuffer .................................................................................................................... 204, 205
ByteOrder ............................................................................................................................. 208
C
CallableStatement ................................................................................................................ 246
callback .................................................................................................................................. 93
catch
champ ................................................................................................................................... 349
channel dentre sortie
/373
Rvision : J3
Date : 4/6/02
java.nio .................................................................................................................... 204
CharArrayReader ................................................................................................................. 174
CharBuffer ........................................................................................................................... 204
chargeur de classe ................................................................................................................ 349
CharSequence ...................................................................................................................... 213
ChoiceFormat ....................................................................................................................... 127
Class
classe java.lang.Class ............................................................................................ 253
classe
abstraite .................................................................................................................. 350
anonyme ........................................................................................................... 58, 350
dencapsulation ..................................................................................................... 350
interne ............................................................................................................... 57, 350
locale ....................................................................................................................... 351
membre ................................................................................................................... 351
ClassLoader ............................................................................................................................ 98
ClassNotFoundException .................................................................................................... 198
CLASSPATH ....................................................................................................................... 351
client/serveur ........................................................................................................................ 237
code natif .............................................................................................................................. 351
Collator ................................................................................................................................ 129
compilation conditionnelle ................................................................................................... 351
Component ............................................................................................................................. 18
taille preferee ........................................................................................................... 27
composition .......................................................................................................................... 351
conception ............................................................................................................................ 352
ConcurrentModificationException ........................................................................................ 83
Connection
objet JDBC .............................................................................................................. 238
constante .............................................................................................................................. 352
constructeur .......................................................................................................................... 352
aide-memoire ......................................................................................................... 333
Constructor
java.lang.reflect.Constructor ............................................................................... 258
Container ................................................................................................................................ 18
container ............................................................................................................................... 352
continue
conversion ............................................................................................................................ 352
copie de rfrence
mmoire de travail dun thread ............................................................................ 75
Cp1252
codage Windows ................................................................................................... 175
Currency ............................................................................................................................... 125
/374
Rvision : J3
Date : 4/6/02
D
DatagramPacket ................................................................................................................... 189
DatagramSocket ................................................................................................................... 189
DataInputStream .................................................................................................................. 176
DataOuputStream ................................................................................................................. 176
DateFormat .......................................................................................................................... 127
DateFormatSymbols ............................................................................................................ 127
DecimalFormat .................................................................................................................... 126
dcorateur (modle structurel) ............................................................................................. 166
dlgation ............................................................................................................................. 353
dvnements ........................................................................................................... 47
design patterns ..................................................................................................................... 164
destroy .................................................................................................................................. 309
DigestInputStream ............................................................................................................... 177
directive ................................................................................................................................ 353
do...while
doclet .................................................................................................................................... 353
doPrivileged ......................................................................................................................... 116
double-buffering .................................................................................................................... 40
drivers JDBC ........................................................................................................................ 237
dynamic proxy ..................................................................................................................... 261
dynamicit ............................................................................................................................ 353
E
enableassertions
option de lancement ............................................................................................. 155
encapsulation ........................................................................................................................ 353
Entreprise Java Bean ............................................................................................................ 264
ErrorManager ....................................................................................................................... 159
espace de nom ...................................................................................................................... 353
vnement ............................................................................................................................ 353
vnements AWT ................................................................................................................... 46
categories .................................................................................................................. 52
exception .............................................................................................................................. 354
Exportation dun objet (RMI) .............................................................................................. 219
expression ............................................................................................................................ 354
expression rgulire
java.util.regex ......................................................................................................... 135
Expressions rgulires ......................................................................................................... 213
extensions installes ............................................................................................................... 98
Externalizable ...................................................................................................................... 199
/375
Rvision : J3
Date : 4/6/02
F
Federated Management Bean ............................................................................................... 264
Field
java.lang.reflect.Field ............................................................................................ 256
FileChannel .......................................................................................................................... 204
FileInputStream .................................................................................................................... 174
FilePermission ..................................................................................................................... 107
FileReader ............................................................................................................................ 174
Filter
de Log ..................................................................................................................... 146
filtre ...................................................................................................................................... 354
dE/S ............................................................................................................... 176, 177
finally
descriptions simples de la syntaxe ..................................................................... 321
flot ........................................................................................................................................ 354
FlowLayout ...................................................................................................................... 25, 27
FocusListener ......................................................................................................................... 52
fonction ................................................................................................................................ 355
for
forage de type ..................................................................................................................... 355
Formatter .............................................................................................................................. 146
G
garbage collector .................................................................................................................. 355
garbage-collector
distribu .................................................................................................................. 218
GatheringByteChannel ......................................................................................................... 208
gestionnaire dvnement .............................................................................................. 46, 355
gestionnaire de disposition (LayoutManager) ..................................................................... 355
gestionnaire de scurit ........................................................................................................ 355
getActionCommand ............................................................................................................... 46
getAudioClip ........................................................................................................................ 307
getCodeBase ........................................................................................................................ 307
getDocumentBase ................................................................................................................ 307
mthode de Applet ............................................................................................... 103
getImage ............................................................................................................................... 307
getModifiers ........................................................................................................................... 46
getParameter ........................................................................................................................ 307
getResource .......................................................................................................................... 104
getSource() ............................................................................................................................. 46
getStackTrace ....................................................................................................................... 159
getSystemClassLoader ........................................................................................................... 98
glaneur de mmoire .............................................................................................................. 355
glossaire ............................................................................................................................... 347
/376
Rvision : J3
Date : 4/6/02
GridBagConstraints ................................................................................................................ 37
GridBagLayout ...................................................................................................................... 36
GridLayout ............................................................................................................................. 34
H
Handler ................................................................................................................................. 146
handler .................................................................................................................................... 46
hritage ................................................................................................................................. 356
multiple .................................................................................................................. 356
hiding ................................................................................................................................... 365
historiques ............................................................................................................................ 142
holdsLock
mthode de Thread ................................................................................................. 83
Hotspot ................................................................................................................................. 356
HTML .......................................................................................................................... 298, 344
aide-memoire ......................................................................................................... 344
I
I.E.E.E 754 ........................................................................................................................... 356
if
IllegalMonitorStateException ................................................................................................ 88
IllegalThreadStateException .................................................................................................. 65
implmenter ......................................................................................................................... 356
implements ............................................................................................................................. 49
InetSocketAddress ............................................................................................................... 189
InheritableThreadLocal .......................................................................................................... 74
init ........................................................................................................................................ 309
InputStream .......................................................................................................................... 172
InputStreamReader .............................................................................................................. 174
instance ................................................................................................................................ 357
IntBuffer ............................................................................................................................... 204
interface .................................................................................................................... 48, 49, 357
interface homme/machine .................................................................................................... 357
Internationalisation .............................................................................................................. 117
Internationalization and Localization ToolKit ..................................................................... 129
interrupt
mthode de Thread ................................................................................................. 67
introspection ......................................................................................................................... 357
Introspector
java.beans.Introspector ......................................................................................... 265
InvocationHandler ................................................................................................................ 262
InvocationTargetException .................................................................................................. 257
isAlive
mthode de Thread ................................................................................................. 65
/377
Rvision : J3
Date : 4/6/02
ISO8859-1 ............................................................................................................................ 175
ItemListener ........................................................................................................................... 52
J
JAAS .................................................................................................................................... 116
Jar ........................................................................................................................................... 99
jar ......................................................................................................................................... 343
jarindex ................................................................................................................................ 110
jarsigner ................................................................................................................................ 113
java.beans ............................................................................................................................. 265
java.beans.beancontext ........................................................................................................ 265
java.lang.reflect
package ................................................................................................................... 255
java.nio ................................................................................................................................. 177
java.nio.channels .................................................................................................................. 204
java.util.prefs ........................................................................................................................ 132
java.util.regex ....................................................................................................................... 213
javadoc ................................................................................................................................. 344
javap ..................................................................................................................................... 343
javax.net.ssl .......................................................................................................................... 229
jdb ........................................................................................................................................ 343
JDBC .................................................................................................................................... 236
mappage de types de donnes SQL ................................................................... 244
JDBC-Net ............................................................................................................................. 237
Jini ........................................................................................................................................ 231
JIRO ..................................................................................................................................... 264
JIT ........................................................................................................................................ 357
join
mthode de Thread ................................................................................................. 68
journalisations,rapports ........................................................................................................ 141
JPanel ..................................................................................................................................... 25
JScrollPane ............................................................................................................................. 29
JTextArea ............................................................................................................................... 29
JVM ...................................................................................................................................... 357
K
KeyListener ............................................................................................................................ 52
keystore ................................................................................................................................ 111
keytool .................................................................................................................................. 112
L
LayoutManager ...................................................................................................................... 18
liaison dynamique ................................................................................................................ 357
liaison statique ..................................................................................................................... 358
/378
Rvision : J3
Date : 4/6/02
linearisation .......................................................................................................................... 358
linarisation .......................................................................................................................... 199
LineNumberReader .............................................................................................................. 177
Listener .................................................................................................................................. 47
ListResourceBundle ............................................................................................................. 122
litteral ................................................................................................................................... 358
load
mthode de java.util.Properties .......................................................................... 105
Locale ................................................................................................................................... 119
log ........................................................................................................................................ 142
Logger .................................................................................................................................. 145
LogRecord ............................................................................................................................ 146
look and feel ........................................................................................................................... 19
lookup .................................................................................................................................. 224
M
mandataire ............................................................................................................................ 358
Mandataires dynamiques ..................................................................................................... 261
Manifest ............................................................................................................................... 101
MappedByteBuffer .............................................................................................................. 214
MediaTracker ......................................................................................................................... 63
membre ................................................................................................................................ 358
mmoire principale ................................................................................................................ 75
MemoryHandler ................................................................................................................... 160
message ................................................................................................................................ 359
MessageFormat .................................................................................................................... 127
Metal
charte graphique swing .......................................................................................... 19
Method
java.lang.reflect.Method ....................................................................................... 257
mthode ................................................................................................................................ 329
asynchrones (chargement media) ....................................................................... 308
dinstance ....................................................................................................... 330, 359
de classe .......................................................................................................... 332, 359
membre
description simple de la syntaxe ......................................................................315
modle structurel .................................................................................................................. 359
Modle/Vue/Controleur ....................................................................................................... 359
moniteur ........................................................................................................................... 79, 80
monitorat .............................................................................................................................. 142
MouseListener ........................................................................................................................ 52
MouseMotionListener ............................................................................................................ 52
Multicast ...................................................................................................................... 182, 192
Multicast Announcement
protocole Jini .......................................................................................................... 231
/379
Rvision : J3
Date : 4/6/02
Multicast Request
protocole Jini .......................................................................................................... 231
MulticastSocket .................................................................................................................... 192
mutateur ............................................................................................................................... 360
N
Naming ......................................................................................................................... 223, 224
NaN ...................................................................................................................................... 360
native2ascii .......................................................................................................................... 343
newAudioClip ...................................................................................................................... 307
node
noeud de larbre des prfrences ........................................................................ 133
NodeChangeListener ............................................................................................................ 139
notifyAll ................................................................................................................................. 89
NotSerializableException .................................................................................................... 199
NumberFormat ..................................................................................................................... 125
O
ObjectInputField.GetField ................................................................................................... 212
ObjectInputStream ............................................................................................................... 198
ObjectOutputStream ............................................................................................................ 198
objet ...................................................................................................................................... 360
Observer/Observable ............................................................................................................ 164
obsolescence ........................................................................................................................ 360
ODBC .................................................................................................................................. 237
ordonnancement
des threads ............................................................................................................... 63
ordonnanceur de tches .......................................................................................................... 62
outils ..................................................................................................................................... 343
OutputStream ....................................................................................................................... 172
OutputStreamWriter ............................................................................................................. 175
P
pack()
mthode de JFrame ................................................................................................. 21
package ................................................................................................................................ 360
passage par rfrence ........................................................................................................... 361
passage par valeur ................................................................................................................ 361
pattern .................................................................................................................................. 361
pattern (modles structurels) .................................................................................................. 54
persistence ............................................................................................................................ 361
PersistenceDelegate ............................................................................................................. 267
Personnalisation de la linarisation ...................................................................................... 202
petit-boutien ................................................................................................................. 208, 361
/380
Rvision : J3
Date : 4/6/02
pile ........................................................................................................................................ 362
PipedInputStream ................................................................................................................. 174
PipedReader ......................................................................................................................... 174
pipes ..................................................................................................................................... 171
poids fort/poids faible .......................................................................................................... 362
pointeur ................................................................................................................................ 362
policytool ............................................................................................................................. 115
polymorphisme .................................................................................................................... 362
pool ...................................................................................................................................... 362
porte .................................................................................................................................... 363
PreferenceChangeListener ................................................................................................... 139
PreferenceFactory ................................................................................................................ 139
Prfrences ........................................................................................................................... 131
primitif ................................................................................................................................. 363
PrintWriter ........................................................................................................................... 177
Procdure stocke ................................................................................................................ 246
Process
getInputStream() ................................................................................................... 174
processus lgers (threads) ...................................................................................................... 61
projection de type ................................................................................................................. 355
PropertyResourceBundle ..................................................................................................... 123
proprit ............................................................................................................................... 363
Protection Domain ............................................................................................................... 300
Proxy
java.lang.reflect.Proxy .......................................................................................... 263
pseudocode ........................................................................................................................... 363
PushBackInputStream .......................................................................................................... 177
putFields
mthode des OutputStreams ............................................................................... 212
R
R.M.I .................................................................................................................................... 215
RandomAccessFile .............................................................................................. 177, 205, 214
Reader .................................................................................................................................. 173
readFields()
mthode dObjectInputstream ............................................................................ 212
readResolve
mthode des objets Serializable .......................................................................... 212
readUnshared ....................................................................................................................... 212
rebind ................................................................................................................................... 223
rcursivit ............................................................................................................................. 364
redfinition ........................................................................................................................... 364
rfrence ............................................................................................................................... 364
rfrences distantes .............................................................................................................. 364
rfrences faibles ................................................................................................................. 364
/381
Rvision : J3
Date : 4/6/02
reflection/introspection ........................................................................................................ 365
ReflectPermission ................................................................................................................ 255
Remote
interface java.rmi ................................................................................................... 217
RemoteException ................................................................................................................. 217
Requte prpare .................................................................................................................. 245
resolveObject ....................................................................................................................... 212
ResourceBundle ................................................................................................................... 150
Resourcebundle .................................................................................................................... 121
Ressources ............................................................................................................................ 103
ressources (au sens des E/S en mode flot) ........................................................................... 171
ResultSet .............................................................................................................................. 243
ResultSetMetaData .............................................................................................................. 243
resume .................................................................................................................................... 93
return
RMI
URL des objets ....................................................................................................... 224
rmic .............................................................................................................................. 220, 343
RMIClientSocketFactory ..................................................................................................... 229
rmid .............................................................................................................................. 230, 343
rmiregistry .................................................................................................................... 222, 343
RMIServerSocketFactory .................................................................................................... 229
Runnable ................................................................................................................................ 64
rupture du lien statique ......................................................................................................... 365
S
sandbox security model ........................................................................................................ 365
Sandbox Security Policy ...................................................................................................... 106
sandbox security policy ........................................................................................................ 300
scalaire ................................................................................................................................. 365
ScatteringByteChannel ........................................................................................................ 208
SDK ...................................................................................................................................... 342
Sealed
attributs de package dans les archives Jar ......................................................... 110
Scurit ................................................................................................................................ 106
scurit ................................................................................................................................. 300
SecurityManager .................................................................................................. 108, 227, 301
selectable
dispositif dE/S ..................................................................................................... 204
SequenceInputStream .......................................................................................................... 177
Serializable ........................................................................................................................... 199
serialization .................................................................................................................. 199, 365
ServerSocket ........................................................................................................................ 184
ServerSocketChannel ........................................................................................................... 204
/382
Rvision : J3
Date : 4/6/02
service distant (RMI) ........................................................................................................... 217
setDaemon
mthode de Thread ................................................................................................. 69
mthode de ThreadGroup ..................................................................................... 73
setLayout ................................................................................................................................ 25
setMaxPriority
mthode de ThreadGroup ..................................................................................... 73
setPriority
mthode de Thread ................................................................................................. 69
signature
dune methode ....................................................................................................... 329
SimpleDateFormat ............................................................................................................... 127
sleep
mthode de Thread ................................................................................................. 67
Socket ................................................................................................................................... 183
getInputStream() ................................................................................................... 174
SocketAddress ...................................................................................................................... 189
SocketChannel ..................................................................................................................... 204
sockets .................................................................................................................................. 182
datagram ................................................................................................................ 183
stream ..................................................................................................................... 183
source
option de lancement -source ............................................................................... 155
source devenement ............................................................................................................... 46
spcification ......................................................................................................................... 366
SSL ....................................................................................................................................... 229
stackTrace ............................................................................................................................ 142
start ....................................................................................................................................... 309
mthode de Thread ................................................................................................. 65
Statement .............................................................................................................................. 242
statique ................................................................................................................................. 366
stop ................................................................................................................................. 93, 309
StreamTokenizer .................................................................................................................. 177
StringReader ........................................................................................................................ 174
StringTokenizer .................................................................................................................... 135
structure de contrle ............................................................................................................. 366
structures de contrle
droutement
descriptions simples de la syntaxe ...................................................................321
Stub ...................................................................................................................................... 221
surcharge .............................................................................................................................. 366
suspend ................................................................................................................................... 93
swing ...................................................................................................................................... 19
switch
/383
Rvision : J3
Date : 4/6/02
synchronized .......................................................................................................................... 80
synchronizedCollection .......................................................................................................... 83
T
talon (stub) ........................................................................................................................... 218
tas ......................................................................................................................................... 366
TCP/IP ................................................................................................................................. 182
Telechargement dynamique des codes de classe
rmi ........................................................................................................................... 227
Thread
cration avec un Runnable ..................................................................................... 64
cycle de vie ............................................................................................................... 65
dfinition par hritage ............................................................................................ 69
thread .................................................................................................................................... 367
ThreadGroup .................................................................................................................. 73, 187
ThreadLocal ........................................................................................................................... 74
throw
time-slicing ............................................................................................................................ 62
Tool tips ................................................................................................................................. 40
transient ................................................................................................................................ 199
transtypage ........................................................................................................................... 367
try
Types SQL ........................................................................................................................... 244
U
UDP ...................................................................................................................................... 182
UML ..................................................................................................................................... 367
uncaughtException
mthode de ThreadGroup ............................................................................. 73, 187
Unicast Discovery Protocol
protocole Jini .......................................................................................................... 231
UnicastRemoteObject .......................................................................................................... 219
URL
openStream() .......................................................................................................... 174
syntaxe .................................................................................................................... 298
URLClassLoader .................................................................................................................. 228
UTF-8 ................................................................................................................................... 198
UTF8 .................................................................................................................................... 175
V
variable ................................................................................................................................. 322
automatique ........................................................................................................... 327
/384
Rvision : J3
Date : 4/6/02
dinstance ....................................................................................................... 323, 367
de classe .......................................................................................................... 325, 367
partage .................................................................................................................. 367
variable locale
variable membre
veilleur ........................................................................................................................... 47, 367
veilleur (evenement) .............................................................................................................. 47
ventilation
operations multi-Buffer sur des channels .......................................................... 208
verrou
sur fichier (FileChannel) ....................................................................................... 204
volatile
modificateur des variables membres ................................................................... 75
W
wait/notify .............................................................................................................................. 87
while
WindowListener ..................................................................................................................... 52
Writer ................................................................................................................................... 173
writeReplace
mthodes des objets Serializable ........................................................................ 212
writeUnshared ...................................................................................................................... 212
X
XML ..................................................................................................................................... 368
formattage des rapports de log ........................................................................... 146
pour limport/export de prfrence ................................................................... 139
XMLDecoder ....................................................................................................................... 266
XMLEncoder ....................................................................................................................... 266
Y
yield
mthode de Thread ................................................................................................. 67
Z
ZipInputStream .................................................................................................................... 177
zombie .................................................................................................................................... 65
/386
Rvision : J3
Date : 4/6/02
Rvision : J3
Date : 4/6/02
Rapport derreur
Malgr tous nos soins des erreurs (ou des fautes dorthographe!) sont
peut-tre encore prsentes dans ce support. Merci dutiliser cette page
pour nous les signaler en mettant le numro de chapitre et le numro de
page (remettre ensuite le document lanimateur, merci!).

Support de Cours Java2 PDF

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Support de Cours Java2 PDF

Transféré par

Droits d'auteur :

Formats disponibles

Intitul Cours : Matrise de la programmation en langage Java

La mthode statique ClassLoader.getSystemClassLoader()

On notera que lorsquune classe du bootstrap ClassLoader demande une

Attention : la notation de codeBase est celle dune URL (avec sparateur

On peut agir sur le Locale par dfaut au moment du lancement de la JVM

Dans lexemple ci-dessus seul getObject() devra tre utilis.

Attention le sparateur des milliers en Franais est vu comme un blanc

Ici utilisation dune assertion . Le code doit se compiler avec loption:

Nota: il est possible de dcouvir dynamiquement des informations sur la

Le modle de scurit Java 2 sapplique ds quun SecurityManager est

Les arguments numriques de la mthode drawString() sont les

Les dsignations de ressource par rapport une URL de base peuvent

Les mthodes de chargement de media comme getImage() sont des

Quelques dnitions dans ce glossaire sont marques terminologie non-

Vous aimerez peut-être aussi