Support de Cours Java2

Matrise de la programmation en langage Java

Intitul Cours :

Matrise de la programmation en langage Java

Date :

4/6/02

Protections Juridiques

AVERTISSEMENTCe 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

Protections JuridiquesIntutil Cours : Matrise de la programmation en langage Java Rvision : J3 Date : 4/6/02

2

IntroductionObjectifsCe 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

Intitul Cours: Matrise de la programmation en langage Java Rvision : J3 Date : 4/6/02

PrrequisPour pouvoir tirer un maximum de bnces de ce cours il est vivement conseill:

Davoir une bonne pratique des aspects fondamentaux de Java1:

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)IntroductionIntitul Cours: Matrise de la programmation en langage Java Rvision : J3 Date : 4/6/02

/4

PhasesLe 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). Un bloc de chapitres introduit les relations avec lenvironnement local dexcution: archives, ressources, internationalisation, prfrences, rapports et journalisation. 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).

2.

3.

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.

IntroductionIntitul Cours: Matrise de la programmation en langage Java Rvision : J3 Date : 4/6/02

/5

IntroductionIntitul Cours: Matrise de la programmation en langage Java Rvision : J3 Date : 4/6/02

/6

Table des MatiresIntroduction ............................................................................................................... 3

Introduction technique, composants Swing .......................................................... 15Le 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 .......................................................... 45Les 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)....................................................................................... 61Multi-tches (rappel)............................................................................................................ 62 Processus lgers: principes .................................................................................................. 63 Conception dun Thread ...................................................................................................... 64


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.................................................................................................... 77Accs 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................................................................................. 97Les ClassLoaders ................................................................................................................. 98 Archives jar.......................................................................................................................... 99 Archives jar: lancement dune application ........................................................................ 101 Ressources.......................................................................................................................... 103 Ressources applicatives ..................................................................................................... 104 Scurit .............................................................................................................................. 106 Scurit: politique configure ............................................................................................ 107

Internationalisation ............................................................................................... 117Pourquoi 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 ............................................................................................................. 131Preferences: principes ........................................................................................................ 132 Preferences: contextes de nommage .................................................................................. 133/8Intitul Cours: Matrise de la programmation en langage Java 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 .................................................................. 141LA.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......................................................... 163Modles 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 ......................................................................................... 181Modles 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

/9Intitul Cours: Matrise de la programmation en langage Java 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 ...................................................................................... 197E/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.).......................................................................... 215La 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).......................................................... 235Le 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


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 ................................................................................. 251Pourquoi 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 .................................................................................................. 269Problmatiques 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............................................................................. 281Pourquoi 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/11Intitul Cours: Matrise de la programmation en langage Java Rvision : J3 Date : 4/6/02

Invocation de JAVA dans du C ......................................................................................... 296

Java et le Web: les applets .................................................................................... 297Applets ............................................................................................................................... 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 ....................................................... 311Plan 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........................................................................................................ 341Le SDK .............................................................................................................................. 342 Les outils............................................................................................................................ 343 javadoc et HTML............................................................................................................... 344 Glossaire ............................................................................................................................ 347 Adresses utiles ................................................................................................................... 369


Premire partie: aspects fondamentaux du langage.



Introduction technique, composants SwingPoints essentielsPremire revue des bases techniques de Java.

1

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.


1Le code portable JavaLa lire de production du code Java : chier source compilation: javac chier binaire excution

Hello.java On a donc ici deux phases :

Hello.class

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).

Introduction technique, composants SwingIntitul Cours: Matrise de la programmation en langage Java Rvision : J3 Date : 4/6/02

1/16

1Les machines virtuellesLe pseudo-code Java (bytecode) obit des spcications prcises. Portable, il est excut sur la plate-forme locale par un excuteur propre cette plate-forme

chier binaire (pseudo-code) conforme aux spcications JVM

plate-forme de type A

plate-forme de type B

JVM (interprteur spcique)

librairies java

JVM (interprteur spcique)

librairies java

OS

systme de fentrage

OS

systme de fentrage

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.)


1/17

1Portabilit: exemple des applications graphiquesAWTLe 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):

Motif

Windows

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). x (0,0) Container (Frame)

y

Composant (TextField)

Bien que possible le positionnement en coordonnes absolues nest pas portable 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).Introduction technique, composants SwingIntitul Cours: Matrise de la programmation en langage Java Rvision : J3 Date : 4/6/02

1/18

1SwingLe 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 sousrpertoire 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/19

1Un premier programme SwingIci sur un systme de fentrage Motif, le rsultat de lexcution dun programme montrant un message simple dans une fentre:

Le chier source Message.java import javax.swing.* ; //directive utilisation de librairie public class Message {//dclaration classe JFrame fentre ; var.membre instance 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

constructeur

