Vous êtes sur la page 1sur 44

Programmation 

événementielle 
g
et réseau avec le langage Java
g g Interface graphique
Interface graphique
Gestion des Événements
Module I6 Système d'Entrée‐Sortie, Flux et Fichiers
Programmation réseau UDP TCP Client Serveur
Programmation réseau, UDP, TCP, Client‐Serveur
IUT d'Aix‐en‐Provence
Réseaux et Télécommunications JAVA
Février 2011
Février 2011 (I6)
Ivan Madjarov
IvMad, Février 2011 2

Les packages (rappel) 
• Un package regroupe un ensemble de classes 
sous un même espace de nommage.
sous un même espace de nommage.
– L'intérêt est de regrouper les classes par :
thème lien logique dépendance
thème, lien logique, dépendance…
– Le package peut être représenté comme un répertoire 
contenant des fichiers classes
d fi hi l
– Permet de limiter la portée du nom des classes
Le langage Java Partie 5
Le langage Java – Partie 5
• Un package peut contenir des sous‐packages
– LLes noms des packages suivent le schéma : 
d k i tl hé
JAVA name.subname.subsubname ...
INTERFACE GRAPHIQUE
INTERFACE GRAPHIQUE • Les API de java sont organisées en packages
((ex: java.lang, java.io, java.net, javax.swing
j g, j ,j ,j g …))
IvMad, Février 2011 3 IvMad, Février 2011 4
Les packages (rappel) Les core API (rappel) 
• Les API les plus courants :
• les noms complets des classes sont : 
nom du package nom de la classe
nom_du_package.nom_de_la_classe – jjava.langg : Types de bases, Threads, Exception, Math, ...
yp , , p , ,
ou encore – java.util : Hashtable, Vector, Stack, Date, ...
package.souspackage.classe – java.applet : Interface vers les applications Web
– java.awt : Interface graphique portable
• pour utiliser des classes sans les préfixer du nom de leur 
– java.io : accès aux i/o par flux (fichiers, stdin, stdout,..)
package il faut :
package il faut : – java.net : Socket (UDP, TCP, multicast), URL, ...
– import package.souspackage.classe;
– java.lang.reflect : introspection sur les classes et les objets
– import package.*;
package *; (TOUTES les classes)
– java.beans : composants logiciels
• Exemple :  – java.sql (JDBC) : accès homogène aux bases de données
– import java.io.File; // UNE seule classe – java.security : signature, cryptographie, authentification
– import java.io.*; // toutes les classes – java.rmi : Remote Method Invocation
• le '*' n ’est pas récursif !  • Les API sont installées en version binaire
L API i llé i bi i
– utilisables via la javadoc associée (au format HTML)
• Implicite dans un prog.java 
p p gj : import
p java.lang.*;
j g
– A télécharger en même temps que le JDK!
A télé h ê t l JDK!
IvMad, Février 2011 5 IvMad, Février 2011 6

Interface graphique Interface graphique
• Deux packages permettent de gérer les interfaces  • Il y a deux principaux types de composants utilisés 
graphiques : AWT et SWING. 
graphiques : AWT et SWING d
dans une interface graphique :
i t f hi
• AWT utilise des composants "lourds", c'est à dire  – les conteneurs
les conteneurs qui sont destinés à contenir d
qui sont destinés à contenir d’autres
autres 
des ressources du système d'exploitation. composants (ex: fenêtres, cadres);
• Swing utilise des composants 
utilise des composants "légers"
légers  qui ne se 
qui ne se – les composants atomiques qui sont des 
réfèrent pas aux ressources système.  composants qui ne peuvent pas en contenir 
– Le Swing est plus robuste que l'AWT,  d’autres (ex: boutons).
Le Swing est plus portable, et plus facile à utiliser. 
– Le Swing est plus portable et plus facile à utiliser L l hi J ài t t
• Les classes graphiques en Java à importer sont:
– Le Swing ne remplace pas complètement AWT – java.awt .
java.awt .*;; // le package de l AWT
// le package de l'AWT
– Le Swing fournit des composants d'interface plus 
– javax.swing.*; // le package du Swing
performants.
performants. 
IvMad, Février 2011 7 IvMad, Février 2011 8
Conteneurs et composants Conteneurs et composants
• Les composants d'une interface graphique sont placés  • Le schéma de dépendance
dans des conteneurs
dans des conteneurs. Object
(fro m l a ng )

– Un conteneur : sous‐classe de la classe java.awt.Container Button Hiérarchie d’héritage


des principaux éléments des
des principaux éléments des 
• Un composant est une partie "visible" de l'interface  Canvas Component interfaces  graphiques en Java

( , )
utilisateur Java (les boutons, les zones de textes). Ch eckbox

Container

– une sous‐classes de la classe abstraite java.awt.Component Choice

• Ch
Chaque objet Conteneur utilise un gestionnaire de 
bj t C t tili ti i d Label
Panel W indow

placement (layout) pour contrôler la taille de l'écran  Scrollbar List

et la disposition des objets qu'il contient. TextComponent
Applet
(fro m a p p l e t)
Dial og Frame

• Un gestionnaire de placement fait la mise en écran 
Un gestionnaire de placement fait la mise en écran
FileDialog
des composants utilisateurs. TextArea TextField

IvMad, Février 2011 9 IvMad, Février 2011 10

Interface graphique AWT Conteneurs et composants
• Un Frame représente une fenêtre de haut niveau avec 
un titre une bordure et des angles de
un titre, une bordure et des angles de 
redimensionnement.
import java.awt.*;
Création d’une fenêtre
public class EssaiFenetre1 (un objet de la classe
{ Frame) avec un titre
public static void main(String[] args)
{
Frame f =new Frame("Ma première fenêtre"); Création du bouton ayant
Button b=
b new Button("coucou");
( ) pour label "coucou"
coucou
f.add(b);
f.pack(); Ajout du bouton dans la
f.show();
(); fenêtre
}
}
On demande à la fenêtre
de c o s la
choisir a ta e
taille
minimum avec pack() et
de se rendre visible avec
show()
()

IvMad, Février 2011 11 IvMad, Février 2011 12


Interface graphique AWT Application graphique AWT
import java.awt.*;  // importer le package graphique de base
class GUIApp {       
class GUIApp { // nom de la classe graphique
// nom de la classe graphique
public static void main(String argv[])  { // la méthode main
// instanciation de l'objet cadre en tant que conteneur
// i i i d l' bj d
Frame fn = new Frame("GUIAppJava");
// instanciation d'un objet de type étiquette avec alignement
Label bnj = new Label("Bonjour tout le monde!",Label.CENTER);
// ajouter le cadre au conteneur avec alignement vertical
fn.add("Center",bnj);
// délimiter le champ visuel
f ( ,
fn.resize(300,150); );
// faire visible à l'écran
fn.show(); } }
fn.show();     }   }
IvMad, Février 2011 13 IvMad, Février 2011 14

