French FR Logiciel Software Tutorial Programmation Java SUN LJ-295 - Realiser Une Application Java

Raliser une application JAV A
Projet : Raliser une application JAVA Client : Sun Service Formation Rf. Sun : SL-285
Rvision : Date :
D2 23/8/99
Rvision : Date :
D2 23/8/99
Rvision : Date :
D2 23/8/99
Rvision : Date :
D2 23/8/99
Rvision : Date :

D2 23/8/99
Sun Microsystems
Sun Microsystems
Sun Microsystems
Sun Microsystems
Sun Microsystems
Projet : Raliser une application JAVA Client : Rf. Sun : Sun Service Formation SL-285
Rvision : Date :
D2 23/8/99
Rvision : Date :
D2 23/8/99
Rvision : Date :

D2 23/8/99
Sun Microsystems France
Raliser une application JAVA
Intitul Cours : Client : Rf. Sun : Sun Microsystems France S.A. Service Formation 143 bis, avenue de Verdun 92442 ISSY LES MOULINEAUX Cedex Tel 01 41 33 17 17 Fax 01 41 33 17 20 Rvision : Date :
Raliser une application JAVA Sun Service Formation SL-285 D2 23/8/99
Protections Juridiques
1998 Sun Microsystems, Inc. 2550 Garcia Avenue, Mountain View, California 94043-1100 U.S.A.
AVERTISSEMENT
Ce produit ou document est protg par un copyright et distribu avec des licences qui en restreignent lutilisation, la copie, la distribution, et la dcompilation. Aucune partie de ce produit ou de sa documentation associe ne peut tre reproduite sous aucune forme, par quelque moyen que ce soit, sans lautorisation pralable et crite de Sun et de ses bailleurs de licence, sil y en a. Des parties de ce produit pourront tre drives du systme UNIX licenci par Novell, Inc. et du systme Berkeley 4.3 BSD licenci par lUniversit de Californie. UNIX est une marque enregistre aux Etats-Unis et dans dautres pays et licencie exclusivement par X/Open Company Ltd. Le logiciel dtenu par des tiers, et qui comprend la technologie relative aux polices de caractres, est protg par un copyright et licenci par des fournisseurs de Sun. Sun, Sun Microsystems, le logo Sun, sont des marques dposes ou enregistres de Sun Microsystems, Inc. aux Etats-Unis et dans dautres pays. Toutes les marques SPARC, utilises sous licence, sont des marques dposes ou enregistres de SPARC International, Inc. aux Etats-Unis et dans dautres pays. Les produits portant les marques SPARC sont bass sur une architecture dveloppe par Sun Microsystems, Inc. Les interfaces dutilisation graphique OPEN LOOK et Sun ont t dveloppes par Sun Microsystems, Inc. pour ses utilisateurs et licencis. Sun reconnat les efforts de pionniers de Xerox pour la recherche et le dveloppement du concept des interfaces dutilisation visuelle ou graphique pour lindustrie de linformatique. Sun dtient une licence non exclusive de Xerox sur linterface dutilisation graphique Xerox, cette licence couvrant aussi les licencis de Sun qui mettent en place linterface dutilisation graphique OPEN LOOK et qui en outre se conforment aux licences crites de Sun. Le systme X Window est un produit de X Consortium, Inc. CETTE PUBLICATION EST FOURNIE EN LETAT SANS GARANTIE DAUCUNE SORTE, NI EXPRESSE NI IMPLICITE, Y COMPRIS, ET SANS QUE CETTE LISTE NE SOIT LIMITATIVE, DES GARANTIES CONCERNANT LA VALEUR MARCHANDE, LAPTITUDE DES PRODUITS A RPONDRE A UNE UTILISATION PARTICULIERE, OU LE FAIT QUILS NE SOIENT PAS CONTREFAISANTS DE PRODUITS DE TIERS.
Protections Juridiques
Intutil Cours : Raliser une application JAVA Client : Sun Service Formation Rf. Sun : SL-285
7
Rvision : D2 Date : 23/8/99
Introduction....................................................................................................................................... i Prrequis ................................................................................................................................ ii Objectifs du cours ................................................................................................................. iii Le Projet ............................................................................................................................................1 Projet : Le poste de travail dun courtier en bourse ................................................................2 Gnralits ..................................................................................................................2 Expos du problme....................................................................................................2 Le systme existant .....................................................................................................2 Le systme existant (suite)..........................................................................................3 Spcifications (suite)...................................................................................................4 Spcifications gnrales..............................................................................................5 Limitations ..................................................................................................................6 PHASE 1 : larchitecture gnrale..........................................................................................7 PHASE 2 : laccs la base....................................................................................................9 PHASE 3 : linteraction utilisateur .......................................................................................11 PHASE 4 : assemblage dun produit complet.......................................................................13 PHASE 5 : consolidations, extensions..................................................................................15 SQL (et miniSQL) ...........................................................................................................................17 Objectifs....................................................................................................................17 Rfrences.................................................................................................................17 Introduction mSQL ...........................................................................................................18 Gnralits ................................................................................................................18 la ralisation de mSQL.............................................................................................19 Les outils de mSQL ..................................................................................................19 les outils mSQL (suite) ............................................................................................20 Contrle daccs mSQL (pour mmoire)..............................................................................21 les outils mSQL (suite) ............................................................................................23 Commandes mSQL...............................................................................................................24 Gnralits ................................................................................................................24 La requte SELECT................................................................................................25 La requte SELECT (suite)......................................................................................26 La requte SELECT (suite)......................................................................................27 La commande INSERT.............................................................................................28 La commande DELETE...........................................................................................28 La commande UPDATE ...........................................................................................29 La commande CREATE (pour mmoire) .................................................................30 La commande DROP (pour mmoire)......................................................................30 Exercices ...............................................................................................................................31 rappels: API JDBC ..................................................................................................................33 Introduction...........................................................................................................................34 Pilote JDBC.......................................................................................................................35 Organigramme JDBC............................................................................................................37 Lenchainement des appels .......................................................................................37 Package java.sql............................................37 Organigramme JDBC............................................................................................................38 Exemple JDBC......................................................................................................................39
8
Intitul Cours : Raliser une application JAVA Client : Sun Service Formation Rf. Sun : SL-285 Rvision : D2 Date : 23/8/99
Cration de pilotes JDBC......................................................................................................41 Cration explicite dune instance de pilote JDBC ....................................................41 Pilotes JDBC.........................................................................................................................43 Dsignation dune base de donnes ..........................................................................43 Connexion une base de donnes ............................................................................44 Interrogation dune base de donnes.........................................................................45 Instructions JDBC.................................................................................................................46 Soumission dune requte .........................................................................................46 requte prpare (non disponible sous mSQL).........................................................47 Exemple ....................................................................................................................47 Les mthodes setXXX ..............................................................................................47 Mthodes setXXX ...............................................................................................................48 procdure stocke (non disponible sous mSQL) ......................................................49 Exemple ....................................................................................................................50 Appel de procdure ...................................................................................................50 Rcupration de rsultats ..........................................................................................51 Mthodes getXXX ...............................................................................................................53 Correspondance des types de donnes SQL en Java ............................................................54 Utilisation de lAPI JDBC ....................................................................................................55 Types de conception des pilotes JDBC.....................................................................55 Types darchitecture daccs aux bases de donnes .............................................................56 Conceptions en deux niveaux ...................................................................................56 Conceptions en trois niveaux ....................................................................................57 Applets ..................................................................................................................................58 Applets et applications de bases de donnes traditionnelles.....................................58 Performances.............................................................................................................58 Contraintes de scurit..............................................................................................59 Rappels : AWT...............................................................................................................................61 Accs au manipulations graphiques......................................................................................62 Le package AWT ......................................................................................................62 Les gestionnaires de Disposition (LayoutManager) .............................................................63 Les vnements.....................................................................................................................65 Evnements sources ..................................................................................................65 Traitements dvnements ........................................................................................65 Modle de dlgation (JDK 1.1)...............................................................................66 Comportement de linterface graphique utilisateur Java ......................................................70 Catgories dvnements ..........................................................................................70 Tableaux................................................................................................................................71 Comportement de linterface graphique utilisateur Java ......................................................72 Evnements gnrs par composants AWT..............................................................72 Obtention dinformations sur un vnement.............................................................73 Rcepteurs multiples.................................................................................................73 Adaptateurs dvnements ....................................................................................................74 Button........................................................................................................................76 List ........................................................................................................................................80 TextArea ...............................................................................................................................83
9
TextComponent.........................................................................................................84 Frame ....................................................................................................................................85 Panel......................................................................................................................................86 Dialog....................................................................................................................................87 FileDialog .............................................................................................................................89 ScrollPane .............................................................................................................................90 Menus....................................................................................................................................91 Menu Aide ................................................................................................................91 MenuBar ...............................................................................................................................92 Menu .....................................................................................................................................93 MenuItem..............................................................................................................................94 CheckboxMenuItem..............................................................................................................95 PopupMenu ...........................................................................................................................96 Contrle des aspects visuels..................................................................................................98 Couleurs ....................................................................................................................98 Polices .......................................................................................................................99 Polices .....................................................................................................................100 Impression...........................................................................................................................101 Les composants SWING...............................................................................................................103 Points Essentiels : ...................................................................................................103 Java Foundation Classes .....................................................................................................104 Les Composants SWING....................................................................................................106 SWING : hirarchie des composants ..................................................................................107 Une application Swing de base :.........................................................................................108 La classe JComponent.........................................................................................................111 Rappels: Flots E/S, linarisation..................................................................................................113 E/S JAVA : concepts fondamentaux...................................................................................114 flots dE/S (Streams)...............................................................................................114 I/O Streams et Reader/Writer..................................................................................115 catgories de flots ...................................................................................................115 filtres .......................................................................................................................116 Fichiers................................................................................................................................117 Linarisation .......................................................................................................................118 Classes DataInputStream et DataOutputStream...............118 Object Input/Output ................................................................................................119 Architecture de linarisation ...............................................................................................120 Package java.io .......................................................................................................120 Interface Serializable ......................................121 Elments srialisables .............................................................................................121 Ecriture et lecture dun flot dobjets ...................................................................................122 Lecture ....................................................................................................................122 quest ce qui est transferr?.....................................................................................123 personnalisation de la lecture/criture dobjet ........................................................124 Externalisable..........................................................................................................125 Rappels : Programmation rseau Java .......................................................................................127 Programmation rseau sous Java ........................................................................................128
10
Sockets ....................................................................................................................128 Le modle rseau de Java. ..................................................................................................129 Principe dun Serveur TCP/IP ............................................................................................130 Principe dun Client TCP/IP ...............................................................................................131 changes UDP....................................................................................................................132 Exemple de Serveur UDP ..................................................................................................133 Exemple de client UDP.....................................................................................................134 UDP en diffusion (Multicast)...........................................................................................135 Exemple de Serveur Multicast ...........................................................................................136 Exemple de client Multicast................................................................................................137 Rappels: RMI ..........................................................................................................................139 Fonction de larchitecture RMI en Java..............................................................................141 Packages et hirarchies RMI...............................................................................................142 Package java.rmi ...............................................................................................142 Cration dune application RMI .........................................................................................145 Exemple bancaire....................................................................................................145 Cration dune application RMI .........................................................................................146 Interfaces bancaires.................................................................................................146 Procdure ................................................................................................................148 Interface Account ........................................... 149 Interface AccountManager .................................... 150 ralisation de linterface Account AccountImpl................... 151 AccountManagerImpl ....................................... 153 Compilation du code ...............................................................................................156 Utilisation de la commande rmic ................................. 157 Application BankServer ...................................... 158 Application rmiregistry ..................................... 160 Application BankClient ...................................... 161 Excution de lapplication BankClient............................ 164 Scurit RMI.......................................................................................................................166 Chargement de classe..............................................................................................166 Invocation RMI au travers dun coupe-feu.............................................................167 Mthodes natives avec JNI...........................................................................................................169 Pourquoi raliser du code natif? .........................................................................................170 un exemple : "Hello World" en C .......................................................................................171 rsum des phases :.................................................................................................171 Ecriture du code JAVA...........................................................................................172 Cration des binaires JAVA de rfrence...............................................................173 Gnration du fichier dinclusion C/C++ ...............................................................174 Ecriture du code natif..............................................................................................175 Cration dune librairie dynamique ........................................................................176 Excution ................................................................................................................177 prsentation de JNI .............................................................................................................178 JNI: types, accs aux membres, cration dobjets ..............................................................179 rfrences sur des objets JAVA: .........................................................................................182 exceptions ...........................................................................................................................183
11
invocation de JAVA dans du C...........................................................................................184 Recommandations de programmation........................................................................................185 Organisation des packages et des rpertoires......................................................................186 convention de codage..........................................................................................................187 Identificateurs (conventions standard)....................................................................187 Identificateurs (conseils complmentaires).............................................................187 Nommage (conseils complmentaires) ...................................................................188 Mise en page ...........................................................................................................189 portabilit ............................................................................................................................190 performances.......................................................................................................................191 traces, exceptions ...............................................................................................................192 le "bon " et le "beau" code ? ...............................................................................................193 les interactions graphiques..................................................................................................197 rpartition............................................................................................................................198 les protocoles ..........................................................................................................199 internationalisation..............................................................................................................200 intgration des mthodes natives ........................................................................................201 Latelier de dveloppement..........................................................................................................203 introduction : R.A.D et/ou matrise du code de base? ........................................................204 Lintgration des outils, les ateliers ....................................................................................206 analyse et conception ..........................................................................................................207 Lditeur..............................................................................................................................208 Outils annexes lditeur....................................................................................................209 Laide la conception dinteraction ...................................................................................210 Gestion des sources.............................................................................................................211 principes..................................................................................................................211 outils........................................................................................................................211 points.......................................................................................................................212 Gestionnaires de maintenance.............................................................................................213 Documentation de code, aide en ligne ...............................................................................214 Debug..................................................................................................................................215 outils........................................................................................................................215 gnration (make) ...............................................................................................................216 tests .....................................................................................................................................217 principes..................................................................................................................217 produits ...................................................................................................................217 points.......................................................................................................................218 analyse de couverture..........................................................................................................219 analyses de performances ...................................................................................................220 principes..................................................................................................................220 outils........................................................................................................................220 points.......................................................................................................................220 Analyses statiques du code .................................................................................................221 principes..................................................................................................................221 outils........................................................................................................................221 points.......................................................................................................................221
12
prparation la livraison.....................................................................................................222 livraison/dploiement..........................................................................................................223 autres outils .........................................................................................................................224 dcompilateurs/brouilleurs......................................................................................224 outils syntaxiques....................................................................................................224 aide mmoire outils .......................................................................................................................225 JavaWorkshop: Gestionnaire de projets..............................................................................226 Mise en oeuvre du Project Manager....................................................................226 crer ou importer un portefeuille ............................................................................227 crer ou importer un projet .....................................................................................227 fixer les attributs dun projet...................................................................................228 JavaWorkshop: dition, compilation, tests .........................................................................229 dition .....................................................................................................................229 personnalisation de ldition ...................................................................................229 contrle daccs et version......................................................................................229 compilation .............................................................................................................230 test ...........................................................................................................................230
13
Introduction
Durant ce stage vous aurez la possibilit de mener bien un projet JAVA complet. Laccent est mis sur la pratique et vous tes vivement encourag confronter vos reexions celles des autres stagaires (ou celles de lanimateur). Ce stage contient peu de cours thoriques mais, selon vos besoins, lanimateur peut-tre amen faire quelques rappels rapides -en rgle gnrale vous vous appuierez plutt sur les aide-mmoires du supportVous trouverez dans le prsent support:
q q
La description gnrale du projet raliser. Une srie daide-mmoires concernant lutilisation de SQL, JDBC, AWT, les entres-sorties, la programmation rseau et RMI. Un cours sur lintgration de mthodes natives complte ces rappels. Deux chapitres constituant une introduction la pratique professionnelle du dveloppement en JAVA : les savoir-faires et la lire des outils.
i
Copyright 1999 Sun Microsystems, Inc. All Rights Reserved. SunService 1998
Prrequis
Pour participer ce cours il est vivement conseill de maitriser:
q
Le contenu des cours LJ20 (introduction Java) et LJ21 (programmation Java avance) et en particulier:
q
Les Api Java standard La cration dinterface graphiques ralises avec AWT. La programmation des sockets TCP/IP avec Java La programmation parallle (Threads)
q q q
Les techniques de programmation Objet
Introduction Revision D
Copyright 1999 Sun Microsystems, Inc. Tous droits rservs.
-ii
Objectifs du cours
A la suite de ce cours vous serez capable de:
q
dinitier un projet JAVA depuis la conception jusqu la ralisation et aux tests. organiser les dveloppements JAVA dans le cadre dune lire professionnelle. mettre en place une lire de maintenance enrichir en permanence vos savoir-faires en JAVA moyennant des investissements modiques dans la veille technologique.
q q
-iii
-iv
Le Projet
Objectifs
Ce chapitre dcrit:
Les spcications gnrales du projet raliser durant le stage Les diffrentes phases de ralisation du code.
Intitul Cours: Raliser une application JAVA Client : Sun Service Formation Rf. Sun : SL-285
1
Projet : Le poste de travail dun courtier en bourse
Gnralits
Lexpos du problme ne dnit pas toutes les spcications (on retrouve ici une situation courante dans la vie relle!). Quelques prcisions supplmentaires seront donnes par lanimateur dans les prsentations de phases . Il faudra donc rchir des spcications plus dtailles, en discuter en quipe et prendre des dcisions dnitives en accord avec les orientations que xera lanimateur.
Expos du problme
Une socit de courtage en bourse a commenc raliser une application pour la saisie dordres de bourse. Pour diffrentes raisons il y a eu un dbut de ralisation et lquipe que vous allez constituer doit tenir compte du systme existant.
Le systme existant
La socit va dployer son application sur son rseau local scuris (vision "intranet") Vous disposez des composants suivants :
Une base de donnes relationnelle. Le schma de la base est dj dni. Pour les besoins de ce stage on oprera sur Mini-SQL (mSQL) une petite base de donnes du domaine public -toutefois le projet sera adaptable dautres basesUn processus permanent de mise jour de la cotation des valeurs. Ce processus est cens fournir les volutions de la cote en temps rel. Pour les besoins du projet il sagit dun programme JAVA qui est fourni. Un serveur HTTP
Le Projet
1/2
Le systme existant (suite)

Quelques informations complmentaires:
La base de donnes, le serveur de cotations et le serveur HTTP "tournent" sur un seul serveur Sun. Base mSQL:

Le schma est prdni et ne peut tre chang Le processus mSQL sert les requtes sur le port 1112 en protocole TCP/IP .
Lapplication de mise jour de la cote est un programme JAVA fourni :

La cotation volue toute les 45 secondes Toute modication doit tre reporte dans la base de donnes. La manire dont les informations seront diffuses aux clients reste arrter. Si linitiative des demandes de mises jour reste aux clients on utilisera alors un serveur coutant sur le port 5432.
serveur HTTP :

coute sur le port standard (80). les chiers HTML seront disponibles sur le serveur dans un rpertoire accessible aux diffrentes quipes de dveloppement..
Le Projet
1/3
1
Le poste de travail dun courtier en bourse
Spcications (suite)
Conguration de la base :
La base existante, StockMarket, est congure selon le schma suivant: Customer Table Field Name ssn cust_name address Type char (15) char (40) char (100) Comment clef primaire
Shares Table Field Name ssn symbol quantity Type char (15) char (8) int Comment Not null Not null
Stock Table Field Name symbol price Type char (8) real Comment clef primaire
Le Projet
1/4
1
Spcications gnrales
Loutil dvelopper en JAVA doit tre un systme oprant en mode client/serveur permettant de mettre jour les informations contenues dans la base de donnes.
Fonctionnalits principales :
Permettre au courtier("lutilisateur") dajouter ou de supprimer un client dans la base. Il est admis que le nombre de clients dans la base peut tre trs important. Permettre de modier le nom ou ladresse dun client (mais pas son identiant unique -ssn-). Permettre de visualiser la cotation courante dune ou de plusieurs valeurs. Les valeurs changeant en permanence on tudiera la manire la plus approprie de porter ces modications la connaissance de loprateur. Il est admis que le nombre de valeurs de la cote est trs limit (tout au plus quelques centaines). Permettre dacheter et de vendre des actions pour un client. La base de donnes et linterface homme/machine doivent tre mises jour en consquence. On devra pouvoir visualiser le portefeuille du client et le modier.
Des spcications complmentaires devront tre arrtes au cours du projet. On simulera ainsi les ncessaires volutions du projet au fur et mesure que les besoins safneront (bien entendu ces volutions devront rester dans les limites raisonnables du temps qui est imparti!)
Le Projet
1/5
1
Limitations
Du fait de limitations importantes dans le temps on sefforcera de simplier certains aspects du projet. Ainsi on peut admettre que :
Les requtes concernant les clients utiliseront leur identiant unique(ssn), alors quil semblerait plus normal de les rechercher par leur nom (et mme par leur nom approximatif!). Idem pour les valeurs de la cote qui ne seront connues que par leur code (symbol). On utilisera essentiellement des composants graphiques fournis (AWT standard, JFC) des adaptations de ces composants sont toutefois possibles.
Le Projet
1/6
1
PHASE 1 : larchitecture gnrale
principes
Dterminer larchitecture gnrale du projet. Cette dnition sappuie sur les principes suivants :
Un produit peut tre dcompos en quelques grands composants qui collaborent entre eux pour rendre le service attendu. Ces composants principaux communiquent entre eux au moyen dun protocole minimum (une A.P.I.). Il est important de dnir ces protocoles car ils permettent de raliser une architecture adaptable et un dveloppement incrmental bas sur la dnition de "services" abstraits. Un exemple :
Une demande de mise jour de la base peut provenir dune interface utilisateur interactive, dune interface utilisateur simplie en mode texte, dune requte provenant dune ligne de communication distante, etc. Abstraire ces diverses possibilits dans un seul concept (une interface JAVA par exemple) permet de faire fonctionner les requtes la base dans diffrentes situations : - On peut ainsi valider les interrogations la base sans attendre la ralisation de linterface interactive, - On peut tester cette base laide de scenarios contenus dans des chiers textes, - On peut transformer un produit dans lequel linterface et linterrogation la base fonctionnent dans le mme processus en un produit dans lequel ces deux fonctions communiquent au travers du rseau (linterrogation la base se fait sur le serveur, linterface utilisateur est sur un client distant), - etc.
Le Projet
1/7
1
ralisation
1. 2. Former les quipes de dveloppement Au sein des quipes discuter de larchitecture gnrale, puis dnir dune part les classes principales (ex. : "Client", "Valeur" pour une valeur de la cote, "Portefeuille" pour dcrire le portefeuille dun Client) et dautre part dcrire les grands composants (en dcrivant les mthodes dAPI qui les caractrisent) Proposer une politique gnrale pour le traitement des traces et des Exceptions. Obtenir un accord entre les quipes pour que les mthodes dAPI soient communes (objectif: un composant ralis par une quipe doit pouvoir tre utilis par lautre). Organiser les premiers "packages" de dveloppement et coder les dnitions qui seront ncessaires pour la suite du projet. Noter les interrogations sur la suite du projet, les diffrentes options que lon peut entrevoir, etc.
3. 4.
5. 6.
rfrences
voir chapitres :
recommandations de programmation : packages, convention de codage, traces et exceptions. La conception gnrale (UML) sort du cadre du prsent cours. outils : les outils danalyse et de conception sortent du cadre de ce cours
Le Projet
1/8
1
PHASE 2 : laccs la base
principes
Raliser le module dinterrogation de la base de donnes au travers de JDBC. Ce module sera test laide dune interface trs simplie lisant des requtes en mode texte sur lentre standard.
ralisation
1. 2. 3. Eventuellement, remise jour des connaissances sur SQL et JDBC Finaliser la mise en place de lenvironnement de dveloppement. (commencer utiliser JavaWorkshop) Raliser le ou les modules implantant les mthodes dinterrogation de la base. Documenter ces modules (javadoc) Raliser un module permettant de tester simplement la ralisation prcdente par de simples requtes sous forme texte. Tester leffet sur la base en ralisant des requtes SQL sur msql. Tester simplement les mcanismes dexceptions. Donner quelques exemples de spcications fonctionnelles complmentaires qui permettront de tester votre API (c.a.d. quelques rgles implicites que lAPI doit aussi vrier). Si lon dispose de loutil JAVASPEC (et dun peu de temps) essayer dimplanter ces rgles et de les appliquer au module daccs la base de donnes.
4.
5. 6.
Le Projet
1/9
1
rfrences
voir chapitres :

