CONNEXION 0 UNE BASE DE DONNE POSTGRESTSQL EN JAVA

//public class Connexion_base {

import import import import

java.sql.Connection; java.sql.DriverManager; java.util.Enumeration; java.util.Properties;

public class Connexion_base { public static void main(String[] args) { //telcharger le driver de posrgres version 4 et le mettre dans le dossier de jre LIB/ext ou dans le dossier de la classe try { Class.forName("org.postgresql.Driver"); System.out.println("DRIVER OK ! ");//pour initaliser la connexion de la faon reflexive String url = "jdbc:postgresql://localhost:5432/ECOLE";//Laddresse du server de base de donne String user = "postgres";//nom dutilisateur String passwd = "arianab";//mot de pass Connection conn = DriverManager.getConnection(url, user, passwd); System.out.println("Connection effective !"); } catch (Exception e) { e.printStackTrace(); } } }

MANIPULATION DES DONNS DEPUIS JAVA

import java.sql.Connection; import java.sql.DriverManager; import java.sql.ResultSet; import java.sql.ResultSetMetaData; import java.sql.Statement; public class Connect { public static void main(String[] args) { try { Class.forName("org.postgresql.Driver"); String url = "jdbc:postgresql://localhost:5432/Ecole"; String user = "postgres"; String passwd = "postgres"; Connection conn = DriverManager.getConnection(url, user, passwd); //Cration d'un objet Statement Statement state = conn.createStatement(); //L'objet ResultSet contient le rsultat de la requte SQL ResultSet result = state.executeQuery("SELECT * FROM classe"); //On rcupre les MetaData ResultSetMetaData resultMeta = result.getMetaData(); System.out.println("\n******************************* ***"); //On affiche le nom des colonnes for(int i = 1; i <= resultMeta.getColumnCount(); i++) System.out.print("\t" + resultMeta.getColumnName(i).toUpperCase() + "\t *"); System.out.println("\n******************************* ***"); while(result.next()){ for(int i = 1; i <= resultMeta.getColumnCount(); i++)

System.out.print("\t" + result.getObject(i).toString() + "\t |"); System.out.println("\n--------------------------------"); } result.close(); state.close(); } catch (Exception e) { e.printStackTrace(); } }
}

Comment a fonctionne
Je vous ai fourni un morceau de code, il fonctionne, mais comment a marche ? Voici le moment o tout vous sera dvoil. Comme je vous le disais plus haut, l'objet Statement est l'objet qui vous permet de faire des requtes SQL. Celles-ci peuvent tre de type :

CREATE ; INSERT ; UPDATE ; SELECT ; DELETE.

Vous n'tes pas sans savoir que, selon le type de requte excute, celle-ci retourne un / des rsultat(s), dans le cas d'un SELECT, ou une validation / un message d'erreur dans les autres cas.

L'objet Statement vous est fourni par l'objet Connection grce l'instruction conn.createStatement(); . Nous verrons, dans le chapitre suivant, un peu plus de choses concernant l'objet Statement.

Ce que j'ai fait ensuite, c'est demander mon objet Statement d'excuter une requte SQL de type SELECT. Vous la voyez, celle-ci : Code : SQL - Slectionner
1 SELECT * FROM classe

Cette requte me retournant un rsultat contenant beaucoup de lignes, elles-mmes contenant plusieurs colonnes, nous avons stock ce rsultat dans un objet ResultSet, objet permettant de faire diverses actions sur des rsultats de requtes SQL ! Aprs cette ligne de code : ResultSet result = state.executeQuery("SELECT * FROM classe"); , les rsultats sont stocks dans l'objet ResultSet et nous n'avons plus qu' afficher les donnes. Ici, j'ai utilis un objet de type ResulSetMetaData afin de rcuprer les "meta data" de ma requte. Comprenez ceci comme "rcuprer les informations globales de ma requte". Ici, nous avons utilis cet objet afin de rcuprer le nombre de colonnes renvoy par la requte SQL ainsi que leurs noms. Cet objet "meta data" permettent de rcuprer des informations trs utiles comme :

le nombre de colonnes d'un rsultat ; le nom des colonnes d'un rsultat ; le type de donnes stock dans chaque colonne ; le nom de la table qui appartient la colonne (dans le cas d'une jointure de table) ; ...

Vous voyez que ces informations peuvent tre utiles. Il existe aussi un objet DatabaseMetaData qui, lui, fournit des informations sur la base de donnes !

Vous comprenez mieux ce que signifie cette portion de code : Code : Java - Slectionner
System.out.println("\n**********************************"); 1 //On affiche le nom des colonnes 2 for(int i = 1; i <= resultMeta.getColumnCount(); i++) 3 System.out.print("\t" + 4 resultMeta.getColumnName(i).toUpperCase() + "\t *"); 5 6 System.out.println("\n**********************************");

Nous nous servons de la mthode nous donnant le nombre de colonnes dans le rsultat afin de rcuprer le nom de la colonne grce son index ! ATTENTION : contrairement aux indices de tableaux, les indices de colonnes SQL commencent 1 !

Ensuite, nous rcuprons les donnes de notre requte en nous servant de l'indice des colonnes : Code : Java - Slectionner
while(result.next()){ 1 for(int i = 1; i <= resultMeta.getColumnCount(); i++) 2 System.out.print("\t" + 3 result.getObject(i).toString() + "\t |"); 4 5 System.out.println("\n--------------------------------6 "); }

Nous utilisons une premire boucle afin que, tant que notre objet

ResultSet nous retourne des lignes de rsultats, nous parcourions ensuite chaque ligne via notre boucle for . La mthode next() permet de positionner l'objet sur la ligne suivante dans sa liste de rsultat ! Au premier tour de boucle, cette mthode positionne l'objet sur la premire ligne. Si vous ne positionnez pas l'objet rsultat et que vous tentez de lire des donnes, une exception sera leve !

Je suis parti du postulat que ne connaissons pas le type de donnes de nos colonnes, mais vu que nous les connaissons, ce code aurait tout aussi bien fonctionn : Code : Java - Slectionner
while(result.next()){ System.out.print("\t" + result.getInt("cls_id") + "\t 1 |"); 2 System.out.print("\t" + result.getString("cls_nom") + 3 "\t |"); 4 System.out.println("\n--------------------------------5 "); }

On a le droit de faire a ? Tout fait ! Nous connaissons le nom de nos colonnes retournes par la requte SQL, nous connaissons aussi leurs types, il nous suffit donc d'invoquer la mthode adquat de l'objet ResultSet en utilisant le nom de la colonne rcuprer ! Par contre, si vous essayez de rcuprer le contenu de la colonne "cls_nom" avec la mthode getInt("cls_nom") , vous aurez une zolie exception !

Il existe une mthode getXXX() par type primitif et quelques autres correspondant aux types SQL :

getArray(int colummnIndex) ;

getAscii(int colummnIndex) ; getBigDecimal(int colummnIndex) ; getBinary(int colummnIndex) ; getBlob(int colummnIndex) ; getBoolean(int colummnIndex) ; getBytes(int colummnIndex) ; getCharacter(int colummnIndex) ; getDate(int colummnIndex) ; getDouble(int colummnIndex) ; getFloat(int colummnIndex) ; getInt(int colummnIndex) ; getLong(int colummnIndex) ; getObject(int colummnIndex) ; getString(int colummnIndex) ;

Et, la fin, nous fermons nos objets : Code : Java - Slectionner

1 result.close(); 2 state.close();

Introduction aux sockets

Bienvenue dans mon tout premier mini-tutoriel consacr aux sockets en langage Java. On ne va pas tout apprendre sur les sockets mais tudier le plus important concernant ces classes du rpertoire java.net.

Avant de vous lancer dans la lecture de ce tutoriel, les deux premires parties de cysboy sur le langage Java ainsi que la lecture de celui sur les threads et les flux d'entres et sorties (1/2) sont primordiales pour bien suivre le cours !

Je vous recommande galement de lire le chapitre de Dalshim Bien fermer ses threads en Java si vous voulez bien matriser la fermeture de vos threads.

Les sockets servent communiquer entre deux htes appels Client / Serveur l'aide d'une adresse IP et d'un port que j'appelle prise ; ces sockets permettront de grer des flux entrant et sortant afin d'assurer une communication entre les deux (le client et le serveur), soit de manire fiable l'aide du protocole TCP/IP, soit non fiable mais plus rapide avec le protocole UDP. Nous allons tudier le premier mode, le mode TCP/IP Voici ce qu'on peut raliser l'aide des sockets :

des jeux en ligne ; des systmes distribus ; des espaces messengers comme MSN Messenger, Yahoo Messenger, ; des applications comme BitComet permettant de grer les fichiers .torrent que vous connaissez ; et bien d'autres choses.

Les sockets sont utiliss dans plusieurs autres langages, tels que :

le langage C : ( lien vers un tutoriel) ; le langage C++ : (lien vers un autre tutoriel) ; le langage PHP : (lien vers un troisime tutoriel) ; l'Action Script : (aller lire le tutoriel) ; le Erlang : (lien vers le tuto concern) ; et bien d'autres.

Lire les parties histoire et dfinitions de tutoriels ci-dessus ne vous fera pas de mal. Ne tardons pas et commenons. Sommaire du tutoriel :

Rcuprer une adresse IP avec InetAddress Qu'est-ce qu'un socket ? change de message TP : un mini-chat entre le client et le serveur ! Q.C.M.

Rcuprer une adresse IP avec InetAddress

Le package java.net de la plate-forme Java fournit une classe InetAddress qui nous permet de rcuprer et manipuler son adresse internet, IP pour les intimes. Cette classe n'a pas de constructeur, pour pouvoir avoir une instance de cette classe on a besoin des mthodes de classe. Voici les mthodes dont je vous parle :

getLocalHost() : elle retourne un objet qui contient l'adresse IP de la machine locale. getByName(String nom_de_l_machine) : elle retourne un objet qui contient l'adresse IP de la machine dont le nom est pass en paramtre. getAllByName(String nom_de_l_machine) : elle retourne un tableau d'objets qui contient l'ensemble d'adresses IP de la machine qui correspond au nom pass en paramtre.

A prsent, voyons les mthodes applicables un objet de cette classe :

getHostName() : elle retourne le nom de la machine dont l'adresse est stocke dans l'objet.

getAddress() : elle retourne l'adresse IP stocke dans l'objet sous forme d'un tableau de 4 octets. toString() : elle retourne un String qui correspond au nom de la machine et son adresse.

Et pour terminer un petit exemple : Code : Java - Slectionner

import java.net.InetAddress; import java.net.UnknownHostException; 1 2 3 public class Adressage { 4 5 public static void main(String[] zero) { 6 7 InetAddress LocaleAdresse ; 8 InetAddress ServeurAdresse; 9 10 try { 11 12 LocaleAdresse = 13 InetAddress.getLocalHost(); 14 System.out.println("L'adresse locale est 15 : "+LocaleAdresse ); 16 17 ServeurAdresse= 18 InetAddress.getByName("www.siteduzero.com"); 19 System.out.println("L'adresse du 20 serveur du site du zro est : "+ServeurAdresse); 21 22 } catch (UnknownHostException e) { 23 24 e.printStackTrace(); 25 } 26 } }

Et le rsultat est : Code : Console - Slectionner

L'adresse locale est : softdeath/239.254.78.177 L'adresse du serveur du site du zro est : www.siteduzero.com/ 80.248.219.123

Fastoche, hein ? La classe InetAdress peut lever une exception de type UnknownHostException, tchez de ne pas l'oublier !

Nous savons maintenant comment rcuprer l'adresse IP de notre machine ou d'une machine distante, que diriez-vous si l'on l'utilisait pour crer notre tout premier socket ? C'est parti

Qu'est-ce qu'un socket ?

Un socket est un point de terminaison d'une communication bidirectionnelle, c'est--dire entre un client et un serveur en cours d'excution sur un rseau donn. Les deux sont lis par un mme numro de port TCP de sorte que la couche puisse identifier la demande de partage de donnes. Un serveur fonctionne sur une machine bien dfinie et est li un numro de port spcifique. Le serveur se met simplement l'coute d'un client, qui demande une connexion.

En outre, java.net comprend la classe ServerSocket, qui met en oeuvre une sorte de prise que les serveurs peuvent utiliser pour couter et accepter les connexions des clients. Ce qui nous donne : Code : Java - Slectionner
1 ServerSocket socketserver = new ServerSocket(numero_port);

Ainsi on obtient un objet de la classe ServerSocket sur un port spcifique : si ce dernier est 0, le socket est cre sur n'importe quel port libre. Il existe deux autres constructeurs ; l'un a deux paramtres, le premier est bien sr le numro de port et le nombre total de connexion simultanes acceptes, voyez : Code : Java - Slectionner
1 ServerSocket socketserver = new ServerSocket(numer_port,nbr_max);

nbr_max est le nombre maximal de connexions traites simultanment. Par exemple au-del de cinq tentatives de connexion conscutives autorises, les connexions sont refuss.

Pour le second constructeur il suffit de spcifier l'adresse locale du serveur. Code : Java - Slectionner
1 ServerSocket socketserver = new ServerSocket(numer_port,nbr_max,adresse_locale);

Quant au client, celui-ci connat le nom de la machine sur laquelle le serveur est en excution et le numro de port sur lequel il coute. Le client va demander une connexion au serveur en s'identifiant avec son adresse IP ainsi que le numro de port qui lui est li. Pour cela Java.net fournit une classe Socket qui met en oeuvre un ct d'une connexion bidirectionnelle entre votre programme Java et un autre programme sur le rseau. La classe Socket se trouve au sommet d'une plate-forme de charge de mise en oeuvre en cachant les dtails d'un systme particulier de votre programme Java. En utilisant la Socket classe au lieu de compter sur du code natif, vos programmes Java peuvent communiquer sur le rseau en une plate-forme indpendante de la mode. La cration d'un socket pour le client ncessite un des constructeurs suivants : Code : Java - Slectionner
1 Socket socket = new Socket(param1, param2)

Le premier paramtre correspond l'identit du client, il peut tre une chaine de caractre ou de type InetAddress, param2 correspond au numro de port sur lequel on souhaite se connecter sur le serveur. Il est possible galement de spcifier son adresse local comme troisime paramtre et le numro de port local : Code : Java - Slectionner
1 Socket socket = new Socket(adresse_distante, port_distant,

adresse_locale, port_locale)

Aprs tentative de connexion, si tout va bien, le serveur accepte la connexion du client, et reoit un nouveau socket qui est directement li au mme port local. Il a besoin d'une nouvelle prise de sorte qu'elle puisse continuer couter le socket d'origine pour les demandes de connexion, tout t'en satisfaisant les besoins du client connect. Voici comment accepter une connexion d'un client : Code : Java - Slectionner
1 Socket socketduserveur = socketserver.accept();

Une fois le socket cr, l'attente de connexion provenant du client se fait l'aide de la mthode accept(). La mthode accept() reste bloquante tant qu'elle n'a pas dtect de connexion.

Afin d'viter une attente infinie, il est possible de spcifier un dlai maximal d'attente l'aide d'un mutateur setSoTimeout. Si un timeout est une valeur strictement positive, l'appel accept() va gnrer une attente maximale gale timeout. Si ce temps expire, une exception de type InterruptedIOException est leve sans toute fois que la socket de type ServerSocket ne soit invalide. La lecture de ce timeout se fait l'aide de l'accesseur getSoTimeout(). Ct client, si la connexion est accepte, une socket est cr et le client peut utiliser la socket pour communiquer avec le serveur. L'tablissement d'une connexion peut lever une exception de type IOException. On va essayer d'tablir une communication. Vous avez tout les lments porte de main, vous pouvez dsormais tablir une connexion, au boulot !

...Ce n'tait pas si difficile que a, voyons la correction Le client et le serveur peuvent prsent communiquer par l'criture ou la lecture de leurs prises.

Secret (cliquez pour afficher)

Serveur.java Code : Java - Slectionner

import java.io.IOException; 1 import java.net.ServerSocket; 2 import java.net.Socket; 3 4 public class Serveur { 5 6 public static void main(String[] zero) { 7 8 ServerSocket socketserver ; 9 Socket socketduserveur ; 10 11 try { 12 13 socketserver = new ServerSocket(2009); 14 socketduserveur = socketserver.accept(); 15 System.out.println("Un zro s'est 16 connect !"); 17 socketserver.close(); 18 socketduserveur.close(); 19 20 }catch (IOException e) { 21 e.printStackTrace(); 22 } 23 } 24 25 }

Client.java Code : Java - Slectionner

import java.io.IOException; 1 import java.net.InetAddress; 2 import java.net.Socket; 3 import java.net.UnknownHostException; 4 5 6 public class Client { 7 8 public static void main(String[] zero) { 9 10 Socket socket; 11 12 try { 13 14 socket = new 15 Socket(InetAddress.getLocalHost(),2009); 16 socket.close(); 17 18 }catch (UnknownHostException e) { 19 20 e.printStackTrace(); 21 }catch (IOException e) { 22 23 e.printStackTrace(); 24 } 25 } 26 27 }

Lancez le serveur en premier et ensuite le client !

Vous venez d'tablir votre premire connexion entre un serveur et un client . Maintenant, voyons comment envoyer et recevoir des messages. Attention : il ne faut jamais oublier de fermer le socket ! Sinon si vous utilisez le mme port dans un autre programme, ce (l'action de fermer une socket) ne sera plus possible car il (le port) sera occup !

change de message

Une fois la connexion tablie et les sockets en possession, il est possible de rcuprer le flux d'entre et de sortie de la connexion TCP vers le serveur. Il existe deux mthodes pour permettre la rcupration des flux :

getInputStream() de la classe InputStream. Elle nous permet de grer les flux entrant ; getOutputStream() de la classe OuputStream. Elle nous permet de grer les flux sortant.

Ces deux mthodes nous permettent donc de grer les flux en entre et en sortie. En gnral le type d'entre et sortie utilis est BufferedReader et InputStreamReader pour la lecture, PrintWriter pour l'criture. Mais on peut utiliser tous les autres flux. En se basant sur l'annexe du tuto Java :

BufferedReader : cette classe permet de lire des caractres partir d'un flux tamponn, afin de faire des lectures plus rapides ; InputStreamReader : convertit un flux binaire en flux de caractres : elle convertit un objet de type InputStream en objet de type Reader ; PrintWriter : la classe PrintWriter ajoute un flux la possibilit de faire des critures sous forme de texte des types primitifs Java, et des chanes de caractres.

Un petit exemple de communication en image et en code source :

Serveur.java Code : Java - Slectionner

1 import java.io.BufferedReader; 2 import java.io.IOException; 3 import java.io.InputStreamReader; 4 import java.io.PrintWriter; 5 import java.net.InetAddress; 6 import java.net.ServerSocket; 7 import java.net.Socket; 8 import java.net.UnknownHostException; 9 import java.io.PrintWriter; 10 11 public class Serveur { 12 13 public static void main(String[] zero) { 14 15 ServerSocket socketserver ; 16 Socket socketduserveur ; 17 BufferedReader in; 18 PrintWriter out; 19 20 try {

21 22 socketserver = new ServerSocket(2009); 23 System.out.println("Le serveur est 24 l'coute du port "+socketserver.getLocalPort()); 25 socketduserveur = socketserver.accept(); 26 System.out.println("Un zro s'est 27 connect"); 28 out = new 29 PrintWriter(socketduserveur.getOutputStream()); 30 out.println("Vous tes connect zro 31 !"); 32 out.flush(); 33 34 socketduserveur.close(); 35 socketserver.close(); 36 37 }catch (IOException e) { 38 39 e.printStackTrace(); } } }

Client.java Code : Java - Slectionner

1 import java.io.BufferedReader; 2 import java.io.IOException; 3 import java.io.InputStreamReader; 4 import java.io.PrintWriter; 5 import java.net.InetAddress; 6 import java.net.Socket; 7 import java.net.UnknownHostException; 8 9 10 public class Client { 11 12 public static void main(String[] zero) { 13 14 15 Socket socket; 16 BufferedReader in; 17 PrintWriter out; 18 19 try {

20 21 socket = new 22 Socket(InetAddress.getLocalHost(),2009); 23 System.out.println("Demande de 24 connexion"); 25 26 in = new BufferedReader (new 27 InputStreamReader (socket.getInputStream())); 28 String message_distant = in.readLine(); 29 System.out.println(message_distant); 30 31 socket.close(); 32 33 }catch (UnknownHostException e) { 34 35 e.printStackTrace(); 36 }catch (IOException e) { 37 38 e.printStackTrace(); 39 } } }

Rsultat chez le serveur : Code : Console - Slectionner

Le serveur est l'coute du port 2009 Un zro s'est connect

Rsultat chez le client : Code : Console - Slectionner

Demande de connexion Vous tes connect zro !

Ho l ! Un instant ! C'est quoi, ces encapsulations et ce flush ?

Rassurez-vous, on va tout expliquer en dtail (

), surtout ne vous affolez pas.

Ct Serveur
Aprs tablissement de la connexion, le serveur obtient son socket qu'il utilise pour grer le flux sortant l'aide de socketduserveur.getOutputStream() ; ensuite, l'aide de la mthode println on envoie un message au client, on utilise flush pour vider le buffer tout simplement. Et pour finir on ferme la connexion.

Ct Client
Aprs avoir obtenu notre socket, on utilise socket.getInputStream() pour rcuprer le flux sortant. La mthode readLine() nous permet de lire une chane de caractres. Il existe plusieurs autres mthodes telles :

readInt() permettant de lire un entier ; readDouble() permettant de lire un nombre de type double ;

Pour finir, on affiche le message reu et on ferme notre socket. a a l'air trs simple premire vue pour deux htes, mais si l'on veut que plus que deux puissent communiquer entre eux la fois, comment faire ? D'o la ncessit d'utiliser les Threads.

Utilisation des threads

Je pars du principe que vous connaissez ce que sont les threads et comment les utiliser et pourquoi doit-on les utiliser dans nos programme, on va donc attaquer directement la pratique. Le principe d'utilisation des Threads est simple (sera simple si vous suivez

attentivement :D). Aprs avoir crer un objet ServerSocket par le serveur, on le place (l'objet) comme paramtre un constructeur de la classe qui implmente la classe Runnable ou tend la classe Thread, ds qu'un client souhaite se connecter avec le serveur, un Thread s'occupe de la connexion, il ne sera plus la peine de faire appel au serveur lorsqu'un client souhaite se connecter, tout le boulot sera confi un Thread. Vous commencez comprendre l'utilit des Threads avec le temps vous ne pourrez plus vous en passer. Voyons un petit exemple de connexion Multi-Threads en image et avec un code source toujours :

Serveur.java Code : Java - Slectionner

1 import java.io.IOException; 2 import java.net.*; 3 4 public class Serveur { 5 6 public static void main(String[] zero){ 7 8 ServerSocket socket; 9 try { 10 socket = new ServerSocket(2009); 11 Thread t = new Thread(new

12 Accepter_clients(socket)); 13 t.start(); 14 System.out.println("Mes employeurs sont prts 15 !"); 16 17 } catch (IOException e) { 18 19 e.printStackTrace(); 20 } 21 } 22 } 23 24 class Accepter_clients implements Runnable { 25 26 private ServerSocket socketserver; 27 private Socket socket; 28 private int nbrclient = 1; 29 public Accepter_clients(ServerSocket s){ 30 socketserver = s; 31 } 32 33 public void run() { 34 35 try { 36 while(true){ 37 socket = socketserver.accept(); // Un 38 client se connecte on l'accepte 39 System.out.println("Le client numro 40 "+nbrclient+ " est connect !"); 41 nbrclient++; 42 socket.close(); 43 } 44 45 } catch (IOException e) { 46 e.printStackTrace(); } } }

Client.java

Code : Java - Slectionner

1 import java.io.IOException; 2 import java.net.*; 3 4 public class Client { 5 6 public static void main(String[] zero){ 7 8 Socket socket; 9 try { 10 socket = new Socket("localhost",2009); 11 socket.close(); 12 } catch (IOException e) { 13 14 e.printStackTrace(); 15 } 16 } 17 }

Rsulats : Code : Console - Slectionner

Mes employeurs sont prts ! Le client numero 1 est connect ! Le client numero 2 est connect ! Le client numero 3 est connect !

Si vous m'avez bien suivis vous ne devriez pas avoir du mal comprendre ce code. Ds que quelqu'un tape la porte, on demande un employer de lui ouvrir la porte, celui-l va le saluer et lui dire bye bye avec socket.close(); s'il ne veut pas parler (communiquer) .

TP : un mini-chat entre le client et le serveur !

prsent que nous savons su manier les sockets en utilisant les threads, ralisons un petit programme client / serveur : aprs la connexion du client, celui-ci devra s'authentifier en premier, le serveur va vrifier dans un fichier la validit de ses donnes ; si tout est O.K., un message lui dira qu'il est connect,

ils pourront ensuite envoyer tous leurs messages au serveur. Voil : trs simple. On devra avoir quelque chose de ce genre ct serveur, pour plusieurs clients la fois : Code : Console - Slectionner
Le serveur est l'coute du port 2009 Un zro veut se connecter softdeath vient de se connecter softdeath : salut, M. le serveur, j'ai besoin de vos services. Un zro veut se connecter chabanus vient de se connecte chabanus : salut, j'ai besoin d'accder telles donnes.

et du ct du client, tte--tte avec le serveur aprs connexion : Code : Console - Slectionner

Demande de connexion Connexion tablie avec le serveur, authentification : Entrez votre login : chabanus Entrez votre mot de passe : chabanus Je suis connect Votre message : salut Le serveur vous dit : salut Votre message : a va ? Le serveur vous dit : bien et toi ?

Allez au boulot ! J'espre que vous avez au moins essay.

Cette solution n'est ni unique ni la meilleure, elle est simple et minimale pour vous montrer comment les threads doivent tre grs. Voyons la correction : Ct Serveur Secret (cliquez pour afficher)

Accepter_connexion.java Code : Java - Slectionner

import java.io.*; 1 import java.net.*; 2 3 4 public class Accepter_connexion implements Runnable{ 5 6 private ServerSocket socketserver = null; 7 private Socket socket = null; 8 9 public Thread t1; 10 public Accepter_connexion(ServerSocket ss){ 11 socketserver = ss; 12 } 13 14 public void run() { 15 16 try { 17 while(true){ 18 19 socket = socketserver.accept(); 20 System.out.println("Un zro veut se 21 connecter "); 22 23 t1 = new Thread(new 24 Authentification(socket)); 25 t1.start(); 26 27 } 28 } catch (IOException e) { 29 30 System.err.println("Erreur serveur"); 31 } 32 33 } }

Authentification .java Code : Java - Slectionner

1 import java.net.*; 2 import java.util.NoSuchElementException; 3 import java.util.Scanner; 4 import java.io.*; 5 6 public class Authentification implements Runnable { 7 8 private Socket socket; 9 private PrintWriter out = null; 10 private BufferedReader in = null; 11 private String login = "zero", pass = null; 12 public boolean authentifier = false; 13 public Thread t2; 14 15 public Authentification(Socket s){ 16 socket = s; 17 } 18 public void run() { 19 20 try { 21 22 in = new BufferedReader(new 23 InputStreamReader(socket.getInputStream())); 24 out = new 25 PrintWriter(socket.getOutputStream()); 26 27 while(!authentifier){ 28 29 out.println("Entrez votre login :"); 30 out.flush(); 31 login = in.readLine(); 32 33 34 out.println("Entrez votre mot de passe 35 :"); 36 out.flush(); 37 pass = in.readLine(); 38 39 if(isValid(login, pass)){ 40 41 out.println("connecte"); 42 System.out.println(login +" vient 43 de se connecter "); 44 out.flush(); 45 authentifier = true; 46 }

47 else {out.println("erreur"); 48 out.flush();} 49 } 50 t2 = new Thread(new 51 Chat_ClientServeur(socket,login)); 52 t2.start(); 53 54 } catch (IOException e) { 55 56 System.err.println(login+" ne rpond pas 57 !"); 58 } 59 } 60 61 private static boolean isValid(String login, String 62 pass) { 63 64 65 boolean connexion = false; 66 try { 67 Scanner sc = new Scanner(new 68 File("zero.txt")); 69 70 71 while(sc.hasNext()){ 72 if(sc.nextLine().equals(login+" 73 "+pass)){ 74 connexion=true; 75 break; 76 } } } catch (FileNotFoundException e) { System.err.println("Le fichier n'existe pas !"); } return connexion; } }

Chat_ClientServeur.java Code : Java - Slectionner

1 import 2 import 3 import 4 import java.io.BufferedReader; java.io.IOException; java.io.InputStreamReader; java.io.PrintWriter;

5 import java.net.Socket; 6 7 8 public class Chat_ClientServeur implements Runnable { 9 10 private Socket socket = null; 11 private BufferedReader in = null; 12 private PrintWriter out = null; 13 private String login = "zero"; 14 private Thread t3, t4; 15 16 17 public Chat_ClientServeur(Socket s, String log){ 18 19 socket = s; 20 login = log; 21 } 22 public void run() { 23 24 try { 25 in = new BufferedReader(new 26 InputStreamReader(socket.getInputStream())); 27 out = new 28 PrintWriter(socket.getOutputStream()); 29 30 Thread t3 = new Thread(new 31 Reception(in,login)); 32 t3.start(); 33 Thread t4 = new Thread(new Emission(out)); 34 t4.start(); 35 36 } catch (IOException e) { 37 System.err.println(login +"s'est dconnect "); } } }

Emission .java Code : Java - Slectionner

1 import java.io.IOException; 2 import java.io.PrintWriter; 3 import java.util.Scanner; 4 5 6 public class Emission implements Runnable { 7 8 private PrintWriter out;

9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 :"); 24 25 26 27 28 }

private String message = null; private Scanner sc = null; public Emission(PrintWriter out) { this.out = out; } public void run() { sc = new Scanner(System.in); while(true){ System.out.println("Votre message message = sc.nextLine(); out.println(message); out.flush(); } }

Reception.java Code : Java - Slectionner

1 import java.io.BufferedReader; 2 import java.io.IOException; 3 4 5 public class Reception implements Runnable { 6 7 private BufferedReader in; 8 private String message = null, login = null; 9 10 public Reception(BufferedReader in, String login){ 11 12 this.in = in; 13 this.login = login; 14 } 15 16 public void run() { 17 18 while(true){ 19 try { 20 21 message = in.readLine(); 22 System.out.println(login+" : "+message); 23 24 } catch (IOException e) {

25 26 27 28 29 30 31 }

e.printStackTrace(); } } }

Serveur.java Code : Java - Slectionner

import java.io.*; import java.net.*;

1 2 public class Serveur { 3 public static ServerSocket ss = null; 4 public static Thread t; 5 6 7 public static void main(String[] args) { 8 9 try { 10 ss = new ServerSocket(2009); 11 System.out.println("Le serveur est 12 l'coute du port "+ss.getLocalPort()); 13 14 t = new Thread(new 15 Accepter_connexion(ss)); 16 t.start(); 17 18 } catch (IOException e) { 19 System.err.println("Le port 20 "+ss.getLocalPort()+" est dj utilis !"); 21 } 22 23 } 24 25 }

Ct Client

Secret (cliquez pour afficher)

Chat_ClientServeur.java Code : Java - Slectionner

import java.io.*; import java.net.*; import java.util.Scanner;

1 2 3 public class Chat_ClientServeur implements Runnable { 4 5 private Socket socket; 6 private PrintWriter out = null; 7 private BufferedReader in = null; 8 private Scanner sc; 9 private Thread t3, t4; 10 11 public Chat_ClientServeur(Socket s){ 12 socket = s; 13 } 14 15 public void run() { 16 try { 17 out = new 18 PrintWriter(socket.getOutputStream()); 19 in = new BufferedReader(new 20 InputStreamReader(socket.getInputStream())); 21 22 sc = new Scanner(System.in); 23 24 Thread t4 = new Thread(new 25 Emission(out)); 26 t4.start(); 27 Thread t3 = new Thread(new 28 Reception(in)); 29 t3.start(); 30 31 32 33 } catch (IOException e) { 34 System.err.println("Le serveur distant 35 s'est dconnect !"); 36 } 37 } }

Client.java Code : Java - Slectionner

import java.io.*; import java.net.*; 1 2 public class Client { 3 4 public static Socket socket = null; 5 public static Thread t1; 6 7 public static void main(String[] args) { 8 9 10 try { 11 12 System.out.println("Demande de connexion"); 13 socket = new Socket("127.0.0.1",2009); 14 System.out.println("Connexion tablie avec le 15 serveur, authentification :"); // Si le message s'affiche 16 c'est que je suis connect 17 18 t1 = new Thread(new Connexion(socket)); 19 t1.start(); 20 21 22 23 } catch (UnknownHostException e) { 24 System.err.println("Impossible de se connecter 25 l'adresse "+socket.getLocalAddress()); 26 } catch (IOException e) { 27 System.err.println("Aucun serveur l'coute du port 28 "+socket.getLocalPort()); 29 } 30 31 32 33 } }

Connexion.java Code : Java - Slectionner

1 import java.net.*; 2 import java.util.Scanner;

3 import java.io.*; 4 5 public class Connexion implements Runnable { 6 7 private Socket socket = null; 8 public static Thread t2; 9 public static String login = null, pass = null, 10 message1 = null, message2 = null, message3 = null; 11 private PrintWriter out = null; 12 private BufferedReader in = null; 13 private Scanner sc = null; 14 private boolean connect = false; 15 16 public Connexion(Socket s){ 17 18 socket = s; 19 } 20 21 public void run() { 22 23 try { 24 25 out = new 26 PrintWriter(socket.getOutputStream()); 27 in = new BufferedReader(new 28 InputStreamReader(socket.getInputStream())); 29 sc = new Scanner(System.in); 30 31 32 while(!connect ){ 33 34 System.out.println(in.readLine()); 35 login = sc.nextLine(); 36 out.println(login); 37 out.flush(); 38 39 System.out.println(in.readLine()); 40 pass = sc.nextLine(); 41 out.println(pass); 42 out.flush(); 43 44 if(in.readLine().equals("connecte")){ 45 46 System.out.println("Je suis connect "); 47 connect = true; 48 } 49 50 else { 51 System.err.println("Vos informations sont 52 incorrectes "); 53 }

54 55 } 56 57 t2 = new Thread(new 58 Chat_ClientServeur(socket)); 59 t2.start(); 60 61 } catch (IOException e) { 62 System.err.println("Le serveur ne rpond plus "); } } }

Emission.java Code : Java - Slectionner

import java.io.IOException; 1 import java.io.PrintWriter; 2 import java.util.Scanner; 3 4 5 public class Emission implements Runnable { 6 7 private PrintWriter out; 8 private String login = null, message = null; 9 private Scanner sc = null; 10 11 public Emission(PrintWriter out) { 12 this.out = out; 13 14 } 15 16 17 public void run() { 18 19 sc = new Scanner(System.in); 20 21 while(true){ 22 System.out.println("Votre message 23 :"); 24 message = sc.nextLine(); 25 out.println(message); 26 out.flush(); 27 } 28 } 29 }

Reception.java Code : Java - Slectionner

import java.io.BufferedReader; 1 import java.io.IOException; 2 3 4 public class Reception implements Runnable { 5 6 private BufferedReader in; 7 private String message = null; 8 9 public Reception(BufferedReader in){ 10 11 this.in = in; 12 } 13 14 public void run() { 15 16 while(true){ 17 try { 18 19 message = in.readLine(); 20 System.out.println("Le serveur vous dit 21 :" +message); 22 23 } catch (IOException e) { 24 25 e.printStackTrace(); 26 } 27 } 28 } 29 30 }

Lancez serveur.java et ensuite client.java, n'oubliez pas de crer un fichier pour le serveur pour qu'il puisse y vrifier l'identit de ses clients, je l'ai nomm zero.txt : vous pouvez le nommer comme vous le souhaitez, c'est votre guise. Optimisation : Pour ne pas dire qu'il en existe l'infini, plusieurs autres possibilits s'offrent vous, vous pouvez :

rendre l'application client / client. Le serveur authentifie les deux clients et ces deux-l pourront discuter ensemble sans que d'autres puissent y entrer : grosso modo raliser un salon , comme on l'appelle ; utiliser les bases de donnes pour la sauvegarde des messages et pour authentifier les clients ; raliser une interface graphique en swing ou en swt ;

Croyez-moi : lorsque vous matriserez les sockets en utilisant les threads, rien ne sera plus compliqu pour vous. Bonne continuation tous ; surtout n'hsitez pas l'amliorer et envoyez-moi un MP pour m'exposer votre travail