import java.awt.*;
public class Fenetre1 extends Frame {
Label la; // étiquette
public static void main (String args[]) {
Fenetre1 f = new Fenetre1("Ma fenêtre");
f.setBounds(200, 100, 300, 300);
Interface graphique Swing
TextField tf; // champ de saisie f.setVisible(true);
TextArea ta ; // aire de saisie
Button b ; // bouton }
f.ta.requestFocus();
• Une application graphique (voir une fenêtre) peut  
Checkbox cb; // Case à cocher
Choice ch; // liste déroulante
}
être construite selon le principe suivant :
être construite selon le principe suivant : 
List li; // Liste simple
Scrollbar sc; // défilement
public Fenetre1(String titre) { // Constructeur
super(titre); // appel à la super-classe Frame
this.setBackground(Color.lightGray); // couleur de fond
la = new Label("Voici une étiquette");
b = new Button("Un bouton");
tf = new TextField("Une ligne de saisie", 30);
tf.setBackground(Color.CYAN);
ta = new TextArea ("Une zone de saisie multiligne", 3 ,30);
ta.setBackground(Color.ORANGE);
ch = new Choice(); // liste déroulante
ch.add ("Lundi"); // ajout de composants
ch.add ("Mardi"); ch.add ("Mercredi");
ch.add ("Jeudi"); ch.add ("Vendredi");
li = new List(); // Liste simple
li.add ("Janvier"); // ajout de composants
li.add ("Février"); li.add ("Mars");
li.add ("Avril"); li.add ("Mai");
cb = new Checkbox("R&T 2010", true); // case à cocher
sc = new Scrollbar(Scrollbar.HORIZONTAL, 100 , 30 , 0, 1000);
FlowLayout fl = new FlowLayout (FlowLayout.CENTER, 5, 5);
this.setLayout(fl);
add(la); add(b); add(ta); add(tf);
add(ch); add(li); add(cb); add(sc);
} IvMad, Février 2011 15 IvMad, Février 2011 16
Interface graphique Swing Fenêtre graphique Swing
• L'ordre d'affichage des composants :  • JWindow : C'est la fenêtre la plus basique. C'est juste 
un conteneur sans barre de titre boutons de
un conteneur  sans barre de titre, boutons de 
fermeture et n'est pas redimensionnable.
• JDialog : C'est une fenêtre destinée aux boîtes de 
dialogue Ce type de fenêtre est modal c à d qu'elle
dialogue.  Ce type de fenêtre est modal, c.à.d. qu elle 
bloque une autre fenêtre tant qu'elle est ouverte. 
• JFrame : Forme la fenêtre principale d'une 
application. Ne dépendant d'aucune autre fenêtre et 
pp p
ne peut pas être modale.  Elle a une barre de titre, 
bouton de fermeture et de redimensionnement et 
bouton de fermeture et de redimensionnement et
peut accueillir une barre de menu et peut être 
iconifié
iconifié.
IvMad, Février 2011 17 IvMad, Février 2011 18

La hiérarchie des composants La hiérarchie des composants
• Button : classe des boutons à cliquer. • Container : classe abstraite (sans objet) qui sert de support à 
• Canvas : objet zone de dessin.
: objet zone de dessin d'autres composants. Principales méthodes : add(), remove()
p p (), ()
• Checkbox : boîte à cocher. – Panel : c'est un objet conteneur qui contient lui‐même 
d'autres
d autres conteneurs, placé souvent dans un objet Frame.
conteneurs, placé souvent dans un objet Frame.
• CheckboxGroup : objet qui regroupe plusieurs objets 
Checkbox réalise un ensemble de boutons radio. – Applet: application interprétée par un navigateur Web.
• Choice : objet qui permet de gérer une liste de choix. • Window : fenêtre d
: fenêtre d'application
application sans bordure, ni barre de 
sans bordure ni barre de
menus; c'est un conteneur, géré par défaut par un 
• Label : affiche simplement une ligne de texte fixe (étiquette). BorderLayout Rarement instanciée directement on utilise ses
BorderLayout. Rarement instanciée directement, on utilise ses 
• List : objet spécialisé dans l'affichage d'une liste d'items. sous‐classes Dialog et Frame. 
• : objet pour choisir une valeur dans un intervalle
Scrollbar : objet pour choisir une valeur dans un intervalle. Méthodes : setVisible(), dispose(), pack().
Méthodes :  setVisible() dispose() pack()
• TextComponent : – Dialog : fenêtre de dialogue, qui dépend d'une fenêtre Frame, 
– TTextField
tFi ld : une simple ligne d'édition (champ de saisie).
i l li d'éditi ( h d ii ) aussi conteneur
aussi conteneur
– TextArea : zone d'édition de texte de plusieurs lignes, munie de  – Frame : fenêtre encadrée affichable, redimensionnable : c'est la 
barres de défilement
barres de défilement. fenêtre typique d'une
fenêtre typique d une application graphique Java.
application graphique Java.
IvMad, Février 2011 19 IvMad, Février 2011 20
Interface graphique ‐ Fenêtre Interface graphique ‐ Fenêtre
• Une fenêtre (conteneur) de type JFrame • Une fenêtre (conteneur)  héritée de type JFrame
import javax.swing.JFrame;
public class TestFen {
import javax.swing.Jframe;
public static void main(String[] args){
public class Fenetre extends Jframe {
// Instancier
sta c e l'objet
objet fenêtre
e êt e
public
bli Fenetre()
F t () {
JFrame fn = new JFrame();
// Définir un titre pour la fenêtre
// Définir un titre pour votre fenêtre
this.setTitle("Ma première fenêtre java");
fn setTitle("Ma
fn.setTitle( Ma première fenêtre java");
java );
// Définir sa taille: 400 px de large et 500 px de haut
// Définir sa taille: 500 px de large et
this.setSize(400, 500);
// 400 px de haut
// p
positionner au centre
f
fn.setSize(500,
tSi (500 400)
400);
this.setLocationRelativeTo(null);
// Alignement centré
// Fermer lorsqu'on clique sur "Fermer" !
fn.setLocationRelativeTo(null);
this setDefaultCloseOperation(JFrame EXIT ON CLOSE);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//Terminer le processus au clique "Fermer"
// Rendre visible
fn.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setVisible(true);
// Rendre visible la fenêtre à l'écran
}
fn.setVisible(true);
}
}
}

IvMad, Février 2011 21 IvMad, Février 2011 22

Interface graphique ‐ Fenêtre Interface graphique ‐ bouton


• Méthodes liées au  JFrame : import java.awt.* ;
– Positionner
Positionner la fenêtre à l
la fenêtre à l'écran
écran :: po t ja a s g ;
import javax.swing.* ;
<refObjet>.setLocation(int x, int y);  class MaFenetre extends JFrame {
– Empêcher le redimensionnement de la fenêtre :
Empêcher le redimensionnement de la fenêtre private JButton MonBouton ;    // bouton
; // bouton
<refObjet>. setResizable(false); public MaFenetre ()  {                 // Constructeur
– Faire que la fenêtre soit toujours au premier plan :
l f ê l super() ; // Appel au constructeur de la classe JFrame
super() ; // Appel au constructeur de la classe JFrame
<refObjet>. setAlwaysOnTop(boolean b); setTitle("Ma première fenêtre avec un bouton") ;
// initialisation du titre de la fenêtre
// initialisation du titre de la fenêtre
– Retirer les contours et les boutons de contrôles :
<refObjet>. setUndecorated(Boolean b); setBounds(10, 40, 300, 200) ;
// l
// le coin supérieur gauche de la fenêtre est placé au pixel de 
i éi h d l f ê l é i ld
– Référencer le conteneur :
coordonnées x=10, y=40 et ses dimensions seront de 300 X 
f j g
<refObjet>. getContentPane(); (); 200 i l
200 pixels.

IvMad, Février 2011 23 IvMad, Février 2011 24


Interface graphique ‐ bouton Interface graphique ‐ bouton
MonBouton = new JButton("Un bouton") ; public class MonProgGraphique {
//* création d
création d’un
un bouton de référence MonBouton
bouton de référence MonBouton portant public static void main(String args[]) {
public static void main(String args[]) {
l’étiquette "Un bouton" */
JFrame  fen = new MaFenetre() ;
getContentPane().add(MonBouton) ;
tC t tP () dd(M B t )
/* Pour ajouter un bouton à une fenêtre, il faut incorporer
fen.setVisible(true) ;
le bouton dans le contenu de la fenêtre.  // rend isible la fenêtre de référence fen
// rend visible la fenêtre de référence fen
La méthode getContentPane de la classe JFrame fournit une  }
référence à ce contenu, de type Container. }
La méthode add de la classe Container permet
p
d’ajouter le bouton au contenu de la fenêtre. */
}
}

IvMad, Février 2011 25 IvMad, Février 2011 26

Interface graphique ‐ bouton Conteneurs Swing : JFrame


• Un bouton est visible par défaut. • Montrer et cacher un composant 
• Une fenêtre
Une fenêtre de de type JFrame
type JFrame peut être retaillée, 
peut être retaillée void setVisible(boolean b)
déplacée et réduite à une icône. • Activer et désactiver un composant 
void setEnabled(boolean b)
• La fermeture de la fenêtre ne met pas fin au 
p g
programme, mais rend simplement la fenêtre 
, p • Modifier la couleur de fond d'un composant
void setBackground(Color c)
invisible. 
• Modifier la couleur du premier plan d'un composant
• Pour mettre fin au programme, il faut fermer la 
P tt fi il f t f l void setForeground(Color c)
fenêtre console ou interrompre le programme par 
• Modifier la taille d
Modifier la taille d'un
un composant
composant
Ctrl/c! void setSize(int largeur, int hauteur)
• Modifier la position et la taille d'un composant
Modifier la position et la taille d'un composant
void setBounds(int x, int y, int largeur, int hauteur)

IvMad, Février 2011 27 IvMad, Février 2011 28


Les composants atomiques Les composants atomiques
• La classe JComponent est une classe abstraite  • La méthode setPreferredSize de la classe 
dérivée de la classe Container
dérivée de la classe Container Jcomponent permet d
permet d'imposer
imposer une taille à un 
une taille à un
• La classe JComponent
p encapsule les composants 
p p composant. 
atomiques d'une interface graphique, tels que: • Elle prend en argument un objet de type 
– boutons,  Dimension.
Dimension
– les cases à cocher,
les cases à cocher • Exemple:
p
– les boutons radio,  JButton bouton = new JButton("Un bouton") ;
– les étiquettes,  bouton.setPreferredSize(new Dimension(10, 20)) ;
– les champs de texte,  // b t d l
// bouton de largeur 10 et de hauteur 20 pixels
10 t d h t 20 i l
– les boîtes de liste.
les boîtes de liste
IvMad, Février 2011 29 IvMad, Février 2011 30

Les cases à cocher Les cases à cocher
• La case à cocher de type JCheckBox permet à  • Par défaut, une case à cocher est construite dans 
ll’utilisateur
utilisateur d
d’effectuer
effectuer un choix de type oui/non. 
un choix de type oui/non l’ét t
l’état non coché (false). 
hé (f l )
Exemple:
• La
La méthode isSelected
méthode isSelected de la classe AbstractButton
de la classe AbstractButton
class MaFenetre extends JFrame  {
permet de connaître l’état (true ou false). 
p
private JCheckBox MaCase;
public MaFenetre ()  { • La méthode setSelected de la classe 
super("Ma
super( Ma première fenêtre
première fenêtre")) ;; AbstractButton permet de modifier l
permet de modifier l’état
état d
d’une
une 
setBounds(10, 40, 300, 200) ; case à cocher.
M C
MaCase = new JCheckBox("Une case") ;
JCh kB ("U ")
• Exemple:
// la référence MaCase portant l’étiquette Une case
getContentPane().add(MaCase) ; MaCase.setSelected(true) ;
M C tS l t d(t )
} }
}   } // coche la case de référence MaCase
//
IvMad, Février 2011 31 IvMad, Février 2011 32
Les boutons radio Les étiquettes
class MaFenetre extends JFrame {
private JRadioButton bRouge;          private JRadioButton bVert;
• Une étiquette de type JLabel permet d’afficher 
public MaFenetre() { dans un conteneur un texte
dans un conteneur un texte (d
(d’une
une seule ligne) 
seule ligne)
super("Une fenetre avec des boutons radio") ;        setBounds(10,40,300,200) ; non modifiable, mais que le programme peut 
bRouge = new JRadioButton("Rouge")
bRouge = new JRadioButton( Rouge ) ;   // bouton radio de référence bRouge
; // bouton radio de référence bRouge
bVert = new JRadioButton("Vert") ;   // bouton radio de référence bVert
faire évoluer.
pg p
ButtonGroup groupe = new ButtonGroup() ; p() ; ...
groupe.add(bRouge) ;        groupe.add(bVert) ; private JLabel MonTexte;
/* Un objet de type ButtonGroup sert à désactiver un bouton dans le groupe 
activé.  Sinon le bouton radio se comporte comme une case à cocher */
i é Si l b di à h */ ...
Container contenu = getContentPane() ;   contenu.setLayout(new FlowLayout()) ; MonTexte = new JLabel ("texte initial") ;
//* Un objet de type FlowLayout
Un objet de type FlowLayout est un gestionnaire de mise en forme qui dispose 
est un gestionnaire de mise en forme qui dispose
les composants les uns à la  suite des autres */ //
//Une étiquette de référence MonTexte
é d éfé avec  "texte initial"
" l"
contenu.add(bRouge) ;  contenu.add(bVert) ; getContentPane().add(MonTexte) ;
/* Ajout de chaque bouton radio dans la fenêtre. Un objet de type ButtonGroup MonTexte.setText("nouveau texte") ;
n’est pas un composant et ne peut pas être ajouté à un conteneur */
} //modification du texte de l étiquette de référence MonTexte
//modification du texte de l’étiquette de référence MonTexte
}
IvMad, Février 2011 33 IvMad, Février 2011 34

Les champs de texte Les boîtes de liste
• Un champ de texte de type JTextField est une zone  • Le type JList permet de choisir une ou plusieurs 
rectangulaire dans laquelle l’utilisateur
rectangulaire dans laquelle l utilisateur peut entrer 
peut entrer valeurs dans une liste prédéfinie Initialement
valeurs dans une liste prédéfinie.  Initialement, 
ou modifier un texte (d’une seule ligne). aucune valeur n’est sélectionnée dans la liste.
… • Exemple:
p
private JTextField MonChamp1 ;
p
String[] couleurs = 
String[] couleurs =

{"rouge", "bleu", "gris", "vert", "jaune", "noir"};
MonChamp1 = new JTextField("texte
MonChamp1 = new JTextField( texte initial
initial", 20) ;
20) ;
JList MaListe = new Jlist(couleurs) ;
//champ de taille 20 caractères avec un texte initial
getContentPane().add(MonChamp1) ;
C P () dd(M Ch 1) MaListe setSelectedIndex(2) ;
MaListe.setSelectedIndex(2) ;
• La méthode getText
g permet de connaître à tout 
p //sélection préalable de l’élément de rang 2
moment le contenu d’un champ de texte. Exemple
String ch= Monchamp1 getText() ;
String ch= Monchamp1.getText() ;
IvMad, Février 2011 35 IvMad, Février 2011 36
Les boîtes de liste combinée Les boîtes de liste combinée
• Le type JComboBox associe un champs de texte et  String[] couleurs = 
une boîte de liste à sélection simple Tant que le
une boîte de liste à sélection simple. Tant que le  {{"rouge"
rouge , "bleu"
bleu , "gris"
gris , "vert"
vert , "jaune"
jaune , "noir"};
noir };
composant n'est pas sélectionné, seul le champ de  JComboBox MaCombo = new JComboBox(couleurs) ;
texte s'affiche : MaCombo.setSelectedIndex(2) ;
• Lorsque l
Lorsque l'utilisateur
utilisateur sélectionne le champ de texte, 
sélectionne le champ de texte //sélection préalable de l’élément
//sélection préalable de l élément de rang 2
de rang 2
la boîte de liste s'affiche : • La boîte combo est dotée d'une barre de défilement 
dès que son nombre de valeurs est supérieur à 8. On 
peut modifier le nombre de valeurs visibles à 4:
MaCombo.setMaximumRowCount(4) ;
• Pour récupérer l’élément choisi on utilise la méthode:
P é é l’élé t h ii tili l éth d
• L'utilisateur peut choisir une valeur dans la boîte 
g = (String) MaCombo.
String ch g getSelectedItem() ;
g
de liste qui s'affiche
de liste qui s affiche alors dans le champ de texte.
alors dans le champ de texte
IvMad, Février 2011 37 IvMad, Février 2011 38

Les dessins avec Java Dessin dans un panneau
• Pour dessiner, on utilise, en général, un conteneur  • Pour obtenir un dessin permanent dans un 
de type JPanel qui est un composant intermédiaire
de type JPanel qui est un composant intermédiaire on appel la méthode :
composant on appel la méthode
(panneau).  void paintComponent (Graphics g)
– Il peut être contenu dans un conteneur et peut contenir
Il t êt t d t t t t i • L’argument g de type Graphics est le contexte
d’autres composants.
g p q
graphique du composant qui a appelé la méthode. 
p q pp
• Un panneau est une sorte de "sous‐fenêtre", sans  Il sert d’intermédiaire entre les demandes de 
titre ni bordure, qui doit être associé par la  dessin et leur réalisation effective sur le 
dessin et leur réalisation effective sur le
méthode add (de la classe Container) à un autre  composant.
conteneur,, ggénéralement une fenêtre.
– getContentPane().add(panneau) ;
Le gestionnaire de mise en forme FlowLayout
• Le gestionnaire de mise en forme FlowLayout est 
est
le gestionnaire par défaut des panneaux.
IvMad, Février 2011 39 IvMad, Février 2011 40
Dessin dans un panneau La police du contexte graphique
• Les couleurs sont représentés par un objet de type  • Une police est définie par le type Font
Color Font f new Font("Serif"
– Font f = new Font( Font ITALIC 18);
Serif , Font.ITALIC, 18);
• Les constantes prédéfinies de la classe Color sont :  – un nom de famille de police (SansSerif, Serif, 
– Color.black, Color.white, Color.blue, Color.green, 
Monospaced) d)
Color.red, Color.yellow.
Color.red, Color.yellow. – un style : style normal (Font.PLAIN), style gras
y y ( ) y g
(Font.BOLD), style italique (Font.ITALIC)
• On peut récupérer ou modifier la couleur de 
d’ t l d l' iè l
d’avant plan ou de l'arrière plan par: On peut récupérer la police du contexte graphique:
• On peut récupérer la police du contexte graphique:
– setForeground ou setBackground
– public abstract Font getFont()
– getColor() et setColor(Color c) • modifier la police du contexte graphique
p ( f)
– public abstract setFont(Font f)
• Les méthodes getColor et setColor sont des 
L éth d tC l t tC l td
méthodes de la classe Graphics. • Les méthodes getFont et setFont sont des 
méthodes de la classe Graphics.
méthodes de la classe Graphics
IvMad, Février 2011 41 IvMad, Février 2011 42

Méthodes de dessin (Graphics) Exemple
public abstract void drawLine(int x1, int y1, int x2, int y2) import java.awt.*;
Trace un trait du point de coordonnées (x1 y1) au point
Trace un trait du point de coordonnées (x1, y1) au point import javax.swing.*;;
import javax.swing.
decoordonnées (x2, y2) class MaFenetre extends JFrame {
public void drawRect(int x, int y, int largeur, int hauteur)
public void drawRect(int x int y int largeur int hauteur) private JPanel panneau;
private JPanel panneau;
Dessine un rectangle de largeur largeur et de hauteur public MaFenetre () {
hauteur au point de coordonnées (x y)
hauteur au point de coordonnées (x, y) super("Une
super( Une fenetre avec un panneau jaune
fenetre avec un panneau jaune");
);
public void drawOval(int x, int y, int largeur, int hauteur) setSize(200, 150); panneau = new Panneau();
Dessine un ovale de largeur largeur et de hauteur hauteur panneau setBackground(Color yellow)
panneau.setBackground(Color.yellow);
au point de coordonnées (x, y) getContentPane().add(panneau);
public abstract void drawstring(String str, int x, int y) }
p
Dessine le texte str au point de coordonnées (x, y) y public static void main(String args[]) {
JFrame fen = new MaFenetre11() ;
fen.setVisible(true) ; 
} }
IvMad, Février 2011 43 IvMad, Février 2011 44
Exemple Exemple
class Panneau extends JPanel { • La classe des figures géométriques développée déjà 
public void paintComponent(Graphics g) {
public void paintComponent(Graphics g) { peut servir de base pour un exercice de dessin
peut servir de base pour un exercice de dessin 
super.paintComponent(g) ; graphique en Java. Voici le résultat souhaité :  
Font f = new Font( Serif , Font.ITALIC, 18);
Font f = new Font("Serif" Font ITALIC 18);
g.setColor(Color.black); g.setFont(f);
g drawString("Rectangle"
g.drawString( Rectangle , 50, 20);
50 20);
g.setColor(Color.red);
g drawRect(50 30 80 50)
g.drawRect(50, 30, 80, 50);
}
}

IvMad, Février 2011 45 IvMad, Février 2011 46

La gestion de la mise en forme La gestion de la mise en forme
• Pour chaque conteneur (fenêtre, boîte de dialogue, • Le gestionnaire de type FlowLayout organise les objets 
…), Java
) Java permet de choisir un gestionnaire de mise 
permet de choisir un gestionnaire de mise ggraphiques dans la fenêtre
p q de gauche à droite et de 
g
en forme ("Layout manager") responsable de la  haut en bas suivant 
disposition des
disposition des composants. (en colonnes, les uns
composants (en colonnes les uns à 
à j
– Les objets sont insérés dans le conteneur à l'aide de la 
la suite des autres, en cercle, ...). méthode add.

– BorderLayout, FlowLayout, CardLayout,
BorderLayout FlowLayout CardLayout GridLayout, 
GridLayout • Les
Les gestionnaire de type GridLayout
gestionnaire de type GridLayout organise les objets 
organise les objets
BoxLayout, GridBagLayout. graphiques dans la fenêtre suivant un quadrillage en 
lignes et colonnes dont les dimensions sont spécifiées 
éh d
• La méthode setLayout d l l
de la classe Container par l'utilisateur au moment de la création du 
permet d'associer un gestionnaire de mise en  gestionnaire. 
f
forme à un conteneur. 
à – Les objets sont insérés séquentiellement à partir de la case 
• Le ggestionnaire BorderLayout
y g
est le gestionnaire  en haut à gauche de la fenêtre, de gauche à droite et de haut 
en bas, suivant l'ordre des appels à la méthode add.
en bas suivant l'ordre des appels à la méthode add
par défaut des fenêtres et des boîtes de dialogue.

IvMad, Février 2011 47 IvMad, Février 2011 48


Les gestionnaires Le gestionnaire BorderLayout
• Le gestionnaire de mise en forme CardLayout  • Ce gestionnaire permet de placer chaque 
permet de disposer les composants suivant une 
permet de disposer les composants suivant une composant dans une zone géographique
composant dans une zone géographique.
pile.
– Seul  le composant supérieur est visible à un moment 
S l l t éi t i ibl à t
donné. Par défaut, c’est le premier ajouté au conteneur.
• Le gestionnaire de mise en forme GridLayout
permet de disposer les composants les uns à la 
suite des autres sur une grille régulière (tableau).
public GridLayout(rows, cols, hgap, vgap);
public GridLayout(rows, cols, hgap, vgap);
– rows et cols définissent respectivement le nombre de
lignes et de colonnes de la grille.
lignes et de colonnes de la grille
– hgap, vgap définissent respectivement l’espacement 
entre les composants placés en écran
entre les composants placés en écran.
IvMad, Février 2011 49 IvMad, Février 2011 50

Le gestionnaire BorderLayout Le gestionnaire BorderLayout


class MaFenetre extends JFrame { • La classe dispose de deux constructeurs :
public MaFenetre ()  {
public MaFenetre () { bl d ()
public BorderLayout() ;
super("Une fenetre") ;     setSize(300, 200) ;
p y ( g p, g p) ;
public BorderLayout(int hgap, int vgap) ;
Container contenu = getContentPane() ; ()
contenu.setLayout(new BorderLayout()) ;   • hgap et vgap définissent l'espace horizontal et 
contenu.add(new JButton("UN")) ; vertical (en pixels) entre
ti l ( i l ) t les composants d'un 
l t d'
// bouton placé au centre par défaut
// p p f conteneur. (5 pixels par défaut).
contenu.add(new JButton("DEUX"), "North") ; • BorderLayout ne tient pas compte de la taille 
contenu add(new JButton("TROIS")
contenu.add(new JButton( TROIS ), "South")
South ) ;; souhaitée des composants
souhaitée des composants.
contenu.add(new JButton("QUATRE"), "West") ;
p p
• Leur taille peut être définie par la méthode 
contenu.add(new JButton("CINQ"), "East") ;
setPreferredSize de la classe JComponent
}
}
IvMad, Février 2011 51 IvMad, Février 2011 52
Le gestionnaire FlowLayout Le gestionnaire FlowLayout
• La classe FlowLayout dispose de trois constructeurs : class MaFenetre extends JFrame {
1 public FlowLayout() ;
1. public FlowLayout() ; public MaFenetre () {
public MaFenetre () {
2. public FlowLayout(int align) ; super("Une fenetre") ; setSize(300, 100) ;
Container contenu = getContentPane() ;
Container contenu = getContentPane() ;
• align
li est un paramètre d'alignement d'une ligne de
è d' li d' li d
contenu.setLayout(new FlowLayout()) ;
composants par rapport aux bords verticaux de la 
f ê
fenêtre. contenu add(new JButton("UN"))
contenu.add(new JButton( UN )) ;;
contenu.add(new JButton("DEUX")) ;
FlowLayout.LEFT("Left"), 
}
FlowLayout.RIGHT("Right")
FlowLayout.CENTER( Center ). 
FlowLayout.CENTER("Center").
• Par défaut les composants sont alignés à gauche.
3.
3 public FlowLayout(int align, int hgap, int vgap) ;
bli Fl L t(i t li i th i t )
• hgap et vgap définissent les espaces entre les composants.
IvMad, Février 2011 53 IvMad, Février 2011 54

Les menus déroulants Les menus déroulants
• Les menus sont des composants d'un conteneur JFrame. private JMenuBar barreMenus ;
private JMenu couleur, dimensions ;
• Les menus déroulants font intervenir trois
Les menus déroulants font intervenir trois sortes d
sortes d'objets:
objets: private JMenuItem rouge,
rouge vert,
vert hauteur
hauteur, largeur ;

– un objet barre de menu de type JMenuBar ; ….
// création d'une
// création d une barre de menu
barre de menu
– différents objets menu (Jmenu), visibles sur la barre de menu 
barreMenus = new JMenuBar() ;
– pour chaque menu, les différentes options, de type  setJMenuBar(barreMenus) ;
JMenuItem, qui le constituent. // ajouter la barre de menu dans la fenêtre
// création d'un menu Couleur et de ses options Rouge
couleur = new JMenu("Couleur") ;
barreMenus.add(couleur) ;
rouge = new JMenuItem("Rouge") ;
couleur.add(rouge) ;
couleur addSeparator() ;
couleur.addSeparator()
// ajouter une barre séparatrice avant l'option suivante

IvMad, Février 2011 55 IvMad, Février 2011 56


Les menus déroulants Les boîtes de dialogue
vert = new JMenuItem("Vert"); couleur.add(vert) ; • La boîte de dialogue est un conteneur qui  permet de 
// é i d'
// création d'un menu Dimensions et de ses options "Hauteur" et "Largeur"
Di i d i "H " "L " regrouper des composants dans une fenêtre qu'on
regrouper des composants dans une fenêtre qu fait
on fait 
dimensions = new JMenu("Dimensions"); apparaître ou disparaître.
barreMenus.add(dimensions); • Java propose un certain nombre de boîtes de dialogue 
hauteur = new JMenuItem("Hauteur");
di
dimensions.add(hauteur);
i dd(h t ) dimensions.addSeparator()
di i ddS t () ;
standard obtenues à l'aide de méthodes de la classe 
largeur = new JMenuItem("Largeur") ; JOptionPane : 
dimensions add(largeur) ;
dimensions.add(largeur) – boîtes de message
boîtes de message, 
– boîtes de confirmation, 
– boîtes de saisie et boîtes d'options. 
– La classe JDialog
La classe JDialog permet de construire des boîtes de 
permet de construire des boîtes de
dialogue personnalisées.

IvMad, Février 2011 57 IvMad, Février 2011 58

Les boîtes de message Les boîtes de message
• Une boîte de message fournit à l'utilisateur un  import java.awt.* ;
message qui reste affiché tant que l'utilisateur
message qui reste affiché tant que l'utilisateur  javax swing * ;
import javax.swing.
n'agit pas sur le bouton OK.  class MaFenetre extends JFrame {
public
bli MaFenetre
M F t () {
• Elle est construite à l'aide de la méthode de classe  super("Une fenêtre") ; setSize(400, 300) ; }
showMessageDialog de la classe JOptionPane.
de la classe JOptionPane public static void main(String args[ ]) {
JFrame fen = new MaFenetre() ; fen.setVisible(true) ;
JOptionPane.showMessageDialog(fen, "Bonjour") ;
//* le premier argument correspond à la fenêtre parent de la
boîte de message. Cet argument peut prendre la valeur
null.
null *//
}
}
IvMad, Février 2011 59 IvMad, Février 2011 60
Les boîtes de confirmation Les boîtes de saisie
• La boîte offre un choix de type oui/non à l'aide • La boîte permet l’acquisition d'une chaîne de
de la méthode de classe showConfirmDialog caractères.
de la classe JOptionPane. • La boîte de saisie est construite à l'aide de la
méthode showInputDialog de la classe
JOptionPane.
public class BoiteConf { public
bli class
l B
BoiteSaisie
it S i i {
public static void main(String args[ ]) { public static void main(String args[ ]) {
JF
JFrame ffen = new M F t () ;
MaFenetre() JFrame fen = ne new MaFenetre() ;
fen.setVisible(true) ; fen.setVisible(true) ;
JOptionPane showInputDialog (fen
JOptionPane.showInputDialog (fen, "Donnez
Donnez un texte
texte")) ;
JOptionPane.showConfirmDialog(fen, "Voulez-vous
}
continuer ?") ;
}
}
}
IvMad, Février 2011 61 IvMad, Février 2011 62

Affichage d’images Affichage d’images (exemple)
• Java traite deux formats d’images :  import java.awt.*;
import javax.swing.*;
le format GIF (Graphical Interface Format) avec 256 
– le format GIF (Graphical Interface Format) avec 256
class MaFenetre extends JFrame {
couleurs disponibles.
private JPanel pan;
– le format JPEG
le format JPEG (Joint Photographic Expert Group) avec 
(Joint Photographic Expert Group) avec public MaFenetre() {
plus de 16 millions de couleurs disponibles. super("Une fenetre avec une image");
• Trois étapes de chargement d'une image:
T i é d h d' i setSize(300, 245);
– le constructeur de la classe ImageIcon permet de  pan = new Panneau();
charger une image. getContentPane().add(pan); 
– la méthode getImage
g g ppermet d'obtenir un objet de 
j }
type Image depuis un objet de type URL ou depuis un  public static void main(String args[]) {
bli i id i (S i []) {
fichier local. JFrame fen = new MaFenetre() ;
fen.setVisible(true) ; 
f tVi ibl (t )
– la méthode drawImage permet d’afficher une image de 
}
type Image.
}
IvMad, Février 2011 63 IvMad, Février 2011 64
Affichage d’images (exemple) Affichage d’images (exemple)
class Panneau extends JPanel {
private ImageIcon rouge;
public Panneau() {
img = new ImageIcon("IMG_1683.jpg") ;
// chargement d'une image dans l’objet de référence img, à partir 
h t d' i d l’ bj t d éfé i à ti
d’un fichier
}
public void paintComponent(Graphics g) {
super.paintComponent(g);
Image imG = img.getImage();
// la méthode getImage retourne une référence à un objet de type 
Image à partir d
à partir d’un
un objet de type ImageIcon
objet de type ImageIcon
g.drawImage(imG, 5, 5, this);
// g
// affiche l’image imG p ( , )
au point de coordonnées (5, 5)
// this pour appeler la méthode repaint()
}
}
IvMad, Février 2011 65 IvMad, Février 2011 66
Programmation événementielle 
Programmation événementielle
et réseau avec le langage Java
et réseau avec le langage Java
Module I6 Le langage Java –
g g Partie 6

IUT d'Aix‐en‐Provence
Réseaux et Télécommunications INTERFACE GRAPHIQUE ET LA
Février 2011
Février 2011 GESTION DES ÉVÉNEMENTS
GESTION DES ÉVÉNEMENTS
Ivan Madjarov

IvMad, I6, Février 2011 2

Le concept d'événement Le concept d'événement
• La programmation événementielle se base sur la  • Chaîne d'événements dans une application Java
conception du comportement
p p d'un programme :
p g – L'événement est une action d'un utilisateur sur un dispositif 
p
– Un programme a un déroulement permanent, en  physique d'interface. (une souris, un clavier,...)
interaction et au service d'un utilisateur. – L'événement est traduit en un "code d'événement matériel" par 
le dispositif d analyse et de contrôle de l
le dispositif d'analyse interface. (un contrôleur 
et de contrôle de l'interface (un contrôleur
– Le programme ne "fait rien" tant que l'utilisateur ne lui  appropriée qui reconnait son "interruption code")
demande "rien".  – Ce code d'événement matériel provoque une "interruption" du 
• Dans la programmation événementielle existe une  système d'exploitation.
è d' l
"boucle d'attente", qui permet au processeur  – Le système d'exploitation 
communique le code à 
communique le code à
d' tt ib d t à d' t
d'attribuer du temps à d'autres programmes  un service de distribution
(fonction d'interruption du système d'exploitation).  d'événements.
• Lorsqu'un utilisateur intervient, il envoie un 
L ' tili t i t i t il i – C
Ce service
i est sensé savoir
t é i
"événement" au programme. à quelle application 
est destiné cet événement.
• L'événement est un "objet" passé à une fonction 
L'é é t t " bj t" éà f ti – L'événement "système" 
particulière du programme, chargée de son  est fourni à la MVJ qui l'a
vers le logiciel qui est sensé le traiter
acheminement vers le logiciel qui est sensé le traiter. distribue à l'objet
distribue à l concerné.
objet concerné.
IvMad, I6, Février 2011 3 IvMad, I6, Février 2011 4
La gestion des événements Traiter un événement
• Exemples d’événements: • En général tout événement qui peut se produire 
– Un clic souris
Un clic souris,  dans une interface graphique est de type XXXEvent
dans une interface graphique est de type XXXEvent
– La frappe d’une touche au clavier,
– Le changement de la taille d une fenêtre.
changement de la taille d’une fenêtre ( ) g
• Le traitement des événements (Event) est délégué à 
• En Java, les événements n’ont pas une valeur  des objets particuliers appelés écouteurs (Listener)
physique mais logique. 
physique, mais logique • En fonction des événements
En fonction des événements qu’ils traitent, un 
qu’ils traitent un
• Un événement dépend du composant qui l’a  écouteur doit implémenter une interface
é éé
généré. particulière, dérivée de l’interface EventListener, 
• On appelle source d’un événement l’objet qui l’a  qui correspond à une catégorie d’événements.
qui correspond à une catégorie d événements.
généré.
é éé
– MouseEvent : un clic souris dans une fenêtre – Pour traiter un événement de type XXXEvent, un 
– ActionEvent : un clic souris sur un bouton écouteur doit implémenter l’interface XXXListener.
é t d it i lé t l’i t f XXXLi t

IvMad, I6, Février 2011 5 IvMad, I6, Février 2011 6

Traiter un événement Traiter un événement
• En général l'écouteur d'événement d'un composant d'interface, 
• Interfaces à implémenter pour le traitement des  est souvent le conteneur de ce composant.
est souvent le conteneur de ce composant. 
événements
• Un objet écouteur (JPanel) contient un à plusieurs objets source 
d événements (par exemple des JButton) 
d'événements (par exemple des JButton)
• L'écouteur s'enregistre auprès des sources d'événements afin de 
pouvoir les écouter
pouvoir les écouter
– JPanel doit implémenter l'interface ActionListener possédant une seule 
méthode actionPerformed()
méthode actionPerformed() 
• Lorsqu'un événement se produit (clic de souris), l'écouteur 
reçoit un objet ActionEvent
reçoit un objet ActionEvent. 
• La méthode getSource() (héritée de EventObject superclasse 
des classes événements) permet de déterminer quel est l objet 
des classes événements) permet de déterminer quel est l'objet
source de l'événement, ou la méthode getActionCommand()
renvoie la chaine de commande associée à l'action
renvoie la chaine de commande associée à l action. 
IvMad, I6, Février 2011 7 IvMad, I6, Février 2011 8
Traiter un événement Traiter un événement
• Exemple:  public void mouseClicked(MouseEvent e) ;
LL’interface MouseListener correspond à une catégorie 
interface MouseListener correspond à une catégorie /* lé l d’ li i t (l
/* appelé lors d’un clic souris sur un composant (la 
d’événements souris de type MouseEvent. souris n’a pas été déplacée entre l’appui et le 
public
bli iinterface
t f MouseListener
M Li t extends
t d EventListener
E tLi t {
public void mousePressed(MouseEvent e) ;
relâchement du bouton) */
/* appelé lorsqu’un bouton de la souris est pressé sur 
/* lé l ’ b t d l i t é public void mouseEntered(MouseEvent e) ;
public void mouseEntered(MouseEvent e) ;
un composant l’argument e de type MouseEvent /* appelé lorsque la souris passe de l’extérieur à 
correspond à l’objet événement généré */ l’i é i d’
l’intérieur d’un composant */*/
public void mouseReleased(MouseEvent e) ; p
public void mouseExited(MouseEvent e) ; }
( );}
/* appelé lorsqu’un bouton de la souris est relâché sur  /*appelé lorsque la souris sort d’un composant (la 
un composant */*/ souris passe de l intérieur à l
souris passe de l’intérieur extérieur du composant) 
à l’extérieur du composant)
*/
IvMad, I6, Février 2011 9 IvMad, I6, Février 2011 10

Intercepter un événement Gérer un événement
• Lorsqu’on souhaite intercepter un événement, on doit  • Pour gérer la fermeture de la fenêtre d'une application 
le préciser dans son constructeur en appelant la
le préciser dans son constructeur en appelant la  Java il nous faut créer un objet qui "écoute"
Java il nous faut créer un objet qui  les
écoute  les 
méthode dans le style: événements qui se  produisent sur la fenêtre et détecte 
addXXXListener(XXXListener
ddXXXLi (XXXLi objetEcouteur);
bj E ) l'événement "fermeture de la fenêtre".
l'é é "f d l f ê "
– où l’argument objetEcouteur
g j correspond à l’objet 
p j • C'est un objet "listener" ou gestionnaire d'événements.
j g
écouteur chargé de traiter l’événement. • Il existe différents types de gestionnaires pour les 
• Exemple: La classe Component définit les méthodes 
Exemple: La classe Component définit les méthodes différents événements qui peuvent se produire sur les
différents événements qui peuvent se produire sur les 
suivantes : composants d'une interface graphique. 
public void
bli id addFocusListener(FocusListener
ddF Li t (F Li t l) // i
l) ; // prise et perte du focus d'un champs
t t d f d' h
– Pour le composant JFrame, le listener s'appelle 
public void addKeyListener(KeyListener l) ;         // événements clavier
public void
public void addMouseListener(MouseListener l) ;  l) ; // événements souris
// événements souris
WindowListener qui définie les méthodes portant à la 
public void addMouseMotionListener (MouseMotionListener l) ; gestion des sept événements qui peuvent être gérés.
// événements liés au déplacement de la souris

IvMad, I6, Février 2011 11 IvMad,


IvMad,I6,
Octobre
Février2008
2011 12
Gérer un événement Gérer un événement
WindowListener win = new WindowListener() { • L'objet chargé de gérer les événements de la fenêtre 
public void windowActivated(WindowEvent
p ( e)  {   /*
) { fenêtre activée */   }}
est lourde
est lourde 
public void windowClosed(WindowEvent e)  {        /* fenêtre fermée */   }
public void windowClosing(WindowEvent e)  {   • On est obligé de définir des méthodes même pour des 
System.exit(0);                                                  /* fermeture de la fenêtre */ événements qu'on ne veut pas gérer. 
}
• On utilise l
On utilise l'interface
interface WindowAdapter
WindowAdapter à la place de 
à la place de
public void windowDeactivated(WindowEvent e)   {
/*  fenêtre désactivée */    } WindowListener.
public void windowDeiconified(WindowEvent e)    { L l Wi d Ad
• La classe WindowAdapter i lé l'i f
implémente l'interface 
/* fenêtre à l'état normal*/   }
WindowListener, avec les sept méthodes vides.
public void windowIconified(WindowEvent e)    {
public void e) {
/* fenêtre à l'état réduit */    } Ainsi :
p p (
public void windowOpened(WindowEvent ) {
e)  {  – définition du gestionnaire d événements
définition du gestionnaire d'événements
/* fenêtre visible */ }
};  – association du gestionnaire à la fenêtre . 

IvMad, I6, Février 2011 13 IvMad,


IvMad,I6,
Octobre
Février2008
2011 14

Gérer un événement Gérer des événements
import java.awt.*;  
• La gestion de la souris avec rendue des coordonnées du clic et la 
import javax.swing.*;   
import java.awt.event.*;
fermeture de la fenêtre principale avec l'arrêt
fermeture de la fenêtre principale avec l de l'application
arrêt de l application
public class MaFenetre extends JFrame { import java.awt.*;
public MaFenetre()  {   // le constructeur
public MaFenetre() { // le constructeur p j
import java.awt.event.*; ;
this.setTitle("Gestion de la fenêtre"); import javax.swing.*;
this.setSize(new Dimension(300, 100)); class MaFenetre extends JFrame {
// création d'un gestionnaire d'événements public MaFenetre() {
WindowAdapter win = new WindowAdapter()  { super("Une fenêtre qui traite les clics souris");
public void windowClosing(WindowEvent e) { System.exit(0); }
setSize(250, 150);
};  // fin gestionnaire fermeture de la fenêtre
addMouseListener( new EcouteurSouris() );
this addWindowListener(win); // on ajoute le GdE à la fenêtre (conteneur)
this.addWindowListener(win);   // on ajoute le GdE à la fenêtre (conteneur)
addWindowListener( new EcouteurFenetre() );   }
}
p ( g[] g ) {
public static void main(String[] args)  { public static void main(String[] args)  {
MaFenetre fn = new MaFenetre(); new MaFenetre().setVisible(true); 
fn.setVisible(true); }   
} }
} IvMad, I6, Février 2011 15 IvMad, I6, Février 2011 16
Gérer des événements Les adaptateurs
class EcouteurSouris extends MouseAdapter { • Pour chaque interface XXXListener possédant plusieurs 
// Redéfinition de la méthode appelée lors d’un clic souris
f pp
méthodes Java fournit une classe particulière
méthodes, Java fournit une classe particulière 
public void mouseClicked(MouseEvent e) {
int x = e.getX();
XXXAdapter, appelée adaptateur, qui implémente 
int y = e.getY(); toutes les méthodes de l’interface avec un corps vide.
l é h d d l’i f id
// Coordonnées du curseur de la souris au moment du clic yp
• Pour définir un écouteur d’événements de type  
System.out.println("clic au point de coordonnées " + x + ", " + y);   XXXEvent, il suffit alors de dériver l'écouteur de la 
}     }
classe XXXAdapter et de redéfinir uniquement les 
classe XXXAdapter et de redéfinir uniquement les
// Méthode assurant la fermeture de la fenêtre
class EcouteurFenetre extends WindowAdapter { méthodes voulues.
public void windowClosing(WindowEvent e) { 
System.out.println("fermeture de la fenêtre");
System.exit(0); 
}   
} (démo)

IvMad, I6, Février 2011 17 IvMad, I6, Février 2011 18

Les interfaces Les interfaces
• Le mot clé "implements" permet de spécifier une ou  • C'est une sorte de standard auquel une classe peut 
des interfaces que la classe implémente
des interfaces que la classe implémente.  répondre Tous les objets qui se conforment à cette
répondre. Tous les objets qui se conforment à cette 
• Cela permet de récupérer quelques avantages de  interface (qui implémentent cette interface) possèdent 
l'héritage multiple.  les méthodes et les constantes déclarée dans celle‐ci.
l éh d l dé l é d ll i
• Avec l
Avec l'héritage
héritage multiple, une classe peut hériter en 
multiple une classe peut hériter en p p
• Plusieurs interfaces peuvent être implémentées dans 
même temps de plusieurs super classes. Ce mécanisme  une même classe. Les interfaces se déclarent avec le 
n'existe
n pas en Java à l'état
existe pas en Java à l pur
état pur.  mot clé interface et sont intégrées aux autres classes 
mot clé interface et sont intégrées aux autres classes
• Les interfaces permettent de mettre en œuvre un  avec le mot clé implements. 
mécanisme de remplacement. • Exemple :
l
• Une interface est un ensemble de constantes et de 
Une interface est un ensemble de constantes et de public class MonApplet extends Applet implements 
déclarations de méthodes correspondant un peu à une  ActionListener, MouseListener  {  ….. }
classe abstraite
classe abstraite. // implémente deux interfaces
// p
IvMad, I6, Février 2011 19 IvMad, I6, Février 2011 20
Les interfaces Les interfaces
import java.awt.*; public void actionPerformed(ActionEvent ae) {
import java.awt.event.*; Object source = ae.getSource();
i
import j i *
javax.swing.*; if ( ) //on
(source == pressme) // li é sur l
a cliqué le b
bouton
public class Frame01 extends JFrame implements ActionListener { JOptionPane.showMessageDialog(null,"C'est le bouton!",
JButton pressme = new JButton("Cliquez ici"); "Message Dialog",JOptionPane.PLAIN_MESSAGE);
public Frame01() { // le constructeur de la fenêtre // un message dans un box de dialogue
super("Un Bouton"); // appel du constructeur parent }
setBounds(50 50 240 200);
setBounds(50,50,240,200); // La méthode principale
// opération de fermeture de la fenêtre public static void main(String args[]) {
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); new Frame01();
// prend la référence du conteneur par défaut }
Container con = this.getContentPane(); }
con.add(pressme);
// met en place l'événement du bouton
pressme.addActionListener(this);
setVisible(true);
t i ibl (t )
}

IvMad, I6, Février 2011 21 IvMad, I6, Février 2011 22

Les interfaces classe interne
• Un autre moyen de récupérer l'action d'un bouton  • Une classe est dite interne lorsque sa définition est 
dans la méthode actionPerformed(ActionEvent evt) est 
dans la méthode actionPerformed(ActionEvent evt) est située à l'intérieure
située à l intérieure dd'une autre classe (ou d'une
une autre classe (ou d une 
de tester le retour de la méthode getActionCommand méthode).
(classe ActionEvent
( l A i E ) qui
) i renvoie la chaîne de 
i l h î d • Un objet d'une classe interne est toujours associé, au 
caractères qui caractérise l'action à réaliser. , j
moment de son instanciation, à un objet d'une classe 
public void actionPerformed(ActionEvent evt) { externe dont on dit qu'il lui a donné naissance.
if (evt.getActionCommand().equals("Ajouter")) {
JOptionPane.showMessageDialog(null,
Un objet d'une
• Un objet d classe interne a toujours accès aux
une classe interne a toujours accès aux 
"bouton en marche") ; champs et méthodes (même privés) de l'objet externe 
} l
lui ayant donné naissance.
d é
}
j j
• Un objet d'une classe externe a toujours accès aux 
champs et méthodes (même privés) de l'objet interne 
auquel il a donné naissance
auquel il a donné naissance.
IvMad, I6, Février 2011 23 IvMad, I6, Février 2011 24
classe interne classe anonyme
• Exemple: • C’est une classe imbriquée sans nom. 
l M F t t d JF
class MaFenetre extends JFrame { { Al il ti ll l F ti $1 l
• A la compilation elle aura le nom: Factive$1.class
public MaFenetre () { p : 
• Exemple
super("Une fenêtre qui gère sa fermeture") ;
public class Factive {
setSize(300, 200) ;
...
addWindowListener( new EcouteurFermer() );
JButton b = new JButton("cliquez ici");
} b ddA ti Li t
b.addActionListener (( new ActionListener ()   {  
A ti Li t () {
// classe interne à la classe MaFenetre public void actionPerformed ( ActionEvent e )  {   
class EcouteurFermer extends WindowAdapter {
l E t F t d Wi d Ad t { System.out.println("un clic");  
i l (" li ")
public void windowClosing(WindowEvent e) { }  }  );
System.exit(0);  } ... 
}  // fin classe interne
} // }
} IvMad, I6, Février 2011 25 IvMad, I6, Février 2011 26

Gestion des menus Méthodes dynamiques
import java.awt.*; import java.awt.event.*; import javax.swing.*; fileMenu.add(newAction);
import javax.swing.event.*; fileMenu.add(openAction); • Normalement les composants d’un conteneur sont créés en 
fileMenu.addSeparator();
public class monMenu extends JFrame {
public monMenu() {
fileMenu add(exitAction);
fileMenu.add(exitAction); même temps que le conteneur et restent affichés en
même temps que le conteneur et restent affichés en 
editMenu.add(cutAction);
super("Menu"); 
this.setBounds(100,100,640,480);
editMenu.add(copyAction);
editMenu.add(pasteAction);
permanence. 
// Ajouter un  listener ' au 
// Ajouter un 'listener Nouveau  menu item
au 'Nouveau' menu item
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this setDefaultCloseOperation(JFrame EXIT ON CLOSE);
this.getContentPane().setBackground(Color.lightGray); newAction.addActionListener(new ActionListener() { • Cependant, on peut ajouter un nouveau composant à un 
C d t t j t tà
public void actionPerformed(ActionEvent ae) {
// Menubar pour JFrame
JMenuBar menuBar = new JMenuBar();
System.out.println("Nouveau"); conteneur (méthode add de la classe Container) ou 
}}        });
});
// Ajouter menubar au frame openAction.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent ae) {
supprimer un composant d’un conteneur (méthode remove
i d’ ( éh d
this.setJMenuBar(menuBar);
// Définir deux drop down menu pour le menubar System.out.println("Ouvrir");
}        });
de la classe Container).
new JMenu("Fichier")
JMenu fileMenu = new JMenu("Fichier"); // Ajouter un 'listener' au 'Sortie' menu item
JMenu editMenu = new JMenu("Edition"); exitAction.addActionListener(new ActionListener() { • Si l’une de ses opérations est effectuée après  l’affichage du 
menuBar.add(fileMenu); public void actionPerformed(ActionEvent ae) {
menuBar.add(editMenu); System.out.println("Fermer");
System.exit(0);
g
conteneur, il faut forcer le gestionnaire de mise en forme à 
// Ajouter simple menu item to the drop down menu
JMenuItem newAction = new JMenuItem("Nouveau"); }
}        }); recalculer les positions des composants (1) soit en appelant 
JMenuItem openAction = new JMenuItem("Ouvrir");
JMenuItem
JM It exitAction
itA ti = new JMenuItem("Sortie");
JM It ("S ti ")
public static void main(String[] args) {
monMenu
M me = new monMenu();
M ()
( p )
la méthode validate (classe Component) du conteneur, (2)  ,( )
JMenuItem cutAction = new JMenuItem("Couper");
JMenuItem copyAction = new JMenuItem("Copier"); }
me.setVisible(true);
soit en appelant la méthode revalidate (de la classe 
}
JMenuItem p pasteAction = new JMenuItem("Coller");
( ); JComponent) des composants du conteneur.
JComponent) des composants du conteneur.
IvMad, I6, Février 2011 27 IvMad, I6, Février 2011 28
Méthodes dynamiques Méthodes dynamiques
import java.awt.* ;  import java.awt.event.* ; class EcouteurBouton implements ActionListener {
import javax.swing.* ;  import javax.swing.event.
import javax.swing. ; import javax.swing.event.* ;; private Container contenu ;
private Container contenu ;
class MaFenetre extends JFrame { public EcouteurBouton (Container contenu) {
private JButton MonBouton ;
private JButton MonBouton ; this.contenu = contenu ;  }
this contenu = contenu ; }
public MaFenetre() { public void actionPerformed(ActionEvent e) {
super("Une
super( Une fenêtre avec des boutons dynamiques
fenêtre avec des boutons dynamiques");
); JButton NvBouton = new JButton("Bouton")
JButton NvBouton = new JButton( Bouton ) ;;
setSize(300, 200); contenu.add(NvBouton) ;   contenu.validate() ;
tD f ltCl O ti (JF EXIT ON CLOSE)
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // l ll iti d t d t
//recalcul les positions des composants du conteneur
Container contenu = getContentPane(); }   }
contenu.setLayout(new FlowLayout());
MonBouton = new JButton("Creation de boutons"); public class MonProgEvtBouton2 { 
contenu.add(MonBouton); public static void main(String args[]) {
MonBouton.addActionListener(new EcouteurBouton(contenu)); JFrame fen = new MaFenetre() ;  fen.setVisible(true) ;
} }   }
IvMad, I6, Février 2011 29 IvMad, I6, Février 2011 30

Méthodes dynamiques
• Le bouton "Création de bouton" provoque la création et 
par la suite l'apparition
par la suite l du nouveau bouton à l'écran
apparition du nouveau bouton à l écran

IvMad, I6, Février 2011 31


Programmation événementielle 
et réseau avec le langage Java
Le langage Java –
g g Partie 7
Module I6
Système 
Système
IUT d'Aix‐en‐Provence
Réseaux et Télécommunications
Entrée Sortie
Entrée‐Sortie, 
Février 2011
Février 2011 Flux et Fichiers
Flux et Fichiers
Ivan Madjarov

IvMad, Février 2011 2

Les flux d'entrée‐sortie Les flots (Stream)
• La communication d’une application Java avec le  • java.io est le package des entrées/sorties. 
monde extérieur s’effectue
monde extérieur s effectue par des Stream
par des Stream (flots): k è d l d
• Le package intègre des classes de gestion :
– Flots de données binaires (bytes) q ,
– fichier classique, 
– Flots de caractères (char) – des classes dédiées à la gestion des flux de données.
• Quel
Quel que soit la communication établie (fichiers ou 
que soit la communication établie (fichiers ou • Les classes de base de java.io
L l d b d j i sont :
t
réseau) et le type de données transportée (Unicode ou 
– InputStream, gère des données en entrée (lecture), 
binaire) la procédure générale consiste à :
binaire), la procédure générale consiste à
– OutputStream, gère des données en sortie (écriture). 
– ouvrir un flot ("Stream") de communication ;
• Ces
Ces deux classes abstraites ne sont pas utilisées 
deux classes abstraites ne sont pas utilisées
– utiliser le flot pour lire ou écrire des données ;
directement mais plutôt comme intermédiaires vers 
– fermer le flot de communication.
fermer le flot de communication
des sous‐classes mieux adaptées.
d l i d é

IvMad, Février 2011 3 IvMad, Février 2011 4


Les flots (Stream) Les flots (Stream)
• Le flot de communication établi est unidirectionnel.  • Exemples de sous‐classes de
On utilisera les classes suivantes pour :
On utilisera les classes suivantes pour et OutputStream :
InputStream et OutputStream
p
• Les opérations d’écriture : – BufferedReader : Lecture de texte depuis un flux 
– InputStream pour les flots de données binaires ; d'entrée (caractères, tableaux et chaînes de caractères). 
– BufferedWriter : Écriture de texte dans un flux de sortie 
: Écriture de texte dans un flux de sortie
– Writer
W it pour les flots de caractères
l fl t d tè ;
(caractères, tableaux et chaînes de caractères). 
• Les opérations de lecture
p : : Lecture de données Java primitives
– DataInputStream : Lecture de données Java primitives. 
– OutputStream pour les flots de données binaires ; – DataOutputStream : Écriture de données Java primitives. 
– Reader
R d pour les flots de caractères;
l fl d è – FileInputStream : Lecture d'octets depuis un fichier. 
– FileOutputStream : Écriture d octets dans un fichier.
: Écriture d'octets dans un fichier.

IvMad, Février 2011 5 IvMad, Février 2011 6

Les flots (Stream) Les flots (Stream)
• java.io.File les méthodes des fichiers. • Exemples (java.io.File):
import java.io.File;
public class monFile {
public static void main(String argv[]) {
File f = new File("java/h.class");
/
System.out.println(f.exists()); // --> true
System.out.println(f.canRead()); // --> > true
System.out.println(f.canWrite()); // --> false
System.out.println(f.length()); // --> 11345
/
File d = new File("java/");
System.out.println(d.isDirectory()); // --> true
String[] files = d.list();
for (int i=0; i < files.length; i++)
System.out.println(files[i]);
}
}

IvMad, Février 2011 7 IvMad, Février 2011 8


Les flots (Stream) Les flots (Stream)
• java.io.File permet d'accéder en lecture et en écriture à  • java.io.Data permet de lire et d'écrire des types 
un fichier
un fichier. primitifs et des lignes sur des flux
primitifs et des lignes sur des flux.
… … … FileInputStream fis = new FileInputStream("source.dat");
FileInputStream fin = new FileInputStream("source.txt"); DataInputStream dis = new DataInputStream(fis);
byte[] data = new byte[ fin.available() ]; int i = dis.readInt();
// available() retourne le nombre d'octets accessibles à lire double d = dis.readDouble();
fin read(data);
fin.read(data); String s = dis.readLine();
String s  dis readLine();
fin.close(); FileOutputStream fos = new FileOutputStream("cible.dat");
... … …  D t O t tSt
DataOutputStream d
dos = new DataOutputStream(fos);
D t O t tSt (f )
FileOutputStream fout = new FileOutputStream("cible.txt"); dos.writeInt(123);
fout.write(data); dos.writeDouble(123.456);
fout.close();
f () dos.writeChars("Une chaine");
( )
IvMad, Février 2011 9 IvMad, Février 2011 10

Les flots (Stream) Les flots (Stream)
• java.io.PrintStream permet de manipuler un  • Les exceptions (rappel): Elles permettent de séparer un 
au travers des méthode print() et
OutputStream au travers des méthode print() et  bloc d'instructions
bloc d de la gestion des erreurs pouvant
instructions de la gestion des erreurs pouvant 
println(). survenir dans ce bloc.  Format:
• PrintStream ps = new PrintStream(new  try {
FileOutputStream("cible.txt", true)); // Code pouvant lever des Exception:  ouverture de fichier, écriture 
• Le paramètre "true" autorise l'ajout de nouvelles lignes  dans un fichier
à la fin du fichier "cible.txt".
à la fin du fichier  cible.txt . }
– ps.println("Une ligne");     catch (Exception e) {
– ps println("Une deuxième);
ps.println("Une deuxième); // Gestion des Exceptions : ici le code pour récupérer le programme
// Gestion des Exceptions : ici le code pour récupérer le programme 
– ps.print("Une autre ligne"); ou se contenter d’afficher un message et  poursuivre
– ps.print("123 et fin"); }
– ps.flush();    ps.close();
IvMad, Février 2011 11 IvMad, Février 2011 12
Le principe des exceptions Lire un fichier texte
• Emetteur: code où il faut anticiper un problème:   String chaine="";
String fichier="source.txt";
dét t l’ b bl t
– détecter l’erreur, probablement avec un if …if créer une 
é try {
nouvelle Exception et la lancer (throw) // Ouvrir le fichier
– laisser la JVM détecter l’erreur, créer et lancer une  InputStream ips = new FileInputStream(fichier);
// Initialiser le flot de lecture
Exception
I
InputStreamReader
tSt R d i
ipsr = new InputStreamReader(ips);
I tSt R d (i )
• Recepteur: code dans l’appelant (quelque part dans la  // Unité de lecture
pile d’appel)
pile d appel)  BufferedReader br = new BufferedReader(ipsr);
String ligne;
– tenter un "try", en espérant que ca marche comme  g
// Lire les lignes du fichier
prévu (écrire le code comme si tout marchait)
é (é i l d i h i) while ((ligne = br.readLine()) != null) {
– se préparer à attraper (catch) une Exception et effectuer  chaine += ligne+"\n";
des opérations de récupération ou afficher un message }
br.close();
h (Exception
} catch ( i ){ }
e){
IvMad, Février 2011 13 IvMad, Février 2011 14

Introduction
• Tout langage de programmation "moderne" offre une 
interface de programmation réseau
interface de programmation réseau 
– Java, C#, Python, etc.
• Java propose le paquetage java.net. Il fournit des 
p p g p
facilités pour la programmation réseau par des sockets 
Le langage Java – Partie 8 en implémentant  les protocoles TCP/IP et UDP.
– Le protocole UDP permet d
Le protocole UDP permet d'établir une connexion sur
établir une connexion, sur 
une socket, en mode non connecté
Transmission de données en mode datagramme. 
• Transmission de données en mode datagramme
Programmation  – Le protocole TCP/IP permet d'établir une connexion en 
mode connecté.
d é
réseau avec Java
é • Transmission de données en mode connecté

IvMad, Février 2011 15 IvMad, Février 2011 16


La Socket Introduction
• La Socket (connecteurs réseau) représente une  • Le modèle OSI (Open System Interconnexion)
interface de programmation pour les communications
interface de programmation pour les communications 
entre processus. 
• Il existe généralement quatre types de sockets :
– Une socket datagram permet une communication 
bidirectionnelle qui n'est pas séquencée. Un processus 
utilisant ce type de socket peut donc recevoir les données 
dans un ordre différent de l'ordre de départ. il s'agit du 
protocole UDP.
– Une socket stream permet une communication 
bidirectionnelle, sûre, séquencée et un flux de données sans 
duplication pouvant entraîner une fragmentation des 
paquets transmis.  Il s'agit du protocole TCP.
– Une socket raw et une socket sequenced packet.
IvMad, Février 2011 17 IvMad, Février 2011 18

Introduction Introduction
• Routage et Passerelle • Le schéma montre le parcours de l'information

IvMad, Février 2011 19 IvMad, Février 2011 20


Introduction Mode datagramme (UDP)
• Le package java.net contient toutes les classes  • Le service offert par la couche IP est l'envoi (et surtout 
orientées réseau bas niveau de l'API JAVA.
orientées réseau bas niveau de l API JAVA. le routage) de datagrammes de l'émetteur
le routage) de datagrammes de l vers le
émetteur vers le 
destinataire, en mode non connecté 
– les datagrammes sont indépendants entre eux, même 
lorsqu’ils font partie d’un même message. 
– la remise du datagramme au destinataire n'est pas 
garantie!
• Dans certains cas de programmation réseau il est 
d
demandé d’envoyer des données d’un ordinateur à un 
dé d’ d d é d’ di t à
autre sans avoir à se soucier de la bonne réception de 
ces données par le destinataire.

IvMad, Février 2011 21 IvMad, Février 2011 22

Mode datagramme (UDP) Mode datagramme (UDP)
• Cette fonctionnalité est assurée par le protocole UDP • La classe DatagramPacket fournit deux constructeurs : un 
(User Datagram Protocol).
(User Datagram Protocol) pour les paquets à recevoir l'autre
pour les paquets à recevoir, l pour les paquets à
autre pour les paquets à 
envoyer.
• Le paquetage java.net fourni deux classes pour faciliter 
la programmation réseau en mode datagramme :  – public DatagramPacket(byte
bli D t P k t(b t buffer[], int
b ff [] i t taille) 
t ill )
Construit un objet pour recevoir un datagramme. 
– DatagramPacket ‐ buffer correspond à la zone de réception
b ff dàl d é ti
– DatagramSocket. ‐ taille maximale des datagrammes à recevoir. 
d é d b d
• Les données sont mises dans un objet de type  bli k (b buffer[], int
– public DatagramPacket(byte b ff [] i taille, 
ill
DatagramPacket qui est envoyé sur le réseau par le  InetAddress adresse, int port) 
biais d’un objet de type DatagramSocket. C t it
Construit un objet pour envoyer un datagramme. 
bj t d t
‐ buffer correspond à la zone d'envoie
‐ taille
t ill correspond à la taille du datagramme à envoyer
d à l t ill d d t à
‐ adresse destinataire de la datagramme 
du UDP
‐ port du UDP
IvMad, Février 2011 23 IvMad, Février 2011 24
Mode datagramme (UDP) Mode datagramme (UDP)
• Le principe de la programmation réseau en mode  • Pour recevoir des datagrammes en Java il faut suivre 
datagramme en Java se base (1) sur l'envoie
datagramme en Java se base (1) sur l des
envoie des  les étapes suivantes :
les étapes suivantes
datagrammes et (2) recevoir des datagrammes. – Créer une instance de la classe DatagramSocket qui 
• Pour envoyer des datagrammes en Java nous devons  attend l’arrivée de données à travers le réseau.
p
suivre les étapes suivantes : – Créer une instance de la classe DatagramPacket
g qui 
q
– Obtenir l’adresse du destinataire et la mettre dans une  reçoit les données par l’instance de DatagramSocket.
instance de la classe InetAddress
instance de la classe InetAddress.
– Mettre les données et l’adresse dans une instance de la 
classe DatagramPacket.
l D t P k t
– Créer une instance de la classe DatagramSocket et lui 
confier l’envoi du datagramme.

IvMad, Février 2011 25 IvMad, Février 2011 26

Mode datagramme (UDP) Mode datagramme (UDP)
• Exemple:  • Deux programmes pour illustrer le mode datagramme:
l’ d IP
– trouver l’adresse IP L "E tt " t l’ i l
– Le programme "Emetteur"  permet l’envoi vers le programme 
correspondant à un "Recepteur" des messages à travers le réseau. 
nom de machine – Le programme "Recepteur" se charge d'afficher le message 
L "R " h d' ffi h l
import java.net.* ; envoyé.
import java.io.* ;
public class ResoudreNom {
public static void main(String[] args) {
InetAddress adresse;
try { adresse = InetAddress.getByName(args[0]);
System.out.println("Nom : "+args[0]+"
IP : "+adresse.getHostAddress());
} catch(UnknownHostException e) {
System.err.println(args[0]+" est inconnu\n");
} } }
IvMad, Février 2011 27 IvMad, Février 2011 28
Émetteur Émetteur
• La première chose est de résoudre le nom de la  • Ensuite, Il nous faut, construire un datagramme en 
machine destinatrice (passé en argument) en adresse
machine destinatrice (passé en argument) en adresse  indiquant l’emplacement
indiquant l des données à transmettre
emplacement des données à transmettre 
réseau.  (tempon), leur longueur (tampon.length) et enfin 
– adr = InetAddress.getByName(args[0]); l’adresse du destinataire (adr) et le port de l'écoute 
l’ d d d i i ( d) l d l'é
• Ensuite
Ensuite une chaîne de caractères est transformée en 
une chaîne de caractères est transformée en (port).
suite d’octets pour de les transmettre sur le réseau. – DatagramPacket paquet = new 
St i "Dé t ti d d DatagramPacket(tampon, tampon.length, adr, port);
g ( p , p g , , p );
– String message = "Démonstration du mode 
datagramme"; • Enfin on ouvre une DatagramSocket en utilisant sa 
– byte[] tampon = new byte[message.length()]; méthode send() pour l'envoi du datagramme
méthode send() pour l'envoi du datagramme.
La transformation se fait par la méthode getBytes() de 
• La transformation se fait par la méthode getBytes() de – DatagramSocket sock = new DatagramSocket();
la classe String. – sock.send(paquet);
t tB t ()
– tampon = message.getBytes();
IvMad, Février 2011 29 IvMad, Février 2011 30

Récepteur Déroulement de l'exécution
• Une zone mémoire tampon pour recevoir les données.  •
b t [] t b t [200]
– byte[] tampon = new byte[200];
• Ensuite nous créons un DatagramSocket pour écouter 
sur le port de destination en attente de données.
– DatagramSocket sock = new DatagramSocket(port);
= new DatagramSocket(port);
• L’ordre d’attente se fait par la méthode receive()
– sock.receive(paquet);
• La
La méthode se charge de placer les données dans un 
méthode se charge de placer les données dans un
DatagramPacket gérant le tampon.
– DatagramPacket
D t P k t paquet = new 
t
DatagramPacket(tampon, tampon.length);

IvMad, Février 2011 31 IvMad, Février 2011 32


Le client UDP Le Serveur UDP
import java.io.*; class ServeurUDP {
import java.net.*; public static void main(String argv[]) throws Exception {
public class ClientUDP { int port = 5000; int taille = 1024; String message;
public static void main(String argv[]) throws Exception { byte buffer[] = new byte[taille];
String Message = "Bonjour
Bonjour tout le monde !";
! ; // Créer la socket pour installer le port d'écoute
d écoute
int l = Message.length(); DatagramSocket socket = new DatagramSocket(port);
// Résoudre l'adresse du récepteur System.out.println("Serveur UDP sur le port 5000");
InetAddress serv = InetAddress.getByName("localhost"); while(true) {
// Coder en octets // Réception de la datagramme
byte buf[] = Message getBytes();
Message.getBytes(); DatagramPacket packet = new
// Préparer la datagramme DatagramPacket(buffer,buffer.length);
g
DatagramPacket data = new DatagramPacket(buf,l,serv,5000);
g socket.receive(packet);
// Ouvrir la socket // Décodage du message
DatagramSocket socket = new DatagramSocket(); message=new String(buffer);
// E
Envoyer l
le paquet
t System.out.println(message);
System out println(message);
socket.send(data); }
} }
} }
IvMad, Février 2011 33 IvMad, Février 2011 34
Programmation événementielle 
et réseau avec le langage Java
Module I6
Module I6 Partie 8
a e8
Programmation en Java par Socket en mode connecté

IUT d'Aix‐en‐Provence
Réseaux et Télécommunications Programmation 
Mars 2011
Mars 2011
Ivan Madjarov
réseau en Java
é J
IvMad, Mars 2011 2

Introduction La Socket
• Java propose un paquetage spécial java.net.  • La Socket (connecteurs réseau) représente une 
Le paquetage fournit des facilités pour la
• Le paquetage fournit des facilités pour la  interface de programmation pour les communications
interface de programmation pour les communications 
programmation réseau par des sockets en  entre processus. 
p p
implémentant  les protocoles TCP/IP/ et UDP.
– Le protocole UDP permet d'établir une connexion, sur  • Il existe généralement quatre types de sockets :
une socket, en mode non connecté – Une socket datagram permet une communication 
• Transmission de données en mode datagramme.  bidirectionnelle qui n'est pas séquencée. Un processus 
– Le protocole TCP/IP permet d'établir une connexion en  utilisant ce type de socket peut donc recevoir les données 
mode connecté. dans un ordre différent de l'ordre de départ. il s'agit du 
• Transmission de données en mode connecté protocole UDP.
– Une socket stream permet une communication 
bidirectionnelle, sûre, séquencée et un flux de données sans 
duplication pouvant entraîner une fragmentation des 
paquets transmis.  Il s'agit du protocole TCP.
– Une socket raw et une socket sequenced packet.
IvMad, Mars 2011 3 IvMad, Mars 2011 4
Les sockets (connecteurs réseau) Connexion réseau
• Les données transitent sur l'Internet dans des paquets  • Le schéma montre le parcours de l'information
d'
d'octets de taille limitée qu'on appel datagrammes. Ils 
d ill li i é ' ld Il
sont  formés d'un entête :
– adresse, 
– numéro de port de l
numéro de port de l'expéditeur
expéditeur et du destinataire,…
et du destinataire,…
– une charge utile composée des données. 
U t f t i t é it l i t
• Un transfert unique peut nécessiter plusieurs paquets.
• Les sockets permettent la gestion d'un transfert de 
données comme un flux ordinaire 
(les paquets sont triés à l arrivée).
(les paquets sont triés à l'arrivée).

IvMad, Mars 2011 5 IvMad, Mars 2011 6

Mode UDP et TCP Le mode connecté (TCP)
• Les principales classes de java.net.*; • Le mode connecté garanti l’arrivée en séquence des 
données émises
données émises. 
• Le mode est assuré au niveau de la couche de 
transport selon le modèle OSI par le protocole TCP
(
(Transmission Control Protocol).
)
• Le paquetage java.net fourni les classes 
S k t
– Socket
– ServerSocket
pour travailler avec le mode connecté.
• Le mode connecté est une interconnexion stable entre 
Le mode connecté est une interconnexion stable entre
un client et un serveur.
IvMad, Mars 2011 7 IvMad, Mars 2011 8
Le mode connecté (TCP) Le mode connecté (TCP)
• Les étapes côté serveur : • Le Client et le Serveur en mode connecté
1 Instancier
1. la classe ServerSocket et l
Instancier la classe ServerSocket et l’instruire à écouter sur
instruire à écouter sur 
un certain port.
2.
2 Accepter les connexions par la méthode accept() et créer un 
A t l i l éth d t() t é
objet Socket pour référencer la nouvelle connexion.
3. Passer la nouvelle connexion au programme approprié.
l ll é
4. Fermer la connexion par la méthode close().
• Les étapes côté client :
1. Se
Se connecter au service approprié en instanciant la classe 
connecter au service approprié en instanciant la classe
Socket et en lui passant comme paramètres l’adresse du 
serveur et le port.
serveur et le port.
2. Lorsque l’échange est terminé ferme la connexion par la 
méthode close()
méthode close().
IvMad, Mars 2011 9 IvMad, Mars 2011 10

Les sockets (connecteurs réseau) Les sockets (connecteurs réseau)
• Les classes java.net.Socket et java.net.ServerSocket • Mise en œuvre  du modèle Client‐Serveur:
implémentent les sockets TCP/IP sous Java
implémentent les sockets TCP/IP sous Java.  L S k t est créée sur le client. 
– La Socket t éé l li t
• Les Sockets assurent 7 opérations élémentaires: – Le ServerSocket fonctionne sur le serveur en attente de 
– connexion à une machine distante (Socket),  connexion (méthode accept()).
i ( éh d ())
– envoi de données (Socket),
envoi de données (Socket),  – La Socket tente de se connecter sur le serveur distant. 
– réception de données (Socket),  – Connexion établie, le ServerSocket génère une Socket pour 
communiquer avec le client. 
– fermeture d'une
fermeture d connexion (Socket)
une connexion (Socket), 
– La connexion établie, les systèmes Client et Serveur 
– attachement à un port (ServerSocket), 
établissent un canal de communication par flux à partir de 
p p
– attente de demande de connexion émanant de machines  leurs Sockets pour échanger des données. 
distantes (ServerSocket), 
p g ,
– Après fin des échanges, l'un des interlocuteurs clôt le canal 
– acceptation de demandes de connexion sur le port local  de communication.
(ServerSocket).

IvMad, Mars 2011 11 IvMad, Mars 2011 12


Les sockets (connecteurs réseau) Les sockets (connecteurs réseau)
• Constructeur : – public outputStream getOutputStream() throws IOException : 
public Socket(String host int port) throws
– public Socket(String host, int port) throws UnknownHostException, 
UnknownHostException retourne le flux de sortie associé à la socket.
retourne le flux de sortie associé à la socket.
IOException; – public void close() throws IOException : ferme le 
– p ( p
public ServerSocket(int )
port) throws p ;
IOException; ServerSocket.
ServerSocket
• Méthodes : – public Socket accept() throws IOException : place le 
– host
host (String) : nom de la machine vers laquelle la socket est créée. 
(String) : nom de la machine vers laquelle la socket est créée ServerSocket en attente de requête d
en attente de requête d'ouverture
ouverture de socket. 
de socket
– addresse (InetAddress) : adresse IP de la machine vers laquelle la socket  • Cette attente est bloquante. Une socket est 
est créée.
est créée.  automatiquement générée et retournée lors de cette
automatiquement générée et retournée lors de cette 
– port (int) : numéro du port sur lequel la socket est créée. requête.
– localAddr ((InetAddress)) : adresse IP locale à la quelle la socket est 
q
associée. 
– localPort (int) : numéro du port local auquel la socket est associée. 
– public void close() throws IOException : ferme la socket.
– public inputStream getInputStream() throws IOException : retourne le flux 
' é éà
d'entrée associé à la socket.
IvMad, Mars 2011 13 IvMad, Mars 2011 14

Les sockets (connecteurs réseau) Les sockets (connecteurs réseau)
• Réalisation d'un Client en Java : • Réalisation d'un Serveur :
t d’ k t( k t(h t
– ouverture d’un socket (new socket(host, port)),t)) t d’ k t
– ouverture d’un socket serveur, 
– ouverture d’un flot d’entrée et de sortie sur le  – attente de connexion et ouverture d’un socket client, 
socket( in=new BufferReader(...), 
k (i B ff R d ( )
– ouverture d’un flot d’entrée et de sortie sur le socket 
out=new PrinterWritter(...) , 
c e t,
client, 
– lecture et écriture sur les flots en accord avec les protocoles 
du serveur  – lecture et écriture sur les flots en accord avec les 
d ( )
in.readLine(...),  protocoles du client (présenté précédemment)
protocoles du client (présenté précédemment), 
out.println(...),  – fermeture des flots, fermeture du socket serveur et du 
– fermeture des flots:  socket client.
k l
in.close(), out.close(), 
– fermeture du socket: socket.close()

IvMad, Mars 2011 15 IvMad, Mars 2011 16


Les sockets (connecteurs réseau) Serveur d'heure TCP
import java.net.*; import java.io.*; import java.util.*;
• Une application Client se connecte par une adresse IP 
class serveurHeure { // Retourne au client la date et l'heure
sur un numéro de port
sur un numéro de port. public static void main(String args[]) {
• Le serveur accepte la connexion et fournit une nouvelle  try {
ServerSocket
S S k t sks
k = new ServerSocket(8080);
S S k t(8080)
socket avec un nouveau port de communication pour  System.out.println("Serveur en attente");
g
continuer à écouter sur la socket originale. Socket sk = sks.accept();
System.out.println(sk.toString());
DataOutputStream out = new
DataOutputStream(sk.getOutputStream());
out.writeBytes(new Date()+"\n"); // ecr. date et heure
sk close();
sk.close(); >java serveurHeure
Serveur en attente
• Du côté du client, si la connexion est acceptée, une  sks.close(); Socket[addr=/127.0.0.1,port=49409,localport=8080]
} catch ( p
(IOException ) { >
e)
socket est créée pour assurer la communication avec le 
socket est créée pour assurer la communication avec le System.out.println(e.getMessage());
serveur. }
} }
IvMad, Mars 2011 17 IvMad, Mars 2011 18

Le Client TCP Client TCP émet un message
// Client cherchant l'heure sur le serveur import java.net.*; import java.io.*;
import java.io.*; public class ClientTCP {
import java.net.*; Socket sock = null;
public class ClientTCPHeure { public ClientTCP(String host, int port, String data) {
public
bli static
t ti voidid main(String
i (St i args[])
[]) { try
t {
String ligne; sock = new Socket(host, port);
try { PrintStream output = new
Socket sk = new Socket("localhost",8080); PrintStream(sock.getOutputStream());
DataInputStream is = new output.println(data);
DataInputStream(sk.getInputStream()); sock.close();
while ((ligne = is.readLine()) != null) } catch(IOException e) { }
System out println(ligne); // message du serveur
System.out.println(ligne); }
} catch (Exception e) { } public static void main(String[] args) {
} ClientTCP client = new
>java ClientTCPHeure ClientTCP("127.0.0.1",1500,"Bonjour!");
}
Wed Nov 25 08:58:32 CET 2009
> }
}
IvMad, Mars 2011 19 IvMad, Mars 2011 20
Serveur TCP traite le message Les sockets (connecteurs réseau)
import java.net.*; while(true) {
import java.io.*; SkC = SocketServeur.accept();
public class ServeurTCP { System.out.println("Nouvelle connexion acceptée: " +
int port=1500; // Port de connexion SkC.getInetAddress());
ServerSocket
S S k t SkS;
SkS input = new BufferedReader(new
Socket SkC; InputStreamReader(SkC.getInputStream()));
BufferedReader input; // Réception et affichage des messages du client
String message; try {
public ServeurTCP() { while(true) {
try { i t dLi ()
message = input.readLine();
SkS = new ServerSocket(port); if (message == null) break;
S t
System.out.println("Serveur
t i tl ("S en attente
tt t sur port:t " + System out println(message);
System.out.println(message);
SkS.getLocalPort()); }
// Serveur en attente infinie: ( ) connexion d'un client,
(1) , } catch (IOException e) {
(2) réception de messages, (3) fermeture de la connexion System.err.println(e.getMessage());
par le client }

IvMad, Mars 2011 21 IvMad, Mars 2011 22

Les sockets (connecteurs réseau) Les sockets (connecteurs réseau)
// Fermeture de la connexion par le client
try {
• Le côté client:
SkC.close();
System.out.println("TCP Serveur STOP!");
break;
b k
} catch (IOException e) { System.out.println(e); }
}
} catch (IOException e) { System.out.println(e); } • Le côté serveur:
}
// Application principale avec appel du constructeur
public static void main(String[] args) {
new ServeurTCP();
S C ()
}
}

IvMad, Mars 2011 23 IvMad, Mars 2011 24


Une requête HTTP 1.0 Serveur HTTPD
import java.net.*;  import java.io.*;  import java.util.*; 
• Une ligne de requête comprend trois éléments devant  public class monoHttpd {   // Le serveur traite une seule connexion à la fois
public static void main(String[] argv) throws IOException {
être séparés par un espace :
être séparés par un espace : ServerSocket ss = new ServerSocket(1234);                     // Installation du serveur
System.out.println("Serveur HTTP sur le port 1234");
– La méthode (GET, POST, …) Socket sock = ss.accept();                                                  // ça boucle en attente de requête
try {   // Formatage de la sortie
{ // d l
– L'URL (Uniform Resource Locator) OutputStream out = sock.getOutputStream(); // Lecture de la requête
String req = (new BufferedReader(new InputStreamReader(sock.getInputStream()))).readLine();
– La version du protocole utilisé par le client (HTTP/1.0)  System out println( "Requête:
System.out.println(  Requête: "+req
+req );  ); // Traitement de la requête "GET
//  Traitement de la requête  GET /index.html HTTP/1.1
/index html HTTP/1 1"

• Les champs d'en‐tête de la requête : lignes facultatives  String str[] = req.split(" ");  //  Décomposition par " " en éléments de tableau


if (str[0].equals("GET")) {                                         // Vérifier si la requête démarre par "GET"
permettant de donner des informations sur la requête
permettant de donner des informations sur la requête  req = str[1].substring(1);                                       // On enlève 
str[1].substring(1);
try {    
// On enlève '/' devant le nom du fichier
/  devant le nom du fichier

et/ou le client (Navigateur, système d'exploitation, ...).  FileInputStream fis = new FileInputStream(req);


byte[] data = new byte[fis.available()]; // available() returns the number of bytes that can be read
• Le corps de la requête : lignes optionnelles séparées  fis.read(data);
out.write(data);
une ligne vide et permettant un envoi de données par  } catch ( FileNotFoundException e )  {  new PrintStream(out).println("404 Not Found"); }
} else {  new PrintStream(out).println("400 Bad Request");  } 
une commande POST lors de l'envoi de données par un  sock.close();
}  catch ( IOException e ) { System.out.println("I/O error " + e.getMessage()); }    
formulaire. } }
}    }

IvMad, Mars 2011 25 IvMad, Mars 2011 26

Serveur HTTPD
Le côté Serveur

Partie 9
a e9
La page 'index.html' Le fichier 'index.html'
Les Threads dans le langage Java

Programmation 
par Threads en Java
Th d J
IvMad, Mars 2011 27 IvMad, Mars 2011 28
Les Threads Les Threads
• Un Thread n'est pas un processus.  • Les Threads ne s'exécutent pas en même temps mais 
L
• Les processus i t td d i t l i lé
existent dans des espaces virtuels isolés  en temps partagé :
en temps partagé :
• Les Threads sont des traitements (file) qui évoluent 
ensemble au sein d'un même processus.
• Les Threads partagent la même mémoire 
Les Threads partagent la même mémoire
contrairement aux processus.
• Un Thread est donc une portion de code capable de  • Le Thread peut avoir 4 états différents 
s'exécuter en parallèle à d'autres traitements.
p – Etat nouveau : état initial après l
Etat nouveau : état initial après l'instanciation
instanciation
– S'adresser de manière personnelle à plusieurs clients  – Etat exécutable : lancé par la méthode start()
s u ta é e t co e es se eu s ou es C at
simultanément comme les serveurs HTTP ou les Chat.
– Etat en attente : n'exécute aucun traitement (wait(), sleep())
Et t tt t ' é t t it t ( it() l ())
– Faire des traitements en tâche de fond, c'est le cas de la 
– Etat mort : Thread qui est sorti de sa méthode run()
coloration syntaxique des éditeurs
coloration syntaxique des éditeurs.
IvMad, Mars 2011 29 IvMad, Mars 2011 30

Les Threads Les Threads
• En général une application de type serveur se charge 
d’écouter
d sur un port les demandes de connexion
écouter sur un port les demandes de connexion
adressées par les clients. 
• A chaque nouvelle connexion il crée un nouveau 
processus ((ou processus léger) qui se charge de cette 
p p g )q g
connexion. 
– la méthode accept() renvoi une instance de Socket avec un 
la méthode accept() renvoi une instance de Socket avec un
port (virtuel) différent du socket serveur.
• Le
Le programme principal retourne à l’écoute de 
programme principal reto rne à l’éco te de
nouvelles connexions sur le port "public".
– Port 80 pour un serveur Web 
– Port 21 pour un serveur FTP
p
IvMad, Mars 2011 31 IvMad, Mars 2011 32
Les Threads Les Threads
• Dans le cas où le serveur doit supporter plusieurs  • Création et démarrage d'un thread :
clients il faut créer un Thread par client connecté:
clients, il faut créer un Thread par client connecté E J il i t d t h i é th d
• En Java, il existe deux techniques pour créer un thread. 
Q
TantQue ( ) {
(vrai) – Soit le Thread est dérivé de la classe java.lang.Thread
- accepter une connexion – Soit l'interface java.lang.Runnable est implémentée.
avec un nouveau client • Les
Les différences sont subtiles,
différences sont subtiles
- créer un Thread pour
communiquer avec ce client • Selon la technique choisie, il y a plus ou moins de 
} facilité pour partager (ou non) des données entre 
différents threads.
• Le "bon" choix dépend du contexte d'application

IvMad, Mars 2011 33 IvMad, Mars 2011 34

Les Threads Les Threads
• Dériver de la classe java.lang.Thread. • L'instance de la classe ServerSocket permet au serveur de:
Il f t é bj t d t Th d
– Il faut créer un objet de type Thread.  – SS’enregistrer auprès du système d’exploitation
enregistrer auprès du système d exploitation,
– Il faut une méthode public run() sans paramètres ni retour,  – Écouter les demandes de connexion sur un port spécifique. 
mais qui détient le code à exécuter
i i dé i l d à é par le Thread. 
l Th d • Le serveur est un processus léger lancé par la méthode 
– Il faut lancer le Thread et l'activer au niveau du système par  start(). 
la méthode start(), codée au niveau de la classe Thread. • Dans la méthode run() (appelée par start()), il y a une 
– A titre indicatif, il y a une méthode sleep() de la classe Thread boucle infinie en attente de nouvelles connexions
boucle infinie en attente de nouvelles connexions 
qui est utilisée pour laisser le temps de visualiser les  (méthode accept()). 
résultats.
• La nouvelle instance de Socket
La nouvelle instance de Socket retournée est passée à une 
retournée est passée à une
• Avec cette technique, Il y a autant d'objets que de  instance de la classe Traitement qui se charge alors de cette 
threads personnalisés.
threads personnalisés nouvelle connexion. 
nouvelle connexion
• Voyons le fonctionnement d'un serveur multithread : • Le serveur retourne alors à l’état d’attente.
IvMad, Mars 2011 35 IvMad, Mars 2011 36
Serveur TCP Multithread Serveur TCP Multithread
import java.net.*;  import java.io.*; class Traitement extends Thread {
class ServeurConnecte extends Thread { Socket sock; Connexions 
reception;
ServerSocket reception;     BufferedReader entree; du client 1
public Traitement(Socket socket) {
static final int port = 1500; sock = socket;
public ServeurConnecte() { try {
try {    
{ entree = new BufferedReader(new      
= new BufferedReader(new
reception = new ServerSocket(port); InputStreamReader(sock.getInputStream()));
}   catch(IOException e)  { } catch(IOException e) { }
System exit(1); }
System.exit(1);  }
this.start();    // Lance la méthode 'run' du Thread Connexions 
}
this.start();            // Lance la méthode 'run' public void run()  {
du client 2
} String text;
public void run() 
public void run() { try {
Socket sock; text=entree.readLine();
System.out.println("Le message du client: "+text+" sur le 
Traitement t; port virtuel: "+sock.getPort()+" du port serveur: 
try { "
"+sock.getLocalPort());
k L lP ()) Etat du 
Etat du
while(true)  { sock.close(); serveur
sock = reception.accept(); }    catch(IOException e) { }
t = new Traitement(sock);
t = new Traitement(sock); }} }}
public class TestServeurConnecte {
} public static void main(String[] args)  {
}  catch(IOException e) { } new ServeurConnecte();
} }
}   } } }
}   }

IvMad, Mars 2011 37 IvMad, Mars 2011 38

Serveur TCP Multithread

IvMad, Mars 2011 39

Vous aimerez peut-être aussi