mthode dinstance

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!


1/20

1Un premier programme Swing: contenuAspects fonctionnelsDans 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 javaLa 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/21

1Point intermdiaire : mise en place dun programmeMini-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/22

1


1/23

1Disposer des composants dans un ContainerVoici 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 * * 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/24

1Disposition : le codeAspects fonctionnelsLa 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 composantsIl 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 javaBarre 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/25

1Disposer des composants dans un Container (suite)Le code utilisant Barre pour crer limage en exemple: import javax.swing.* ; 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() ; } }

Aspects fonctionnelsUn 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 javaNoter la cration dun tableau littral de JComponent (qui dailleurs ne contient que des JButtons).


1/26

1FlowLayout : synthseLe 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.

redimensionnement de la fentre (exemple en AWT)

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 lexposIntroduction technique, composants SwingIntitul Cours: Matrise de la programmation en langage Java Rvision : J3 Date : 4/6/02

1/27

1Gestionnaires de disposition :BorderLayoutBorderLayout 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.

redimensionnement de la fentre (exemple AWT)

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.


1/28

1BorderLayout: exemple de code (simpli)...; import javax.swing.* ; 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/29

1BorderLayout : exemple dveloppVoici 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..)Introduction technique, composants SwingIntitul Cours: Matrise de la programmation en langage Java Rvision : J3 Date : 4/6/02

1/30

1Exemple dvelopp de linterface graphique: package chat; import javax.swing.* ; 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/31

1Point intermdiaire : coder avec des LayoutManagersMini-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/32

1


1/33

1Quelques autres gestionnaires de dispositionGridLayoutDispose un tableau dans lequel tous les composants ont la mme hauteur et la mme largeur:

redimensionnement de la fentre

disposition avec des lments manquants Utilise essentiellement des add(composant) -lordre des appels tant important pour dterminer lordre de composants-


1/34

1BoxLayoutCest 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/35

1GridBagLayoutCest 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/36

1On 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 ("gridx=0;gridy=0"), gbc);// couteux! gbc.gridx = 1 ; gbc.gridy = 1 ; add(new JButton ("gridx=1;gridy=1"), gbc) ;


1/37

1Exercice: pratique des LayoutManagersExercice :

Raliser en Swing un formulaire comprenant un champ de saisie, un bouton et une plage de texte (pour afcher la rponse la question)


1/38

1


1/39

1ComplmentsLes complments techniques suivants constituent une annexe de rfrence

SwingLa 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 doublebuffering, Swing gre par dfaut les contextes graphiques ncessaires. bulles daide (Tool tips): en utilisant la mthode setToolTipText() et en lui passant une chane de caractres explicative on peut fournir lutilisateur une petite bulle daide. Lorsque le curseur fait une pause sur le composant la chane explicative est afche dans une petite fentre indpendante qui apparat proximit du composant cible. utilisation du clavier : en utilisant la mthode registerKeyBoardAction() on peut permettre lutilisateur dutiliser uniquement le clavier pour naviguer dans linterface utilisateur et pour dclencher des actions. La combinaison caractre + touche de modication est reprsente par lobjet KeyStroke. pluggable look and feel : au niveau global de lapplication un UIManager gre la charte graphique (look and feel). La modication de laspect par


1/40

1setLookAndFeel() 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/41

1Java: bases fondamentalesPour 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/42

1Dveloppement avec des packagesExemple dorganisation pratique des rpertoires:

src

fr

gibis

classes

p1 p2

utils

fr

gibis C2.java Classe1.java

p1 p2

utils

C2.class

Classe1.class

javac -classpath classes -d classes -sourcepath src Classe1.java

peut contenir une liste de chemins daccs (spars par : -ou ; sous Win*-)

variables


1/43

1


1/44

Introduction technique (suite), vnementsPoints essentiels

2

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.


2Les vnementsLorsque 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 dvnementsUn 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 dvnementsUn 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.

Introduction technique (suite), vnementsIntitul Cours: Matrise de la programmation en langage Java Rvision : J3 Date : 4/6/02

2/46

2Modle dvnementsModle par dlgationLe 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.

action Applet Panel Bouton handler daction actionPerformed(ActionEvent e) { .... } instance de veilleurgnration ActionEvent

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.


2/47

2Modle dvnementsLe type du veilleurLes 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/48

2Les interfacesUne 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/49

2Exemple de mise en place de traitement dvnementLes 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.*; import javax.swing.* ; 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/50

2Exemple de mise en place de traitement dvnement La classe JButton hrite de AbstractButton une mthode addActionListener(ActionListener). Linterface ActionListener dnit une seule actionPerformed qui recevra un ActionEvent. mthode ,

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 actionPerformed(ActionEvent evt) { .... } public void focusGained(FocusEvent evt) { ... } public void focusLost(FocusEvent evt) { ... } }