rappels: SQL, JDBC, Entres/Sorties recommandations de programmation : portabilit (100% java) outils : JavaWorkShop, mSQL, JAVASPEC
Le Projet
1/10
1
PHASE 3 : linteraction utilisateur
principes
Maquette graphique : concevoir et raliser une premire version dinterface utilisateur. En tenant compte des principes de conception dune interface ergonomique concevoir une interface qui permette loprateur de:

rechercher la description dun client crer, dtruire ou modier la description dun client visualiser le portefeuille dun client modier le portefeuille dun client par achat, vente dun certain nombre dactions (prvoir option "tout vendre" correspondant une action donne). visualiser les cours dune ou plusieurs Valeurs de la cote. (sorganiser ventuellement pour faire ressortir automatiquement certaines valeurs).
ralisation
1. Eventuellement, remise jour des connaissances sur les composants, la disposition AWT, la gestion des vnements graphiques. Faire un "design" gnral sur papier, lafner en codant des parties de cette interface. Se rpartir ventuellement le travail entre les membres de lquipe. Tenir compte, pour le choix des composants, des limites ventuelles (nombre de clients, nombre de valeurs la cote). Tenir compte galement des besoins de personnalisation (taille des police, disposition de certains champs, acclrateurs) Raliser une interface densemble, lassembler en local avec le module dinterrogation de la base et avec le module de mise jour des valeurs. Tester le fonctionnement et le faire tester par un "naf" (un membre dune autre quipe).
Le Projet
2.
3.
1/11
1
4. Tester avec des conditions errones (analyser la mise en oeuvre des mcanismes de rcupration dexceptions et leur effet sur linterface utilisateur). Envisager des modications du type : exploitation dans un contexte dApplet, ajout de fonctions ( identication de loprateur, demande dimpression) , modications du contenu des tables de la base de donnes, amliorations cosmtiques (couleurs, image de fond), personnalisations . En tirer des indications sur lorganisation du code et sa maintenabilit.
5.
rfrences
voir chapitres :

rappels: composants graphiques recommandations de programmation : graphiques, le "bon" et le "beau" code : internationalisation outils : JavaWorkShop les interactions pratique AWT,
Le Projet
1/12
1
PHASE 4 : assemblage dun produit complet
principes
Mise en service dans des conditions relles. Rpartition de lapplication :
Le processus de mise jour des cotations doit fonctionner de manire autonome. (Dans la phase prcdente il tait li lapplication pour les besoins du test). Mise en oeuvre dune application en mode client/serveur. Linterface utilisateur ne fonctionne plus forcment sur le serveur lui-mme.
ralisation
1. 2. Eventuellement, remise jour des connaissances sur Sockets, Threads, DataInput/OutPut, Serialisation, RMI Discuter des diffrentes possibilits de ralisation pour la mise jour des valeurs de la cote sur les postes clients (initiative du serveur, initiative du client). Raliser cette mise jour automatique et intgrer dventuelles modications de linterface utilisateur. Spcier la ralisation du client dport et justier vos choix (application autonome ou Applet, dialogue par Socket ou RMI,...) Raliser le client dport et le mettre en oeuvre (ressources, chier HTML dans le cas dune Applet, etc.) Tester l interface en faisant intervenir les rgles fonctionnelles complmentaires dnies en phase 2.
3. 4. 5. 6.
Le Projet
1/13
1
rfrences
voir chapitres :

rappels: E/S DataInput, ObjectStreams, Socket, RMI recommandations de programmation : rpartition outils : JavaWorkShop (debuger), JAVASPEC,
Le Projet
1/14
1
PHASE 5 : consolidations, extensions
principes
complments de ralisation : impressions, journalisation locale, personnalisation de linterface utilisateur. consolidations : analyse de code, mise en place de processus de maintenance.
ralisation
1. Ralisations facultatives : impression dun document attestant dun ordre de bourse (vente-achat dactions), journalisation locale des oprations effectues par loprateur, personnalisations de linterface utilisateur, exploration de la ralisation de code natif. Faire une proposition pour minimum dans le systme. une scurit/authentication
2. 3. 4.
Tests et analyse de code : analyse de performance, analyse de couverture. Problmatique de la fabrication et de la livraison du produit ni : faire une proposition dorganisation.
rfrences
voir chapitres :

rappels: JNI recommandatins de programmation : performances, 100% pur java, intgration de mthodes natives, outils : JavaWorkShop (analyse de performances), JAVASCOPE
Le Projet
1/15
Le Projet
1/16
SQL (et miniSQL)
2 1
Objectifs

introduction loutil mSQL introduction SQL manipulations sur la base existante
Rfrences
The Practical SQL Handbook, Emerson, Darnovsky, and Bowman, AddisonWesley, 1989. mSQL Manual, Hughes, (unpublished), 1996.
2
Introduction mSQL
Gnralits
Ce cours utilise une base SQL appele mini-SQL (mSQL). mSQL est un produit (disponible sous licence) cr par David Hughes1. Ce produit comprend: le moteur de base de donnes, une interface "terminal" simple, un programme dadministration de la base, un visualiseur de schema et une API en langage "C". LAPI et le moteur fonctionnent dans un environnement client/serveur en utilisant les services de TCP/IP. mSQL est un produit simple et performant permettant de raliser des requtes SQL trs simples (un sous-rensemble du SQL ANSI).
1.
MiniSQL nous est fourni par Hughes Technologies Pty Ltd (Australie). Pour plus dinformations ou pour une copie dvaluation voir ladresse : www.Hughes.com.au.
SQL (et miniSQL)

2/18
2
Introduction mSQL
la ralisation de mSQL
mSQL est crit en C et la version utilise dans ce cours a t adapte pour Solaris. Au coeur de mSQL il y a le daemon msqld qui coute sur un port TCP/IP. Voici un extrait du manuel mSQL : [mSQL] is a single process engine that will accept multiple connections and serialize the queries received. It utilizes memory mapped I/O and cache techniques to offer rapid access to the data stored in a database. It also utilizes a stack based mechanism that ensures that INSERT operations are performed at the same speed regardless of the size of the table being accessed. The server may be accessed either via a well known TCP socket or via a UNIX domain socket with the le system (/dev/msqld). The availability of the TCP socket allows client software to access data stored on machine over the network.
Les outils de mSQL

voir produit et documentation sur : http://www.Hughes.com.au
msqld le moteur mSQL

Cest le moteur de la base de donnes. Le dmon est lanc sur un serveur et peut tourner avec lidentiti de root (ou avec lidentit dun utilisateur local). Au cours de ce stage le dmon aura lidentit de root (lanimateur dsignera la machine hte).
SQL (et miniSQL)

2/19
2
Introduction mSQL
les outils mSQL (suite)
relshow - Visualiseur de schma mSQL
relshow permet dinterroger la base pour connatre les noms des tables ou les caractristiques des champs. Il peut tre lanc soit localement soit distance : relshow [-h hostname] database relshow [-h hostname] database tablename
msqladmin administration de la base (pour mmoire)

Les commandes sont: create DataBase Cre une nouvelle base nomme: DataBase drop DataBase Dtruit la base DataBase
shutdown Demande larrt du serveur mSQL reload daccs Demande au serveur de recharger les informations de contrle
version Donne diverses informations sur le produit. Le serveur mSQL acceptera les commandes dadministration uniquement si elles sont lances par lutilisateur root sur la machine serveur.Seule la commande version peut tre passe par une autre personne.
msqldump image de la base (pour mmoire)

msqldump produit une trace qui peut tre utilise en entre par le terminal mSQL. On peut ainsi facilement crer des copies de la base (y compris sur le rseau avec option -h)
SQL (et miniSQL)

2/20
2
Contrle daccs mSQL (pour mmoire)
Le contrle daccs est dcrit dans le chier msql.acl dans le rpertoire dinstallation de la base. Le chier est spar en plusieurs zone (une par base controle par le serveur). Sans conguration les accs sont globalement autoriss en lecture/criture. Voici un exemple de zone dans ce chier # Sample access control for mSQL database=test read=bambi,paulp write=root host=*.Bond.edu.au,-student.it.Bond.edu.au access=local,remote Selon cette dnition, la base test est accessible la fois par des connexions locales (local) et distantes (remote). Ces connexions peuvent provenir de tout hte dans le domain Bond.edu.au sauf pour la machine student.it.Bond.edu.au. Laccs en lecture est reserv uniquement bambi et paulp (et personne dautre). Laccs en criture est reserv root. Les contrles sont bass sur la premire correspondance trouve. Ainsi une ligne du type read=-*,bambi ne pourra permettre de retirer les droits dcriture tout le monde sauf bambi (-* correspondra aussi bambi). Lentre correcte serait plutt read=bambi,-* bien que le -* soit superu parceque cest la politique par dfaut. Attention: si dans une ligne de conguration une entre particulire est absente (par ex. read ), le comportement par dfaut est le plus scuris (du coup personne ne pourra lire!). Ceci est en contradiction avec le comportement par dfaut si la zone rserve la base nest pas dcrite dans le chier de conguration: l tous les accs sont autoriss! A noter galement: les "zones" dcrivant chaque base doivent tre spars par une ligne blanche (qui marque ainsi la n de la description de la base courante). Il peut y avoir plusieurs lignes portant sur la mme entre comme dans: read=bambi,paulp read=root
SQL (et miniSQL)

2/21
2
Des caractres "jokers" (*) peuvent tre utiliss dans les descriptions. Un joker seul correspondra toute chane, alors quun tel caractre suivi par dautres dclenche un "pattern matching" partiel (exemple: *.Bond.edu.au corresond tout ce qui peut se terminer par la chane Bond.edu.au). Une pratique saine consiste faire, en n de chier, une zone avec une entre database=* de manire dnir des droits par dfaut pour TOUTE base. Les informations sur les listes de contrle daccs peuvent tre recharges en cours dxcution par msqladmin reload. Ceci ranalysera le chier de conguration avant de lancer la commande reload (donc uniquement si lanalyse sest correctment termine). Comme pour toutes les commandes de msqladmin cette commande ne sera accepte que si elle est lance par root sur la machine serveur.
SQL (et miniSQL)

