Your Federal Quarterly Tax Payments are due April 15th Get Help Now >>

Compléments JAVA by hcj

VIEWS: 66 PAGES: 31

									2ISA

511502a9-9f62-4813-a20c-d8d1ad59d5d3.doc

Compléments JAVA
Pré requis : Connaître et savoir utiliser les concepts de la Programmation Orientée Objet en Java (Classe, instance, encapsulation, héritage, classe abstraite, interface)

Sommaire du document : Création d'une interface graphique ................................................................................................................3 Création de la fenêtre .................................................................................................................................3 Ajout de composants..................................................................................................................................4 Comment les composants sont positionnés sur la vitre ? ..........................................................................5 Utilisation de Panneaux (JPanel) ...............................................................................................................6 Gestion des événements .............................................................................................................................7 Exemple 1 : Gestion de la fermeture de la fenêtre.................................................................................7 Exemple 2 : Gestion du click sur un bouton ..........................................................................................7 Exemple 3 : Cas de plusieurs boutons ...................................................................................................8 Composants SWING .................................................................................................................................9 Quelques astuces concernant les fenêtres ..................................................................................................9 Connaître la dimension de l'écran pour fixer la taille d'une fenêtre ......................................................9 Modifier l'icône d'une fenêtre ................................................................................................................9 Mettre une icône sur un bouton .............................................................................................................9 Définir le bouton par défaut d'une fenêtre .............................................................................................9 Centrer la fenêtre par rapport à l'écran ..................................................................................................9 Mettre le focus dans un champ texte .....................................................................................................9 Les flux (stream) ..........................................................................................................................................10 Lecture d'un fichier texte .........................................................................................................................10 Ecriture dans un fichier texte ...................................................................................................................10 Sauvegarde des objets contenus dans une ArrayList dans un fichier ......................................................10 Restauration des objets à partir d'un fichier .............................................................................................10 TP à réaliser : "Viewer" de fichiers .............................................................................................................11 Accès aux bases de données ........................................................................................................................12 Ouverture d'une connexion ......................................................................................................................12 Cas : Utilisation d’ODBC et d’un DSN ...............................................................................................12 Cas : Utilisation de JDBC avec ORACLE ..........................................................................................12 Cas : Utilisation de JDBC pour MySQL .............................................................................................12 Création d'un Statement à partir de la connexion ....................................................................................13 Création d'un ResultSet à partir d'un Statement ......................................................................................13 Lecture séquentielle d'un ResultSet .........................................................................................................13 Autres possibilités du ResultSet ..............................................................................................................13 Requête de mise à jour associée à Statement...........................................................................................13 Fermeture du ResultSet............................................................................................................................14 Fermeture de la connexion.......................................................................................................................14 Classe ResultSetMetaData .......................................................................................................................14 TP à réaliser : Connexion à une base de données ........................................................................................15 Utilisation de procédures stockées : ............................................................................................................16 Utilisation de procédures stockées : ............................................................................................................16 Appel d’une procédure stockée : .............................................................................................................16 Appel d’une procédure stockée retournant un ResulSet : ........................................................................16 Création d'une applet : .................................................................................................................................17 Intégration dans une page HTML : ..........................................................................................................17 Classe JApplet : .......................................................................................................................................17 Page 1 sur 31

2ISA 511502a9-9f62-4813-a20c-d8d1ad59d5d3.doc Récupération des paramètres : .................................................................................................................18 Ajouter des composants graphiques : ......................................................................................................18 Dessiner : .................................................................................................................................................18 TP à réaliser : Une première applet - affichage d’un message ....................................................................19 MultiThreading ............................................................................................................................................21 Créer un objet Runnable ..........................................................................................................................21 Créer un nouveau processus et le lancer ..................................................................................................21 TP à réaliser : Applet avec un message défilant ..........................................................................................22 TP à réaliser : un Diaporama .......................................................................................................................24 Client/serveur ...............................................................................................................................................26 Créer un serveur .......................................................................................................................................26 Créer un client..........................................................................................................................................26 Comment le serveur reçoit la demande de connexion d'un client ...........................................................26 Émettre et recevoir des messages ............................................................................................................26 TP à réaliser : un serveur et un client de chat ..............................................................................................27 Déployer une application avec Java Web Start ...........................................................................................28 Étapes à respecter : ..................................................................................................................................28 Créer une archive (jar) pour l'application. ...........................................................................................28 Créer un fichier JNLP ..........................................................................................................................28 Créer une page HTML. ........................................................................................................................28 Copier les fichiers sur le serveur Web .................................................................................................29 Tester le déploiement de l'application sur le client ..............................................................................29 Restrictions liées à la sécurité ..................................................................................................................30 Pour en savoir plus...................................................................................................................................30 Annexe : Diagramme de classes – Gestion des événements

Page 2 sur 31

2ISA

511502a9-9f62-4813-a20c-d8d1ad59d5d3.doc

Création d'une interface graphique
Pour créer une interface graphique, 2 bibliothèques de composants graphiques (Fenêtre, boutons, zones de texte, labels, combo, etc) sont disponibles dans le JDK :  AWT (Abstract Windowing Toolkit) la plus ancienne (package java.awt),  SWING qui contient les nouvelles classes de composants dérivées des classes AWT (package javax.swing). Pour créer une fenêtre, on procédera en 2 étapes :  L'aspect visuel : création de la fenêtre et ajout des composants  La gestion des événements : interaction avec les utilisateurs (souris, clavier ;…)

Création de la fenêtre
Pour créer une fenêtre, il faut créer une classe dérivée de la classe JFrame.
import javax.swing.JFrame; public class Fenetre1 extends JFrame { }