2/51

2Catgories dvnementsIl existe de nombreux types dinterfaces de veille dans les packages java.awt.event et javax.swing.event. Quelques exemples AWT:

CatgorieAction Item

InterfaceActionListener ItemListener

MethodesactionPerformed(ActionEvent) itemStateChanged(ItemEvent) mouseDragged(MouseEvent) mouseMoved(MouseEvent) mousePressed(MouseEvent) mouseReleased(MouseEvent) mouseEntered(MouseEvent) mouseExited(MouseEvent) mouseClicked(MouseEvent) keyPressed(KeyEvent) keyReleased(KeyEvent) keyTyped(KeyEvent) focusGained(FocusEvent) focusLost(FocusEvent) windowClosing(WindowEvent) windowOpened(WindowEvent) windowIconified(WindowEvent) windowDeiconified(WindowEvent) windowClosed(WindowEvent) windowActivated(WindowEvent) windowDeactivated(WindowEvent)

Mouse MotionMouseMotionListener MouseMouseListener

Key

KeyListener

Focus Window

FocusListener

WindowListener

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 , ...) 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/52

2Point intermdiaire : Mise en place dun veilleurMini-exercice :

Reprendre lexercice de mise en place dun formulaire questionrponse (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 ). Quel est le type dvnement qui permet de grer ces deux actions de la mme manire?


2/53

2Considrations architecturales: classes interdpendantesLa 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/54

2Considrations architecturalesLe gestionnaire dvnement dans une classe externeLe 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 ; } public void actionPerformed(ActionEvent evt) { 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/55

2Considrations architecturalesLe gestionnaire dvnement intgrLe gestionnaire dvnement peut tre intgr la classe de disposition graphique: public class Disposition extends JFrame implements ActionListener{ ... private JTextField leTextField ; .... private int compteur ; public void actionPerformed(ActionEvent evt) { 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 objetssi, 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/56

2Considrations architecturalesLe gestionnaire dvnement dans une classe interneUne 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 JTextField leTextField ; .... private class ControleurAction implements ActionListener{ int compteur ; public void actionPerformed(ActionEvent evt) { 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/57

2Considrations architecturalesLe gestionnaire dvnement dans une classe anonymeDans 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 { ... private JTextField leTextField ; .... bouton.addActionListener(new ActionListener() { int compteur ; public void actionPerformed(ActionEvent evt) { 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/58

2Exercices : Mise en place dun veilleurExercices :

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/59

2


2/60

Processus lgers (threads)Points essentiels:

3

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


3Multi-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.

Processus lgers (threads)Intitul Cours: Matrise de la programmation en langage Java Rvision : J3 Date : 4/6/02

3/62

3Processus lgers: principesDans 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/63

3Conception dun ThreadOn 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/64

3Cycle de vie : dbut et n de vieUne fois cr le Thread est prt tre activ: ceci se fait par linvocation de la mthode start()sur linstance tche.start() ;

run() { new Ordonnanceur start() Eligible Actif

}//FIN DE TACHE mort

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 garbagecollector) 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!).


3/65

3Point intermdiaire : lancement de threadsMini-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/66

3Cycle de vie: retrait de ltat actifDans 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 ; } public void run () { for(int ix = 0 ; ix < max ; ix++) { 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 actif2.

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/67

3Cycle de vie: attente de la terminaison dune tcheLa 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! } public void run () { 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/68

3Autres techniques de crationOn 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 dinitialisation:

deux

mthodes

intressantes

en

phase

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/69

3Point intermdiaire : la vie des threadsMini-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/70

3Etats dun Thread (rsum)

En Attente

n attente interruption

Thread.sleep() autreThread.join() Ordonnanceur

new

start()

Eligible Thread.yield()

Actif

mort

les dattente (sera vu ultrieurement)


3/71

3Exercice : threadsExercice:

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/72

3ComplmentsLes complments techniques suivants constituent une annexe de rfrence

ThreadGroupLes 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/73

3Variables partages lies un ThreadDans 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/74

3Images de la mmoireLe 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/75

3


3/76

Accs concurrentsPoints essentiels

4

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).


4Accs concurrents: problmatiqueImaginons 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).

Accs concurrentsIntitul Cours: Matrise de la programmation en langage Java Rvision : J3 Date : 4/6/02

4/78

4tat de linstance x 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 } ThreadA ThreadB autres Threads

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.


4/79

4Blocs synchronizedReprenons 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/80

4Blocs synchronized

tat de linstance x idx== 3

ThreadA

ThreadB

autres Threads

x.push(obj1){ synchronized(this) tb[3] = obj1 ; tb[3] == obj1 x.push(obj2){ synchronized(this) bloqu

Documents

Support de Cours Java2