2/22
2
Introduction mSQL
les outils mSQL (suite)
msql terminal dinteraction SQL msql lit des requtes en mode texte et afche les rsultats. On peut le lancer localement ou sur un site distant: msql [-h hostname] database Si hostname nest pas spci, msql recherche la variable denvironnement MSQL_HOST et sil ne la trouve pas utilise le site local. msql reconnat quatre commande spciales prxes par (\) pour les distinguer des ordre SQL.
\g Go, execute la prcdente). \p \e \q
requte SQL en cours (ou la requte
Print, afche le contenu du buffer dinterrogation Edite la dernire commande dans votre diteur par dfaut. Quittter mSQL.
SQL (et miniSQL)

2/23
2
Commandes mSQL
Gnralits
Chaque requte SQL commence par un mot-clef particulier, mSQL rpond aux commandes suivantes :
SELECT Recherche denregistrements dans une ou plusieurs tables.. INSERT ajoute un enregistrement dans une table. DELETE Retire des enregistrements dune table. UPDATE Modie des champs dans des enregistrements particuliers. CREATE Cre une nouvelle table avec les champs de noms et de types spcis. DROP dtruit une table de la base.
Exemple : recherche de tous les champs de la table "employee_data" de lenregistrement pour lequel le champ "employee_id" a la valeur 10223 (il sagit ici dune chane de caractres et non dun nombre):2 SELECT * 10223 FROM employee_data WHERE employee_id =
2.
Les requtes mSQL sont indpendantes de la capitalisation des lettres, Les exemples ci-aprs comportent toutefois des lettres majuscules chaque fois quon utilise un mot-clef de SQL.
SQL (et miniSQL)

2/24
2
Commandes mSQL
La requte SELECT
La requte SELECT est la commande lmentaire pour rechercher des valeurs contenues dans la base. Cette commande permet les services suivants :
jointure entre plusieurs tables (pas de "jointure externe") Modieur DISTINCT pour la slection des enregistrements Clauses ORDER BY (tris) Recherches par expressions rgulires ("joker") Utilisation de comparaisons entre colonnes dans les clauses WHERE
La syntaxe gnrale dune requte SELECT en mSQL (on remarquera que ce SQL est incomplet par rapport au SQL standard): SELECT [table.]colonne [ , [table.]colonne ]... FROM table [ , table]... [ WHERE [table.]colonne Operateur Valeur [ AND | OR [table.]colonne Operateur Valeur]... ] [ ORDER BY [table.]colonne [DESC] [, [table.]colonne [DESC] ...] Operateur peut tre <, >, =, <=, >=, <>, ou LIKE.Valeur peut tre une colonne ou une constante littrale.. La syntaxe des expressions rgulires est celle du SQL standard :
A un caractre de soulignement (_) correspond nimporte quel caractre (et un seul). A un caractre pourcent (%) correspond 0,1 ou plusieurs caractres. Un anti-slash (\) est un caractre dchappement pour les caractres spicaux (par exemple, \% doit correspondre un % et \\ correspond un \). tous les autres caractres correspondent eux-mmes.
SQL (et miniSQL)

2/25
2
commandes mSQL
La requte SELECT (suite)
Exemples
SELECT first_name, last_name FROM emp_details WHERE dept = 'finance' Pour trier les rsultats dans lordre ascendant pour le nom (last_name) et en ordre descendant pour le prnom (rst_name) : SELECT first_name, last_name FROM emp_details WHERE dept = 'finance' ORDER BY last_name, first_name DESC
Lorsque des rsultats comprennent les mmes combinaisons de valeurs le modieur DISTINCT permet dliminer les "doublons" : SELECT DISTINCT last_name FROM emp_details WHERE dept = 'finance' ORDER BY last_name Pour rechercher toute personne dans le dpartement "nance" dont le nom ressemble "Dupon" (tels que "Dupond" et "Dupont") SELECT first_name, last_name FROM emp_details WHERE dept = 'finance' AND last_name LIKE 'Dupon_'
SQL (et miniSQL)

2/26
2
Commandes mSQL
La requte SELECT (suite)
Jointures
Cest lopration qui permet doprer des recherches en tablissant des relations entre deux ou plusieurs tables. Exemple : une table dcrit les employs (emp_details) et une autre table decrit les quipes de projet (project_detail). Chaque membre dune quipe est repr par un code (emp_id) qui identie de manire unique un employ. Pour avoir les informations dtailles sur qui travaille dans quel projet : SELECT emp_details.first_name, emp_details.last_name, project_details.project FROM emp_details, project_details WHERE emp_details.emp_id = project_details.emp_id ORDER BY emp_details.last_name, emp_details.first_name La jointure entre les deux tables se fait par leurs champs emp_id respectifs (on notera que ce champ est une clef dans la table emp_details). mSQL ne limite pas le nombre de tables que lon peut impliquer dans une jointure.

en mSQL tous les noms de colonnes dans une jointure doivent tre qualis (cest dire rattachs une table). Il ny a pas de rattachement implicite dune colonne une table.
SQL (et miniSQL)

2/27
2
Commandes mSQL
La commande INSERT
La commande INSERT permet dajouter de nouveaux enregistrements une table. Il faut spcier la fois les noms des champs (dcrire le Nuplet) et la combinaison de valeurs correspondantes (le N-uplet luimme) . INSERT INTO table_name ( column [ , column ]... ) VALUES (value [, value]... ) exemple: INSERT INTO emp_details ( first_name, last_name, dept, salary) VALUES ('David', 'Hughes', 'I.T.S.','12345') Contrairement au SQL standard on ne peut mettre une requte SELECT lintrieur dune requte INSERT..
La commande DELETE
La commande DELETE permet de dtruire des enregistrements dune table. La syntaxe en est: DELETE FROM table_name WHERE column Operateur Valeur [ AND | OR column Operateur Valeur ]... Operateur peut tre <, >, =, <=, >=, <>, ou LIKE Exemple: DELETE FROM emp_details WHERE emp_id = 12345
SQL (et miniSQL)

2/28
2
Commandes mSQL
La commande UPDATE
La commande UPDATE permet de changer une ou plusieurs valeurs de champs dans un enregistrement existant. En mSQL seules des valeurs littrales peuvent tre utilises pour spcier la nouvelle valeur dun champ (on ne peut pas indiquer un nom de colonne par ex.) UPDATE table_name SET column=Valeur [, column=Valeur ]... WHERE column Operateur Valeur [ AND | OR column Operateur Valeur ]... Operateur peut tre <, >, =, <=, >=, <>, ou LIKE. Exemple: UPDATE emp_details SET salary=30000 WHERE emp_id = 1234
SQL (et miniSQL)

2/29
2
Commandes mSQL
La commande CREATE (pour mmoire)
En mSQL la commande CREATE peut seulement tre utilise pour crer une table (on ne peut pas raliser dautres dnitions comme une vue). ATTENTION : il ne peut y avoir quune seule clef primaire par table. La dnition dun champ comme tant un clef entrane automatiquement la proprit "not null" . CREATE TABLE table_name ( col_name col_type [ not null | primary key ] [ , col_name col_type[ not null | primary key ]] ... ) Exemple: CREATE TABLE emp_details( first_name char(15) not null, last_name char(15) not null, dept char(20), emp_id int primary key, salary int ) Les types disponibles sont:
char (len) int real
La commande DROP (pour mmoire)

Drop permet de dtruire une table dans la base: DROP TABLE table_name Exemple : DROP TABLE emp_details
SQL (et miniSQL)

2/30
2
Exercices
1. Lancer msql sur la base StockMarket . Lanimateur doit fournir le nom de la machine serveur. Afcher toutes les informations prsentes dans les trois tables. Exemple: % msql -h serveur StockMarket Welcome to the miniSQL monitor. Type \h for help. mSQL > select * from Stock > \g Query OK. 10 rows matched. +-----------------+--------------+ | symbol | price | +-----------------+--------------+ | SUNW | 68.75 | | CyAs | 22.625 | | DUKE | 6.25 | | ABStk | 18.5 | | JSVCo | 9.125 | | TMAs | 82.375 | | BWInc | 11.375 | | GMEnt | 44.625 | | PMLtd | 203.375 | | JDK | 33.5 | +-----------------+--------------+ mSQL >
SQL (et miniSQL)

2/31
2
Exercices
2. Crer et excuter les requtes suivantes:

ATTENTION: ne crer ni dtruire aucune table..
a. Afcher toutes les valeurs dont la cote est suprieure 50. b. Ajouter dans la base un enregistrement vous dcrivant vousmme.. c. Afcher tous les clients en les triant par ordre alphabtique. d. Ajouter deux enregistrements dans votre portefeuille et vrier si la base a bien tenu compte de votre ordre. e. Vendez toutes les parts sur une valeur de votre portefeuille et la moiti des parts sur une autre valeur. f. Dtruisez-vous en tant que client et mettez jour la table des portefeuilles.

SQL (et miniSQL)

2/32
rappels:
Plan du cours
API
JDBC
LAPI Java de connectivit des bases de donnes (JDBC) permet aux dveloppeurs dcrire un code daccs une base de donnes, sans connatre la ralisation concrte de cette base.
3
Introduction
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. La connectivit JDBC permet au dveloppeur de se concentrer sur lcriture de lapplication en sassurant que les interrogations de la base de donnes sont correctes et que les donnes sont manipules conformment leur conception. La connectivit JDBC permet au dveloppeur dcrire une application en utilisant les noms dinterfaces et les mthodes dcrites dans lAPI, sans tenir compte de leur ralisation dans le pilote (driver JDBC). Le dveloppeur utilise les interfaces dcrites dans lAPI comme sil sagissait de classes courantes. Le constructeur du pilote fournit une ralisation de classe pour chaque interface de lAPI. Lorsquune mthode dinterface est utilise, elle se rfre en fait une instance dobjet dune classe ayant ralis cette interface.
Bibliographie

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

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

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

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

3/37
3
Organigramme JDBC
Chacune de ces interfaces permet un programmeur dapplication dtablir des connexions des bases de donnes spciques, dexcuter des instructions SQL et de traiter les rsultats.
DriverManager
Driver Connection Statement ResultSet
Driver Connection
Connection
Statement
Statement
Statement
ResultSet
ResultSet
Figure 1-1 Organigramme JDBC
Une chane dURL est transmise la mthode getConnection() du gestionnaire de pilotes (DriverManager) qui localise son tour un pilote (Driver). Un pilote vous permet dobtenir une connexion (Connection). Cette connexion vous permet de crer une requte (Statement). Lorsquune requte est excute avec une mthode executeQuery(), un rsultat (ResultSet) peut tre retourn.
Un objet ResultSet est toujours retourn mais il ne contient pas ncessairement de donnes, cest--dire lorsquune mise jour ou une requte dinsertion est excute.
rappels: API JDBC

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

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

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

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

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

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

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

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

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

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

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

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

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

3/48
3
Instructions JDBC
procdure stocke (non disponible sous mSQL)
Une procdure stocke permet lexcution dinstructions non SQL dans la base de donnes. La classe CallableStatement hrite de la classe PreparedStatement qui fournit les mthodes de conguration des paramtres IN. Etant donn que la classe PreparedStatement h rite de la classe Statement, la mthode de rcupration de rsultats multiples par une procdure enregistre est supporte par la mthode Statement.getMoreResults. Ainsi, vous pourriez utiliser une instruction CallableStatement pour enregistrer une instruction SQL prcompile, vous permettant dinterroger une base de donnes contenant les informations sur la disponibilit des siges pour un vol particulier.
rappels: API JDBC

3/49
3
Instructions JDBC
Exemple
String planeID = "727"; CallableStatement querySeats = msqlConn.prepareCall("{call return_seats(?, ?, ?, ?)}"); try { querySeats.setString(1, planeID); querySeats.registerOutParameter(2, java.sql.Type.INTEGER); querySeats.registerOutParameter(3, java.sql.Type.INTEGER); querySeats.registerOutParameter(4, java.sql.Type.INTEGER); querySeats.execute(); int FCSeats = querySeats.getInt(2); int BCSeats = querySeats.getInt(3); int CCSeats = querySeats.getInt(4); } catch (SQLException SQLEx){ System.out.println("Query failed"); SQLEx.printStackTrace(); }
Appel de procdure
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.
rappels: API JDBC

3/50
3
Instructions JDBC
Rcupration de rsultats
Le rsultat de lexcution dune instruction peut se prsenter sous forme de table de donnes accessible via un objet java.sql.ResultSet. Cette table se compose dune srie de lignes et de colonnes. Les lignes sont rcupres dans lordre. Un objet ResultSet maintient un curseur sur la ligne de donnes courante et le positionne tout dabord sur la premire ligne. Le premier appel de linstruction next dnit la premire ligne en tant que ligne courante, le second appel dplace le curseur sur la seconde ligne, etc. Lobjet ResultSet fournit une srie de mthodes get permettant daccder aux nombreuses valeurs de colonne de la ligne courante. Ces valeurs peuvent tre rcupres partir du nom de la colonne ou dun indice. Il est gnralement plus pratique dutiliser un indice pour rfrencer une colonne. Les indices de colonne dbutent 1.
rappels: API JDBC

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

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

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

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

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

3/55
3
Types darchitecture daccs aux bases de donnes
Conceptions en deux niveaux
Une conception en deux niveaux permet lutilisateur de dialoguer avec une application frontale (client) directement connecte la base de donnes (serveur). Une application de base de donnes conue en deux niveaux peut utiliser lun des deux types de pilotes JDBC suivants :
Pilote sappuyant sur une API native Utilise une librairie (gnralement C ou C++) compile et dveloppe pour lquipement spcique et le systme dexploitation sur lequel sexcute lapplication cliente. Ce type de pilote limite donc le programme client une application Java ou une applet (local sur le disque dur de lutilisateur) puisque le pilote doit effectuer des appels de mthodes natives (ou lire des classes prsentes sur le poste client). Pilote de protocole natif Utilise le protocole (en gnral priv) spcique, fourni par le constructeur de la base de donnes. Cela signie que le serveur du constructeur de base de donnes contient une application de rception TCP/IP acceptant les connexions de plusieurs applications clients. Le client utilise un protocole spci par le constructeur de base de donnes pour communiquer les requtes et retourner les rsultats.
rappels: API JDBC

3/56
3
Types darchitecture daccs aux bases de donnes
Conceptions en trois niveaux
Les conceptions intgrent un processus intermdiaire entre lapplication nale et le serveur de base de donnes. Bien que cette conception semble augmenter le temps systme, elle prsente nanmoins plusieurs avantages:
La validation des donnes est transfre au middleware (le niveau intermdiaire). Le client peut accder plusieurs bases de donnes par le biais dune seule connexion par socket. Il devient donc possible dcrire lapplication client sous forme dapplet, tlcharg partir dun browser. Le protocole client/middleware est dni par le constructeur et dpend du SGBD. Lopration de connexion la base de donnes est donc transfre du client au middleware. Le middleware peut inclure des fonctions non offertes par une ou plusieurs bases de donnes, telles que le verrouillage denregistrements ou la notication de modication denregistrement.
Les applications daccs aux bases de donnes conues en deux ou trois niveaux peuvent utiliser un pilote entirement rdig en Java. Dans ce cas, le pilote JDBC traduit les appels en protocole middleware. Le middleware est alors charg de slectionner la base de donnes adquate.
rappels: API JDBC

3/57
3
Applets
Lapplet Java a constitu lutilisation la plus mdiatique de la plate-forme Java. Linterface JDBC peut tre intgre dans des applets pour rendre la base de donnes accessible au World Wide Web (WWW). Ainsi, un utilisateur peut tlcharger un applet Java capable dafcher les vols disponibles une date dnie, en partance et larrive de destinations spcies. Cet applet pourrait accder une base de donnes relationnelle via Internet, pour permettre un client de se renseigner sur les places non rserves, deffectuer une rservation ou une mise jour de la base. Les applets peuvent galement tre utilises dans un scnario intranet pour fournir laccs aux bases de donnes de la compagnie, telles quun rpertoire dentreprise, dans lesquelles plusieurs services travaillent sur diffrentes plates-formes matrielles, mais requirent une interface de base de donnes commune.
Applets et applications de bases de donnes traditionnelles

Il existe plusieurs diffrences entre les applets et les applications de bases de donnes traditionnelles :
Les applets non scurises sont soumises de svres contraintes dans les oprations quelles dsirent effectuer. Dans la majorit des cas, il est interdit aux Applets non scurises daccder aux chiers locaux et il leur est impossible dtablir une connexion de rseau sur une station diffrente de celle ayant fourni lapplet. Les applets prsentes sur Internet ne peuvent pas connaitre lemplacement de base de donnes locale ou du pilote de base se trouvant dans un chier local de la machine client, comme dans ODBC.
Performances
Les performances relatives aux implmentations de connectivit diffrent selon que la base de donnes se trouve ou non sur le rseau. Le temps de rponse dune applet de base de donnes Internet sera trs suprieur celui dune applet de rseau local.
rappels: API JDBC

3/58
3
Applets
Contraintes de scurit
Certaines contraintes de scurit rencontrs avec des applets non scuriss peuvent apparatre lors de lutilisation dune signature digitale ou dun scnario cl cryptographique. Dans ce cas, une applet est traite comme une application au sens scuritaire, mais il subsistera toujours des problmes entre les bases de donnes du client en raison de la difcult localiser la structure de rpertoire de la base de donnes ou du pilote de base de donnes. Comme nous lavons vu prcdemment une conception daccs la base de donnes en trois niveaux peut fournir un middleware de service sur le rseau. La mise en place de middleware permet daccder aux bases de donnes sur plusieurs htes relis en rseau. Ces appels pourraient tre effectus par le biais dinvocations de procdures distance (RPC) ou dun navigateur de requte dobjet (ORB). Dans chaque cas, un paradigme dobjet permet de dnir au mieux le middleware (exemple : objets client avec oprations pour la facturation des clients, les rservations et autres transactions).
rappels: API JDBC

3/59
3
Evolutions
La programmation JDBC reste une programmation, parfois fastidieuse, de relativement bas niveau. La pratique de laccs Java aux bases de donnes sorientera lavenir vers des APIs de plus haut niveau permettant de grer automatiquement les couches basses de laccs aux bases de donnes partir de la dnition de classes JAVA. JAVA BLEND est un tel ensemble doutils et dAPI qui sappuie du JDBC et sur JTS (Java Transaction Service : API daccs aux services transactionnels).
rappels: API JDBC

3/60
Rappels : AWT
Objectifs
Rappels sur :
Les interactions graphiques: composants, mthodes graphiques Les LayoutManagers La gestion des vnements Les composants les plus courants
4
Accs au manipulations graphiques
Le package AWT
Le package AWT fournit les objets pour accder aux services du terminal virtuel portable. Une notion fondamentale dans ce package est la hirarchie Component (un objet graphique) et Container (driv du prcdent: on peut disposer plusieurs Components DANS un Container) Exemples de Container : Frame (une fentre), Panel (un "panneau") et son driv particulier quest lApplet. Exemples de Component: Button, Label (un tiquette), TextField (une zone de saisie Texte), Canvas (zone de dessin graphique). On peut faire des oprations graphiques sur certains composants en agissant sur le comportement des mthodes de rafrachissement dimage:
repaint() -demande asynchrone de remise jour de limage dafchage-, update(Graphics gr) -effacement du contexte graphique (Graphics) et appel des oprations de dessin-, paint(Graphics gr) -ralisation effective du dessin-
Les primitives graphiques de dessin sont lies la classe Graphics Les primitives graphiques peuvent tre utilises pour "dcorer" des composants dun type prdni ou mme pour crer des "Composants poids-plume" en agissant sur des objets crs en sous-classant directement Component ou Container.De tels objets graphiques sont initialement transparents et ne sont pas associs des objets natifs du systme de fentrage local, il faut grer par programme lensemble de leur comportement (aspects , vnements). De tels objets constituent lessentiel de bibliothques dobjets dinteraction comme les JFC (JAVA Foundation Classes)
Rappels : AWT
4/62
4
Les gestionnaires de Disposition (LayoutManager)
Un des points forts de JAVA est de permettre de faire excuter le mme programme sur des plateformes diffrentes sans en modier le code. Pour les interactions graphiques une des consquences de cette situation est quun mme programme va devoir safcher sur des crans ayant des caractristiques trs diffrentes. On ne peut donc raisonnablement sappuyer sur un positionnement des composants en absolu (avec des coordonnes X et Y xes). La disposition relative des diffrents composants lintrieur dun Container sera prise en charge par un "gestionnaire de disposition" attach ce container. Ce LayoutManager va savoir grer les positions des composants en fonctions des dformations subies par le Container correspondant. A chaque Container est associ une liste des composants contenus. Attention une instance de composant ne peut tre dispose qu UN SEUL endroit (il ne sert rien de faire plusieurs oprations add() avec le mme composant -sauf si on veut explicitement le faire changer de zone dafchage-) Quelques gestionnaires standard : 1. FlowLayout : dispose les composants "en ligne". Cest le gestionnaire par dfaut des Panels. panneau.add(new Button("bouton 1")) ; panneau.add(new Button("bouton 2")) ; 2. BorderLayout : dispose des zones dans des points cardinaux autour dune zone centrale qui tend occuper la plus large place possible. Cest le gestionnaire par dfaut des Frames. Panel panCentral = new Panel() ; Panel panBas = new Panel() ; fentre.add(panCentral, BorderLayout.CENTER); fentre.add(panBas, BorderLayout.SOUTH); panBas.add(new Button("OK")); // ici Flowlayout
Rappels : AWT
4/63
4
3. CardLayout : permet de disposer des composants dans une "pile" seul le composant du dessus est visible et on dispose de mthodes spciales pour faire passer un composant particulier sur le "dessus" de la pile. GridBagLayout : dispose les composants lintrieur des "cellules" dune table. Chaque ligne ou colonne de la table peut avoir des dimensions diffrentes de celles des autres lignes ou colonnes (quadrillage irrgulier). Les paramtres controlant la mise en place dun composant particulier sont dcrits par une instance de la classe GridBagConstraints (on peut utiliser sans risque la mme instance pour plusieurs composants)
4.
Component[][] tbComp = {.{...}, {...},...} ; this.setLayout(new GridBagLayout()) ; GridBagConstraints parms = new GridBagConstraints(); parms.anchor=GridBagConstraints.WEST; parms.weightx=parms.weighty=1.0 ; for( iy= 0; iy <tbComp.length; iy++) { parms.gridy= iy ; for (ix= 0; ix < tbComp[iy].length; ix++){ parms.gridx= ix ; this.add(tbcomp[iy][ix], parms); } } a. gridx, gridy : donne les coordonnes x, y de lobjet dans la grille (celle-ci dduit automatiquement son propre nombre de lignes et de colonnes) b. gridwidth, gridheight : nombre de cellules occupes par le composant c. ll : direction du remplissage (le composant tend alors occuper toute sa cellule dans la direction donne). Valeurs: NONE, BOTH, VERTICAL, HORIZONTAL d. anchor: lorsquun composant est plus petit que sa cellule, bord dancrage du composant (un point cardinal: EAST, NORTHEAST, etc..) e. insets: dtermination des "goutires" (distance minimum entre le composant et les frontires de sa cellule) f. weightx,weighty : "poids" relatif de la cellule (valeur entre 0 et 1)
Rappels : AWT
4/64
4
Les vnements
Lorsque lutilisateur effectue une action au niveau de linterface utilisateur, un vnement est mis. Les vnements sont des objets qui dcrivent ce qui sest produit. Il existe diffrents types de classes dvnements pour dcrire des catgories diffrentes dactions utilisateur.
Evnements sources
Un vnement source (au niveau de linterface utilisateur) est le rsultat dune action utilisateur sur un composant AWT. A titre dexemple, un clic de la souris sur un composant bouton gnre (source) un ActionEvent. LActionEvent est un objet (une instance de la classe) contenant des informations sur le statut de lvnement : q ActionCommand : nom de commande associ laction. q modiers : tous modicateurs mobiliss au cours de laction.
Traitements dvnements
Lorsquun vnement se produit, ce dernier est reu par le composant avec lequel lutilisateur interagit (par exemple un bouton, un curseur, un textField, etc.). Un traitement dvnement est une mthode qui reoit un objet Event de faon ce que le programme puisse traiter linteraction de lutilisateur.
Rappels : AWT
4/65
4
Modle dvnements JDK 1.1
Modle de dlgation (JDK 1.1)
JDK 1.1 a introduit un nouveau modle dvnement appel modle dvnement par dlgation. Dans un modle dvnement par dlgation, les vnements sont envoys au composant, mais cest chaque composant denregistrer une routine de traitement dvnement (appel veilleur: Listener) pour recevoir lvnement. De cette faon, le traitement dvnement peut gurer dans une classe distincte du composant. Le traitement de lvnement est ensuite dlgu une classe spare.
Applet Panel Bouton
Panel et Applet Traitements dvnements vnement action Traitement dactio actionPerformed(ActionEvent .... }
Rappels : AWT
4/66
4
modle dvnements JDK 1.1
Les vnements sont des objets qui ne sont renvoys quaux veilleurs enregistrs. A chaque type dvnement est associ une interface dcoute correspondante. A titre dexemple, voici un cadre simple comportant un seul bouton : import java.awt.*; public class TestButton { public static void main (String args[]){ Frame f = new Frame ("Test"); Button b = new Button("Press Me!"); b.addActionListener(new ButtonHandler()); f.add(b,BorderLayout.CENTER); f.pack(); f.setVisible(true); } } La classe ButtonHandler dni une instance de traitement de lvnement . import java.awt.event.*; public class ButtonHandler implements ActionListener{ public void actionPerformed(ActionEvent e) { System.out.println("Action occured"); } }
Rappels : AWT
4/67
4
Modle dvnements JDK 1.1
Modle de dlgation (JDK 1.1) (suite)

La classe Button comporte addActionListener(ActionListener). une mthode
Linterface ActionListener dnit une mthode actionPerformed qui recevra un ActionEvent.
simple,
Lorsquun objet de la classe Button est cr, lobjet peut enregistrer un veilleur pour les ActionEvent par lintermdiaire de la mthode addActionListener, en prcisant la classe dobjets qui implmente linterface ActionListener. Lorsque lon clique sur lobjet Bouton avec la souris, un ActionEvent est envoy chaque ActionListener enregistr par lintermdiaire de la mthode actionPerformed (ActionEvent).
Rappels : AWT
4/68
4
modle dvnements JDK 1.1
Modle de dlgation (JDK 1.1) (suite)
Cette approche prsente plusieurs avantages :
Il est possible de crer des classes de ltres pour classier les vnements . Le modle de dlgation est plus adapt la rpartition du travail entre les classes. Le nouveau modle dvnement supporte Java BeansTM.
Certains problmes/inconvnients du modle mritent galement dtre considrs :
Il est plus difcile comprendre, au moins au dpart. Le passage du code JDK 1.0 au code JDK 1.1 est compliqu. Bien que la version actuelle de JDK gre le modle dvnement JDK 1.0 en plus du modle de dlgation, les modles dvnements JDK 1.0 et JDK 1.1 ne peuvent pas tre mlangs.
Rappels : AWT
4/69
4
Comportement de linterface graphique utilisateur Java
Catgories dvnements
Le mcanisme gnral de rception des vnements partir de composants a t dcrit dans le contexte dun seul type dvnement. Plusieurs vnements sont dnis dans le package java.awt.event, et des composants tiers peuvent sajouter cette liste. Pour chaque catgorie dvnements, il existe une interface qui doit tre implmente par toute classe souhaitant recevoir ces vnements. Cette interface exige aussi quune ou plusieurs mthodes soient dnies. Ces mthodes sont appeles lorsque des vnements particuliers surviennent. Le tableau de la page suivante liste les catgories et indique le nom de linterface correspondante ainsi que les mthodes associes. Les noms de mthodes sont des mnmoniques indiquant les conditions gnrant lappel de la mthode. On remarquera quil existe des vnements de bas niveau (une touche est presse, on clique la souris) et des vnements abstraits de haut niveau (Action = sur un bouton on a cliqu, sur un TextField on a fait un <retour chariot>, ...)
Rappels : AWT
4/70
4
Tableaux
Category
Action Item
Interface Name
ActionListener ItemListener
Methods
actionPerformed(ActionEvent) itemStateChanged(ItemEvent) mouseDragged(MouseEvent) mouseMoved(MouseEvent) mousePressed(MouseEvent) mouseReleased(MouseEvent) mouseEntered(MouseEvent) mouseExited(MouseEvent) mouseClicked(MouseEvent) keyPressed(KeyEvent) keyReleased(KeyEvent) keyTyped(KeyEvent) focusGained(FocusEvent) focusLost(FocusEvent)
Mouse MotionMouseMotionListener Mouse

MouseListener
Key
KeyListener
Focus
FocusListener
Adjustement AdjustmentListener adjustementValueChanged(AdjustementEvent) Component

ComponentListener
componentMoved(ComponentEvent) componentHidden(ComponentEvent) componentResize(ComponentEvent) componentShown(ComponentEvent)
Window
WindowListener
windowClosing(WindowEvent) windowOpened(WindowEvent) windowIconified(WindowEvent) windowDeiconified(WindowEvent) windowClosed(WindowEvent) windowActivated(WindowEvent) windowDeactivated(WindowEvent) componentAdded(ContainerEvent) componentremoved(ContainerEvent) textValueChanged(TextEvent)
Container Text
ContainerListener TextListener
Rappels : AWT
4/71
4
Evnements gnrs par composants AWT
Table 4: Acti on adju st com pon ent q q q cont aine r focu s q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q q mou se q q q mou se moti on q q q win dow
Composant AWT
item
key
text
Button Canvas Checkbox CheckboxMenuItem Choice Component Container Dialog Frame Label List MenuItem Panel Scrollbar ScrollPane TextArea TextComponent TextField Window
q q q
Rappels : AWT
4/72
4
Obtention dinformations sur un vnement
Lorsque les mthodes de traitement, telles que mouseDragged() sont appeles, elles reoivent un argument qui peut contenir des informations importantes sur lvnement initial. Pour savoir en dtail quelles informations sont disponibles pour chaque catgorie dvnement, reportez-vous la documentation relative la classe considre dans le package java.awt.event.
Rcepteurs multiples
La structure dcoute des vnements AWT permet actuellement dassocier plusieurs veilleurs au mme composant. En gnral, si on veut crire un programme qui effectue plusieurs actions bases sur un mme vnement, il est prfrable de coder ce comportement dans la mthode de traitement. Cependant, la conception dun programme exige parfois que plusieurs parties non lies du mme programme ragissent au mme vnement. Cette situation peut se produire si, par exemple, un systme daide contextuel est ajout un programme existant. Le mcanisme dcoute permet dappeler une mthode add*Listener aussi souvent que ncessaire en spciant autant dcouteurs diffrents que la conception lexige. Les mthodes de traitement de tous les couteurs enregistrs sont appeles lorsque lvnement survient.

Lordre dappel des mthodes de traitement nest pas dni. En gnral, si cet ordre a une importance, les mthodes de traitement ne sont pas lies et on ne doit pas utiliser cette fonction pour les appeler. Au lieu de cela, il faut enregistrer simplement le premier couteur et faire en sorte quil appelle directement les autres. Cest ce quon appelle un multiplexeur dvnements
Rappels : AWT
4/73
4
Adaptateurs dvnements
Il est vident que la ncessit dimplanter toutes les mthodes de chaque interface dcouteur reprsente beaucoup de travail, en particulier pour les interfaces MouseListener et ComponentListener. A titre dexemple, linterface MouseListener dnit les mthodes suivantes :

mouseClicked (MouseEvent) mouseEntered (MouseEvent) mouseExited (MouseEvent) mousePressed (MouseEvent) mouseReleased(MouseEvent)
Pour des questions pratiques, Java fournit une classe dadaptateurs pour pratiquement chaque interface de veiller, cette classe implante linterface approprie, mais ne dnit pas les actions associes chaque mthode. De cette faon, la routine dcoute que lon dnit peut hriter de la classe dadaptateurs et ne surcharger que des mthodes choisies.
Rappels : AWT
4/74
4
Adaptateurs dvnements
Par exemple : import java.awt.*; import.awt.event.*; public class MouseClickHandler extends MouseAdapter { //Nous avons seulement besoin du traitement mouseClick, //nous utilisons donc ladaptateur pour ne pas avoir //crire toutes les mthodes de traitement dvnement public void mouseClicked (MouseEvent e) { //Faire quelque chose avec le clic de la souris . . . } }
Rappels : AWT
4/75
4
Les composants :
Button
Cest un composant dinterface utilisateur de base de type "appuyer pour activer". Il peut tre construit avec une tiquette de texte prcisant son rle . Button b = new Button(Sample); add(b); b.addActionListener(this);
Linterface ActionListener doit pouvoir traiter un clic dun bouton de souris. La mthode getActionCommand() de lvnement action (ActionEvent) activ lorsquon appuie sur le bouton rend par dfaut la chane de ltiquette.
Rappels : AWT
4/76
4
Checkbox
La case cocher fournit un dispositif dentre "actif/inactif" accompagn dune tiquette de texte. Checkbox one = new Checkbox("One", false); Checkbox two = new Checkbox("Two", false); Checkbox three = new Checkbox("Three", true); add(one); add(two); add(three); one.addItemListener(new Handler()); two.addItemListener(new Handler()); three.addItemListener(new Handler());
La slection ou dslection dune case cocher est notie la ralisation de linterface ItemListener. Pour dtecter une opration de slection ou de dselection, il faut utiliser la mthode getStateChange() sur lobjet ItemEvent. Cette mthode renvoie lune des constantes ItemEvent.DESELECTED ou ItemEvent.SELECTED, selon le cas. La mthode getItem() renvoie un objet de type chane (String) qui reprsente la chane de ltiquette de la case cocher considre. class Handler implements ItemListener { public void itemStateChanged(ItemEvent ev) { String state = deselected; if (ev.getStateChange() == ItemEvent.SELECTED){ state = selected; } System.out.println(ev.getItem() + + state); } }
Rappels : AWT
4/77
4
CheckboxGroup
On peut crer des cases cocher laide dun constructeur spcial qui utilise un argument supplmentaire CheckboxGroup. Si on procde ainsi, laspect des cases cocher est modi et toutes les cases cocher lies au mme groupe adoptent un comportement de "bouton radio". CheckboxGroup cbg = new CheckboxGroup(); Checkbox one = new Checkbox("One", cbg, false); Checkbox two = new Checkbox("Two", cbg, false); Checkbox three = new Checkbox("Three", cbg, true); add(one); add(two); add(three);
Rappels : AWT
4/78
4
Choice
Le composant Choice fournit une outil simple de saisie de type "slectionner un lment dans cette liste". Choice c = new Choice(); c.addItem("First"); c.addItem("Second"); c.addItem("Third"); c.addItemListener(. . .);
Lorsquun composant Choice est activ il afche la liste des lments qui lui ont t ajouts. Notez que les lments ajouts sont des objets de type chane (String).
Linterface ItemListener sert observer les modications de ce choix. Les dtails sont les mmes que pour la case cocher. La mthode getSelectedIndex() de Choice permet de connatre lindex selectionn.
Rappels : AWT
4/79
4
List
Une liste permet de prsenter lutilisateur des options de texte afches dans une zone o plusieurs lments peuvent tre visualiss simultanment. Il est possible de naviguer dans la liste et dy slectionner un ou plusieurs lments simultanment (mode de slection simple ou multiple). List l = new List(4, true);
Largument numrique transmis au constructeur dnit le nombre ditems visibles. Largument boolen indique si la liste doit permettre lutilisateur deffectuer des slections multiples.
Un ActionEvent, gr par lintermdiaire de linterface ActionListener, est gnr par la liste dans les modes de slection simple et multiple. Les lments sont slectionns dans la liste conformment aux conventions de la plate-forme. Pour un environnement Unix/Motif, cela signie quun simple clic met en valeur une entre dans la liste, mais quun double-clic dclenche laction correspondante. Rcupration: voir getSelectedItems() mthodes getSelectedObjects(),
Rappels : AWT
4/80
4
Canvas
Un canvas fournit un espace vide (arrire-plan color). Sa taille par dfaut tant zro par zro, on doit gnralement sassurer que le gestionnaire de disposition lui affectera une taille non nulle. Cet espace peut tre utilis pour dessiner, recevoir du texte ou des saisies en provenance du clavier ou de la souris. Le canvas est gnralement utilis tel quel pour fournir un espace de dessin gnral.
Le canvas peut couter tous les vnements applicables un composant gnral. On peut, en particulier, lui associer des objets KeyListener, MouseMotionListener ou MouseListener pour lui permettre de rpondre dune faon ou dune autre une interaction utilisateur.
Rappels : AWT
4/81
4
Label
Un label afche une seule ligne de texte. Le programme peut modier le texte. Aucune bordure ou autre dcoration particulire nest utilise pour dlimiter un label. Label lab = new Label(Hello); add(lab);
MaFrame
En gnral, on ne sattend pas ce que les Labels traitent des vnements, pourtant ils effectuent cette opration de la mme faon quun canvas. Dans ce cas, on ne peut capter les activations de touches de faon able quen faisant appel requestFocus().
Rappels : AWT
4/82
4
TextArea
La zone de texte est un dispositif de saisie de texte multi-lignes, multicolonnes. On peut le rendre non ditable par lintermdiaire de la mthode setEditable(boolean). Il afche des barres de dlement horizontales et verticales. TextArea t = new TextArea(Hello!, 4, 30); add(t);
On peut ajouter des veilleurs dvnements de divers type dans une zone de texte. Le texte tant multi-lignes, le fait dappuyer sur <Entre> place seulement un autre caractre dans la mmoire tampon. Si on a besoin de savoir quel moment une saisie est termine, on peut placer un bouton de validation ct dune zone de texte pour permettre lutilisateur de fournir cette information. Un veilleur KeyListener permet de traiter chaque caractre entr en association avec la mthode getKeyChar(), getKeyCode() de la classe KeyEvent.
Rappels : AWT
4/83
4
TextField
Le TextField est un dispositif de saisie de texte sur une seule ligne. TextField f = new TextField(Single line, 30); add(f);
Du fait quune seule ligne est possible, un couteur daction (ActionListener) peut tre inform, via actionPerformed(), lorsque la touche <Entre> ou <Retour> est active. Comme la zone de texte, le champ texte peut tre en lecture seule. Il nafche pas de barres de dlement dans lune ou lautre direction mais permet, si besoin est, un dlement de gauche droite dun texte trop long.
TextComponent
La classe TextComponent dont drivent TextField et TextArea fourni un grand nombre de mthodes. On a vu que les constructeurs des classes TextArea et TextField permettent de dnir un nombre de colonnes pour lafchage. Le nombre de colonnes est interprt en fonction de la largeur moyenne des caractres dans la police utilise. Le nombre de caractres effectivement afchs peut varier radicalement en cas dutilisation dune police chasse proportionnellel.
Rappels : AWT
4/84
4
Frame
Cest la fentre gnrale de "plus haut niveau". Elle possde des attributs tels que : barre de titre et zones de contrle du redimensionnement. Frame f = new Frame(Frame);
La taille dun Frame peut tre dnie laide de la mthode setSize() ou avec la mthode pack(). Dans ce cas le gestionnaire de disposition calcule une taille englobant tous les composants du Frame et dnit la taille de ce dernier en consquence. Les vnements du Frame peuvent tre surveills laide de tous les gestionnaires dvnements applicables aux composants gnraux. WindowListener peut tre utilis pour ragir, via la mthode windowClosing(), lorsque le bouton Quit a t activ dans le menu du gestionnaire de fentres. Il nest pas conseill dcouter des vnements clavier directement partir dun Frame. Bien que la technique dcrite pour les composants de type Canvas et Label, savoir lappel de requestFocus(), fonctionne parfois, elle nest pas able. Si on a besoin de suivre des vnements clavier, il est plutt recommand dajouter au Frame un Canvas, Panel, etc., et dassocier le gestionnaire dvnement ce dernier.
Rappels : AWT
4/85
4
Panel
Cest le conteneur de base. Il ne peut pas tre utilis de faon isole comme les Frames, les fentres et les botes de dialogue. Panel p = new Panel(); Les Panels peuvent grer les vnements (rappel : le focus clavier doit tre demand explicitement).
Rappels : AWT
4/86
4
Dialog
Un Dialog est une fentre qui diffre toutefois dun Frame :
elle est destine afcher des messsages fugitifs elle peut tre modale: elle recevra systmatiquement toutes les saisies jusqu fermeture. elle ne peut-tre supprime ou icnie par les boutons du gestionnaire de fentre, on lui associe habituellement un bouton de validation.
Dialog d = new Dialog(f, "Dialog", false); d.add(new Label("Hello, I'm a Dialog"), BorderLayout.CENTER); d.pack();
Rappels : AWT
4/87
4
Dialog
Un dialog dpend dune Frame : cette Frame apparait comme premier argument dans les constructeurs de la classe Dialog. Les botes de dialogue ne sont pas visibles lors de leur cration.Elles safchent plutt en rponse une autre action au sein de linterface utilisateur, comme le fait dappuyer sur un bouton. public void actionPerformed(ActionEvent ev) { d.setVisible(true); }

Il est recommand de considrer une bote de dialogue comme un dispositif rutilisable. Ainsi, vous ne devez pas dtruire lobjet individuel lorsquil est effac de lcran, mais le conserver pour une rutilisation ultrieure.
Pour masquer une bote de dialogue, appelez setVisible(false). Cette opration seffectue gnralement en ajoutant un WindowListener, et en attendant que la mthode windowClosing() soit appele dans ce gestionnaire dvnement.
Rappels : AWT
4/88
4
FileDialog
Cest une implantation dun dispositif de slection de chier. Elle comporte sa propre fentre autonome et permet lutilisateur de parcourir le systme de chiers et de slectionner un chier spcique pour des oprations ultrieures. FileDialog d = new FileDialog(f, "FileDialog"); d.setVisible(true); String fname = d.getFile();
En gnral, il nest pas ncessaire de grer des vnements partir de la bote de dialogue de chiers. Lappel de setVisible(true) se bloque jusqu ce que lutilisateur slectionne OK. Le chier slectionn est renvoy sous forme de chane .Voir getDirectory(), getFile()
Rappels : AWT
4/89
4
ScrollPane
Fournit un conteneur gnral ne pouvant pas tre utilis de faon autonome. Il fournit une vue sur une zone plus large et des barres de dlement pour manipuler cette vue. Frame f = new Frame("ScrollPane"); Panel p = new Panel(); ScrollPane sp = new ScrollPane(); p.setLayout(new GridLayout(3, 4)); sp.add(p); f.add(sp); f.setSize(200, 200); f.setVisible(true);
Le ScrollPane cre et gre les barres de dlement selon les besoins. Il contient un seul composant et on ne peut pas inuer sur le gestionnaire de disposition quil utilise. Au lieu de cela, on doit lui ajouter un Panel, congurer le gestionnaire de disposition de ce Panel et placer les composants lintrieur de ce dernier. En gnral, on ne gre pas dvnements dans un ScrollPane, mais on le fait dans les composants quil contient.
Rappels : AWT
4/90
4
Menus
Les menus diffrent des autres composants par un aspect essentiel. En gnral, on ne peut pas ajouter de menus des conteneurs ordinaires et laisser le gestionnaire de disposition les grer. On peut seulement ajouter des menus des lments spciques appels conteneurs de menus. Gnralement, on ne peut dmarrer une "arborescence de menu" quen plaant une barre de menus dans un Frame via la mthode setMenuBar(). A partir de l, on peut ajouter des menus la barre de menus et incorporer des menus ou lments de menu ces menus. Lexception est le menu PopUpMenu qui peut tre ajout nimporte quel composant, mais dans ce cas prcis, il nest pas question de disposition proprement parler.
Menu Aide
Une caractristique particulire de la barre de menus est que lon peut dsigner un menu comme le menu Aide. Cette opration seffectue par lintermdiaire de la mthode setHelpMenu(Menu). Le menu considrer comme le menu Aide doit avoir t ajout la barre de menus, et il sera ensuite trait de la faon approprie pour un menu Aide sur la plateforme locale. Pour les systmes de type X/Motif, cela consiste dcaler lentre de menu lextrmit droite de la barre de menus.
Rappels : AWT
4/91
4
MenuBar
Cest la barre de menu horizontale. Elle peut seulement tre ajout lobjet Frame et constitue la racine de toutes les arborescences de menus. Frame f = new Frame(MenuBar); MenuBar mb = new MenuBar(); f.setMenuBar(mb);
MenuBar
Menu
Menu
MenuItem
MenuItem
Rappels : AWT
4/92
4
Menu
La classe Menu fournit le menu droulant de base. Elle peut tre ajoute une barre de menus ou un autre menu. MenuBar mb = new MenuBar(); Menu m1 = new Menu("File"); Menu m2 = new Menu("Edit"); Menu m3 = new Menu("Help"); mb.add(m1); mb.add(m2); mb.add(m3); mb.setHelpMenu(m3);

Les menus prsents ici sont vides ce qui explique laspect du menu File.
On peut ajouter un ActionListener un objet Menu, mais cest assez inhabituel. Normalement, les menus servent seulement disposer des MenuItem dcrits plus loin.
Rappels : AWT
4/93
4
MenuItem
Les lments de menu MenuItem sont les feuilles dune arborescence de menu. Menu m1 = new Menu("File"); MenuItem mi1 = new MenuItem("Save"); MenuItem mi2 = new MenuItem("Load"); MenuItem mi3 = new MenuItem("Quit"); m1.add(mi1); m1.add(mi2); m1.addSeparator(); m1.add(mi3);
En rgle gnrale, on ajoute un ActionListener aux objets MenuItem an dassocier des comportements aux menus.
Rappels : AWT
4/94
4
CheckboxMenuItem
Les lments de menu cocher permettent de proposer des slections (activ/dsactiv) dans les menus. Menu m1 = new Menu("File"); MenuItem mi1 = new MenuItem("Save"); CheckboxMenuItem mi2 = new CheckboxMenuItem("Persistent"); m1.add(mi1); m1.add(mi2);
Llment de menu cocher doit tre surveill via linterface ItemListener. Cest pourquoi la mthode itemStateChanged() est appele lorsque ltat de llment cocher est modi.
Rappels : AWT
4/95
4
PopupMenu
Fournit un menu autonome pouvant safcher instantanment sur un autre composant. On peut ajouter des menus ou lments de menu un menu instantan. Frame f = new Frame("PopupMenu"); Button b = new Button("Press Me"); b.addActionListener(...); PopupMenu p = new PopupMenu("Popup"); MenuItem s = new MenuItem("Save"); MenuItem l = new MenuItem("Load"); s.addActionListener(...); l.addActionListener(...); f.add("Center", b); p.add(s); p.add(l); f.add(p);
Rappels : AWT
4/96
4
PopupMenu (suite)

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

Le composant dorigine doit tre sous (ou contenu dans) le composant parent dans la hirarchie des composants.
Rappels : AWT
4/97
4
Contrle des aspects visuels
On peut contrler lapparence des composants AWT en matire de couleur de fond et de premier plan ainsi que de police utilise pour le texte.
Couleurs
Deux mthodes permettent de dnir les couleurs dun composant :
setForeground(...) setBackground(...)
Ces deux mthodes utilisent un argument qui est une instance de la classe java.awt.Color. On peut utiliser des couleurs de constante dsignes par Color.red Color.blue etc. La gamme complte de couleurs prdnies est documente dans la page relative la classe Color. Qui plus est, on peutcrer une couleur spcique de la faon suivante : int r = 255, g = 255, b = 0; Color c = new Color(r, g, b); Un tel constructeur cre une couleur daprs les intensits de rouge, vert et bleu spcies sur une chelle allant de 0 255 pour chacune.
Rappels : AWT
4/98
4
Polices
La police utilise pour afcher du texte dans un composant peut tre dnie laide de la mthode setFont(). Largument utilis pour cette mthode doit tre une instance de la classe java.awt.Font. Aucune constante nest dnie pour les polices, mais on peut crer une police en indiquant son nom, son style et sa taille en points. Font f = new Font(TimesRoman, Font.PLAIN, 14); Voici quelques noms de polices valides :
Dialog SansSerif (remplace Helvetica) Serif (remplace TimesRoman ) Monospaced (remplace Courier)
On peut obtenir la liste complte des polices en appelant la mthode getFontList() de la classe Toolkit. La bote outils (toolkit) peut tre obtenue partir du composant, une fois ce dernier afch on appelle la mthode getToolkit(). On peut aussi utiliser le ToolKit par dfaut obtenu par Toolkit.getDefaultToolkit().
Rappels : AWT
4/99
4
Polices
Les constantes de style de police sont en ralit des valeurs entires (int), parmi celles cites ci-aprs :
Font.BOLD Font.ITALIC Font.PLAIN Font.BOLD + Font.ITALIC
Les tailles en points doivent tre dnies avec une valeur entire.
Rappels : AWT
4/100
4
Impression
Limpression est gre dans Java 1.1 dune faon similaire lafchage sur cran. Grace une instance particulire de java.awt.Graphics toute instruction de dessin dans ce contexte est en fait destine limprimante. Le systme dimpression Java 1.1 permet dutiliser les conventions dimpression locales, de sorte que lutilisateur voit safcher une bote de dialogue de slection dimprimante lorsque lon lance une opration dimpression. Lutilisateur peut ensuite choisir dans cette boite de dialogue les options telles que la taille du papier, la qualit dimpression et limprimante utiliser. Frame f = new Frame("Print test"); Toolkit t = f.getToolkit(); PrintJob job = t.getPrintJob(f,"Mon impr.", null); if (job != null) { Graphics g = job.getGraphics(); ..... } Ces lignes crent un contexte graphique (Graphics) "connect" limprimante choisie par lutilisateur. Pour obtenir un nouveau contexte pour chaque page : f.printAll(g);// ou printComponents() On peut utiliser nimporte quelle mthode de dessin de la classe Graphics pour crire sur limprimante. Ou bien, comme indiqu ici, on peut simplement demander un composant de se tracer. La mthode print() demande un composant de se tracer , mais elle nest lie quau composant pour lequel elle a t appele. Dans le cas dun conteneur, comme ici, on peut utiliser la mthode printAll() pour que le conteneur et tous les composants quil contient soient tracs sur limprimante. Utiliser printComponents() si on utilise des composants 100% JAVA. g.dispose(); job.end(); Aprs avoir cr une page de sortie conforme ce que lon souhaite, on utilise la mthode dispose() pour que cette page soit soumise limprimante.
Rappels : AWT
4/101
4
Impression
Une fois ce travail termin, on appele la mthode end() sur lobjet tche dimpression. Elle indique que la tche dimpression est termine et permet au systme de traitement en diffr dexcuter rellement la tche puis de librer limprimante pour dautres tches. Nota: Dans le contexte Solaris il nexiste pas dobjet standard de menu dimpression. On peut utiliser le 3me argument de getPrintJob() qui est un dictionnaire de proprits (qui peut aussi tre null Frame f = new Frame("Print test"); Toolkit t = f.getToolkit(); Properties pprops = new Properties(); pprops.put("awt.print.paperSize","a4"); pprops.put("awt.print.orientation","landscape"); PrintJob job = t.getPrintJob(f,"Mon impr.", pprops); .....
Les proprits de ce dictionnaire sont : awt.print.destination awt.print.printer awt.print.fileName awt.print.options awt.print.orientation (portrait, landscape) awt.print.paperSize (letter,legal,executive,a4) awt.print.numCopies
Rappels : AWT
4/102
Les composants SWING

Points Essentiels :
La plateforme Java 2 intgre de nouveaux services pour raliser des prsentations graphiques :
Java2D permet de raliser des oprations graphiques sophistiques et Swing constitue un ensemble cohrent de services et de composants dinteractions graphiques. La hirarchie des composants comprend dun cot des composants racine comme JFrame qui drivent de composants lourds comme Frame, et dautre part des composants lgers crits en Java qui drivent de la classe JComponent. Les deux types de classes offrent de nombreux services spciques qui les distinguent des composants AWT classiques.
Intitul Cours: Programmation JAVA avance Copyright Sun Service Formation Rf. Sun : SL275
Rvision : F-beta Date : 18/2/99
5
Java Foundation Classes

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

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

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

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

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

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

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

5/111

5/112
Rappels: Flots E/S, linarisation

Objet
Rappels des notions fondamentales sur les Entres/Sorties JAVA:
Flots (Streams) I/OStreams et Reader/Writer catgories de ots ltres chiers
Rappels spciques sur la linarisation:
Data Input/Output Object Input/Output
6
E/S JAV A : concepts fondamentaux
Pour pouvoir tre raliss de manire portable sur tous les systmes les Entrs/Sorties Java sappuient sur des concepts abstraits de haut niveau.
ots dE/S (Streams)

Un ot de donnes (Stream) est un dispositif qui permet daccder squentiellement des donnes. Dans un ot dentre on consomme successivement ces donnes et dans un ot de sortie on les envoie. Une abstraction comme un InputStream lit des octets et dispose dun petit nombre de mthodes fondamentales comme: int read() int read(byte[]) int read(byte[], int, int) La mthode read renvoie un argument int contenant un octet lu partir du ot ou la valeur -1 indiquant la n de chier. Les deux autres mthodes lisent dans une buffer de byte et renvoient le nombre doctets lus. void close() permet de fermer le ot. Dautre mthodes permettent de "sauter" un nombre doctets dtermin ou mme, si cest possible, de "marquer" un emplacement, de faire des lectures anticipes et de revenir ensuite la marque initiale.

6/114
6
I/O Streams et Reader/Writer
Au niveau des ots fondamentaux de bas niveau on distingue dune part les I/OStream qui manipulent des octets (byte) et les Reader et Writer qui manipulent des caractres. Comme JAVA utilise des caractres 16 bits UNICODE les ralisations de base ne sont pas les mme pour ces deux catgories. Une situation particulire est celle o on est au conuent des mondes JAVA (avec des caractres UNICODE) et non-JAVA (avec un codage dun autre type). Les classes InputStreamReader et OutputStreamWriter disposent de convertisseurs qui permettent dassurer un fonctionnement corrects des ots. Il faut toutefois veiller spcier correctement le type de conversion (qui, par dfaut, est dduit de lenvironnement local)
catgories de ots
Parmi les classes de lAPI JAVA on peut classier les ots selon:
leur structure dorigine (c.a.d. lendroit do proviennent les donnes) : buffers (ByteArrayInputStream, CharArrayReader, StringReader,...), threads (PipedInputStream, PipedReader ), fichiers ( FileInputStream, FileReader ), flots de communications produits par des Socket, URL, Process, etc. (InputStream produits par les mthodes getInputStream()) ou mme regroupement de Streams (SequenceInputStream) les particularits de leur mode de fonctionnement: bufferisation (BufferedInputStream, BufferedReader), possibilit de rpudiation de lecture (PushbackInputStream, PushbackReader), formattages particulier (DataInputStream, ObjectInputStream , GZIPInputStream , PrintWriter, StreamTokenizer...)
Larchitecture des hritages est particulirement complexe apprhender mais la notion centrale est celle de ltre (exemple : FilterInputStream)

6/115
6
ltres
De nombreuses classes dE/S -et, en particulier, les classes de type Filter* (FilterInputStream, FilterReader,..)sont des adaptateurs qui permettent de combiner les caractristiques de plusieurs classes dEntres/Sorties. On peut ainsi contruire une instance de ot qui enchane diffrents services dE/S : String str ; BufferedReader inr = new BufferedReader(new InputStreamReader(System.in); while ((str = in.readLine()) != null) { System.out.println("Read: " + str); }
La construction ci-dessus (un ltre bufferis avec conversion de caractres du codage local vers UNICODE) est rendu possible par le fait que les constructeurs des classes admettent en paramtre un anctre commun (Reader pour BufferedReader, InputStream pour InputStreamReader,...)

6/116
6
Fichiers
La classe File est un abstraction permettant de crer, manipuler des chiers ou dobtenir des informations sur ces chiers.
Noms de chiers
String getName() String getPath() String getAbsolutePath() String getParent() boolean renameTo(File newName)
Tests de chiers
boolean exists() boolean canWrite() boolean canRead() boolean isFile() boolean isDirectory() boolean isAbsolute();
Information gnrale axe sur les chiers et utilitaires

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

boolean mkdir() String[] list()

6/117
6
Linarisation
Classes DataInputStream etDataOutputStream
Ces ots permettent la lecture et lcriture de types de base Java. Voici une palette de mthodes :
Mthodes DataInputStream
byte readByte() boolean readBoolean() char readChar() short readShort() int readUnsignedShort() int readInt() long readLong() float readFloat() double readDouble() String readUTF()
DataOutputStream fourni les mthodes dcriture correspondantes. Les mthodes *UTF permettent de lire/crire des chanes de caractres UNICODE en restant dans le monde JAVA. Elles utilisent un type de codage particulier (UTF8) qui permet de condenser des chanes UNICODE lors dun transfert sur une ligne de communication.

6/118
6
Linarisation
Bibliographie
voit documentation http://chatsubo.sun.com/current/serial/index.html
Object Input/Output
Linterface API de linarisation dobjet Java fournit un moyen simple et transparent permettant de transfrer des objets JAVA ou de les conserver dans un chier. LAPI fournit des mthodes permettant de gnrer et dexploiter ce ot. Les objets que lon souhaite utiliser sous forme de structures linariser ralisent une interface permettant denregistrer ou de rcuprer le contenu de lobjet en un seul ot. Il sagit des interfaces java.io.ObjectOutput et java.io.ObjectInput..

6/119
6
Architecture de linarisation
Package java.io
LAPI de linarisation est base sur des interfaces conues pour introduire ou extraire des objets (ou des types scalaires) dun ot dE/S..
java.io.DataOutput
java.io.OutputStream
ObjectOutput
ObjectOutputStream
ObjectStreamConstants
java.io.DataInput
java.io.InputStream
ObjectInput
ObjectInputStream
java.lang.Object
java.io.Serializable
Lgende Classe Classe abstraite Interface
java.io.Externalizable
Etend Implante

6/120
6
Interface Serializable
Linterface Serializable sert identier les classes pouvant tre linarises. Toute classe peut tre linarise dans la mesure o elle satisfait aux critres suivants :
La classe (ou une classe de la hirarchie de cette classe) doit implmenter java.io.Serializable. Les champs ne pas linariser doivent tre reprs laide du mot cl transient. Parmi ces champs, citons les classes java.io.FileInputStream, java.io.FileOutputStream et java.lang.Threads. Si le mot cl transient nest pas affect ces champs, une tentative dappel de la mthode writeObject() gnrera une exception NotSerializableException.
Elments srialisables
Tous les champs (donnes) dun objet Serializable sont crits dans le ot. Sont concerns les types scalaires, les tableaux et les rfrences dautres objets. Les champs statiques ne sont pas linariss. Il est noter que le mcanisme daccs aux champs (private, protected et public) na aucun effet sur le champ en cours de linarisation. Si ncessaire on doit dclarer les champs private en tant que private transient.

6/121
6
Ecriture et lecture dun ot dobjets
Ecriture
Lcriture et la lecture dun objet dans un ot de chiers est un processus simple. Examinons le fragment de code suivant qui transmet une instance dun objet java.util.Date un chier : Date d = new Date(); FileOutputStream f = new FileOutputStream("date.ser"); ObjectOutputStream s = new ObjectOutputStream (f); try { s.writeObject (d); s.close (); } catch (IOException e) { e.printStackTrace(); }
Lecture
La lecture de lobjet est aussi simple que lcriture, une exception prs la mthode readObject() retourne le ot sous forme de type Object et elle doit tre associe au nom de classe correspondant, avant que lexcution des mthodes sur cette classe soit possible : Date d = null; FileInputStream f = new FileInputStream ("date.ser"); ObjectInputStream s = new ObjectInputStream (f); try { d = (Date)s.readObject (); } catch (IOException e) { e.printStackTrace(); } System.out.println ("Date serialized at: "+ d);

6/122
6
quest ce qui est transferr?
Le transfert dun objet suppose la conservation :
de la dsignation de la classe, de sa "signature" des valeurs des champs non-statiques et non-transient (y compris les objets rfrencs)
Cela implique :
que le correspondant connaisse la classe dsigne pour pouvoir la reconstituer. que la classe connue par le correspondant soit compatible avec la version de la classe expdie. La signature de la classe (voir utilitaire serialver) donne un identiant caractrisant la version. Dans la spcication du langage JAVA des rgles complexes dnisse la compatibilit entre deux versions dune mme classe. que le Stream courant garde trace des identiants dinstances transfres. Ceci a plusieurs consquences :
linariser un objet peut entraner la linarisation dun graphe complexe de rfrences (on prendra soin de mettre de nombreux champs transient si on ne veux pas transfrer par inadvertance un grand nombre dobjets) le graphe des rfrences est reconstitu correctement larrive (mme sil y a des cycles!).Cette complexit peut conduire des performances faibles du transfert si le Stream est ferm puis rouvert on perd la trace correcte des instances (voir connexions client/serveur). Par contre si le Stream reste ouvert il est impossible de transfrer successivement une mme instance dans laquelle il y a modication de valeurs de champs.
Rappels: Flots E/S, linarisation 6/123
6
personnalisation de la lecture/criture dobjet
On peut personnaliser la linarisation dune classe en dnissant deux mthodes prives writeObject and readObject. La mthode writeObject permet de contrler quelles informations sont sauvegardes. Typiquement on lutilise pour envoyer des informations complmentaires qui permettront de reconstituer correctement lobjet larrive : supposons par exemple quon ait des deux cots un mcanisme de dictionnaire (ou de base de donnes) qui permette de rechercher un objet en connaissant une clef; au lieu de transfrer cet objet (qui est rfrenc par lobjet courant) on peut transfrer sa clef et le reconstituer larrive en consultant le dictionnaire. private void writeObject(ObjectOutputStream s) throws IOException { s.defaultWriteObject(); // code spcifique } La mthode readObject doit tre soigneusement conue pour lire exactement les donnes dans le mme ordre. private void readObject(ObjectInputStream s) throws IOException { s.defaultReadObject(); //lecture des donnes personnalises ... // code de mise jour de linstance courante } Les mthodes writeObject et readObjectne sont responsables que de la linarisation de la classe courante. Toute linarisation de super-classe est traite automatiquement. Si on a besoin de coordination explicite avec la super-classe il vaut mieux passer par le mcanisme de linterface Externalizable.

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

6/125

6/126
Rappels : Programmation rseau Java

Objectifs
Rappels :
Crer un code serveur sous TCP/IP. Crer un code client sous TCP/IP. utiliser UDP utiliser UDP en diffusion ("multicast")
7
Programmation rseau sous Java
Sockets
Les Sockets sont des points dentre de communication bi-directionnelle entre deux applications sur un rseau. Les diffrents types de Socket conditionnent la faon dont les donnes vont tre transfres :
Stream sockets (TCP) Permettent dtablir une communication en mode connect. Un ot continu est tabli entre les deux correspondants : les donnes arrivent dans un ordre correct et sans tre corrompues. Datagram sockets (UDP) Permettent dtablir une connexion en mode non-connect, que lon appelle aussi mode Datagramme. Les donnes doivent tre assembles et envoyes sous la forme de paquets indpendants de toute connexion. Un service non connect est gnralement plus rapide quun servcie connect, mais il est aussi moins able : aucune garantie ne peut tre mise quand au fait que les paquets seront effectivement distribus correctement -ils peuvent tre perdus, dupliqus ou distribus dans le dsordre-.

7/128
7
Le modle rseau de Java.
Dans Java, les sockets TCP/IP sont implantes au travers de classes du package java.net. Voici la faon dont ces classes sont utilises. :
Serveur
ServerSocket (port #, nb_cnx) accept() retourne un objet Socket
Enregistrer ce service. Attendre une connexion du client. Utiliser la Socket
Client
Socket (host, port#)

(attempt to connect)
InputStream OutputStream
OutputStream InputStream
close ()
close ()
Dans ce modle, le fonctionnement est le suivant :
Le Serveur enregistre son service sous un numro de port, indiquant le nombre de client quil accepte de faire "bufferiser" un instant T. Puis, le serveur se met en attente sur ce service par la mthode accept() de son instance de ServerSocket. Le client peut alors tablir une connexion avec le serveur en demandant la cration dune socket destination du serveur pour le port sur lequel le service a t enregistr. Le serveur sort de son accept() et rcupre une Socket en communication avec le Client. Ils peuvent alors utiliser des InputStream et OutputStream pour changer des donnes.
Rappels : Programmation rseau Java 7/129
7
Principe dun Serveur TCP/IP
Exemple de code de mise en oeuvre dun serveur TCP/IP
import java.net.*; import java.io.*; public class SimpleServer { public static void main(String args[]) { ServerSocket s = null; Socket s1; String sendString = "Hello Net World!"; OutputStream s1out; DataOutputStream dos; // enregistrer votre service sur try { s = new ServerSocket(5432,5); } catch (IOException e) { } port 5432
// boucle infinie listen/accept while (true) { try { // attente dune connexin s1=s.accept(); // rcuperr un stream dcriture s1out = s1.getOutputStream(); dos = new DataOutputStream (s1out); // envoyer la chane! dos.writeUTF(sendString); // fermer la connexion mais pas lattente de // connexion dos.close(); s1.close(); } catch (IOException e) { } } } }

7/130
7
Principe dun Client TCP/IP
Le client correspondant : import java.net.*; import java.io.*; public class SimpleClient { public static void main(String[] args) throws IOException { int c; Socket s1; InputStream s1In; DataInputStream dis; // votre connection args[0]t, sur port 5432 s1 = new Socket(args[0],5432);

The above statement could potentially throw an IOException.
// rcupration dun stream en lecture s1In = s1.getInputStream(); dis = new DataInputStream(s1In); String st = new String (dis.readUTF()); System.out.println(st); // on coupe la connexion s1.close(); }

7/131
7
changes UDP
On na pas ici de connexion ouverte en permanence. Les paquets, autonomes, sont transfrs avec leur propres informations dadresse. Le service nest pas "able" car il y a des risques de perte, ou de duplication de paquets. Lordre darrive nest pas garanti. Pour limiter les incidents il vaut mieux limiter la taille des paquets envoys de manire ce quils noccupent quun seul paquet IP. Les objets fondamentaux :
DatagramSocket : dtermine un canal (socket) UDP. Pour un serveur on prcisera le port (pas ncessaire pour le client) DatagramSocket serverSock = new DatagramSocket(9789); DatagramSocket clientSock= new DatagramSocket() ;
DatagramPacket : structure daccueil des donnes et des informations dadresse. Les methodes getData(), getAddress(), getPort() permettent de rcuprer ces informations.
// pour un envoi sendPack = new DatagramPacket(byteBuff, len, addr, port); socket.send(sendPack) ; // pour une reception revPack = new DatagramPacket(byteBuffer, len) ; socket.receive(recvPack);
InetAddress : permet de produite une adresse inet partir dune dsignation (mthode getByName()) ou de la machine locale (getLocalHost())

7/132
7
Exemple de Serveur UDP
Ce serveur reoit un objet dun client et le renvoie suivi dun java.sql.Timestamp. On utilise les donnes dadressage du paquet reu du client pour reexpdier les donnes
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35
1import java.io.* ; import java.net.* ; import java.sql.* ; public class DatagServer { public static final int PORT = 9999 ; public static final int DATA_MAX_SIZE = 512 ; public static void main (String[] tbArgs) { byte[] recBuffer = new byte[DATA_MAX_SIZE] ; try{ DatagramSocket veille = new DatagramSocket(PORT) ; while (veille != null) { DatagramPacket recvPack = new DatagramPacket( recBuffer, recBuffer.length) ; veille.receive(recvPack) ; ObjectInputStream inz = new ObjectInputStream (new ByteArrayInputStream(recvPack.getData())) ; Object obj = inz.readObject() ; System.out.println(obj) ; ByteArrayOutputStream boz = new ByteArrayOutputStream(); ObjectOutputStream oz = new ObjectOutputStream (boz); oz.writeObject(obj) ; oz.writeObject(new Timestamp(System.currentTimeMillis())); // consommation excessive de donnes (deux byte buffers!) DatagramPacket sendPack = new DatagramPacket(boz.toByteArray(), boz.size(), recvPack.getAddress() ,recvPack.getPort()); veille.send(sendPack) ; } } catch (Exception exc ) { System.err.println(exc) ; } }//End main

7/133
7
Exemple de client UDP
Correspond au serveur prcdent : on envoie un java.sql.Timestamp et on le reoit en echo suivi de celui du serveur.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 import java.io.* ; import java.net.* ; import java.sql.* ; public class DatagClient { public static final int DATA_MAX_SIZE = 512 ; public static void main (String[] tbArgs) { byte[] recBuffer = new byte[DATA_MAX_SIZE] ; try{ DatagramSocket socket = new DatagramSocket() ; if (socket != null) { ByteArrayOutputStream boz = new ByteArrayOutputStream(); ObjectOutputStream oz = new ObjectOutputStream (boz) ; oz.writeObject(new Timestamp(System.currentTimeMillis())) ; // consommation excessive de donnes (deux byte buffers!) DatagramPacket sendPack = new DatagramPacket( boz.toByteArray(), boz.size(), InetAddress.getByName(tbArgs[0]), DatagServer.PORT) ; socket.send(sendPack) ; DatagramPacket recvPack = new DatagramPacket(recBuffer, recBuffer.length) ; socket.receive(recvPack) ; ObjectInputStream inz = new ObjectInputStream (new ByteArrayInputStream(recvPack.getData())) ; Object obj = inz.readObject() ; System.out.println(obj) ; obj = inz.readObject() ; System.out.println(obj) ; } } catch (Exception exc ) { System.err.println(exc) ; } }//End main

7/134
7
UDP en diffusion (Multicast)
Une adresse de diffusion (multicast) est une adresse comprise entre 224.0.0.0 et 239.255.255.255. Des MulticastSocket permettent de diffuser des donnes simultanment un groupe dabonns. Sur une telle socket on peut sabonner une adresse multicast par joinGroup(InetAddress mcastaddr) ou se dsabonner par leaveGroup(InetAddress). Le paramtre TTL de ces sockets permet de xer le nombre maximum de routeurs traverss - si ces routeurs le permettent- (important si on veut limiter la diffusion lextrieur dune entreprise)

Actuellement les accs "Multicast" ne sont pas autoriss dans les Applet.

7/135
7
Exemple de Serveur Multicast
Diffuse un java.sql.TimeStamp toute les secondes. Les paquets ne se transmettent pas au travers des relais rseaux (TTL = 1).
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 import java.io.* ; import java.net.* ; import java.sql.* ; public class MultigServer { public static final int PORT = 9999 ; public static final String GROUP = "229.69.69.69" ; public static final byte TTL = 1 ; // pas de saut! public static final int DATA_MAX_SIZE = 512 ; public static void main (String[] tbArgs) { byte[] recBuffer = new byte[DATA_MAX_SIZE] ; try{ MulticastSocket veille = new MulticastSocket(PORT); InetAddress adrGroupe = InetAddress.getByName(GROUP) ; while (veille != null) { ByteArrayOutputStream boz = new ByteArrayOutputStream(); ObjectOutputStream oz = new ObjectOutputStream (boz) ; oz.writeObject(new Timestamp(System.currentTimeMillis())) ; // consommation excessive de donnes (deux byte buffers!) DatagramPacket sendPack = new DatagramPacket(boz.toByteArray(), boz.size(), adrgroupe, PORT) ; veille.send(sendPack, TTL) ; try{ Thread.sleep(1000) ; } catch (InterruptedException exc) {} } } catch (Exception exc ) { System.err.println(exc) ; } }//End main }

7/136
7
Exemple de client Multicast
Reoit 10 objets du serveur
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 import java.io.* ; import java.net.* ; import java.sql.* ; public class MultigClient { public static final int DATA_MAX_SIZE = 512 ; public static void main (String[] tbArgs) { MulticastSocket socket = null; InetAddress adrGroupe = null ; byte[] recBuffer = new byte[DATA_MAX_SIZE] ; try{ socket = new MulticastSocket(MultigServer.PORT) ; adrGroupe = InetAddress.getByName(MultigServer.GROUP) ; if (socket != null) { socket.joinGroup(adrGroupe) ; // danger! on reutilise le meme buffer? DatagramPacket recvPack = new DatagramPacket(recBuffer, recBuffer.length) ; for( int ix = 0 ; ix < 10 ; ix++) { socket.receive(recvPack) ; ObjectInputStream inz = new ObjectInputStream (new ByteArrayInputStream( recvPack.getData())) ; Object obj = inz.readObject() ; System.out.println(obj) ; inz.close() ; }// for } } catch (Exception exc ) { System.err.println(exc) ; } finally { if ( socket != null) { try{ socket.leaveGroup(adrGroupe) ; } catch (IOException exc) {} } } } }

7/137

7/138
Rappels:
Objectifs
RMI
LAPI dinvocation de mthodes distance (RMI) permet dcrire un code qui accde aux objets distants comme si ctait des objets locaux.
le prsent chapitre constitue une introduction RMI
8
Bibliographie
Certaines parties de ce module sont extraites de :
The Java Remote Method Invocation Specication disponible sur http://chatsubo.javasoft.com/current/doc/rmi-spec/ rmi-spec.ps
Java RMI Tutorial disponible sur http://chatsubo.javasoft.com/current/doc/tutorial/ rmi-getstart.ps
Frequently Asked Questions, RMI and Object Serialization disponible sur http://chatsubo.javasoft.com/current/faq.html
Rappels: RMI
8/140
8
Fonction de larchitecture RMI en Java
Ralisation
Client Application Stub rmic(compiler)
Class
Serveur Object Implementation Skeleton
Method call Method Results
L API RMI contient une srie de classes et dinterfaces permettant au dveloppeur dappeler des objets distants, dj existants dans une application sexcutant sur une autre machine virtuelle Java (JVM). Cette JVM distante ou serveur peut tre excute sur la mme machine ou sur une machine entirement diffrente du client RMI. Larchitecture RMI en Java est un mcanisme utilisant uniquement le langage Java.
Rappels: RMI
8/141
8
Packages et hirarchies RMI
Package java.rmi
java.lang.SecurityManager java.lang.Object java.io.IOException
RMISecurityManager
Naming
RemoteException*
Lgende
Remote
Classe Classe extraite Interface
*Bien quil existe davantage dexceptions dans les packages java.rmi et java.rmi.server , RemoteException est lexception que vous rencontrerez le plus frquemment.
Etend Implante
Naming Cette classe nale est utilise par les clients et serveurs RMI pour communiquer avec un aiguilleur appel Registre des noms (Registry) et situ sur la machine serveur. Lapplication serveur utilise les mthodes bind et rebind pour enregistrer ses implantations dobjets auprs du Registre, alors que le programme client utilise la mthode lookup de cette classe pour obtenir une rfrence vers un objet distant. Remote Cette interface doit tre tendue par toutes les interfaces client qui seront utilises pour accder aux implantations dobjets distants. RemoteException Cette exception doit tre gnre par toute mthode dclare dans des interfaces et des classes de ralisation distantes. Tous les codes client doivent donc naturellement tre crits pour traiter cette exception. RMISecurityManager Cette classe permet aux applications locales et distantes daccder aux classes et aux interfaces RMI.
Rappels: RMI
8/142
8
Package java.rmi.server
java.lang.Object
Operation
LoaderHandler
RMIClassLoader
ObjID
RMISocketFactory java.rmi.Remote RemoteObject
UID java.io.Serializable
RemoteStub
RemoteServer
java.io.PrintStream
UnicastRemoteObject RemoteCall RMIFailureHandler

Lgende
LogStream
Skeleton Unreferenced java.io.Externalizable RemoteRef
Classe Classe extraite Interface Etend
ServerRef
Implante
Rappels: RMI
8/143
8
Package java.rmi.server (suite)
RMIClassLoader ClassLoader sert charger les stubs (talons) et les skeletons dobjets distants, ainsi que les classes des arguments et les valeurs retournes par les appels de mthodes distance. Lorsque RMIClassloader tente de charger des classes partir du rseau, une exception est gnre si aucun gestionnaire de scurit nest install. UnicastRemoteObject Classe parent de chaque classe distante en RMI
Rappels: RMI
8/144
8
Cration dune application RMI
Server Open an account Account Manager Creates Account Instance Get current balance Deposit money Withdraw money Client
Exemple bancaire
Pour illustrer lutilisation de linvocation RMI, nous allons tudier lexemple simple dune banque dans laquelle on va ouvrir un compte. Les comptes sont contrls par un employ de banque : le gestionnaire de comptes. Aprs avoir ouvert un compte, on peut y dposer ou en retirer de largent et vrier le solde.
Rappels: RMI
8/145
8
Interfaces bancaires
Si on tente de modliser ce problme en utilisant linvocation RMI, on peut crer deux interfaces Java du type suivant :
Account.java package rmi.bank; interface Account extends Remote { public float getBalance (); public void withdraw (float money); public void deposit (float money); }
AccountManager.java package rmi.bank; interface AccountManager extends Remote { public Account open (String name, float startingBalance); }
Rappels: RMI
8/146
8
Interfaces bancaires (suite)
Il est noter que ces interfaces sont conues de sorte que lon utilise linterface AccountManager pour gnrer une instance dun objet Account. AccountManager est charg de retourner linstance courante dun objet Account si le compte existe dj. Cette approche de la cration dobjet est un type de conception dni dans la mthodologie de programmation par une mthode appele Gnrateur (Factory).1 Ce "Gnrateur" permet un objet de contrler la cration dautres objets et, dans le cas considr, il sagit de la solution idale car le gestionnaire de comptes (AccountManager) doit contrler la cration de nouveaux comptes. Si lon se rendait dans la banque et on tentait douvrir un autre compte, on rpondrait Vous possdez dj un compte dans notre tablissement. Utilisez-le.
1.
Design Patterns - Elements of Reusable Object-Oriented Software par Gamma, Helm, Johnson et Vlissides (Editions Addison-Wesley, 1995)
Rappels: RMI
8/147
8
BankClient.java Account.java (interface) AccountManager.java (interface) %java BankClient BankServer.java AccountManagerImpl.java AccountImpl.java Account %rmi registry& Instance %java BankServer
Procdure
Le processus permettant de crer une application accessible distance dans RMI est le suivant : 1. 2. 3. 4. 5. 6. 7. 8. Dnir les objets distants utiliser sous forme dinterfaces Java. Crer des classes de ralisation pour les interfaces. Compiler linterface et les classes de ralisation. Crer des classes stubs et skeletons laide de la commande rmic sur les classes de ralisation. Crer une application serveur permettant de grer et de compiler les ralisations. Crer et compiler un client permettant daccder aux objets distants. Lancer rmiregistry et lapplication serveur. Tester le client.
Rappels: RMI
8/148
8
Interface Account
Lexemple suivant prsente linterface Account complte : // The Account interface // Methods for getting the account balance, depositing, and // withdrawing money package rmi.bank; import java.rmi.*; public interface Account extends Remote { // Get the account balance public float getBalance () throws RemoteException; // Deposit money to the account // throw an exception if the value // is 0 or a negative number public void deposit (float balance) throws BadMoneyException, RemoteException; // Withdraw money from the account //but throw an exception if the // amount of the withdrawal will exceed the account balance public void withdraw (float balance) throws BadMoneyException, RemoteException; } Linterface Account doit tendre java.rmi.Remote et tre dclare public an dtre rendue accessible distance (aux clients utilisant dautres JVM). Il est noter que toutes les mthodes gnrent une exception java.rmi.RemoteException. Cette exception apparat lorsque survient un problme daccs la mthode dun objet distant. Les mthodes de dpt et de retrait gnrent galement une exception BadMoneyException indiquant quune valeur ngative a t transmise pour un dpt, ou quune tentative de retrait suprieur au solde du compte a t effectue.
Rappels: RMI
8/149
8
Interface AccountManager
Linterface AccountManager complte inclut : // The Account Manager interface // Method for creating a new Account with the user's // name and initial account balance package rmi.bank; import java.rmi.*; public interface AccountManager extends Remote { public Account open (String name, float initialBalance) throws BadMoneyException, RemoteException; }
Rappels: RMI
8/150
8
ralisation de linterface Account AccountImpl
Linterface Account est ralise par une classe devant son tour implanter toutes les mthodes dnies dans Account et tendre UnicastRemoteObject. Par convention, pour les classes ralisant des contrats d interface RMI, le sufxe Impl sera ajout au nom du chier dinterface : // // // // // AccountImpl - Implementation of the Account interface This class is an instance of an Account and implements the balance, deposit and withdraw methods specified by the Account interface.
package rmi.bank; import java.rmi.*; import java.rmi.server.UnicastRemoteObject; public class AccountImpl extends UnicastRemoteObject implements Account { // The current balance of the account private float balance = 0; // Create a new account implementation with a new account balance public AccountImpl (float newBalance) throws RemoteException { balance = newBalance; }
Rappels: RMI
8/151
8
ralisation de linterface Account AccountImpl (suite)
// Methods implemented from Account // Return the current account balance public float getBalance () throws RemoteException { return balance; } // Deposit money into the account, // as long as it is a positive number public void deposit (float money) throws BadMoneyException, RemoteException { // Is the deposit amount a negative number? if (money < 0) { throw new BadMoneyException ("Attempt to deposit negative money!"); } else { balance += money; } } // Withdraw money from the account, up to the // value of the current account balance public void withdraw (float money) throws BadMoneyException, RemoteException { // Is the deposit amount a negative number? if (money < 0) { throw new BadMoneyException ("Attempt to deposit negative money!"); } else { // Is there sufficient money in the account? if ((balance - money) < 0) { throw new BadMoneyException ("Attempt to overdraw your account!"); } else { balance -= money; } } } }
Rappels: RMI
8/152
8
AccountManagerImpl
La classe AccountManagerImpl est charge de crer et denregistrer de nouveaux comptes (sous forme dobjets AccountImpl). Cette classe utilise un vecteur (Vector) permettant denregistrer les objets Account dans une classe de conteneurs appele AccountInfo, associe au nom du compte String. Cette classe utilitaire facilite la recherche dun objet Account existant. // AccountManagerImpl - Implementation of the AccountManager // interface // // This version of the AccountManager class stores all // instances of the Account(s) it creates in a Vector // object - if an account requested exists, it will // return that account. package rmi.bank; import java.util.Vector; import java.rmi.*; import java.rmi.server.UnicastRemoteObject; public class AccountManagerImpl extends UnicastRemoteObject implements AccountManager { // Local storage of account names private static Vector accounts = new Vector (); // This empty constructor is required to create an // instance of this class in the server public AccountManagerImpl () throws RemoteException { }
Rappels: RMI
8/153
8
AccountManagerImpl (suite)
// Implement method from AccountManager interface // Create an instance of an Account - if the account // name already exists, return that account instead // of creating a new one public Account open (String name, float initialBalance) throws BadMoneyException, RemoteException { AccountInfo a; // Check if this name is in the list already for (int i = 0; i < accounts.size(); i++) { a = (AccountInfo)accounts.elementAt(i); if (a.name.equals (name)) { return (a.account); } } // Check the initial account value... if (initialBalance < 0) { throw new BadMoneyException ("Negative initial balance!"); } // Store the new account a = new AccountInfo(); // Try to create a new account with the starting balance try { a.account = new AccountImpl (initialBalance); } catch (RemoteException e) { System.err.println ("Error opening account: " + e.getMessage()); throw (e); } a.name = name; accounts.addElement (a); // Return and instance of an AccountImpl object return (a.account); } }
Rappels: RMI
8/154
8
AccountManagerImpl
Classe de conteneurs
La classe de conteneurs AccountInfo est utilise par la classe AccountManagerImpl. // A container class for instance of Accounts // that is stored in the Vector object class AccountInfo { String name; AccountImpl account = null; }
Rappels: RMI
8/155
8
Compilation du code
Le chemin daccs aux classes est important pour la russite de lexcution du code RMI. Il est recommand denvisager lutilisation de loption -d du compilateur pour localiser les chiers de classes crs : %
javac -d classDirectory *.java
Dans lexemple de code ci-dessus, le rpertoire de package rmi/bank est cr dans le rpertoire courant.
Rappels: RMI
8/156
8
Utilisation de la commande rmic
Aprs compilation des classes de ralisation , vous devez crer les codes stub et skeleton permettant daccder aux classes de ralisation. Vous rappellerez les classes stubs utilises par le code client pour communiquer avec le code skeleton du serveur. La commande rmic crera des codes stub et skeleton partir des dnitions des interfaces et des classes de ralisation. Cette tape doit tre excute aprs compilation des classes de ralisation et avant excution de lapplication serveur. La syntaxe de la commande est la suivante : rmic [options] package.interfaceImpl ...
Exemple :
%
rmic -d classDirectory rmi.bank.AccountManagerImpl \ rmi.bank.AccountImpl
Lexemple suivant crera quatre classes supplmentaires dans le rpertoire rmi/bank (package) : AccountImpl_Skel.class AccountImpl_Stub.class AccountManagerImpl_Skel.class AccountManagerImpl_Stub.class
Rappels: RMI
8/157
8
Application BankServer
BankServer gre lobjet AccountManagerImpl. Son unique fonction consiste fournir une instance AccountManager tout client demandeur. // BankServer - This class is run on the RMI server // and is responsible for registering the AccountManager // implementation. package rmi.bank; import java.rmi.*; public class BankServer { public static void main(String args[]) { // Create and install the security manager System.setSecurityManager(new RMISecurityManager()); try { // Create the object instance for registration System.out.println ("BankServer.main: creating an AccountManagerImpl"); AccountManagerImpl acm = new AccountManagerImpl (); // Bind the object instance to the registry System.out.println ("BankServer.main: bind it to a name: bankManager"); Naming.rebind("bankManager", acm); System.out.println("bankManager Server ready."); } catch (Exception e) { System.out.println ("BankServer.main: an exception occurred: " + e.getMessage()); e.printStackTrace(); } } }
Rappels: RMI
8/158
8
Application BankServer (suite)
Le serveur publie linstance de lobjet AccountManagerImpl en associant cet objet un nom stock dans une application daiguillage rmiregistry. Laffectation seffectue la ligne 23 du programme prcdent Naming.rebind("bankManager", acm); par le biais de la mthode rebind de la classe java.rmi.Naming. Cette mthode associe ou affecte le nom bankManager lobjet acm, en supprimant tout objet prcdemment affect ce nom dans le Registre. La classe Naming fournit deux mthodes permettant au dveloppeur denregistrer une ralisation, bind et rebind, la seule diffrence rsidant dans le fait que la mthode bind gnrera une exception java.rmi.AlreadyBoundException si un autre objet a dj t enregistr sur ce serveur, laide du nom transmis la mthode en tant que premier argument. Les arguments daffectation et de raffectation se prsentent sous forme de chane de type URL contenant le nom dinstance de ralisation dobjet. La chane URL doit respecter le format rmi://host:port/name o rmi dsigne le protocole, host est le nom du serveur RMI (qui devrait tre compatible DNS ou NIS+), port est le numro de port que le serveur doit couter pour les requtes, et name est le nom exact que les clients doivent utiliser dans les requtes Naming.lookup pour cet objet. Les valeurs par dfaut sont rmi pour le protocole, lhte local pour host 1099 pour port.
Rappels: RMI
8/159
8
Application rmiregistry
rmiregistry est une application fournissant un simple service daiguillage sur un nom. Lapplication BankServer fournit lapplication rmiregistry la rfrence dobjet et un nom string par le biais de lappel de mthode rebind. Lapplication rmiregistry doit tre excute avant que lapplication BankServer ne tente laffectation : % %
rmiregistry & java rmi.bank.BankServer &
Les proprits peuvent tre dnies pour la machine JVM du serveur RMI dans la ligne de commande :
java.rmi.server.codebase Cet URL indique lemplacement o les clients peuvent tlcharger les classes. java.rmi.server.logCalls Si la valeur retourne est vraie, le serveur consigne les appels dans stderr. La valeur par dfaut est faux.
java -Djava.rmi.server.logCalls=true rmi.bank.BankServer &
Aprs exportation de la ralisation par le Registre, le client peut expdier une chane URL pour demander ce que lapplication rmiregistry fournisse une rfrence de lobjet distant. La recherche seffectue par le biais dun appel client de Naming.lookup, en transmettant une chane URL sous forme dargument : rmi://host:port/name La page suivante prsente la recherche utilise par lapplication client.
Rappels: RMI
8/160
8
Application BankClient
Lapplication BankClient tente de localiser un objet AccountManager en effectuant une recherche laide dun aiguilleur (Registry). Cet aiguilleur se situe dans host:port dans la chane URL transmise la mthode Naming.lookup(). Lobjet retourn est vu (converti par cast) comme un gestionnaire de compte (AccountManager) et peut servir ouvrir un compte avec un nom et lancer le calcul du solde. // BankClient - the test program for the Bank RMI example // // This class simply attempts to locate the "bankManager" // RMI object reference, then binds to it and opens an // instance to an AccountManager implementation at the // <server> location. // // Then it requests an Account with <name> and optionally, // an initial balance (for a new account). // // The class then tests the account by depositing and // withdrawing money and looking at the account balance. package rmi.bank; import java.rmi.*; public class BankClient { public static void main(String args[]) { // Check the argument count if (args.length < 2) { System.err.println ("Usage:"); System.err.println ("java BankClient <server> <account name> [initial balance]"); System.exit (1); } // Create and install the security manager System.setSecurityManager(new RMISecurityManager());
Rappels: RMI
8/161
8
Application BankClient (suite)
try { // Get the bank instance System.out.println ("BankClient: lookup bankManager"); String url = new String ("rmi://"+args[0]+"/bankManager"); AccountManager acm = (AccountManager)Naming.lookup(url); // Set the account balance, if passed as an argument float startBalance = 0.0f; if (args.length == 3) { Float F = Float.valueOf(args[2]); startBalance = F.floatValue(); } // Get an account (either new or existing) Account account = acm.open (args[1], startBalance); // Now do some stuff with the remote object implementation System.out.println ("BankClient: current balance is: " + account.getBalance ()); System.out.println ("BankClient: withdraw 50.00"); account.withdraw (50.00f); System.out.println ("BankClient: current balance is: " + account.getBalance ()); System.out.println ("BankClient: deposit 100.00"); account.deposit (100.00f); System.out.println ("BankClient: current balance is: " + account.getBalance ()); System.out.println ("BankClient: deposit 25.00"); account.deposit (25.00f); System.out.println ("BankClient: current balance is: " + account.getBalance ());
Rappels: RMI
8/162
8
} catch (Exception e) { System.err.println("BankClient: an exception occurred: " + e.getMessage()); e.printStackTrace(); } System.exit(1); } }
Rappels: RMI
8/163
8
Application BankClient (suite)
Aprs avoir ouvert un compte, lapplication BankClient excute les oprations simples de dpt et de retrait. Cette classe pourrait (et devrait probablement) possder une interface interactive qui permettrait au client de saisir le nom du compte, puis deffectuer un retrait ou un dpt.
Excution de lapplication BankClient

Lapplication BankClient peut tre excute partir de tout hte autoris accder au Registre et au package contenant les chiers de classes de lapplication client, des stubs et des interfaces.
Rappels: RMI
8/164
8
Excution de lapplication BankClient
Syntaxe
java rmi.bank.BankClient hostname accountName initialBalance
Exemples
% java rmi.bank.BankClient mach1 fred 1000 BankClient: lookup bankManager BankClient: current balance is: 1000.0 BankClient: withdraw 50.00 BankClient: current balance is: 950.0 BankClient: deposit 100.00 BankClient: current balance is: 1050.0 BankClient: deposit 25.00 BankClient: current balance is: 1075.0 Il est noter que lobjet distant AccountManagerImpl situ sur le serveur, enregistre linstance du compte cr avec le nom fred. Par consquent, la rexcution de lapplication BankClient avec le mme nom de compte utilisera le mme objet : % java rmi.bank.BankClient mach1 fred BankClient: lookup bankManager BankClient: current balance is: BankClient: withdraw 50.00 BankClient: current balance is: BankClient: deposit 100.00 BankClient: current balance is: BankClient: deposit 25.00 BankClient: current balance is:
1075.0 1025.0 1125.0 1150.0
Rappels: RMI
8/165
8
Scurit RMI
Chargement de classe
Pour utiliser RMIClassLoader, un gestionnaire de scurit doit dj exister an de sassurer que les classes charges partir du rseau satisfont aux critres standard de scurit Java. Si aucun gestionnaire nest en place, lapplication ne peut pas charger les classes partir dhtes distants.
Ct serveur RMI
Lors de lenvoi de la commande java permettant dappeler la machine JVM ct serveur, il est possible de dnir deux proprits (dont lune des deux a t prcdemment voque dans ce module) pour dterminer lemplacement des classes RMI :
java.rmi.server.codebase Cet URL indique lemplacement partir duquel les clients peuvent tlcharger les classes et indique que le serveur peut, si ncessaire, charger des classes partir des URL du client. java.rmi.server.useCodebaseOnly Si la valeur retourne est vrai, le chargement de classes partir des URL du client est dsactiv.
Rappels: RMI
8/166
8
Scurit RMI
Chargement de classe
Ct client RMI
Si le programme client RMI est une applet, son gestionnaire de scurit (SecurityManager) et son chargeur de classe (ClassLoader) sont mandats par le browser ct client. Cependant, si le programme client est une application, les seules classes qui seraient tlcharges partir du serveur RMI seraient les dnitions dinterfaces distantes, les classes stubs , les classes darguments tendues et les valeurs retournes par les appels de mthodes distants. Si une application client tente de charger des classes supplmentaires partir du serveur, elle peut utiliser RMIClassLoader.loadClass, en fournissant comme paramtres les mmes URL et identicateur que ceux transmis dans Naming.lookup.
Invocation RMI au travers dun coupe-feu

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

Objectifs
Ce chapitre 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++.
9
Pourquoi raliser du code natif?
Il y a des situations dans laquelle le code ne peut pas tre compltement crit en JAVA :
Une grande quantit de code compil existe dja et fonctionne de manire satisfaisante. La fourniture dune interface avec JAVA peut tre plus intressante quune rcriture complte. Une application doit utiliser des services non fournis par JAVA (et en particulier pour exploiter des spcicits de la plateforme dexcution. Exemple : accs des cartes). Le systme JAVA nest pas assez rapide pour des applications critiques et la ralisation dans un code natif serait plus efciente.
Il est possible dimplanter en JAVA des mthodes natives ralises typiquement en C ou C++. Une classe comprenant des mthodes natives ne peut pas tre tlcharge au travers du rseau de manire standard: il faudrait que le serveur ait connaissance des spcicits de la plate-forme du client. De plus une telle classe ne peut faire appel aux services de scurit de JAVA (en 1.1) Bien entendu pour toute application JAVA qui sappuie sur des composants natifs on doit raliser un portage du code natif sur chaque plate-forme spcique. De plus cest un code potentiellement plus fragile puisque les contrles (pointeurs, taille, etc.) et la rcupration derreurs sont entirement sous la responsabilit du programmeur. Il existe diverses manires dassurer cette liaison code compil-Java. Depuis la version JAVA 1.1 le protocole JNI a t dni pour rendre cette adaptation plus facilement indpendante de la ralisation de la machine virtuelle sous-jacente. Dautre part il est galement possible dexcuter du code JAVA au sein dune application crite en C/C++ en appelant directement la machine virtuelle ( JAVA "enchass" dans C).

9/170
9
un exemple : "Hello World" en C
rsum des phases :
Ecriture du code JAV A:
Cration dune classe "HelloWorld" qui dclare une mthode (statique) native.
Cration des binaires JAV A 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.

9/171
9
Ecriture du code JAV A
Le code de lexemple dnit une classe JAVA nomme "HelloWorld" et faisant partie du package "hi". package hi ; class HelloWorld { static { System.loadLibrary("hello"); } public static native String getGreetings(); public static void main (String[] tArgs) { for (int ix = 0 ; ix < tArgs.length; ix++) { System.out.println(getGreetings() + tArgs[ix]) ; } }// main } Cette classe pourrait contenir galement dautres dnitions plus classiques (champs, mthodes, etc.). On remarquera ici :
La prsence dun bloc de code static excut au moment du chargement de la classe. A ce moment il provoque alors le chargement dune bibliothque dynamique contenant le code excutable natif li la classe. Le systme utilise un moyen standard (mais spcique la plate-forme) pour faire correspondre le nom "hello" un nom de bibliothque ( "libhello.so" sur Solaris, "hello.dll" sur Windows,...) La dnition dun en-tte de mthode native. Une mthode marque native ne dispose pas de corps. Comme pour une mthode abstract le reste de la "signature" de la mthode (arguments, rsultat,...) doit tre spci. (ici la mthode est static mais on peut, bien sr, crer des mthodes dinstance qui soient natives).

9/172
9
Cration des binaires JAV A de 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 sousrpertoire "hi" du rpertoire cibl par loption "-d"

9/173
9
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).

9/174
9
Ecriture du code natif
En reprenant les prototypes dnis dans le chier dinclusion on peut dnir un chier source C : "hi_HelloWorldImp.c" : #include <jni.h> #include "hi_HelloWorld.h" /* * Class: hi_HelloWorld * Method: getGreetings * Signature: ()Ljava/lang/String; * on a une methode statique et cest la classe * qui est passe en paramtre */ JNIEXPORT jstring JNICALL Java_hi_HelloWorld_getGreetings (JNIEnv * env , jclass curclass) { return (*env)->NewStringUTF(env, "Hello "); }
env nous fournit une fonction NewStringUTF qui nous permet de gnrer une chane JAVA partir dune chane C. NOTA : en C++ les fonctions JNI sont "inline" et le code scrirait : JNIEXPORT jstring JNICALL Java_hi_HelloWorld_getGreetings (JNIEnv * env , jclass curclass) { return env->NewStringUTF("Hello "); }

9/175
9
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

9/176
9
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)

9/177
9
prsentation de JNI
JNI est une API de programmation apparue partir de la version 1.1 de JAVA. Il existait auparavant dautres manires de raliser des mthodes natives. Bien que ces autres APIs soient toujours accessibles elles prsentent quelques inconvnients en particulier parce quelles accdent aux champs des classes JAVA comme des membres de strcutures C (ce qui oblige recompiler le code quand on change de machine virtuelle) ou parcequelles posent quelques problmes aux glaneurs de mmoire (garbage collector). Les fonctions de JNI sont adressables au travers dun environnement (pointeur dinterface vers un tableau de fonctions) spcique un thread. Cest la machine virtuelle elle mme qui passe la ralisation concrte de ce tableau de fonctions et on assure ainsi la compatibilit binaire des codes natifs quel que soit la machine virtuelle effective. Les fonctions proposes permettent en particulier de :
Crer, consulter, mettre jour des objets JAVA, (et oprer sur leurs verrous). Oprer avec des types natifs JAVA. Appeler des mthodes JAVA Manipuler des exceptions Charger des classes et inspecter leur contenu
Le point le plus dlicat dans ce partage de donnes entre C et JAVA et celui du glaneur de mmoire (garbage collector): il faut se protger contre des drfrencements dobjets ou contre des effets de compactage en mmoire (dplacements dadresses provoqus par gc), mais il faut savoir aussi faciliter le travail du glaneur pour recuprer de la mmoire.

9/178
9
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

9/179
9
La mthode native getMess(int nb, String mess) gnre un tableau de chanes contenant "nb" fois le mme message "mess" : /* Class: hi_Uni * Method: getMess * Signature: (ILjava/lang/String;)[Ljava/lang/String; */ JNIEXPORT jobjectArray JNICALL Java_hi_Uni_getMess (JNIEnv * env , jobject curInstance, jint nb , jstring chaine) { /* quelle est la classe de String ? */ jclass stringClass = (*env)->FindClass(env, "java/lang/String") ; /* un tableau de "nb" objet de type "stringClass" * chaque element est initialise a "chaine" */ return (*env)->NewObjectArray(env, (jsize)nb,stringClass,chaine) ; }
La fonction NewObjectArray est une des fonctions de cration dobjets JAVA. Elle doit connatre le type de ses composants (ici fourni par "stringClass"). Linitialisation de chaque membre dun tel tableau se fait par laccesseur SetObjectArrayElement() - mais ici on prote du paramtre dinitialisation par dfautJNI fournit des types C prdnis pour reprsenter des types primitifs JAVA (jint) ou pour des types objets (jobject, jstring,..) La fonction FindClass permet dinitialiser le bon paramtre dsignant la classe "java.lang.String" (la notation utilise le sparateur "/"!). Noter galement la reprsentation de la signature de la fonction "getMess": (ILjava/lang/String;) indique un premier paramtre de type int (symbolis par la lettre I) suivi dun objet (lettre L+ type + ; ) . De mme [Ljava/lang/String; dsigne un rsultat qui est un tableau une dimension (lettre [) contenant des chanes.

9/180
9
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

9/181
9
rfrences sur des objets JAV A:
Le passage du glaneur de mmoire sur des objets JAVA pourrait avoir pour effet de rendre leur rfrence invalide ou de les dplacer en mmoire. Les refrences dobjet JAVA transmises dans les transitions vers le code natif sont protges contre les invalidations (elles redeviennent rcuprables la sortie du code natif). Toutefois JNI autorise le programmeur explicitement rendre une rfrence locale rcuprable. Inversement il peut aussi se livrer des oprations de "punaisage" (pinning) lorsque, pour des raisons de performances, il veut pouvoir accder directement une zone mmoire protge : const char * str = (*env)->GetStringUTFChars(env, javaString,0) ; .... /* oprations sur "str" */ (*env)->ReleaseStringUTFChars(env, javaString, str) ; Des techniques analogues existent pour les tableaux de scalaires primitifs (int, oat, etc.). Bien entendu il est essentiel que le programmeur C libre ensuite la mmoire ainsi gele. Si on veut viter de bloquer entirement un tableau alors quon veut oprer sur une portion de ce tableau , on peut utiliser des fonctions comme : void GetIntArrayRegion(JNIenv* env, jintArray tableau, jsize debut, jsize taille, jint * buffer) ; void SetIntArrayRegion(.... Le programmeur a aussi la possibilit de crer des refrences globales sur des objets JAVA. De telles rfrences ne sont pas rcuprables par le glaneur la sortie du code natif, elles peuvent tre utilises par plusieurs fonctions implantant des mthodes natives. Ici aussi il est de la responsabilit du programmeur de librer ces rfrences globales.

9/182
9
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); } ...

9/183
9
invocation de JAV A dans du C
/*lanceur.c * usage : lanceur <classe_JAVA_en_format_/> <args> */ JavaVM *jvm ; JNIEnv * env; JDK1_1InitArgs vm_args ; /* 1.2 : JavaVMInitArgs */ main(argc, argv) int argc; char ** argv; { int cnt ; jint res ; jclass mainclass ; jmethodID methodID; jobjectArray jargs ; /* ici controles de lancement a faire */ .... /* initialisation des champs de vm_args ATTENTION*/ vm_args.version = 0x00010001 ; /* CHANGE en 1.2 ! */ /* appel obsolete en JAVA 1.2 */ res = JNI_GetDefaultJavaVMInitArgs(&vm_args) ; /* APPEL OBSOLETE (non portable). CHANGE en 1.2 */ vm_args.classpath = getenv("CLASSPATH"); if (0> JNI_CreateJavaVM(&jvm, &env, &vm_args))exit(1) ; if (!(mainclass= (*env)->FindClass(env,argv[1]))) exit(1); if(!(methodID= (*env)->GetStaticMethodID(env,mainclass, "main","([Ljava/lang/String;)V")))exit(2); .... jargs = (*env)->NewObjectArray(env,(jsize)(argc-2), (*env)->FindClass(env,"java/lang/String"), NULL) ; for (cnt = 0 ; cnt < (argc - 2) ; cnt++) { jobject stringObj = (*env)->NewStringUTF(env, argv[cnt+2]); (*env)->SetObjectArrayElement(env, jargs,(jsize)cnt,stringObj); } (*env)->CallStaticVoidMethod(env, mainclass, methodID, jargs) ; ..... (*jvm)->DestroyJavaVM(jvm) ; } Un tel code doit tre li la librairie binaire JAVA (libjava.so sous UNIX). La version de JAVA 1.2 introduit quelques modications (voir documentation).

9/184
Recommandations de programmation
Objectifs
10
Dans ce document nous avons rassembl quelques considrations sur la manire de coder en JAVA. Ces remarques sont faites pour guider vos recherches plutt que pour dicter des rgles intangibles. JAVA tant un langage neuf lessentiel des savoir-faires est encore en gestation.

organisation en "packages" conventions de codage portabilit performances traces, exceptions Le "bon" et le "beau" code les interactions graphiques la rpartition linternationalisation lintgration de code natif
10
Organisation des packages et des rpertoires
Ne pas dvelopper de classe sans quelle soit rattache un package. Un package regroupera un ensemble de classes relies par des objectifs communs. Linstruction "package XXXX ;" doit tre la premire dun chier ".java". Le package permet de crer un espace de nommage. Par exemple ont peut utiliser plusieurs classes "Rectangle" tant que chacune existe dans un package diffrent (et que lon sait lever les ambiguits en les dsignant dans le code). Il est recommand de prxer tous les packages dune socitt ou organisation par lidentication Internet de cette organisation. Exemple: soit la socit ACME (adresse "acme.com"); alors un package pourra se dclarer comme : package com.acme.finance.swap ; Bien que a ne soit pas strictement obligatoire il est vivement conseill de faire correspondre une hirarchie de rpertoires la hirarchie de packages. Exemple (sous Unix) : package projet1.package1; // dans Fichier.java javac projet1/package1/Fichier.java java projet1.package1.Fichier <APPLET code="projet1.package1.Applet2.class"... Autre ide dorganisation utile : sparer soigneusement la hirarchies des rpertoires contenant les sources ".java" des hirarchies contenant les chiers ".class"
avantages : permet de disposer de plusieurs types de chiers ".class" (avec debug, optimis, avec ou sans traces, etc.), permet de dvelopper et tester des modications pendant que les autres dveloppeurs utilisent lancienne version des classes, etc. inconvnients : demande une bonne matrise des CLASSPATH et du comportement du compilateur (en particulier au niveau de la recherche de mise jour des classes dpendantes)
ATTENTION : Au sein dune application le ClassLoader peut tre amen charger autre choses que des ".class" (par ex. des chiers de ressources -images, properties,etc.-) Ces ressources font partie des hirarchies de package et il faut sorganiser en consquence.
Recommandations de programmation 10/186
10
convention de codage
rfrences :
De nombreux sites (on constatera quil ny a pas unanimit sur les rgles suivre!), voir par ex: http://g.oswego.edu/dl/html/javaCodingStd.html
Identicateurs (conventions standard)

Classes et interfaces : MaClasse, MonInterface Constantes de Classe : MAX, MAX_SIZE Variables, mthodes : maVariable, maMethode()
Identicateurs (conseils complmentaires)
Eviter les caractres "_" et "$" au milieu des identicateurs (risques de confusion avec des identiants gnrs pour les classes internes ou les mthodes natives) Certaines conventions de nommage sont standard :
Conventions "Beans" (obligatoires pour permttre linstrospection) : Accesseurs (proprits), Proprits boolennes, Proprits indexes, mthodes sur vnements,.. // Accesseur simple public PropertyType getPropertyName() public void setPropertyName(PropertyType x) Conventions spciques aux mthodes natives
10/187
10
convention de codage (suite)
Nommage (conseils complmentaires)
Eviter les excs bureaucratiques : il est souhaitable que chaque nom soit facilement lisible et que lon comprenne lintention smantique qui lui est associ, par contre un excs de rgles formalises nest pas forcment un plus! Exemple: obliger les programmeurs mettre dans le nom une indication qui rappelle de type de lobjet est plutot gnant surtout si ce type est amen changer au cours du dveloppement-. Nommage des Exceptions : ToutVaMalException ; Lemploi de variables nommes "i", "j", "x", "p" etc. namliore pas la lisibilit. De plus avec la plupart des diteurs la recherche des endroit o ces variables sont employes peut savrer difcile! (prfrer alors "iy", "ix", etc.) En RMI marquer nettement les objets qui sont des rfrences distantes en leur attribuant des noms signicatifs : ex: remoteQqch
10/188
10
convention de codage (suite)
Mise en page
Mettre en place des rgles cohrentes de mise en page :
// alignements des accolades public void maMethode(int arg) { //indentations internes correctes ... }//End maMethode if ( cestVrai ) { // on met les accolades // mme pour une seule instruction }
Rendre lisibles les sources : limiter le nombre de caractres par ligne (et xer des rgles de continuation sur la ligne suivante), penser des rgles de prsentation des commentaires, etc. Penser crire des squelettes standard de chiers pour Classes, Applets, etc. de nombreux diteurs savent utiliser de tels modles. Attention : certains diteurs (Emacs par ex.) font de lanalyse du code non par analyse syntaxique mais par "pattern-matching", le non-respect de certains rgles peut perturber la mise en page automatique du code. Pour harmoniser la description de types (voir remarque ci-dessus) prfrer la notation : String[] args String args[] ; // pour les nostalgiques du C! Autre rappel aux nostalgiques du langage C : il nest pas ncessaire de concentrer toutes les dclarations de variables locales en dbut de bloc. On peut dclarer la variable le plus prs possible de lendroit o on lutilise -dcision prendre en fonction de critres de maintenabilit-.
10/189
10
portabilit
rfrences :
http://java.sun.com/100percent/ "Write once, run everywhere" tel est le slogan de JAVA. Si la portabilit est un des points forts de JAVA elle nest pas entirement automatique: il est parfaitement possible dcrire des programmes non-portables! On trouvera en n de ce support une copie dun document en Anglais dcrivant les principales prcautions prendre pour viter dcrire du code non-portable. Plus important encore: un Label "100%" JAVA peut tre accord aux produits que vous dveloppez. Une autre difcult peut surgir lorsque JAVA volue et que les nouveaux codes ne sont pas totalement compatibles avec les anciens. Ainsi le passage de la version 1.0 de JAVA la version 1.1 a donn lieu de nombreux problmes dadaptation des Applets puisque des Applets publies sur le WEB pouvaient tre mis en oeuvre par des clients ayant des niveaux diffrents de JAVA. Le site java.sun.com publie les techniques pratiques concernant de telles mises jour. Mme si elles donnent lieu quelques rcriminations ces modications sont aussi une garantie dvolution et de recherche de qualit! Pour ce qui est de la mise jour des navigateurs voir JAVA PLUGIN (module de mise jour des JVM lies au navigateurs)
10/190
10
performances
rfrences :
Ici aussi de nombreux sites parlent des optimisations JAVA. par ex: http://www.cs.cmu.edu/~jch/java/optimization.html ou les articles spcialiss dans "JavaWorld"
Il y a de trs nombreuses "recettes" pour des optimisations de dtail (de plus ceci peut varier en fonction des compilateurs et des JVM). Quelques constantes :
Lopration "new" cote cher. Penser rutiliser directement les objets dont vous navez plus besoin. Toutefois ceci peut rentrer en contradiction avec une architecture comprenant des variables membres qui sont "nal" (il y a donc des choix faire). On peut aider le glaneur de mmoire (garbage collector) en mettant explicitement des rfrences null ( par exemple pour des membres inutiliss dun tableau). Lexploitation des moniteurs (synchronized,..) cote trs cher.A utiliser avec modration (en particulier dans les classes utilitaires de "bas niveau"). Pour des cas extrmes de performances dans les Threads lutilisation de bibliothques de Threads natifs permet lutilisation des architectures multi-processeurs. Le problme numero 1 des performances est celui de la complexit cache : combiner laction des plusieurs composants de haut niveau avec une encapsulation parfaite conduit parfois ce que chacun fasse plusieurs fois le mme travail de son cot. La dtection de ces anomalies est particulirement ardue si on fait collaborer plusieurs composants pour lesquels on na pas accs au code. Attention donc lusage indiscrimin de composants "gros consommateurs" Les classiques : faire des E/S bufferises, ne pas rcrire en JAVA ce qui existe dans les mthodes dAPI (ex. arraycopy()), conserver certaines valeurs utiles, etc.
10/191
10
traces, exceptions
Comment laisser dans les sources du code ddi aux traces sans que ce code soit toujours compil et inclus dans les excutables ? (Rappel: il ny a pas en JAVA de prprocesseur permettant des compilations conditionnelles) Solution : utiliser des variables boolennes static et nal (dont la valeur est connue au moment de la compilation), le code protg par une condition (if) pour laquelle le compilateur se rendra compte quelle est toujours fausse ne sera pas inclus dans le binaire. Exemple: if( Trace.DEBUG && (Trace.traceMask > 8)) { // code de trace }
La spcication des exceptions doit faire partie des spcications gnrales dun projet. On doit, ds le dpart, dnir les grandes lignes du traitement dexception pour que les programmeurs ne laissent pas le code correspondant dans un tat mal dni (qui nest jamais ensuite repris!). Quelques suggestions :
Dnir quelques classes dexceptions de base dont toutes les autres exceptions seront drives : on pourra ainsi mettre en place, en temps utile, des mcanismes adapts qui seront appels au moment du dclenchement de lexception. Ex. mettre en place une trace conditionnelle de la pile, etc. Dterminer quels appels de mthodes mettre en place au moment de la rcupration de lexception. On pourra ensuite mettre au point des rcuprations sophistiques. Il est en effet dommage de se contenter dcrire un message sur la sortie derreur standard alors quon peut, par exemple, faire parvenir lutilisateur un message simpli pendant que lon envoie (par mail) un message dtaill ladministrateur, ou lquipe de maintenance. Pour les applications grant des transactions critiques le mcanisme finally doit tre employ avec discernement : il faut que toute opration de terminaison soit sans effet si elle est sans objet (exemple: envoyer un close ne fait rien si open na pas t appel)
10
le "bon " et le "beau" code ?
Il est ici hors de question de dnir ce qui caractrise un "bon" code, de plus il ny a pas encore de consensus sur ce que sont dune part les constructions potentiellement dangereuses et dautre part ce qui caractrise un code bien architectur en terme dvolutivit, lisibilit, etc. Toutefois une quipe de dveloppement JAVA se doit de tenir jour un registre des savoir-faires et den discuter la pertinence lors des revues de code. Quelques exemples de constructions documenter :
La rednition dune variable dinstance dans un hritage (datahiding): produit en gnral des effets non-vidents Dans une surcharge de mthode la dnition de deux mthodes qui diffrent simplement du fait de types objet situs dans la mme hirarchie risque de produire des effets indsirables. methode(Pere x) { .... } methode(Fils x) {.... } ; Appels de mthodes dans un constructeur: contrler de prs. En effet on doit, dans un constructeur, se limiter raliser des initialisations. Lancer des traitements peut se rvler hasardeux car lobjet peut tre dans un tat incomplet (par exemple on va appeler une mthode rednie dans le ls alors que lon est dans linitialisation de "super"). Le problme est particulirement dlicat dans AWT o lon peut tre tent de tout dcrire dans le constructeur dun Frame par ex. Il est donc de bon ton de doter ce Frame dune mthode appele init(), ou go() ou autre et qui soit explicitement appele aprs les initialisations minimum du constructeur -cette mthode contiendra lessentiel du code qui sera en attente dinteractions-.
10/193
10
Documenter particulirement les objets qui peuvent servir de support une opration synchronized ou un wait. Il serait dommage que, par inadvertance, un programmeur oublie de synchroniser dautres accs. Par ailleurs veiller mettre un wait dans une boucle retestant la condition (on nest pas sr au reveil que cette condition soit remplie). Faire attention aux inter-blocages : ne pas utiliser suspend/resume et prferer notifyAll. Eviter les effets de bord par modication du contenu dobjets passs en paramtre une mthode. Si une mthode doit modier ltat dun de ses paramtres il vaut mieux quil soit rendu en rsultat. Outre le fait que ce comportement est considr comme thoriquement malsain, il va tre gnant si cette mthode connait une ralisation via RMI. De mme documenter la non-utilisation dun rsultat de mthode : Object inutilis = maMethode(ix) ; Il est possible que lemploi dun == entre objets et dun = dans un test ne corresponde pas lintention du programmeur. Dans un cas cest souvent un obj1.equals(obj2) qui est recherch , dans lautre cest un == (le compilateur va dailleurs le dtecter sauf si on tente dcrire des expressions comme " if (cond == true)" au lieu de "if (cond)" ) Autant que possible initialiser explicitement les variables membres class MaClasse { Vector vect = new Vector() ; // sinon risques en accdant vect Bien quune Applet soit un Panel son utilisation dans une application autonome (ou dans une autre Applet) demande des prcautions trs particulires. En effet de nombreux services (getDocumentBase, getImage, etc.) dpendent de la prsence de AppletStub et AppletContext. Penser linternationalisation. En AWT ne pas baser le comportement du programme sur une valeur en dur dune tiquette : passer par setActionCommand(), setName(),... pour distinguer les noms symboliques des composants et des actions associes de leur tiquette afche.
10/194
10
le "bon " et le "beau" code ?
Quelques autres thmes de discussion :
Importer explicitement une classe dun package plutt que dimporter avec "import pack.* ; " Un main de test peut accompagner chaque classe ayant une fonction bien dlimite. Pour des points dentre dapplication faire une classe part pour le main. Choix concernant lencapsulation : prfrer protected private; ne pas dnir systmatiquement des accesseurs quand des membres "blank nal" (constantes en attente dinitialisation) sufraient: final String clef ; // initialise dans constructeur Pour les classes destines connatre une instanciation dynamique faut-il systmatiquement dnir un constructeur sans argument -appelable par newInstance()- doubl dune mthode dinitialisation des champs, ou prvoir de faire appel la classe Constructor? Dans le premier cas on bncie de contrles au moment de la compilation mais on ne peut pas toujours tout faire.
Un des points critiques du "beau" code : la programmation AWT. Le dbutant a souvent tendance crer un code mal architectur : il est difcile de "voir" la dispositon et de la faire voluer. Le codage demande donc de gros efforts de discipline :
Ne pas disperser les rfrences un objet graphique sur lensemble du code. On cre un Container, on dispose son contenu et ceci rcursivement dans la hirarchie des Containers. Ceci suppose que lon cre des blocs de code (ou des mthodes) qui isolent chaque lment architectural de la disposition. Ce dcoupage demande beaucoup de soins car il faut savoir rapprocher les objets dinteractions des objets applicatifs : les points critiques sont alors la dnition des Listeners (utiliser plutt des classes internes qui ont accs aux donnes locales) et les objets graphiques qui doivent avoir accs aux donnes locales mais qui sont situs dans un autre zone de disposition (par ex. dans une barre doutils loigne du Panel local -il faut imaginer un change entre ce Panel et la barre doutils-)
10
Comparer les techniques employes dans ces deux exemples : // VERSION 1 public class ButtonPanel extends Panel { public ButtonPanel(Actor[] tAct) { super(new FlowLayout(FlowLayout.LEFT)) ; for (int ix = 0 ; ix < tAct.length; ix++) { Button but = new Button(tAct[ix].message) ; but.addActionListener(tAct[ix].act) ; add(but) ; } } //avec Actor {String message ;ActionListener act ;...}
//
VERSION
public class ButtonPanel2 extends Panel implements ActionListener{ Button b1, b2 ; public ButtonPanel2 () { super(new FlowLayout(FlowLayout.LEFT)) ; b1 = new Button ("Hello") ; b1.addActionListener(this) ; b2 = new Button ("World") ; b2.addActionListener(this) ; add(b1) ; add(b2) ; } public void actionPerformed (ActionEvent evt) { Object source = evt.getSource() ; if (source == b1) { // action sur b1 } else if (source == b2) { // action sur b2 } } }
10/196
10
les interactions graphiques
La conception visuelle dune interaction graphique est un vritable mtier qui fait appel des comptences diverses concernant lergonomie et le "design". Lobjectif peut se rsumer en un conseil particulirement difcile suivre : FAIRE SIMPLE! Quelques incitations ;
Eviter de prsenter trop de fonctions diverses sur un mme cran. Lutilisateur doit tre concentr sur un petit nombre dobjectifs. Dun autre cot il faut aussi viter de disperser les interactions sur une succession dcrans de saisie (lutilisateur ne sait plus se situer, et la navigation est trop directive). Eviter la dispersion visuelle (mme souci que prcdemment). Eviter les "papillotements" : objets graphiques disperss sans que des lignes de force apparaissent, contrastes graphiques fatigants, arrives dinformations ou animations intempestives. JAVA permet de faire de belles choses : protez-en! Sachez dpasser laspect "terminal de saisie grand systmes" (une succession de formulaires), laspect "tableau de bord davion" (des informations partout, sur un fond gris) mais nen faites pas trop tout de mme (certains designs trs "mode" sont saisissants pour vendre un produit mais insupportables pour une utilisation journalire) Connaissez le mtier de lutilisateur. On ne conoit pas de la mme manire une interaction sadressant un utilisateur novice (et qui doit favoriser lapprentissage) et une interaction pour un utilisateur professionnel. Un "trader" qui travaille veut aller trs vite et prfre souvent pouvoir se limiter quelques interactions clavier, il souhaitera quaprs chaque action le "focus" aille en priorit sur certaines zones, il souhaitera pouvoir congurer lui mme son poste pour en attendre certains comportements. Quelle personnalisations? Changer de police de caractres, changer les acclrateurs, changer de palettes de couleur (vaut mieux que de changer les couleurs trop librement),.. Pour un "trader" ce qui est critique cest la personnalisation de sa vision des cours et de leur volution, chacun a son truc et sa formule et sera mme prt crire un programme JAVA spcique! Protez donc de la dynamicit de JAVA pour dnir une API dextension...
10
rpartition
Un des points forts de JAVA est de permettre de diffuser du code "nomade" sur le rseau et de fournir tous les mcanismes de scurit associs cette excution dynamique et locale dun code "tranger". On peut utiliser des mcanismes prdnis comme celui des Applets, ou on peut , au travers de RMI par ex., tlcharger le comportement dun Objet et lutiliser dynamiquement . Un des choix fondamentaux de la rpartition en JAVA est bien celui des pralables : les partenaires dun change connaissent-ils avant lchange le dtail du comportement des objets? par exemple RMI connait deux mode de fonctionnement : un dans lequel les objets sont dnis de chaque cot (et lon change des instances), lautre dans lequel on dcouvre dynamiquement des objets nouveaux. A chaque type de comportement sont associs des savoir-faires spciques et des dcisions stratgiques importantes. Prenons le cas des Applets:
Avantages : pas de problme de dploiement, le code (et donc le protocole) est automatiquement jour (dans les systmes client/serveur classique lharmonisation des versions tourne au cauchemar); Les mcanismes de scurit sont pleinement actifs, cela permet de sadapter toute une gamme de clients plus ou moins "proches". Inconvnients : le tlchargement peut prendre du temps; les contraintes de scurit peuvent savrer trop contraignantes (impressions locales, communications avec dautre serveurs,...); le contrle dexcution au sein sein dun navigateur peut savrer insufsant pour certaines applications (on peut se retrouver avec une transaction incomplte parcequun utilisateur peut passer autre chose...) Au niveau graphique, il faut beaucoup de rexion pour dnir une interface qui dcouvre dynamiquement des objets (et qui soit de plus haut niveau que lAPI des Applet) .
10/198
10
rpartition (suite)
les protocoles
La dnition des protocoles doit permettre une volutivit maiximum: les actions lmentaires devraient tre dnies par des interfaces; les paramtres des mthodes devraient tre au maximum encapsuls (c.a.d. tre eux-mme des objets ou des interfaces); les objets passs doivent tenir compte des contraintes de linarisation et viter les effets de bord (tous les paramtres sont passs rellement en copie); dans les types en retour prvoir des extensions futures de code dacceptation.
// delicat a maintenir void creeClient(String nom, String id, String prenom); // plus evolutif Acceptation creeClient(Client client) throws CreationRightsException, UniqueIDException; // Acceptation peut contenir un certificat, un Objet // qui en loccurence p.e. un Client avec mise a jour // dun champ qui fixe un numero ce client
Veiller aux proprits de linarisation des objets (transient, etc.) pour viter de transfrer plus dinformations que ncessaire. Dnir le type de relation Client/Serveur :
protocole sans tat : le client tabli une connexion, fait un requte et la connexion est coupe. Le serveur ne conserve aucun contexte. session sans conservation de connexion : Le serveur mmorise lappel du client et lui conserve un contexte. session avec conservation de connexion : une connexion reste active pendant toute la dure du dialogue.
10/199
10
internationalisation
rfrences :
documentation JDK docs/guide/intl/index.html Comme pour le traitement des exceptions les mcanismes dinternationalisation dune application doivent tre arrts avant le dmarrage du codage (la rintroduction a posteriori de code dinternationalisation est pnible et trs facilement errone). Les objets de type java.util.Locale permettent de dsigner une "aire culturelle" (par ex. Franais sous-varit Canadienne). A partir de cette information il est possible de paramtriser des formats (formats de date, de nombre, etc.) et des oprations sur chanes (recherche de "mots", tri alphabtiques). Le package java.util.text offre aussi des outils permettant de paramtriser des dsignations (ex. dans un menu) et des messages (ex. messages derreur). Au fur et mesure que lon enrichira les aires culturelles pour lesquelles une application sera susceptible dtre intelligible, il faudra mettre jour des ressources contenant les versions localiss des messages ou des formats de message (c.a.d. des chanes de caractres contenant des emplacements pour des valeurs renseignes par le programme : montants, numros de ligne, etc.). Il faut donc organiser ces ressources en utilisant le mcanisme des java.util.ResourceBundle qui permet dorganiser des hirarchies de ressources : ainsi si une information nest pas spcique laire du Canadien Franais on la retrouvera dans laire du Franais. Un des choix fondamentaux est la manire dindexer les messages : faut-il oprer en passant par un nom symbolique ("erreur.securite.droit_creation") ou en utilisant directement le message comme clef de recherche? Ce second choix est plus facile pour le programmeur car il na pas attendre de dcision sur la dnition dun nouveau type derreur et peut tre immdiatement oprationnel pour des tests. Par contre il nest pas ralisable avec le mcanisme par dfaut (PropertyResourceBundle) et il peut conduire une dispersion des types derreurs. Il faut, de plus, construire un outil qui extraie (et qui maintienne) automatiquement la base des messages de lapplication. (NOTA: ceci nest plus vrai en 1.2, le message clef peut prendre nimporte quel aspect).
10/200
10
intgration des mthodes natives
Un code natif est potentiellement un point faible la fois pour la scurit et pour la robustesse gnrale de lapplication. Sur ce dernier point quelques "recettes" concernant JNI:
Toujours tester les rsultats de retour des fonctions dcouvrant dynamiquement des classes, attributs, mthodes,.. (FindClass, get*ID): lutilisation, par la suite, de dsignations JAVA inexistantes, est une garantie daccident grave. Vrier si une exception na pas a t leve chaque fois quune fonction dinterface appelle du code JAVA susceptible de dclencher un exception. Sauf pour des "petits" codes natifs penser protger lexcution par captation des signaux (y compris ceux signalant une violation mmoire grave) -voir fonctions standard C signal..-. Ne pas conserver des rfrences locales, ne pas les passer entre Threads, sassurer de lappariement des fonctions rservant des zones mmoires et de celles qui les librent (variables globales, "punaisage"). Utiliser le "punaisage" partiel pour de gros tableaux.
... et, bien entendu, isoler soigneusement tout code posant des problmes de portabilit (facilit de maintenance, de portage) ou des problmes de scurit (essayer davoir une politique cohrente de scurit avec le code JAVA lui-mme - partir de JAVA 1.2 on peut dnir une politique de scurit pour des applications "locales"-).
10/201
10
10/202
Latelier de dveloppement
Objectifs
11
Ce chapitre constitue un aide-mmoire1 pour la ralisation dune chane de production JAVA. On y trouvera :
Une liste des fonctions et des outils susceptibles de constituer une telle lire. Des indications sur les points surveiller. Ces critres ne sont pas extensifs mais peuvent servir de point de dpart des rexions sur le choix et le calibrage des outils.
Le march des outils JAVA voluant trs vite il est conseill de consulter les sites qui les recensent (par ex. javaworld)
1.
Ce chapitre ne dveloppe pas larchitecture gnrale dune chaine de dveloppement : on reste dans le contexte dun projet classique, les organisations adaptes lapproche par composants (CBSD) ncessitent des stratgies particulires. Rfrence gnrale consulter : http://www.sei.cmu.edu/technology/str
11
introduction : R.A.D et/ou matrise du code de base?
Le developpement logiciel est souvent dcrit comme passant phases suivantes :

par les
Analyse Conception Ralisation/codage Tests Rvisions
Toutefois si on tente de raliser ces phases les une aprs les autres tout en appliquant des rgles svres de qualit on court des risques importants de drive (volutions des besoins non prises en compte par la ralisation, difcults imprvues de ralisation qui obligent revoir la conception, etc.). Le cycle de dveloppement optimum est le plus souvent une "spirale" dans laquelle on procde par itrations successives. La ralisation dune maquette, puis de prototypes avec rafnements successifs permettent de rinjecter les leons de la ralisation dans lanalyse et la conception. Les tests, prsents dans toutes ces phases, permettent de calibrer le produit en prparation et de marquer de manire incontestable lavancement du projet (ce qui est ventuellement utile pour dbloquer des nancements!). Pour acclrer le cycle de dveloppement un certains nombres doutils, dits de R.A.D. (Rapid Application Development), permettent, au travers dinterfaces essentiellement interactives , dintgrer des composants spcialiss (interactions utilisateurs, accs aux bases de donnes, client/serveur, etc.). Au del de la grande diversit de ces produits il faut savoir apprcier leurs limites et savoir adapter la qualit de fabrication du code en fonction des moyens et des objectifs poursuivis: veut-on fabriquer un logiciel pour une diffusion restreinte ou pour une diffusion large? quelles sont les marges dadaptabilit que lon se xe? quels sont les objectifs de abilit ? etc.
11/204
11
introduction : au del du R.A.D?
Quelques critiques courantes concernant les outils de R.A.D :
On est tent de confondre "maquette" et "produit". De plus linteraction utilisateur EST lapplication : on tend conomiser sur la phase de conception ce qui est mauvais pour labstraction, larchitecture du logiciel, lvolutivit. La mise en place de tests systmatiques devient difcile. Loutil de R.A.D. est indissociablement li des composants "proprtaires" que ce soit dans la phase de conception ou dans la phase dexcution. Lenrichissement de la conception laide de composants dnis par le programmeur est limit. Par ailleurs le produit livr en clientle suppose souvent la prsence de binaires spciques (problmes de royalties, de portages, de maintenance,...). Dans dautres cas cest le code gnr qui est opaque et difcile debuguer et maintenir. De plus on ne peux pas avoir des composants interchangeagles qui permettraient de modier des dtails de comportement (ex. modalits dchanges client/serveur).
Une des grandes forces des environnements JAVA est de permettre de graduer le choix des outils et de les combiner en fonction des objectifs: le march offre des outils trs divers allant de la gnration rapide de maquettes jusqu la lire de production "lourde". On peut concevoir en JAVA un outil de RAD dbarrass des dfauts ci-dessus et le faire cooprer, en amont ou en aval, avec des lires de contrle troit du code. Il y a dans JAVA lui-mme des dispositifs qui facilitent la production du logiciel, citons pour exemple:
Lorganisation par "objets", la dynamicit, les APIs ("Beans" en particulier). On a la possibilit de dnir de vritables composants rutilisables (soit directement soit par drivation de composants existants). Les outils eux-mmes ont la possibilit dintgrer dynamiquement ces composants (ex. "beanbox"). La prise en compte des leons de la lire C/C++ : limination des constructions dangereuses, portabilit, liaisons codedocumentation, etc. Par ailleurs les outils de production JAVA protent des dmarches abordes dans ces lires prcdentes.
11/205
11
Lintgration des outils, les ateliers
Une chane de production professionnelle nest pas destine un seul acteur, elle doit impliquer des personnes ayant des rles diffrents depuis le programmeur jusquau chef de projet. Il est important que les outils impliqus dans les diffrentes phases puissent se coordonner facilement. De plus certaines tches sont purement interactives, dautres relvent au contraire de tches de fond en batch. Il est de pratique courante de lier les productions des diffrents outils au travers de scripts exploitant des chiers (sources, binaires, traces, etc.) et des rgles de dclenchement (Makele) Les "ateliers" de programmation, qui sont au centre de lactivit de production, doivent faire preuve dun minimum douverture soit en exportant leurs chiers et des rgles cohrentes daccs ces chiers, soit en publiant une API daccs leurs ressources. Les API daccs en JAVA devraient normallement connatre un fort dveloppement la fois pour assurer ces liaisons et pour permettre des personnalisations approfondies des outils. Exemple : de nombreux ateliers sous-traitent la partie "gestion de version" des produits tiers; la prsence dune API permet de changer le produit qui cette tche est cone.
11/206
11
analyse et conception
La notation UML va permettre dharmoniser le langage des descriptions des systmes dcrits laide des concepts objets. Si les outils danalyse et de conception sortent du cadre de ce cours on retiendra toutefois quils nchappent pas la ncessit dassurer une coordination avec lensemble du processus de production de logiciel. Le cas le plus dlicat est celui de la gnration automatique de code. Les squelettes de code gnrs sont amens tre complts et modis, le corps des mthodes va tre dcrit, etc. Il faut que soient facilits :

La reprise du code existant dans des spcications modies. La modication des spcications elles-mmes par reinjection des modications acquises dans le code. La liaison avec les systmes de gestion de version de code (tablissement de la version des spcications : voir java.lang.Package partir de la version 1.2)
11/207
11
Lditeur
Au del de qualits classiques dergonomie un diteur de programme source sera plus riche sil dispose :
dune connaissance de la structure des programmes JAVA. Lditeur peut reconnatre et mettre en valeur les "blocs" du langage et les zones rserves aux commentaires et Javadoc. Il peut ainsi permettre de vrier les appariements des accolades et des parenthses; il peut colorier de manire utile (et paramtrable!) les en-ttes de dclaration (classes et classes internes, constructeurs, mthodes, variables); il peut ltrer les zones que lon veut voir apparatre lcran (effets de "zoom" : visualisation du squelette du code, ltrages sur Javadoc); il dispose de "pretty-printing" avec colorisation et ltres; etc. Exemple : les diteurs de la famille Emacs permettent de reconnatre des structures et de programmer des comportements. dune connaissance du langage JAVA. On a une dition sous contrle qui prpare le travail du compilateur puisquon ne peut plus diter de syntaxe illgale. La connaissance des objets du programme facilite la compltion automatique ou assiste (quels sont les champs ou mthodes possibles pour cette instance?). dune laision aise avec dautres programmes : liens automatiques avec les messages derreur du compilateur; suivi des actions dun debugueur; liens avec un navigateur, un outil de recherche, une aide en ligne lies des composants, etc.
Exemple : colorisation sous Xemacs
11/208
11
Outils annexes lditeur
Ce sont les outils externes qui collaborent avec lditeur pour amliorer le confort de la programmation. La consultation en ligne de la documentation des classes et la qualit de la navigation dans cette documentation sont des points essentiels. Un outil comme SNIFF permet de rechercher des classes, de mesurer rapidement limpact dune modication en recherchant dans le code toutes les utilisations dune mthode, etc.
11/209
11
Laide la conception dinteraction
Il est sduisant denvisager de gnrer des programmes partir dun outil permettant de mettre en place interactivement des objets graphiques, mais il convient de bien prendre en compte les points suivants :
Il faut que loutil sache mettre en place des LayoutManagers au lieu de faire du positionnement en absolu. Il faut que loutil sache mettre en place des composants dnis par des parties tierces (Beans) sans imposer que ces composants intgrent des classes spciques loutil. Il doit tre facile dintervenir dans le code gnr ( en particulier au niveau de larchitecture de gestion des vnements). Toute modication dans la disposition doit permettre de respecter le code dj crit. Une solution lgante consiste en la gnration dune ressource sous forme texte qui dcrit la disposition et qui est interprt au run-time (dans ce cas un composant spcique dexcution doit effectivement tre livr avec loutil) Attention la dynamicit des composants! Exemple : lutilisateur dun Network Computer doit pouvoir disposer dun prol qui personnalise ses objets dinteractions. Ainsi on doit tre capable de grer une barre doutils dans lequel le nombre dlments nest pas connu lavance.
Lavenir de ce type doutils se situe du cot des assembleurs de Beans. On a ainsi des possibilits de dcouverte des capacits des composants, des personnalisations ventuelles de la mise en oeuvre, etc. Les assembleurs de Beans vont au del des composants graphiques et permettent aussi de spcier des modalits d changes dinformations entre composants.
11/210
11
Gestion des sources
principes
Les outils de gestion de sources permettent :
darchiver les versions successives de chaque chier source. On peut ainsi marquer un logiciel avec une indication de la version de tous ses composants et reconstituer une version antrieure (suivi de bug. par ex.). grer la concurrence daccs sur les sources : un dveloppeur peut sassurer lexclusivit dune mise jour. Les outils les plus sophistiqus permettent des volutions en parallle entre des sites distant avec des procdures de reharmonisation. dassurer des services annexes (dpend des produits) : suivi des bugs et corrections, gestion de conguration (voir chapitre livraisons), etc.
Le point clef dune politique de gestion de version est celui de la signication des niveaux de version et de lordonnancement ( un certain niveau il ny a plus dordre historique entre deux feuilles situes sur des branches diffrentes de larbre des versions).
outils
Outils standards lis des systmes dexploitation : SCCS, RCS, PVCS, Outils spciques (sappuyant ventuellement sur les prcdents) : JAVASAFE (JavaSoft),TEAMWARE, etc...
11/211
11
Gestion des sources
points
JAVA pose des problmes particuliers dans la gestion de version. En effet une "application" peut faire appels des composants diffrents. Ces composants peuvent avoir diverses origines et donc relever chacun dune gestion de version qui leur est propre : chaque version dapplication est susceptible de fonctionner sur des combinaisons possibles de versions de composants. Lorsque ces composants sont chargs dynamiquement les incompatibilits apparaissent au run-time. "Java Product Versionning Specication" pose des jalons pour lmergence de pratiques standard:
A la base, les informations publiques de version (celles qui sont accessibles aprs livraison) sappliquent au niveau package. Le package constitue le niveau atomique dobjet soumis version. Un produit est distribu en archivant des packages et est identi avec son propre numro. (Les identications sont ports dans les chiers Manifest situs dans les archives .jar) Apparue partir de la version 1.2 la classe java.lang.Package distingue les versions de spcications des versions de ralisation. La version des spcications dsigne les interfaces dappels des classes et permet ventuellement de grer les compatibilits au niveau des appels des services rendus par ces classes. La version de ralisation gre les modications dans limplantation (corrections de bugs, etc.).
11/212
11
Gestionnaires de maintenance
Le gestionnaire de version doit tre exploit pour suivre la maintenance. Les bugs, les anomalies sont reports dans une ressource. Par la suite on utilise cette ressource pour suivre les oprations : qualication du bug, documentation, inscription dans une base de connaissance pour le helpdesk, oprations de correction (et modication de la base de test), insertion dans une nouvelle version (ou suivi de la livraison de corrections durgence). Des outils trs complets de Help-desk ( ex. Remedy) : personnaliss pour assurer ces fonctions. peuvent tre
La coopration de diffrents outils par changes dinformations est ici aussi trs importante : la gestion des anomalies doit tre coordonne avec les autres projets dextension/modication (planning, ressources, WorkFlow etc.)
11/213
11
Documentation de code, aide en ligne
Un projet complet gnre une importante documentation. De manire non-exhaustive citons: les documentations de spcication, la documentation du code, la documentation dutilisation des classes, la documentation dutilisation dun produit, la documentation utilisateur en ligne... sans compter les documentations de suivi de projet, dvolution, etc. Il faut pouvoir gnrer cette documentation, la consulter, grer les versions, sassurer quelle suit bien les volutions de ce quelle documente, pouvoir la ltrer (par exemple sparer la documentation prcise du code de la documentation de classe), lanalyser pour rechercher des mots-clefs, etc. Cette gestion devient difcile si chaque outil gnre un format particulier, ne sait pas importer/exporter la documentation gnre, ne fournit pas un format structur analysable facilement. Un format dcrit en SGML a lavantage de permettre ces manipulations par programme.
Javadoc facilite une meilleure intgration codesource/documentation de classe et fournit une construction documentaire hyper-texte de bon niveau. Un mcanisme de personnalisation des formats (Doclets) est apparu depuis la version 1.2. Quelques possibilits gnralement oublies : ltrer la documentation des membres en fonction de leur statut priv, public, etc.; sortie en format PostScript. LAPI JavaHelp permet la mise en oeuvre dune aide en ligne. Les ressources daide peuvent tre situes sur le site client ou sur le rseau, Le mcanisme sait cooprer avec dautres logiciels comme des moteurs de recherche. Les moteurs de recherche (ex. Excite) peuvent tre utiliss la fois dans latelier de programmation et dans les aides en ligne.
11/214
11
Debug
Un outil de Debug permet de suivre le droulement dune excution : pose des points darrt (sur incident, en un point prcis, sur une condition), excution pas pas, examen de la pile, de ltat dobjets (instances, threads, groupe de thread), modications interactives de valeurs, appel interactif de mthodes, etc. La concurrence (threads) lintrieur de Java et la rpartition des applications peut ncessiter lintervention de dbugueurs sophistiqus capables dobserver plusieurs processus (ventuellement situs sur des machines diffrentes), capables dobserver des verrous sur des instances ou des classes, etc. La liaison avec un debug du code de mthodes natives pose galement des problmes complexes.
outils
Gnralement fournis avec les ateliers de dveloppement et lis une JVM. ex: jdb avec le JDK Exemple de produit autonome: JWatch
11/215
11
gnration (make)
On peut dcrire la gnration dun produit comme un enchainement de compilations (et/ou dautre tches). En pratique la somme des tches excuter est trop importante pour tre dclenche chaque fois que lon apporte une modication au cours du dveloppement ou de la maintenance. On cherche donc ne dclencher que le minimum dactions qui permettent daboutir un tat complet dune portion du projet. Traditionnellement la description des actions dclencher en cas de modication se fait par lintermdiaire dun utilitaire de type Make (le chier de description est appel Makele) - voir par ex. le produit domaine public "GNU Make" ("http://www.fsf.org/software/make/make.html")-.. Dans un Makele on dcrit des objectifs et des rgles de dpendances entre chiers : un chier B doit avoir une date de modication ultrieure celle dun chier A, dans le cas contraire (ou si B nexiste pas) on dcrit les actions qui permettent de crer ou de mettre jour B. La formalisation de ces rgles suit une syntaxe particulire. Exemple : .c .o: $(CC) -c $(CPPFLAGS) $(ALL_CFLAGS) $< Dans un projet JAVA le Makele nest toutefois pas impliqu dans le processus de compilation lui mme (pour passer des ".java" aux ".class"). En tenant compte des capacits de chargement dynamique de JAVA le compilateur assure lui-mme une mise jour plus optimise que celle dun Makele classique. Il faut donc correctement sorganiser (voir architecture des rpertoires de package) et bien comprendre ce fonctionnement du compilateur: sil compile une classe il vrie les classes immdiatement rfrences dans le code courant; si la classe rfrence nest pas jour il tente de la recompiler MAIS il ne vrie pas les dpendances pour les classes quil ne recompile pas (sauf prciser loption -depend il ne recompilera pas une classe C modie et rfrence par une classe B jour et elle mme refrence par une classe A qui fait lobjet de la compilation). Les Makele sont utiliss par contre pour gnrer des chiers ".jar", pour recompiler des mthodes natives, pour gnrer des documentations, passer des tests, etc. Attention : les scripts associs aux rgles sont dpendants de la nature de la plate-forme de production.
11/216
11
tests
principes
On peut catgoriser les tests en fonction de primtres (tests de composants, tests dapplication), de positionnement dans la vie du logiciel (tests de non-regression,...), de nature (tests fonctionnels, de charge, etc.). Bien que les catgories suivantes se recoupent elles sont commodes pour caractriser des outils ou des procdures de tests :
tests fonctionnels : vrications conformit aux spcications; productions de rsultats conformes ; contrles sur les contraintes;... tests aux limites : proches du cas prcdent sur les contrles des cas illgaux; accent mis sur des combinaisons de valeurs remarquables (grandes, petites) pour tester les capacits du logiciel (taille des donnes, nombre de cas, prcision des calculs, valeurs particulires...) tests de charge : simulation de situations relles; calibrage du logiciel, capacit servir des nombreux utilisateurs simultanment, grand nombre de donnes, etc.. tests dinterface : "rejouer" automatiquement des interactions utilisateur; conformit des comportements; enchainements sur des comportements fonctionnels quivalents,..
produits
SunTest fournit des outils de tests eux-mmes crits en JAVA : JAVASPEC (tests fonctionnels); JAVASTAR (tests dinterface); JAVALOAD (tests de charge client-serveur)
11/217
11
tests
points
La mise au point de tests fonctionnels est particulirement intressante lorsquon sadresse des Interface JAVA . En effet, du fait du polymorphisme, pour le mme appel de mthode on pourra avoir des ralisations effectives diffrentes et il peut tre intressant de controler toutes les parties caches du "contrat" dinterface. Il y a des limites une gnration automatique dune combinatoire de tests (voir mesures de la testabilit). Il est vivement recommand de mettre au point pour les grands composants dune application un mcanisme de test prenant en entre des scenarios dcrits sous forme de texte et produisant du texte comme rsultat.
Les scenarios pourront tre enrichis rapidement dans la vie du logiciel au fur et mesure que de nouvelles anomalies sont dtectes. Quand ces anomalies sont corriges on a ainsi les moyens de controler la non-regression des version ultrieures Lanalyse des rsultats se fait rapidement par des outils de comparaisons de texte (limite: lorsque des valeurs dpendent de la date ou de la localisation courante!)
11/218
11
analyse de couverture
Il faut avoir des indications sur ltendue de la couverture des tests : dans quelle mesure ont-ils permis de passer par toutes les branches du code? Avant de passer les tests fonctionnels on doit "instrumenter" de code, cest dire le recompiler de manire ce que lexcution puisse tracer le passage dans les diffrentes parties. Un outil danalyse de couverture (ex. JAVASCOPE de Suntest) permet dinstrumenter puis danalyser ensuite la couverture (production dinformations spciques des parties du code, mtriques diverses -dont taux de couverture-) Linterprtation globale des rsultats est dlicate : il faut savoir ltrer des parties exceptionnelles du code qui ne sont pas pertinentes pour obtenir un bon taux de couverture. Par ailleurs les informations obtenues ne prjugent pas de la pertinence fonctionnelle des tests : les informations les plus prcieuses se trouvent dans le dtail des parcours des "branches" de larbre des appels et il faut savoir les rechercher.
11/219
11
analyses de performances
principes
En excutant du code Java avec un moniteur spcial (par exemple en utilisant loption de proling -prof de la commande java) on peut gnrer des informations donnant des indications sur la "consommation" de chaque appel de mthode. Pour tre signicatifs les tests qui servent analyser les informations de performances doivent tre reprsentatifs de conditions relles dexcution. En effet lobjectif nest pas doptimiser tout le code mais les quelques points qui peuvent rellement poser des problmes signicatifs. La "consommation" a de multiples facettes. Tous les systmes danalyse proposent des informations du type : temps cumul pass dans une mthode, nombre dappels dune mthode ( et donc des ratios: mthodes les plus couteuses en temps cumul, mthodes pour lesquelles chaque appel est couteux, etc.). Selon les outils on peut aussi obtenir des informations sur les graphes des appels, le nombre dinstances gnres par classe et lutilisation de la mmoire, lutilisation des Threads, etc. . On peut galement obtenir des informations de trace au cours de lexcution elle mme.
outils
Il y a des outils qui exploitent les traces standard du proling JAVA (HyperProf, JWS) et dautres plus sophistiqus (JProbe, "Optimize It") qui utilisent des moniteurs spciques.
points
Il est essentiel de pouvoir ltrer les informations : on dtecte les "points chauds" et on limine les donnes qui concernent les autres classes. Attention: un mme code java peut sexcuter sur des JVM diffrentes: interprt, JIT, "HotSpot".
11/220
11
Analyses statiques du code
principes
Sans recourir une excution on peut avoir des informations sur la qualit du code en ayant recours des analyseurs statiques. On trouve ici deux catgories doutils : les "dbourreurs" et les outils de "physique du logiciel".
Sur le modle du programme standard C Lint un "dbourreur" analyse le code pour tenter de dtecter des constructions potentiellement dangereuses. Un tel outil dispose dune base de savoir-faires et de rgles et produit des diagnostics arguments (et faisant rfrence des portions de code source). Les outils de physique du logiciel analyse la complexit et la testabilit des programmes. Ils calculent des mtriques : complexit cyclomatique, complexit de Halstead, etc.
outils
Dtecteurs de constructions critiques : CodeWizard, etc, Loutil de test JavaPureCheck est aussi mettre dans cette catgorie (bien que spcialis dans les problmes de portabilit) Physique du logiciel : TotalMetric,...
points
Les qualits dun dbourreur se jugent sur la pertinence de ses rgles, la capacit ltrer ces rgles ou dsarmer localement lapplication dune rgle (dans un commentaire) Linterprtation des mesures de complexit demande une grande exprience.
11/221
11
prparation la livraison
Une fois que ltat davancement du projet est tel que lon peut procder des livraisons on ne peut directement transfrer des binaires ou des ressources directement depuis lespace de dveloppement. Voici quelques suggestions pour mettre en place des procdures qualit trs strictes: 1. 2. 3. Mettre en place un environnement "vierge" compltement tanche par rapport aux environnements de dveloppement existants. Extraire des archives ressources la version courante des sources et des
Lancer la gnration des binaires avec toutes les options appropries (optimisations, pas de traces ni dinformation de debug, etc.) Transformations ventuelles du code pour marquage, brouillage... Excution des tests et contrles. -ventuellement sur des plateformes multiplesGnration et contrle des documentations "Empaquetage" des livraisons et tests de la validit des procdures de livraison/installation Mise en place des liens avec les mcanismes de livraison automatique, de Help-Desk, de gestion, etc.
4. 5. 6. 7. 8.
Sauf exception lenchainement est absolu : tout chec sur une phase doit entraner une reprise zero de tout le processus.
11/222
11
livraison/dploiement
Applet ou application autonome? Le choix est important pour organiser le dploiement du logiciel et surtout pour garantir le suivi rapide des volutions :
Avec une Applet on a un client qui charge son code avant de sexcuter, tous les clients sont assurs ainsi de disposer de la dernire version du code . Toutefois :
Il faut quilibrer les regroupements de classes et de ressources sur plusieurs archives ".jar" et il faut viter de charger une trop grande quantit de code dun seul coup. Les restrictions de scurit prennent leur plein effet (ce peuttre un avantage ou un inconvnient) Il nest pas garanti que toutes les librairies standard soient jour du cot client.
Avec une application autonome on doit mettre en place des procdures de livaison/installation. On peut utiliser des produits (InstallShield, InstallAnyWhere,..) qui permettent de packager un logiciel et dautomatiser les procdures dinstallation (avec lecture dun contrat de licence, installation de licence, etc.). Ces logiciels simplient en outre la livraison par chargement direct au travers du rseau. Toutefois :
La mise jour nest pas assure et il faut mettre en place des procdures particulires. Il peut savrer intressant de "packager" une application JAVA, sa JVM et ses classes standard (voir JRE) Pour utiliser au mieux les dispositifs de scurit JAVA il faut utiliser au minimum la version 1.2
Une solution intermdiaire existe : lutilisation des technologies PUSH (ex. Castanet de Marimba). Lapplication autonome est stocke sur le poste client mais avant utilisation elle se connecte au serveur pour ventuellement faire une mise jour diffrentielle des sources.
11/223
11
autres outils
dcompilateurs/brouilleurs
Les chiers "binaires" JAVA facilitent linspection du code et le passage dun bon dcompilateur donne une ide assez prcise du contenu du source. On trouve donc la fois des dcompilateurs et des brouilleurs ("obfuscator") qui transforment un code JAVA de manire le rendre difcile dcompiler. Les identiants prennant des formes bizarres il faut conserver dans latelier de dveloppement un dictionnaire permettant de reconstituer le nom rel partir de la forme brouill (ceci est ncessaire si on veut rcuprer et comprendre des messages derreurs imprvus). Il faut savoir aussi ne pas tout brouiller, en particulier lorsque le code contient des recherches dynamiques par nom (introspection, Beans) En pratique un bon dcompilateur arrive donner une image dle de la structure du programme : cest labsence didentiant signicatif qui trouble la comprhension.
outils syntaxiques
Pour des raisons de robustesse du code, Java nutilise pas de prprocesseur : lutilisation de macros risque de conduire un texte "lisible" qui est diffrent du code rellement compil. Diffrents produits proposent des macro-processeurs pour JAVA : lutilisation doit tre limite (ex. macros de trace, marquage des messages internationaliser) et ne pas concerner des parties critiques du code Des analyseurs acceptant des grammaires sophistiques sont disponibles voir JavaCC "http://www.suntest.com/JavaCC"
11/224
aide mmoire outils
12 2
Objectifs
Ce chapitre constitue un aide-mmoire simpli dutilisation pour des outilsl JAVA
JAVAWorkshop est le premier atelier ouvert crit en JAVA
12
JavaWorkshop: Gestionnaire de projets
JWS connat deux niveaux dorganisation : le projet (project) et le portefeuille (portfolio). Un projet est une unit dorganisation lie la gnration. Un projet a pour objectif de gnrer un produit livrable (application autonome, Applet, Bean) ou un package. Un projet peut sappuyer sur dautres projets qui sont ncessaires sa gnration : ces projets sont vus alors comme des sous-projets du projet principal. Un portefeuille est une collection de projets.
Mise en oeuvre du Project Manager

Pour obtenir la fentre project manager cliquer correspondante ou lancer depuis le menu principal par : project show project manager sur licne
aide mmoire outils

12/226
12
crer ou importer un portefeuille
File new portfolio File add portfolio Cration : prciser le nom dun chier (suivi de .psf) ce chier sera cr dans le sous-rpertoire jws du rpertoire daccueil de lutilisateur. Il est possible de prciser un autre rpertoire (attention rfrence stocke sous forme de cheminom relatif dans le chier $HOME/jws<version>/portfolios)
crer ou importer un projet

Slectionner un portefeuille dans larbre des projets (fentre project manager) File new project File add project Il apparat alors une fentre de dialogue :
cliquer sur le type de projet (Standalone, applet, bean, package) cliquer sur le type de GUI (no GUI, ou gui created manually) > Next prciser le rpertoire dans lequel sera cr le projet (et ventuellement prciser si des chiers existants sont conserver dans le projet) dans le cas dun package il faut donner le nom du package, et le nom du rpertoire racinedes classes (quivalent de celui prcis par loption -d de javac),
Dans le cas dun sous-projet on oprera cette cration/importation en se positionnant dans le projet englobant.
aide mmoire outils

12/227
12
xer les attributs dun projet
Cette opration permet de xer un ensemble de conditions pour la gnration et lexcution dun projet Project edit Il apparat alors un dossier onglets:
General- informations gnrales : nom, type, rprtoire sources, sous-projet (informations xes la cration) point important : lordre des sous-projet xe lordre des compilations (dou la possiblitde modier lordre des sous-projets dans la liste) Build- permet de xer les informations utiles pour la compilation: options du compilateur (-g pour le debugger est propos par dfaut), rpertoire daccueil des classes (pour option d de javac), lments complmentaires du CLASSPATH (nota: on peut lancer jws avec option -classpath) Debug/Browse- permet de xer les options pour loutil de debug: Chemins dacces rajouter pour visualiser les sources des classes Point dentre : classe avec main, applet avec init La page HTML associe au lancement (cas dune Applet) Options de linterprteur java (pour application autonome) Outil de visualisation utiliser pour une Applet Type de debug (local ou sur machine distante) Run- options de lancement de tests (hors debug): Pour un programme autonome : point dentree, options dexecution, paramtres de lancement Pour une applet : denition des paramtres dapplet dans le HMTL
aide mmoire outils

12/228
12
JavaWorkshop: dition, compilation, tests
dition
Dans project manager: File new file pour crer un chier dans projet courant File add file pour lajouter dans projet courant
personnalisation de ldition
Dans fentre dition : Preferences source editor Preferences keyboard
contrle daccs et version

Pour le choix de loutil Preference Version Control enregistrement dans le systme de versionnement File version check In New pour creation de lenregistrement checkIn : pour enregistrement checkOut : pour mise en edition Remarques: lenregistrement il y a demande de commentaires, mais il ny pas de versionnement n.
aide mmoire outils

12/229
12
JavaWorkshop: dition, compilation, tests
compilation
Build Build recompile les chiers qui ont chang depuis la dernire recompilation du projet Build Build All recompile tous les chiers du projet Build compile file permet de ne compiler que le chier en dition Preference builder permet de choisir le compilateur impliquer La fenetre Build donne les erreurs (qui sont signales dans lditeur de code lui-mme)
test
Lancer Project run (voir options pour lancements Applets)
aide mmoire outils

12/230

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

French FR Logiciel Software Tutorial Programmation Java SUN LJ-295 - Realiser Une Application Java

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

French FR Logiciel Software Tutorial Programmation Java SUN LJ-295 - Realiser Une Application Java

Uploaded by

Copyright:

Available Formats

Raliser une application JAV A

Raliser une application JAV A

Raliser une application JAV A

Raliser une application JAV A

Raliser une application JAV A

Raliser une application JAV A

Raliser une application JAV A

Raliser une application JAV A

Sun Microsystems France

Sun Microsystems France

Sun Microsystems France

Raliser une application JAVA

Raliser une application JAVA Sun Service Formation SL-285 D2 23/8/99

Sun Microsystems France

Les techniques de programmation Objet

Rvision : D2 Date : 23/8/99

Le systme existant (suite)

Lapplication de mise jour de la cote est un programme JAVA fourni :

SQL (et miniSQL)

Rvision : D2 Date : 23/8/99

SQL (et miniSQL)

Les outils de mSQL

msqld le moteur mSQL

SQL (et miniSQL)

msqladmin administration de la base (pour mmoire)

msqldump image de la base (pour mmoire)

SQL (et miniSQL)

SQL (et miniSQL)

SQL (et miniSQL)

\g Go, execute la prcdente). \p \e \q

requte SQL en cours (ou la requte

SQL (et miniSQL)

SQL (et miniSQL)

SQL (et miniSQL)

SQL (et miniSQL)

SQL (et miniSQL)

SQL (et miniSQL)

SQL (et miniSQL)

char (len) int real

La commande DROP (pour mmoire)

SQL (et miniSQL)

SQL (et miniSQL)

SQL (et miniSQL)

Rvision : D2 Date : 23/8/99

rappels: API JDBC

rappels: API JDBC

Application Java (API JDBC)

Gestionnaire de pilotes JDBC

Pilote de liaison JDBC-ODBC

Pilotes ODBC et de bases de donnes

Possibilits dimplmentation JDBC

rappels: API JDBC

Driver Connection Statement PreparedStatement CallableStatement ResultSet ResultSetMetaData DatabaseMetaData

rappels: API JDBC

Driver Connection Statement ResultSet

Figure 1-1 Organigramme JDBC

rappels: API JDBC

rappels: API JDBC

rappels: API JDBC

Cration explicite dune instance de pilote JDBC

rappels: API JDBC

rappels: API JDBC

rappels: API JDBC