Les caractéristiques de cette fenêtre seront définies dans le constructeur de cette fenêtre :
import javax.swing.JFrame; public class Fenetre1 extends JFrame { //Constructeur public Fenetre1(){ //Appel du constructeur de la classe mère //pour donner un titre à la fenêtre super("Fenetre 1"); //Taille de la fenêtre this.setBounds (0,0,200,200); //Rend le fenêtre visible this.setVisible(true); } }

Pour tester la fenêtre, on crée une instance de cette fenêtre :
public class Testeur { public static void main(String[] args) { new Fenetre1(); } }

Page 3 sur 31

2ISA

511502a9-9f62-4813-a20c-d8d1ad59d5d3.doc

Ajout de composants
Pour ajouter des composants sur la fenêtre, il faut :  Récupérer la "vitre" sur laquelle on pourra ajouter des composants. L'objet Container agit comme une sorte de calque sur lequel on créera les composants.  Créer des instances de composants en appelant le constructeur de chacun des composants.  Puis ajouter ces composants sur la "vitre".
import java.awt.Container; import javax.swing.JButton; import javax.swing.JFrame; public class Fenetre1 extends JFrame { //Constructeur public Fenetre1(){ //Appel du constructeur pour donner un titre à la fenêtre super("Fenetre 1"); //Récupération du container géré par JFrame //C'est la vitre sur laquelle on pourra poser des composants Container c=this.getContentPane(); //Création d'un bouton bt1 = new JButton("Bouton1"); //Ajout de ce bouton sur la vitre c.add("North",bt1); //Création d'un bouton bt2 = new JButton("Bouton2"); //Ajout de ce bouton sur la vitre c.add("Center",bt2); this.setBounds (0,0,200,200); //Rend le fenêtre visible this.setVisible(true); } //Propriétés de la fenêtre JButton bt1,bt2; }

Résultat obtenu lors de l'exécution Les boutons occupent toute la largeur de la fenêtre. Voyons comment les composants sont agencés.

Page 4 sur 31

2ISA

511502a9-9f62-4813-a20c-d8d1ad59d5d3.doc

Comment les composants sont positionnés sur la vitre ?
SWING a résolu les problèmes de re-dimensionnement des fenêtres en introduisant les Layout. Un Layout Manager est un gestionnaire qui permet de définir la position des composants selon des règles spécifiques. Par défaut, le container (la vitre) de JFrame utilise un BorderLayout. Ce type de Layout découpe la fenêtre en 5 zones. Le BorderLayout est un peu limité car il permet d'insérer seulement 5 composants sur la fenêtre (un par zone). North Center South

West

East

Il existe d'autres types de Layout : FlowLayout, BoxLayout, GridLayout, … qui permettront d'obtenir d'autres dispositions. (Voir documentation java pour les spécificités de chaque type de Layout). Pour modifier le type de Layout associé à la vitre :
import java.awt.FlowLayout; public class Fenetre1 extends JFrame { //Constructeur public Fenetre1(){ … Container c=this.getContentPane(); c.setLayout(new FlowLayout()); //Création d'un bouton bt1 = new JButton("Bouton1"); bt2 = new Jbutton("Bouton2"); //Ajout de ce bouton sur la vitre c.add(bt1); c.add(bt2); .... } //Propriétés de la fenetre private JButton bt1,bt2; }

Voilà le résultat obtenu avec un FlowLayout

Page 5 sur 31

2ISA

511502a9-9f62-4813-a20c-d8d1ad59d5d3.doc

Utilisation de Panneaux (JPanel)
Pour obtenir des présentations plus élaborées, il est aussi possible d'insérer des Layouts dans un Layout et de les combiner… Pour ce faire, il est possible de créer des panneaux et d'y associer des Layout.
public class Fenetre1 extends JFrame { //Constructeur public Fenetre1(){ super("Fenetre 1"); //Récupération du container géré par JFrame (BorderLayout) Container c=this.getContentPane(); //Création d'un panneau JPanel pNorth = new JPanel(new FlowLayout()); //Création des composants lblNom = new JLabel("Votre nom :"); txtNom = new JTextField(20); lblTexte = new Jlabel(); btBonjour = new JButton("Bonjour"); btAuRevoir = new JButton("Au revoir"); //Ajout des composants au panneau pNorth.add(lblNom); pNorth.add(txtNom); pNorth.add(btBonjour); pNorth.add(btAuRevoir); //Ajout du panneau à la vitre c.add("North",pNorth); c.add("Center",lblTexte); this.setBounds (0,0,400,200); //Rend le fenêtre visible this.setVisible(true); } }

Page 6 sur 31

2ISA

511502a9-9f62-4813-a20c-d8d1ad59d5d3.doc

Gestion des événements
En JAVA, la gestion des événements est réalisée par l'intermédiaire de classes spécifiques appelées écouteurs (en anglais listeners). Ces classes se trouvent dans le package java.awt.event. Le mécanisme de gestion des événements dépend de AWT et non de SWING. MouseListener, WindowListener, MouseMotionListener, ActionListener … sont des interfaces. Chaque interface décrit les méthodes devant être obligatoirement implémentées par les classes qui l’implémenteront. La classe MouseAdapter implémente l'interface MouseListener. La classe WindowAdapter implémente l'interface WindowListener. La classe WindowAdapter décrit ainsi toutes les méthodes de l'interface WindowListener. (Voir aide JAVA)

Exemple 1 : Gestion de la fermeture de la fenêtre
1ère étape : création d'une classe interne écouteur Dans la classe Fenetre1, on déclare une classe interne EcouteurFenetre dérivée de la classe WindowAdapter et on surcharge les méthodes qui correspondent aux événements que l'on souhaite gérer (ici windowClosing).
import java.awt.event.WindowAdapter; import java.awt.event.WindowEvent; public class Fenetre1 extends JFrame{ //Constructeur public Fenetre1(){ } //Classe interne EcouteurFenetre class EcouteurFenetre extends WindowAdapter{ //Sucharge de la méthode windowClosing public void windowClosing(WindowEvent we){ System.exit(0); } } }

2ème étape : Association de l'écouteur à la fenêtre
public class Fenetre1 extends JFrame { public Fenetre1(){ … Container c=this.getContentPane(); c.setLayout(new BorderLayout()); this.setDefaultCLoseOperation(Jframe.DO_NOTHING_ON_CLOSE); this.addWindowListener(new EcouteurFenetre()); } //Classe interne EcouteurFenetre class EcouteurFenetre extends WindowAdapter{ // public void windowClosing(WindowEvent we) { System.exit(0); } } }

Exemple 2 : Gestion du click sur un bouton
Même méthode : on crée une classe interne écouteur puis on l'associe au composant qui écoute. Page 7 sur 31

2ISA

511502a9-9f62-4813-a20c-d8d1ad59d5d3.doc

Petite particularité, il n'existe pas de classe ActionAdapter, on crée une classe interne qui implémente directement l'interface ActionListener car celle-ci ne comprend qu'une seule méthode actionPerformed.
import java.awt.event.ActionEvent; import java.awt.event.ActionListener; ... public class Fenetre1 extends JFrame { //Constructeur public Fenetre1(){ ... bt1 = new JButton("Bouton1"); bt1.addActionListener(new EcouteurBouton()); c.add(bt1); } class EcouteurBouton implements ActionListener{ public void actionPerformed(ActionEvent ae) { //Code à effectuer si click } } //Propriétés de la fenetre private JButton bt1; }

Exemple 3 : Cas de plusieurs boutons
ae.getSource() indique quel composant a généré l'événement. Il est conseillé de créer une procédure pour traiter chaque cas.
import java.awt.event.ActionEvent; import java.awt.event.ActionListener; ... public class Fenetre1 extends JFrame { //Propriétés private JButton bt1,bt2; //Constructeur public Fenetre1(){ bt1 = new JButton("Bouton1"); bt1.addActionListener(new EcouteurBouton()); c.add(bt1); bt2 = new JButton("Bouton2"); bt2.addActionListener(new EcouteurBouton()); c.add(bt2); ... } private void traitementBt1(){ System.out.println("Clic bouton1"); } private void traitementBt2(){ System.out.println("Clic bouton2"); } class EcouteurBouton implements ActionListener{ public void actionPerformed(ActionEvent ae){ if(bt1.equals(ae.getSource())) traitementBt1(); if(bt2.equals(ae.getSource())) traitementBt2(); } } }

Page 8 sur 31

2ISA

511502a9-9f62-4813-a20c-d8d1ad59d5d3.doc

Composants SWING
Autres composants SWING utilisables : JTextField, JLabel, JTextArea, JComboBox, JOptionPane, JScrollPane, JTable... A voir dans le tutorial Java de Sun : A Visual Index to the Swing Components

Quelques astuces concernant les fenêtres
Connaître la dimension de l'écran pour fixer la taille d'une fenêtre
Dimension d = tk.getScreenSize().getDefaultToolkit(); setBounds(0,0,d.width,d.height);

Modifier l'icône d'une fenêtre
URL u = this.getClass().getResource("images/find.png"); setIconImage(tk.getImage(u));

Mettre une icône sur un bouton
JButton btnärcourir = new JButton(); URL u = this.getClass().getResource("images/find.png"); btnParcourir.setIcon(new ImageIcon(u));

Définir le bouton par défaut d'une fenêtre
getRootPane().setDefaultButton(btnParcourir);

Centrer la fenêtre par rapport à l'écran
setLocationRelativeTo(null);

Mettre le focus dans un champ texte
txtAEnvoyer.requestFocus();

Page 9 sur 31

2ISA

511502a9-9f62-4813-a20c-d8d1ad59d5d3.doc

Les flux (stream)
Les flux d'entrée-sortie mettent en jeu de nombreuses classes définies dans le package java.io.

Lecture d'un fichier texte
//chemin contient le chemin du fichier à lire FileReader fr= new FileReader(chemin); BufferedReader br = new BufferedReader(fr); String ligne=null; while((ligne=br.readLine())!=null){ //ligne contient la ligne lue } br.close();

Les exceptions à gérer sont IOException et FileNotFoundException.

Ecriture dans un fichier texte
Le fichier sera crée s'il n'existe pas :
FileWriter fw = new FileWriter("c:\\essai2.txt"); BufferedWriter bw = new BufferedWriter(fw); bw.write("ligne1"); bw.newLine(); bw.write("ligne2"); bw.close();

Il est possible d'ouvrir le fichier en mode append (ajout de lignes à la fin).

Sauvegarde des objets contenus dans une ArrayList dans un fichier
Les objets sont crées en mémoire, il est possible de les rendre persistant en les sérialisant, c'est à dire en les stockant dans des fichiers par exemple. Ce fragment de code montre comment écrire les objets d'une ArrayList dans un fichier.
//l est une ArrayList qui contient des objets FileOutputStream fos = new FileOutputStream(fichier,true); ObjectOutputStream os= new ObjectOutputStream(fos); for(int i=0;i<l.size();i++){ os.writeObject(l.get(i)); } os.close();

Pour être sérialisable, une classe doit implémenter l'interface Serializable. Cette interface ne décrit aucune méthode, elle sert à typer les objets qui peuvent être rendus persistants.

Restauration des objets à partir d'un fichier
FileInputStream fos = new FileInputStream(fichier); ObjectInputStream os= new ObjectInputStream(fos); while((o=os.readObject())!=null){ // o est l'objet récupéré } os.close();

Page 10 sur 31

2ISA

511502a9-9f62-4813-a20c-d8d1ad59d5d3.doc

TP à réaliser : "Viewer" de fichiers
Objectif :
Créer une fenêtre pour visualiser le contenu d'un fichier texte dans une zone de texte multi ligne. Cette fenêtre doit comprendre :  Une zone de texte simple (JTextField) pour saisir le chemin et le nom du fichier texte à lire.  Un bouton (JButton) pour lire et afficher le contenu du fichier texte (utiliser un JTextArea associé à un JScrollPane (Ascenceur).

Exemple de résultat à obtenir :

Consignes de réalisation :
Réfléchir à l'agencement des composants sur la fenêtre (utilisation des layout). Vous pourrez créer une classe Fichier qui contient une méthode de lecture d'un fichier texte vers une chaîne de caractères.

Evolutions possibles (S'il vous reste du temps) :
   Afficher un message à l'aide de JOptionPane si le fichier n'existe pas. Ajouter un bouton parcourir qui permettra à l'aide d'une fenêtre de sélection de fichiers (JFileChooser) de sélectionner directement le fichier texte à visualiser. Afficher un message de confirmation lors de la fermeture de la fenêtre

Page 11 sur 31

2ISA

511502a9-9f62-4813-a20c-d8d1ad59d5d3.doc

Accès aux bases de données
Les classes nécessaires pour accéder aux bases de données se trouvent dans le package java.sql.

Ouverture d'une connexion
Il faudra dans un premier temps :  charger la classe correspondant au driver en mémoire à partir de son nom (méthode statique forName de la classe Class),  obtenir une connexion (méthode getConnection de la classe DriverManager). Ces méthodes nécessitent d'intercepter 2 types d'exception : ClassNotFoundException et SQLException.

Cas : Utilisation d’ODBC et d’un DSN
Ici AVIONS représente un DSN=Data Source Name
String driver = "sun.jdbc.odbc.JdbcOdbcDriver"; Class.forName(driver); String dsn="AVIONS"; String lien = "jdbc:odbc:"+dsn; Connection cn=DriverManager.getConnection(lien);

Cas : Utilisation de JDBC avec ORACLE
Pour accéder à une base Oracle en JDBC, il faut charger en mémoire le driver JDBC fourni par Oracle. Pour ce faire, il faut ajouter aux bibliothèques du projet un fichier jar externe : ojdbc14.jar (sinon on obtient ClassNotFoundException). Il faut ensuite préciser : le type de driver. Ici le driver thin est utilisé, il ne nécessite pas d’installation du Client Oracle. Le nom du serveur, le port, le nom de la base de données doivent être précisés. Au moment de la connexion, il faut aussi indiquer l’utilisateur et le mot de passe.
String driver="oracle.jdbc.driver.OracleDriver"; Class.forName(driver); String lien= "jdbc:oracle:thin:@2isadev2:1521:di03"; cn=DriverManager.getConnection(lien,”AVIATION”,”AVIATION”);

Cas : Utilisation de JDBC pour MySQL
Pour accéder à une base MySQL en JDBC, il faut charger le driver JDBC fourni par MySQL et ajouter le fichier jar aux bibliothèques du projet. Il faut préciser l’adresse du serveur (ici localhost) et le nom de la base de données. Ici, la connexion a été réalisée avec l’utilisateur root.
String driver ="org.gjt.mm.mysql.Driver"; Class.forName(driver); String lien = "jdbc:mysql://localhost/aviation"; cn = DriverManager.getConnection(lien,"root","");

Page 12 sur 31

2ISA

511502a9-9f62-4813-a20c-d8d1ad59d5d3.doc

Création d'un Statement à partir de la connexion
Statement st =cn.createStatement();

La méthode createStatement de l'objet Connection renvoie un objet Statement qui permettra d'envoyer ensuite des instructions SQL à la base de données. Cet objet permettra de soumettre des requêtes SQL à la base de données. Notons que par défaut createStatement permet de créer des ResultSet avec les caractéristiques suivantes : TYPE_FORWARD_ONLY , CONCUR_READ_ONLY. (Voir Constantes statiques de la classe Statement). Lors de l'appel de createStatement, il sera possible de modifier ces paramètres par défaut.

Création d'un ResultSet à partir d'un Statement
La méthode executeQuery de la classe Statement retourne un objet ResulSet.
String sql="SELECT * FROM AVION"; ResultSet rs=st.executeQuery(sql);

La méthode executeQuery ne permet d'exécuter que des instructions de type SELECT.

Lecture séquentielle d'un ResultSet
Dans un ResulSet, le curseur est placé avant la première ligne, la méthode next déplace le curseur sur la ligne suivante et retourne false quand il n'y a plus de lignes à lire.
while(rs.next()){ //Utilisation du nom de la colonne System.out.println(rs.getString("AVNO")); //Utilisation du numéro de colonne //i entier variant de 1 au nombre total de colonnes de la requête System.out.println(rs.getString(i)); }

Des méthodes getxxxx (getString, getInteger,....) permettent de récupérer la valeur d'un champ de la ligne courante du ResulSet. Ces méthodes admettent pour paramètre le nom de la colonne ou un index (A noter : l'index vaut 1 pour la première colonne).

Autres possibilités du ResultSet
D'autres méthodes sont associées à l'objet ResultSet : previous, last, first, beforeFirst, insertRow, deleteRow, updateRow,…. Ces méthodes sont disponibles si le Resulset n'est pas en lecture seule et si le ResulSet n'est pas en FORWARD-ONLY. (Voir Documentation JAVA pour plus de détails)

Requête de mise à jour associée à Statement
La méthode executeUpdate permet d'exécuter des ordres SQL : UPDATE, DELETE, INSERT ou un ordre SQL qui ne renvoie rien tel qu'un ordre DDL (CREATE TABLE …). String sql ="UPDATE PILOTE SET PILSAL=PILSAL*1.05 WHERE PILNO='101"; st.executeUpdate(sql); Page 13 sur 31

2ISA

511502a9-9f62-4813-a20c-d8d1ad59d5d3.doc

Fermeture du ResultSet
rs.close();

Fermeture de la connexion
if (!cn.isClosed()) cn.close();

Classe ResultSetMetaData
Cette classe permet d'obtenir le nombre de colonnes d'un ResultSet (getColumnCount), le nom (getColumnName) et le type(getColumnType) de chacune des colonnes.
ResultSetMetaData meta = rs.getMetaData();

Page 14 sur 31

2ISA

511502a9-9f62-4813-a20c-d8d1ad59d5d3.doc

TP à réaliser : Connexion à une base de données
Objectif :
Créer une fenêtre pour visualiser le contenu d'une table d'une base de données (exemple : table AVIONS en ACCESS, ORACLE ou MySQL). Cette fenêtre doit comprendre :  Des labels, des zones de textes pour afficher le contenu de chaque ligne de la table.  Des boutons pour accéder à la première ligne, à la ligne suivante, à la précédente et à la dernière.   A l'ouverture, la fenêtre affichera la première ligne de la table.

Exemple de résultat à obtenir :

Consignes de réalisation :
Réfléchir à l'agencement des composants sur la fenêtre (utilisation des layout). Structurer en constituant des procédures pour traiter les actions à effectuer pour chaque bouton.

Évolutions possibles (S'il vous reste du temps) :
Créer une classe pour externaliser la connexion. On pourrait imaginer une fenêtre modale (JDialog) qui permettrait de saisir les infos de connexion (user, mot de passe, base) et qui se chargerait d'établir la connexion à la base. Cette classe possède par exemple une méthode getConnection qui renvoie une connexion à notre fenêtre (la connexion sera égale à null si elle n'a pu être établie).

Page 15 sur 31

2ISA

511502a9-9f62-4813-a20c-d8d1ad59d5d3.doc

Utilisation de procédures stockées :
Les exemples ci-dessous utilisent des procédures stockées Oracle écrites en PL/SQL. L’objet cn représente la connexion à la base ORACLE (supposée déjà ouverte).

Appel d’une procédure stockée :
La procédure QUERY_REFLIVRE admet 2 paramètres : en entrée le numéro d’exemplaire et en sortie le référence du livre. La classe CallableStatement permet d’appeler et exécuter une procédure stockée.
CallableStatement cs; //La procédure QUERY_REFLIVRE dépend du package IISA //Elle admet 2 paramètres cs = cn.prepareCall("{call IISA.Query_REFLIVRE(?,?)}"); //La procédure utilise un paramètre en sortie (le deuxième, type VARCHAR) cs.registerOutParameter(2,OracleTypes.VARCHAR); //On indique ici la vleur donnée au premier paramètre (en entrée) cs.setString(1,txtExcleunik.getText()); cs.execute(); //La valeur du paramètre en sortie est récupérée lblReflivre.setText("La référence du livre correspondant est "+ cs.getString(2));

Appel d’une procédure stockée retournant un ResulSet :
La procédure stockée getStagiaires renvoie la liste des stagiaires (ResulSet) correspondant à une promotion (paramètre en entrée).
CallableStatement cs; cs = cn.prepareCall("{call IISA.getStagiaires(?,?)}"); cs.registerOutParameter(2,OracleTypes.CURSOR); cs.setString(1,txtPromo.getText()); cs.execute(); //Nécessité de caster en OracleCallableStatement //pour avoir accès à la méthode getCursor ResultSet rs = ((OracleCallableStatement)cs).getCursor(2);

Le Result Set ainsi obtenu peut être exploité par le programme.

Page 16 sur 31

2ISA

511502a9-9f62-4813-a20c-d8d1ad59d5d3.doc

Création d'une applet :
Une applet est un programme Java qui est exécuté par la machine virtuelle d'un navigateur ou par l'appletViewer du jdk. Il est recommandé de tester les applets dans l'appletViewer pour s'affranchir des problèmes liés au cache. Une applet est un programme Java embarqué dans une page HTML.

Intégration dans une page HTML :
<HTML> <HEAD> <TITLE> </TITLE> </HEAD> <BODY> <APPLET height='200' width='400' code='AppletMessage.class' name='AppletMessage'> <PARAM name='message' value='Ma première applet....'> </APPLET> </BODY> </HTML>

Classe JApplet :
Une applet est une classe qui hérite de la classe JApplet.  La méthode init() permet l'initialisation de l'applet (c'est une sorte de constructeur). Elle est exécutée une seule fois au chargement de l'applet. Elle permet notamment de récupérer la valeur des paramètres.  La méthode start() est appelée après la méthode init().  La méthode stop() est appelée automatiquement lorsqu'on quitte la page HTML.  La méthode destroy() est appelée après l'arrêt de l'applet, elle libère les ressources utilisées, c'est une sorte de destructeur.  La méthode paint(Graphics g) permet d'afficher le contenu de l'applet à l'écran, elle reçoit en paramètre un contexte graphique qui possède des méthodes de dessin.  La méthode repaint() force l'appel à la méthode paint() et permet le rafraîchissement.  La méthode getParameter(String p) permet de récupérer la valeur d'un paramètre à partir de son nom. Pour écrire une applet, on crée une classe qui hérite de JApplet, on peut ainsi redéfinir les méthodes telles que init(), paint().
public class AppletMessage extends JApplet { //Propriétés de l'applet private String message; public void init(){ //Redéfinition de la méthode init } public void paint(Graphics g){ //Redéfinition de la méthode paint } }

Page 17 sur 31

2ISA

511502a9-9f62-4813-a20c-d8d1ad59d5d3.doc

Récupération des paramètres :
Dans la méthode init(), il est possible de récupérer les paramètres passés par le page HTML. On peut aussi créer une interface graphique en ajoutant des composants à la "vitre" de l'applet (comme pour une JFrame).
public void init(){ //Récupération des paramètres message = this.getParameter("message"); }

C'est la méthode getParameter(String) qui permet de récupérer la valeur d'un paramètre à partir de son om. Les valeurs récupérées sont toujours de type String, elles pourront être converties par la suite en utilisant les classes enveloppes telles que Integer, Double, …. Il est conseillé de stocker la valeur de chaque paramètre dans une propriété de l'applet, pour pouvoir ainsi l'utiliser dans les autres méthodes de l'applet.

Ajouter des composants graphiques :
public void init(){ Container c = this.getContentPane(); Jbutton bt1 = new Jbutton("Bouton1"); c.add(bt1); }

Dessiner :
La méthode paint(Graphics) permet d'accéder au contexte graphique qui permet de dessiner.
public void paint(Graphics g){ super.paint(g); g.setColor(Color.RED); g.drawString(message,0,100); }

La classe Graphics possède des méthodes drawString() qui permettent d'écrire une chaine de caractères, setColor(Color) qui permet d'indiquer la couleur utilisée pour l'écriture, de dessiner des images, des formes … (Consulter l'aide au sujet de la classe Graphics).

Page 18 sur 31

2ISA

511502a9-9f62-4813-a20c-d8d1ad59d5d3.doc

TP à réaliser : Une première applet - affichage d’un message
Objectif :
    Ecrire une première applet (une applet hérite de la classe JApplet). Savoir récupérer des paramètres dans la méthode init() Savoir dessiner en utilisant la méthode paint(Graphics g) Tester l’applet avec l’AppletViewer puis créer une page HTML pour la tester avec un navigateur.

Enoncé :
Paramètres de l’applet :  Texte à afficher  Nom de la police à utiliser  Taille de la police  Couleur du texte sous la forme RGB : 255,0,0  Eventuellement, couleur de fond sous la forme RGB Traitements à effectuer : Cette applet affiche un texte en utilisant la police, la taille et la couleur indiquées par l’utilisateur par l’intermédiaire des paramètres. Résultat à obtenir :

Page 19 sur 31

2ISA Classes à utiliser : Classes Méthodes init() JApplet getParameter(String) Paint(Graphics)

511502a9-9f62-4813-a20c-d8d1ad59d5d3.doc

Utilisation Méthode exécutée une fois au chargement de l’applet Récupération d’un paramètre A redéfinir dans l’applet pour récupérer le contexte graphique de l’applet et dessiner grâce à la classe Graphics

Constructeur Constructeur setColor(Color) setFont(Font) drawString(String,int,int) StringTokenizer Constructeur Color Font Graphics

Fixe la couleur utilisée Fixe la police utilisée et ses caractéristiques Permet d’écrire un texte Permet d’isoler les différents éléments constituants d’un paramètre (séparés par une virgule)

Page 20 sur 31

2ISA

511502a9-9f62-4813-a20c-d8d1ad59d5d3.doc

MultiThreading
Toute application java est associé à un processus (thread) principal (lancé par la JVM). En tant que programmeur, vous pouvez choisir de lancer vos propres tâches pour exécuter certains travaux. Tout se passe comme si les tâches s'exécutaient en parallèle, en réalité les différentes tâches s'exécutent en temps partagé. Pour ce faire, nous disposons la classe Thread et de l'interface Runnable. Thread est une classe du package java.lang qui représente une tâche à effectuer, elle possède des méthodes pour démarrer la tâche (start), pour mettre la tâche en sommeil (sleep) pour permettre aux autres tâches d'avoir une chance de se dérouler. Runnable est une interface qui permettra de décrire le travail à effectuer par la tâche.

Créer un objet Runnable
Runnable est une Interface qui possède une seule méthode : run(). Il faut écrire une classe qui implémente l'interface Runnable, cette classe devra posséder une méthode public void run() dans laquelle on va définir le travail à effectuer par la tâche. C'est cette classe qui va contenir le travail à effectuer par la tâche.
public class MessageDefilant extends JApplet implements Runnable { public void run() { //Placer ici le code qui doit être exécuté par la tâche } }

Créer un nouveau processus et le lancer
Créer un objet de type Thread, lui passer l'objet de type Runnable et le démarrer.
public void init() { Thread t = new Thread(this); //this est un objet de type Runnable t.start(); }

Une thread oscille entre plusieurs états. Une tâche est exécutable à partir du moment où elle est démarrée (start) et le reste tant qu'on est pas sorti de la méthode run(). La JVM, donnera du temps d'exécution à la tâche dès qu'elle le pourra. Les tâches doivent être mise en attente pour donner une chance aux autres tâches de s'exécuter. Si on veut par exemple qu'un travail soit effectué à chaque intervalle de temps, on va écrire une boucle sans fin et mettre la tâche en sommeil à chaque intervalle. A noter que la méthode sleep() est une méthode statique. Un thread qui se réveille revient toujours à l'état exécutable.
public void run() { while (true) { // try { Thread.sleep(1000); //Intervalle de temps en millisecondes } catch (InterruptedException e) { e.printStackTrace(); } }

} Un thread est dans un état "mort" quand il est sorti de la méthode run().

Page 21 sur 31

2ISA

511502a9-9f62-4813-a20c-d8d1ad59d5d3.doc

TP à réaliser : Applet avec un message défilant
Objectif :
  Faire évoluer l’applet précédente pour rendre la message défilant. Découvrir le concept de processus (interface Runnable et classe Thread)

Enoncé du problème :
Paramètres de l’applet :  Texte à afficher  Nom de la police à utiliser  Taille de la police  Couleur du texte sous la forme RGB : 255,0,0  Intervalle en millisecondes  Eventuellement, Défilement vertical ou horizontal Traitements à effectuer : Cette applet affiche un texte en utilisant la police, la taille et la couleur indiqués par l’utilisateur par l’intermédiaire des paramètres. Ce texte se déplace à chaque intervalle de temps. Quand il atteint les limites de l’applet, le texte repart au début. Résultat à obtenir :

Page 22 sur 31

2ISA Classes à utiliser : Classes JApplet Utilisation init() getParameter(String) paint(Graphics)

511502a9-9f62-4813-a20c-d8d1ad59d5d3.doc

repaint() Constructeur Color Constructeur Font setColor(Color) Graphics setFont(Font) drawString(String,int,int) StringTokenizer Constructeur hasMoreToken() nextToken() Runnable Thread Interface Constructeur start() run() sleep(long)

Commentaires Exécutée u chargement de l’applet Récupération d’un paramètre A redéfinir dans l’applet pour récupérer le contexte graphique de l’applet et dessiner grâce à la classe Graphics Force l’appel à paint(Graphics)

Fixe la couleur utilisée Fixe la police utilisée et ses caractéristiques Permet d’écrire un texte Permet d’isoler les différents éléments constituants d’un paramètre (séparés par une virgule) Pour être un processus l’applet doit implémenter cette interface Pour créer une tâche Pour la démarrer Contient le code à exécuter par la tâche Pour laisser la main aux autres processus pendant un certain temps (exprimé en millisecondes)

Page 23 sur 31

2ISA

511502a9-9f62-4813-a20c-d8d1ad59d5d3.doc

TP à réaliser : un Diaporama
Objectifs
  Créer une classe qui sera utilisée aussi bien dans une applet que dans une application. Travailler avec des images.

Enoncé du problème :
Traitements : Créer une classe PanneauDiaporama qui hérite de la classe JPanel, qui est aussi un processus. Cette classe a un seul constructeur qui admet un tableau d’images (classe Image) comme paramètre Cette classe affiche une image du tableau chaque seconde. Le défilement des images pourra être arrêté/repris par un clic sur me panneau. Créer une applet qui admette 2 images en paramètre et qui contienne un PanneauDiaporama. Les fichiers images seront copiés dans le dossier de l’applet. On pourra ensuite créer ensuite une deuxième applet qui affichera les images contenues dans un dossier nommé images (situé dans le dossier où se trouve l’applet). Résultats à obtenir :

Page 24 sur 31

2ISA Classes à utiliser : Classes Utilisation init() JApplet getParameter(String) getCodeBase() getImage() JPanel

511502a9-9f62-4813-a20c-d8d1ad59d5d3.doc

Commentaires Exécutée u chargement de l’applet Récupération d’un paramètre Récupère le dossier de base de l’applet (URL) Crée une Image à partir d’une URL et du nom de l’image

Graphics Runnable Thread

Image File

URL

Constructeur paintComponent(Graphics) Récupère la contexte graphique du panneau Semblable à paint() de l'applet repaint() appelle paintComponent() et rafraîchit l'affichage drawImage(…) Permet de dessiner une Image Interface Pour être un processus l’applet doit implémenter cette interface Constructeur Pour créer une tâche start() Pour la démarrer sleep(long) Pour laisser la main aux autres processus pendant un certain temps (exprimé en millisecondes) run() Contient le code à exécuter par la thread Constructeur getScaledInstance Pour redimensionner l'image Constructeur Permet d’explorer un dossier listFiles() Crée un tableau avec les fichiers inclus dans un dossier getPath() Converti une URL en chemin

Page 25 sur 31

2ISA

511502a9-9f62-4813-a20c-d8d1ad59d5d3.doc

Client/serveur
Les étapes :  Le client se connecte au serveur  Le serveur établit une connexion et ajoute le client à sa liste de participants  Un autre client se connecte  Un client envoie un message au serveur.  Le serveur distribue le messages à tous les participants.

Créer un serveur
Le package java.net contient des classes qui permettent d'établir une connexion réseau entre 2 machines. Les 2 machines vont échanger des flux d'informations.
ServerSocket serveur = new ServerSocket(1234);

Il faut indiquer un numéro de port pour la communication. Un serveur attend les requêtes des clients.

Créer un client
Pour créer une connexion au serveur, on doit indiquer son adresse IP et un numéro de port. Le client doit connaître le serveur :
Socket s = new Socket("127.0.0.1",1234); //127.0.0.1 = localhost

Par cette commande, le client demande une connexion au serveur.

Comment le serveur reçoit la demande de connexion d'un client
Socket client = serveur.accept();

La méthode accept bloque en attendant la demande d'un client et récupère une Socket qui lui permet d'entrer en communication avec le client. A ce stade, le serveur ajoute le client à sa liste de participants. Le serveur doit connaître tous ses clients. Pour ce faire, il peut gérer une collection de Socket.

Émettre et recevoir des messages
Pour émettre ou écrire des messages, le client utilise un flot de sortie, pour lire les messages envoyés, le client utilise un flot d'entrée.
PrintWriter sortie = new PrintWriter (client.getOutputStream()); sortie.println("Message envoyé"); sortie.flush(); BufferedReader entree = new BufferedReader( new InputStreamReader(client.getInputStream())); String message = entree.readLine();

De son côté aussi, le serveur communiquera avec chaque client connecté avec leur flot d'entrée ou de sortie.

Page 26 sur 31

2ISA

511502a9-9f62-4813-a20c-d8d1ad59d5d3.doc

TP à réaliser : un serveur et un client de chat
Objectif :
Réaliser 2 applications :  Un serveur de chat (port 1234 par exemple)  Un client

Le serveur :
Le serveur ne peut être lancé qu'une seule fois. Une fois le serveur lancé, il se met à l'écoute des demandes de connexion des clients. Quand un client demande une connexion au serveur, le serveur renvoie au client un message lui indiquant que la connexion est bien établie. Le serveur tient à jour une liste (ArrayList par exemple) des clients connectés. Pour chaque client connecté, le serveur démarre un processus qui se chargera d'écouter les messages envoyés par le client et de les renvoyer à tous les clients connectés. Dans un premier temps, le serveur n'a pas besoin d'interface graphique, la console suffit. Plus tard, il pourra disposer d'une IHM pour tracer les messages reçus par exemple.

Le client :
Le client demande une connexion au serveur en fournissant son adresse ip et un numéro de port (Pour plus de souplesse, on pourra prévoir de saisir ces informations). Une fois la connexion établie, le client peut envoyer un message au serveur. Pur recevoir les messages envoyés par le serveur, le client crée un processus distinct pour écouter les messages envoyés par le serveur. Les messages reçus seront affichés dans un champ de type TextArea. 2 clients ne peuvent pas communiquer directement. Un client envoie un message, le serveur le renvoie à tous les clients connectés (broadcast). Exemple d'IHM pour le client

Les clients et le serveur échangent des messages de type chaînes de caractères.

Page 27 sur 31

2ISA

511502a9-9f62-4813-a20c-d8d1ad59d5d3.doc

Déployer une application avec Java Web Start
JWS est une solution qui permet le déploiement d'une application cliente écrite en Java à travers le réseau. JWS permet l'installation d'une application par un simple clic sur un lien hypertexte contenu dans une page HTML. Cette Technologie permet aussi de mettre à jour l'application si une nouvelle version est disponible sur le serveur. Java Web Start est un programme (javaws) installé sur le client avec le JRE (à partir de la version 1.4). L'application à déployer doit être exportée dans un fichier archive .jar executable. Pour distribuer l'application par le Web, JWS utilise un protocole Java Network Launch Protocol (JNLP).

Étapes à respecter :
     Créer une archive (jar) pour l'application. Créer un fichier JNLP au format XML Créer une page HTML. Enfin copier ces fichiers sur un serveur Web. Tester le déploiement

Créer une archive (jar) pour l'application.
Avec Eclipse, exporter les fichiers nécessaires (.class, ressources : images par exemple) dans un fichier jar. Indiquer la classe qui contient la fonction main() pour obtenir un jar exécutable.

Créer un fichier JNLP
C'est un fichier XML qui permet de décrire l'application. Il donne des informations sur l'application et indique les ressources nécessaires (version JRE, localisation fichiers jar, classe application). Le fichier jnlp sera utilisé par le serveur web pour délivrer les ressources (jar) au client, il sera aussi utilisé par JWS sur la machine cliente pour configurer l'application. XML = Extensible Markup Language ou langage de balisage extensible C'est une méthode pour stocker des données. Celles-ci sont écrites entre des balises et sous forme d'attributs. L'ensemble est écrit sous forme d'un arbre dont la racine, ici, est la balise <jnlp.>
<?xml version="1.0" encoding="utf-8"?> <jnlp codebase="http://172.16.21.17/applications" href="jnlp/chat.jnlp"> <information> <title>Client chat</title> <icon href="icones/group_32.gif"/> <vendor> 2isa </vendor> <offline-allowed/> </information> <resources> <j2se version="1.5+"/> <jar href="jar/ChatClient.jar"/> </resources> <application-desc main-class="ClientObjet"/> </jnlp>

Créer une page HTML.
Créer un lien hypertexte pointant sur le fichier jnlp.
<HTML> <BODY> <a href="jnlp/chat.jnlp"> installer client chat </a> </BODY> </HTML>

Page 28 sur 31

2ISA

511502a9-9f62-4813-a20c-d8d1ad59d5d3.doc

Copier les fichiers sur le serveur Web
Il faut vérifier que le serveur connaît le type mime suivant (voir httpd.conf) :
AddType application/x-java-jnlp-file .jnlp

Tester le déploiement de l'application sur le client
Lancer la page HTML et cliquer sur le lien Il faut que la JRE soit installée sur le client.

L'application est téléchargée sur le poste client, puis elle est lancée. Une fois déployée, elle va s'exécuter en dehors du navigateur, comme n'importe quelle application Java.

Ici l'application chat (côté client) est lancée. Elle est mise en cache sur le poste client.

Page 29 sur 31

2ISA

511502a9-9f62-4813-a20c-d8d1ad59d5d3.doc Le programme javaws.exe permet de voir les applications installées, de les exécuter ou de créer un raccourci sur le bureau pour les futurs lancements. Ici le raccourci crée sur le bureau

demo-client chat

Lors des prochains lancements de l'application, JWS sera capable de détecter si une portion de code a été modifiée et téléchargera automatiquement la nouvelle version sans intervention de l'utilisateur final.

Restrictions liées à la sécurité
Du point de vue de la sécurité, les applications JavaWebStart ont un accès limité aux fichiers et au réseau (bac à sable). Toutefois, une application peut fonctionner sans aucune restriction, si le jar est signé et que le client l'accepte.

Pour en savoir plus
http://java.sun.com/products/javawebstart/1.2/fr/docs/Readme_fr.html

Page 30 sur 31

WindowListener windowActivated (WindowEvent) windowClosed (WindowEvent) windowClosing (WindowEvent) windowDeactivated(WindowEvent) windowDeiconified (WindowEvent) window Iconified (WindowEvent) windowOpened (WindowEvent)

WindowSateListener windowStateChanged(WindowEvent) windowGainedFocus (WindowEvent) windowLostFocus (WindowEvent) WindowFocusListener

MouseListener mouseClicked (MouseEvent) mouseEntered (MouseEvent) mouseExited (MouseEvent) mousePressed (MouseEvent) mouseReleased (MouseEvent)

ActionListener actionPerformed (ActionEvent)

MouseAdapter WindowAdapter windowActivated (WindowEvent) windowClosed (WindowEvent) windowClosing (WindowEvent) windowDeactivated(WindowEvent) windowDeiconified (WindowEvent) window Iconified (WindowEvent) windowOpened (WindowEvent) windowStateChanged(WindowEvent) windowGainedFocus (WindowEvent) windowLostFocus (WindowEvent) class MaFenetre extends JFrame{ … this.addWindowListener (new EcouteurFenetre()); … Class EcouteurSouris extends MouseAdapter{ .. public void mouseClicked (MouseEvent me){ } } class EcouteurFenetre extends WindowAdapter{ public void windowClosing (WindowEvent we){ } } class EcouteurAction implements ActionListener{ public void actionPerformed(ActionEvent ae){ } } JFrame mouseClicked (MouseEvent) mouseEntered (MouseEvent) mouseExited (MouseEvent) mousePressed (MouseEvent) mouseReleased (MouseEvent)

Interface Classe abstraite Classe interne Classe

Diagramme de Classe – Gestion des événements

}

Page 31 sur 31


								
To top