PE & Réseaux

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

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(); } }
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é.
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.
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);
}
}
}
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.

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. */
}
}
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)

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
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
//
Les boutons radio Les étiquettes
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
}
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() ;
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
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.
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
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() ;
} }
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);
}
}
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.

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

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.
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 *//
}
}
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 ?") ;
}
}
}
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
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() ;
f tVi ibl (t )
– la méthode drawImage permet d’afficher une image de
}
type Image.
}
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()
}
}
Programmation événementielle
Module I6 Le langage Java –
g g Partie 6
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
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.
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)
*/
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)
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
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 )
}
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.
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.
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) ;
} } }
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

Le langage Java –
g g Partie 7
Module I6
Système
Système
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 é

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.
• 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]);
}
}

• 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");
( )
• 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();
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){
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é

La Socket Introduction
• La Socket (connecteurs réseau) représente une • Le modèle OSI (Open System Interconnexion)
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.
Introduction Introduction
• Routage et Passerelle • Le schéma montre le parcours de l'information

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.
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
• 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.
• 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 {
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");
} } }
É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();
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);

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); }
} }
} }
Module I6
Module I6 Partie 8
a e8
Programmation en Java par Socket en mode connecté
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
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).
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.
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().
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).

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

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. }
} }
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
> }
}
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 }
// 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
new ServeurTCP();
S C ()
}
}

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. } }
} }
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
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.
• 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
• 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
• 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.
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();
} }
} } } }
} }
Serveur TCP Multithread
IvMad, Mars 2011 39

Langue

PE & Réseaux

Transféré par

Informations du document

Titre original

Copyright

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

PE & Réseaux

Titre original :

Transféré par

Droits d'auteur :

Programmation

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

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

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

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

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

Interface graphique ‐ Fenêtre Interface graphique ‐ bouton

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

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

Interface graphique ‐ bouton Conteneurs Swing : JFrame

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

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

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

Le gestionnaire BorderLayout Le gestionnaire BorderLayout

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

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

IvMad, I6, Février 2011 2

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

IvMad, I6, Février 2011 11 IvMad,

IvMad, I6, Février 2011 13 IvMad,

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

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

IvMad, I6, Février 2011 31

IvMad, Février 2011 2

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

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

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

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

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

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

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

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

IvMad, Mars 2011 5 IvMad, Mars 2011 6

IvMad, Mars 2011 11 IvMad, Mars 2011 12

IvMad, Mars 2011 15 IvMad, Mars 2011 16

IvMad, Mars 2011 21 IvMad, Mars 2011 22

IvMad, Mars 2011 23 IvMad, Mars 2011 24

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

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

IvMad, Mars 2011 25 IvMad, Mars 2011 26

IvMad, Mars 2011 33 IvMad, Mars 2011 34

IvMad, Mars 2011 37 IvMad, Mars 2011 38

IvMad, Mars 2011 39

Centres d'intérêt liés

Vous aimerez peut-être aussi