Aller au menu - Aller au contenu

Centre d'aide Vous êtes ici : zCorrecteurs.fr > Les forums > Espace public > Vos questions aux zCorrecteurs… > zCorrection du mini-tutoriel : Introduction aux Sockets en java > Voir le sujet

zCorrection du mini-tutoriel : Introduction aux Sockets en java

Résolu Le problème de ce sujet a été résolu.

Page : 1 
Auteur Message
0 membre et 1 visiteur.
Page : 1 
Hors ligne SoftDeath # Posté le 24/07/2009 à 15 h 45
ben...euh...j'sais plus :s
Avatar de SoftDeath
Messages : 37
Membres
Salut, donc voilà j'ai rédigé un mini-tutoriel concernant les sockets en java, il me reste a terminer le tp, mais le plus important est fait. Je remercierais infiniment le zCorrecteurs qui m'aiderait a le terminer correctement merci d'avance (j'espère ne pas me tromper de porte)

PS: Dommage qu'on ne puisse pas importer directement le fichier.tuto du logiciel zEditor directement sur ce formulaire :-° .

A partir du logiciel zEditor :
Introduction :
Bienvenue dans mon tout premier mini tutoriel et consacrer aux sockets en langage java. On ne va pas tout apprendre sur les sockets mais on va étudier le plus important concernant ces classes du répertoire java.net .

Avant de vous lancer dans la lecture de ce tutoriel les deux premières parties de cyboy sur le langage java ainsi que celui sur les threads et les flux d'entrées et sorties (1/2) sont primondial 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 maitriser la fermeture de vos threads.


Lire les parties histoires et definitions de ces tutoriels ci-dessus ne vous fera pas de mal car les sockets font la même chose partout, grosso modo elles servent a communiquer entre deux hôtes appeler Client/Serveur à l'aide d'une adresse ip et d'un port que j'appel prise , elles permettront (les sockets) de gérer des flux entrant et sortant afin d'assurer une communication entre les deux (le client et le serveur) soit de manière fiable a l'aide du protocole TCP/IP ou non fiable mais plus rapide avec le protocle UDP. Nous allons étudier le premier mode, le mode TCP/IP...

Voici ce qu'on peut réaliser à l'aide des sockets :

  • Des systèmes distribués.
  • Des espaces messengers comme MSN Messenger, Yahoo Messenger...
  • Des applications comme bitcomet permettant de gérer les fichiers .torrent que vous connaissez
  • Et bien d'autres...


Les sockets sont utiliser dans plusieurs autres langages, tels :



Ne tardons pas et commençons :)

Récupérer une adresse ip avec InetAddress


Le java.net package dans la plate-forme Java fournit une classe InetAddres il est possible en java de récupérer 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 méthodes de class. Voici les méthodes 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 paramètre.
  • getAllByName(String nom_de_l_machine) elle retourne un tableau d'objets qui contient l'ensemble d'adresse ip de la machine qui correspond au nom passé en paramètre.


A présent voyons les méthodes applicables à un objet de cette classe:

  • getHostName() elle retourne le nom de la machine dont l'adresse est stockée dans l'objet.
  • getAddress() elle retourne l'adresse ip stockée 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
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
import java.net.InetAddress;
import java.net.UnknownHostException;


public class Adressage {
	
	public static void main(String[] zero) {
		
		InetAddress LocaleAdresse ;
		InetAddress ServeurAdresse;

		try {

			LocaleAdresse = InetAddress.getLocalHost();
			System.out.println("L'adresse local est : "+LocaleAdresse ); 
			
			ServeurAdresse= InetAddress.getByName("www.siteduzero.com");
                        System.out.println("L'adresse du serveur du site du zéro est : "+ServeurAdresse);
		
		} catch (UnknownHostException e) {
			
			e.printStackTrace();
		}
	}

}


et le resultat est :

Code : Console
L'adresse local est : softdeath/169.254.68.177
L'adresse du serveur du site du zéro est : www.siteduzero.com/80.248.219.123


Fastoche hein ! :magicien:

La classe InetAdress peut lever une exception de type UnknownHostException, tâcher de ne pas l'oublier !


Nous savons maintenant comment récupérer l'adresse ip de notre machine ou d'une machine distante, que diriez-vous si l'on l'utilise pour créer notre toute première socket ? C'est partit ;)

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'exécution sur un réseau donné. Les deux sont liès par un même numéro de port TCP de sorte que la couche puisse identifier la demande de partage de données.

Un serveur fonctionne sur une machine bien définie et est lié a un numéro de port spécifique. Le serveur se mets simplement à l'écoute d'un client, qui demande une connexion.

En outre, java.net comprend la classe ServerSocket, qui met en œuvre une sorte de prise que les serveurs peuvent utiliser pour écouter et accepter les connexions des clients. Ce qui nous donne :

Code : Java
1
ServerSocket socketserver = new ServerSocket(numero_port);


Ainsi on obtient un objet de la classe ServerSocket sur un port spécifique, si ce dernier est à 0, la socket est créée sur n'importe quel port libre.

Il existe deux autre constructeur l'un a deux paramètres, le premier est bien sur le numéro de port et le second correspond aux nombres total de connexion simultanés acceptées, voyez :

Code : Java
1
ServerSocket socketserver = new ServerSocket(numer_port,nbr_max);


nbr_max est le nombre maximal de connexions traitées simultanément. Après cinq tentatives de connexion consécutives sont autorisé, au-dela les connexions sont refusé.

Pour le troisième constructeur il suffit de spécifier l'adresse local du serveur.

Code : Java
1
ServerSocket socketserver = new ServerSocket(numer_port,nbr_max,adresse_locale);


Quant au client, celui-ci connait le nom de la machine sur laquelle le serveur est en exécution et le numéro de port sur lequel il écoute. Le client va demander une connexion au serveur en s'identifiant avec son adresse ip ainsi que le numéro de port qui lui est lié.

Pour cela Java.net fournit une classe Socket qui met en œuvre un côté d'une connexion bidirectionnelle entre votre programme Java et un autre programme sur le réseau. La classe Socket se trouve au sommet d'une plate-forme de charge de mise en œuvre en cachant les détails d'un système particulier de votre programme Java. En utilisant le Socket classe au lieu de compter sur du code natif, vos programmes Java peuvent communiquer sur le réseau en une plate-forme indépendante de la mode. La création d'une socket pour le client nécessite un des constructeurs suivants :

Code : Java
1
Socket socket = new Socket(param1, param2)


Le premier paramètre correspond a l'identité du client, il peut être une chaine de caractère ou de type InetAddress, param2 correspond au numéro de port sur lequel on souhaite se connecter sur le serveur. Il est possible également de spécifier son adresse local comme troisème paramètre et le numéro de port local :

Code : Java
1
Socket socket = new Socket(adresse_distante, port_distant, adresse_locale, port_locale)


Après tentative de connexion, si tout va bien, le serveur accepte la connexion du client, et le serveur reçoit un nouveau socket qui est directement liés au même port local. Il a besoin d'une nouvelle prise de sorte qu'elle puisse continuer à écouter la 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
1
Socket socketduserveur = socketserver.accept();


Une fois la socket créee, l'attente de connexions provenant du client se fait à l'aide de la méthode accept.

La méthode accept() reste bloquante tant qu'elle n'a pas détecté de connexions.


Afin d'éviter une attente infinie, il est possible de spécifier un délai maximal d'attente à l'aide d'un mutateur setSoTimeout.

Si un timeout est une valeur strictement positive, l'appel accept() va générer une attente maximale égale à timeout. Si ce temps expire, une exception de type InterruptedIOException est levée sans toute fois que la socket de type ServerSocket ne soit invalidéee. La lecture de ce timeout se fait a l'aide de l'accésseur getSoTimeout().


Côté client, si la connexion est acceptée, un socket est créé et le client peut utiliser le socket pour communiquer avec le serveur.

L'établissement de connexion peut lever une exeception de type IOException.

Lancez le serveur en premier et ensuite le client.

Vous avez tout les éléments en main, vous pouvez désormais établir une connexion, au boulot ! :pirate:

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


Secret (cliquez pour afficher)

Serveur.java

Code : Java
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

public class Serveur {

	public static void main(String[] zero) {
		
		ServerSocket socketserver  ;
		Socket socketduserveur ;

		try {
		
				socketserver = new ServerSocket(2009);
				socketduserveur = socketserver.accept(); 
			        System.out.println("Un zéro s'est connecté !");
		                socketserver.close();
		                socketduserveur.close();
		}catch (IOException e) {
			e.printStackTrace();
		}
	}

}


Client.java
Code : Java
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
import java.io.IOException;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;


public class Client {
	
	public static void main(String[] zero) {
		
		Socket socket;

		try {
		
				socket = new Socket(InetAddress.getLocalHost(),2009);	
				socket.close();
		}catch (UnknownHostException e) {
			
			e.printStackTrace();
		}catch (IOException e) {
			
			e.printStackTrace();
		}
	}

}



Bravo vous venez d'établir votre première connexion entre un serveur et un client :magicien: . Maintenant voyons comment envoyer et recevoir des messages.

Attention il ne faut jamais oublier de fermer la socket ! Sinon si vous utilisez le même port dans un autre programme, il ne sera plus possible car il sera occuper !



Échange de message

Une fois la connexion établie et les sockets en possesion il est possible de récupérer le flux d'entrée et de sortie de la connexion TCP vers le Serveur, il existe deux méthodes pour permettre la récupération des flux :
  • getInputStream() de la class InputStream. Elle nous permet de gérer les flux entrant.
  • getOutputStream() de la class OuputStream. Elle nous permet de gérer les flux sortie.


Ces deux méthodes nous permettent donc de gérer les flux en entrée et en sortie. En général le type d'entrée et sortie utiliser est BufferedReader et InputStreamReader pour la lecture et PrintWriter pour l'écriture. Mais on peut utiliser tout les autres flux

En se basant sur l'annexe du tuto java :

  • BufferedReader Cette classe permet de lire des caractères à partir d'un flux tamponné, afin de faire des lectures plus rapides.
  • InputStreamReader Convertit un flux binaire en flux de caractères : elle convertit un objet de type InputStream en objet de type Reader.
  • PrintWriter La classe PrintWriter ajoute à un flux la possibilité de faire des écriture sous forme de texte des types primitifs java, et des chaînes de caractères.


Un petit exemple de communication :

Secret (cliquez pour afficher)


Code : Java
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.UnknownHostException;
import java.io.PrintWriter;

public class Serveur {
	
	public static void main(String[] zero) {
		
		ServerSocket socketserver  ;
		Socket socketduserveur ;
		BufferedReader in;
		PrintWriter out;
		
		try {
		
			socketserver = new ServerSocket(2009);
			System.out.println("Le serveur est a l'écoute du port "+socketserver.getLocalPort());
			socketduserveur = socketserver.accept(); 
		
			out = new PrintWriter(socketduserveur.getOutputStream());
		        out.println("Vous êtes connecté zéro !");
		        out.flush();
		                
		        socketduserveur.close();
		        socketserver.close();
		        
		}catch (IOException e) {
			
			e.printStackTrace();
		}
	}

}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;


public class Client {
	
	public static void main(String[] zero) {
		
		
		Socket socket;
		BufferedReader in;
		PrintWriter out;

		try {
		
			socket = new Socket(InetAddress.getLocalHost(),2009);	
		        System.out.println("Demande de connexion");

		        in = new BufferedReader (new InputStreamReader (socket.getInputStream()));
		        String message_distant = in.readLine();
		        System.out.println(message_distant);
		        
		        socket.close();
		       
		}catch (UnknownHostException e) {
			
			e.printStackTrace();
		}catch (IOException e) {
			
			e.printStackTrace();
		}
	}

}



Résultat chez le serveur :Code : Console
Le serveur est a l'écoute du port 2009


Résultat chez le client :

Code : Console
Demande de connexion
Vous êtes connecté zéro !


Hola ! Un instant c'est quoi ces encapsulations et ce flush ?


Rassurez-vous on va tout expliquer en détail ^^, surtout ne vous affoulez pas.

Côté Serveur :

Après établissement de la connexion, le serveur obtient sa socket qu'il utilise pour gérer le flux sortant a l'aide de socketduserveur.getOutputStream() ensuite a l'aide de la méthode println en envois un message au client, on utilise flush pour vider le buffer tout simplement. Et pour finir on ferme la connexion.

Côté Client:
Après avoir obtenu notre socket, on utilise socket.getInputStream() pour récupérer le flux sortant. La méthode readLine() nous permet de lire une chaine de caractère. Il existe plusieurs autre méthode telles :

  • readInt() permet de lire un entier
  • readDouble() permet de lire un nombre de type Double
  • ...


Pour finir on affiche le message reçu et on ferme notre socket.

Ca a l'air très simple a première vue pour deux hôtes mais si l'on veut que plus que deux puisse communiquer entre-eux à la fois, comment faire ? D'où la nécessité d'utiliser les threads .


Utilisation des threads

Je pars du point que vous connaissez c'est quoi les threads et comment les utiliser on va donc directement attaquer la pratique.
Comme je l'ai dis plus haut on ne peut établir une connexion entre plus de deux hôtes de manière synchroniser et propre sans utiliser les threads.
Le principe d'utilisation des threads est simple, après avoir créer un objet ServerSocket par le serveur on le passe en paramètre a un thread dès qu'un client veut se connecter le thread se charge de lui, il ne sera plus la peine que le serveur se casse la tête a attendre qu'un client se connecte, tout le boulot sera confier a un thread.
Vous commencez a comprendre l'utilité des threads ;) avec le temps vous ne pourrez plus vous en passer.
Voyons un petit exemple de connexion multi-thread :


Serveur.java

Code : Java
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
import java.io.IOException;
import java.net.*;

public class Serveur {

	public static void main(String[] zero){
		
		ServerSocket socket;
		try {
		socket = new ServerSocket(2009);
		Thread t = new Thread(new Accepter_clients(socket));
		t.start();
		System.out.println("Mes employers sont prêts !");
		
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

class Accepter_clients implements Runnable {

	   private ServerSocket socketserver;
	   private Socket socket;
	   private int nbrclient = 1;
		public Accepter_clients(ServerSocket s){
			socketserver = s;
		}
		
		public void run() {

	        try {
	        	while(true){
				socket = socketserver.accept(); // Un client se connecte on l'accepte
	            System.out.println("Le client numero "+nbrclient+ " est connecter !");
	            nbrclient++;
	            socket.close();
	        	}
	        
	        } catch (IOException e) {
				e.printStackTrace();
			}
		}

	}



Client.java


Code : Java
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
import java.io.IOException;
import java.net.*;

public class Client {

	public static void main(String[] zero){
		
		Socket socket;
		try {
		socket = new Socket("localhost",2009);
		socket.close();
		} catch (IOException e) {
			
			e.printStackTrace();
		}
	}
}


Résulats :

Code : Console
Mes employers sont prêts !
Le client numero 1 est connecter !
Le client numero 2 est connecter !
Le client numero 3 est connecter !


Si vous m'avez bien suivis vous ne devriez pas avoir du mal a comprendre ce code. Dés que quelqu'un tape a la porte, on charge un employer pour lui ouvrir la porte le salue et lui dit bye bye :-° avec socket.close();
Je vous ai concocter un petit tp :pirate: pour conclure.

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

A présent que nous savons su manier les sockets en utilisant les threads, réalisons un petit programme client/serveur, après la connexion du client celui-ci devra s'authentifier en premier, le serveur va vérifier dans un fichier la validité de ses données, si tout est OK un message lui dira qu'il est connecté, ils pourront ensuite envoyer tout leurs messages au serveur, voilà très simple.

On devra avoir quelque chose de ce genre côté serveur, pour plusieurs clients a la fois :

Code : Console
Le serveur est à l'écoute du port 2009
Un zéro veut se connecté 
softdeath vient de se connecter 
softdeath : salut, mr le serveur j'ai besoin de vos services.
Un zéro veut se connecté r 
chabanus vient de se connecte
chabanus : salut, j'ai besoin d'acceder a telles données.


et du côté du client tête a tête avec le serveur après connexion:

Code : Console
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'espère que vous avez au moins essayer :euh: , voyons la correction :

Côté Serveur


Secret (cliquez pour afficher)

Accepter_connexion.java
Code : Java
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
import java.io.*;
import java.net.*;


public class Accepter_connexion implements Runnable{

	private ServerSocket socketserver = null;
	private Socket socket = null;

	public Thread t1;
	public Accepter_connexion(ServerSocket ss){
	 socketserver = ss;
	}
	
	public void run() {
		
		try {
			while(true){
				
			socket = socketserver.accept();
			System.out.println("Un zéro veut se connecté  ");
			
			t1 = new Thread(new Authentification(socket));
			t1.start();
			
			}
		} catch (IOException e) {
			
			System.err.println("Erreur serveur");
		}
		
	}
}

Authentification .java
Code : Java
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
import java.net.*;
import java.util.NoSuchElementException;
import java.util.Scanner;
import java.io.*;

public class Authentification implements Runnable {

	private Socket socket;
	private PrintWriter out = null;
	private BufferedReader in = null;
	private String login = "zero", pass =  null;
	public boolean authentifier = false;
	public Thread t2;
	
	public Authentification(Socket s){
		 socket = s;
		}
	public void run() {
	
		try {
			
			in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
			out = new PrintWriter(socket.getOutputStream());
			
		while(!authentifier){
			
			out.println("Entrez votre login :");
			out.flush();
			login = in.readLine();
			
			
			out.println("Entrez votre mot de passe :");
			out.flush();
			pass = in.readLine();

			if(isValid(login, pass)){
				
				out.println("connecte");
				System.out.println(login +" vient de se connecter ");
				out.flush();
				authentifier = true;	
			}
			else {out.println("erreur"); out.flush();}
		 }
			t2 = new Thread(new Chat_ClientServeur(socket,login));
			t2.start();
			
		} catch (IOException e) {
			
			System.err.println(login+" ne répond pas !");
		}
	}
	
	private static boolean isValid(String login, String pass) {
		
		
		boolean connexion = false;
		try {
			Scanner sc = new Scanner(new File("zero.txt"));
			
			
			while(sc.hasNext()){
				if(sc.nextLine().equals(login+" "+pass)){
              	  connexion=true;
				  break;
				}
             }
			
		} catch (FileNotFoundException e) {	
			System.err.println("Le fichier n'existe pas !");
		}
	return connexion;
		
	}

}

Chat_ClientServeur.java
Code : Java
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;


public class Chat_ClientServeur implements Runnable {

	private Socket socket = null;
	private BufferedReader in = null;
	private PrintWriter out = null;
	private String login = "zero";
	private Thread t3, t4;
	
	
	public Chat_ClientServeur(Socket s, String log){
		
		socket = s;
		login = log;
	}
	public void run() {
		
		try {
		in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
		out = new PrintWriter(socket.getOutputStream());
		
		Thread t3 = new Thread(new Reception(in,login));
		t3.start();
		Thread t4 = new Thread(new Emission(out));
		t4.start();
		
		} catch (IOException e) {
			System.err.println(login +"s'est déconnecté ");
		}
}
}

Emission .java
Code : Java
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Scanner;


public class Emission implements Runnable {

	private PrintWriter out;
	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
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
import java.io.BufferedReader;
import java.io.IOException;


public class Reception implements Runnable {

	private BufferedReader in;
	private String message = null, login = null;
	
	public Reception(BufferedReader in, String login){
		
		this.in = in;
		this.login = login;
	}
	
	public void run() {
		
		while(true){
	        try {
	        	
			message = in.readLine();
			System.out.println(login+" : "+message);
			
		    } catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}

}

Serveur.java

Code : Java
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import java.io.*;
import java.net.*;

public class Serveur {
 public static ServerSocket ss = null;
 public static Thread t;

 
	public static void main(String[] args) {
		
		try {
			ss = new ServerSocket(2009);
			System.out.println("Le serveur est à l'écoute du port "+ss.getLocalPort());
			
			t = new Thread(new Accepter_connexion(ss));
			t.start();
			
		} catch (IOException e) {
			System.err.println("Le port "+ss.getLocalPort()+" est déjà utiliser !");
		}
	
	}

	
	}




Côté Client
Secret (cliquez pour afficher)

Chat_ClientServeur.java
Code : Java
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
import java.io.*;
import java.net.*;
import java.util.Scanner;


public class Chat_ClientServeur implements Runnable {

	private Socket socket;
	private PrintWriter out = null;
	private BufferedReader in = null;
	private Scanner sc;
	private Thread t3, t4;
	
	public Chat_ClientServeur(Socket s){
		socket = s;
	}
	
	public void run() {
		try {
			out = new PrintWriter(socket.getOutputStream());
			in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
			
			sc = new Scanner(System.in);
			
			Thread t4 = new Thread(new Emission(out));
			t4.start();
			Thread t3 = new Thread(new Reception(in));
			t3.start();
		
		   
		    
		} catch (IOException e) {
			System.err.println("Le serveur distant s'est déconnecté !");
		}
	}

}

Client.java
Code : Java
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
import java.io.*;
import java.net.*;

public class Client {

	public static Socket socket = null;
	public static Thread t1;
	
	public static void main(String[] args) {
	
		
	try {
		
		System.out.println("Demande de connexion");
		socket = new Socket("127.0.0.1",2009);
		System.out.println("Connexion établie avec le serveur, authentification :"); // Si le message s'affiche c'est que je suis connecter
		
		t1 = new Thread(new Connexion(socket));
		t1.start();
		
		
		
	} catch (UnknownHostException e) {
	  System.err.println("Impossible de se connecter a l'adresse "+socket.getLocalAddress());
	} catch (IOException e) {
	  System.err.println("Aucun serveur a l'écoute du port "+socket.getLocalPort());
	}
	
	

	}

}

Connexion.java

Code : Java
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
import java.net.*;
import java.util.Scanner;
import java.io.*;

public class Connexion implements Runnable {

	private Socket socket = null;
	public static Thread t2;
	public static String login = null, pass = null, message1 = null, message2 = null, message3 = null;
	private PrintWriter out = null;
	private BufferedReader in = null;
	private Scanner sc = null;
	private boolean connect = false;
	
	public Connexion(Socket s){
		
		socket = s;
	}
	
	public void run() {
		
		try {
			
		out = new PrintWriter(socket.getOutputStream());
		in = new BufferedReader(new InputStreamReader(socket.getInputStream()));	
		sc = new Scanner(System.in);
	
		
		while(!connect ){
		
		System.out.println(in.readLine());
		login = sc.nextLine();
		out.println(login);
		out.flush();
		
		System.out.println(in.readLine());
		pass = sc.nextLine();
		out.println(pass);
		out.flush();
		
		if(in.readLine().equals("connecte")){
			
		System.out.println("Je suis connecté "); 
		connect = true;
		  }
		
		else {
			System.err.println("Vos informations sont incorrectes "); 
		  }
		
	}
			
			t2 = new Thread(new Chat_ClientServeur(socket));
			t2.start();
		
		} catch (IOException e) {
			
			System.err.println("Le serveur ne répond plus ");
		}
	}

}

Emission.java
Code : Java
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Scanner;


public class Emission implements Runnable {

	private PrintWriter out;
	private String login = null, 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
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
import java.io.BufferedReader;
import java.io.IOException;


public class Reception implements Runnable {

	private BufferedReader in;
	private String message = null;
	
	public Reception(BufferedReader in){
		
		this.in = in;
	}
	
	public void run() {
		
		while(true){
	        try {
	        	
			message = in.readLine();
			System.out.println("Le serveur vous dit :" +message);
			
		    } catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}

}


Cette solution n'est pas unique et non la meilleure, il est simple et minime pour vous montrer comment les threads sont gérer. Lancez serveur.java ensuite client.java, n'oubliez pas de créer un fichier pour le serveur pour qu'il puisse y vérifier l'identité de ses clients, je l'ai nommé zero.txt vous pouvez le nommer comme vous le souhaiter c'est a votre guise.

Optimisation :
Pour ne pas dire qu'il en existe a l'infini, plusieurs autres possibilités s'offrent a 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 réaliser un salon comme on l'appel.
  • Utiliser les bases de données pour la sauvegarde des messages et pour authentifier les clients
  • Réaliser une interface graphique en swing ou swt
  • ...


Croyez-moi lorsque vous maitrisez les sockets en utilisant les threads, rien ne sera plus compliquer pour vous ;). Bonne continuation a tous et surtout n'hésitez pas a l'améliorer et MP moi pour m'exposer votre travail.

Conclusion

Le mode UDP existe aussi et il est plus rapide que le mode TCP mais c'est une communication non fiable, car on ne se préocuppe pas du resultat de la réception du recepteur il est donc moins utiliser.
Ce tutoriel est a présent terminer, j'espère que vous avez bien suivis, c'était pas sorcier :)
Modifié le 26/07/2009 à 00 h 08 par SoftDeath

Never trust user input - Pensez à sécuriser votre site
 
Hors ligne Dalshim # Posté le 24/07/2009 à 15 h 53
Avatar de Dalshim
Messages : 535
Membres
Cette réponse a aidé l'auteur du sujet Cette réponse a aidé l'auteur du sujet.
Le service de zcorrection ne fonctionne plus comme ça. Lors de ta demande de validation, le validateur enverra lui même, si besoin est, ton tuto en zcorrection et tu en sera informé.
En gros, tout se fait automatiquement maintenant.
 
Hors ligne SoftDeath # Posté le 24/07/2009 à 16 h 30
ben...euh...j'sais plus :s
Avatar de SoftDeath
Messages : 37
Membres
En résumé le contact entre nous et les zCorrecteurs diminues et on ne peut pas se synchroniser...
Merci bien j'enverrais donc aux validateurs (ce mot n'existe pas dans le disco ^ ^' mais bon).

Never trust user input - Pensez à sécuriser votre site
 
Hors ligne DJ Fox # Posté le 25/07/2009 à 01 h 53
Oh yeah yeah yeah !
Avatar de DJ Fox
Messages : 5469
Groupe : Administrateurs
Cette réponse a aidé l'auteur du sujet Cette réponse a aidé l'auteur du sujet.
Salut,
disons que le système a évolué, car on s'est rendu compte que l'ancien avait quelques défauts : dans l'ancien système, on recevait des tutoriels, que l'on passait du temps à corriger, et parfois, ces tutoriels n'étaient jamais mis en ligne sur le Site du Zéro (car invalidables sur le fond).
Le fait que les tutoriels passent d'abord par la validation nous évite de corriger pour rien. :)
Modifié le 25/07/2009 à 01 h 53 par DJ Fox

PHP Hypertext Preprocessor, Ich liebe es. :) :honte: :pirate:
 
Hors ligne Savageman # Posté le 25/07/2009 à 15 h 15
Ex-administrateur
Avatar de Savageman
Messages : 4236
Groupe : zAnciens
Citation : SoftDeath
En résumé le contact entre nous et les zCorrecteurs diminues et on ne peut pas se synchroniser...

Tu reçois par MP sur le SdZ toutes les remarques faites par les zCorrecteurs lors de la correction de ton tutoriel. Certains zCorrecteurs t'envoient même un MP pendant la correction pour discuter de points particuliers et être certain que la correction qu'ils proposent ne dénaturent pas ton tuto. ;)
 
Hors ligne SoftDeath # Posté le 25/07/2009 à 15 h 48
ben...euh...j'sais plus :s
Avatar de SoftDeath
Messages : 37
Membres
Merci c'est plus claire désormais, bonne continuation a tous

Never trust user input - Pensez à sécuriser votre site
 
Hors ligne SoftDeath # Posté le 26/07/2009 à 15 h 21
ben...euh...j'sais plus :s
Avatar de SoftDeath
Messages : 37
Membres
J'ai demandé a ce que le tutoriel soit valider hier soir, j'aurais aimé y placer quelques schémas mais la page d'ajout d'image du sdz ne passait pas, je laisse pour le tutoriel RMI au cas ou les sockets soient valider ^^ au cas échéant je passerais au webmastering avec JEE et/ou la 3D avec 3DSMax étant donné que ça marche pas avec moi dans la programmation...

Never trust user input - Pensez à sécuriser votre site
 
Hors ligne SoftDeath # Posté le 09/08/2009 à 18 h 47
ben...euh...j'sais plus :s
Avatar de SoftDeath
Messages : 37
Membres
Qu'en est-il de ce tutoriel, il n'a pas encore été corriger ?
J'attends des nouvelles sur ce tutoriel, pour débuter celui sur la technologie RMI, l'introduction à l'action script 3 et illustrator cs2/nouveautés cs3
Merci d'avance
Cordialement
Modifié le 09/08/2009 à 18 h 49 par SoftDeath

Never trust user input - Pensez à sécuriser votre site
 
Hors ligne DJ Fox # Posté le 11/08/2009 à 21 h 08
Oh yeah yeah yeah !
Avatar de DJ Fox
Messages : 5469
Groupe : Administrateurs
Salut,
Ton tutoriel n'a pas encore été envoyé en zCorrection. Je viens de vérifier, il est toujours en cours de validation sur le SdZ.
Si le validateur l'envoie ici, tu recevras un MP sur le SdZ. ;)

PHP Hypertext Preprocessor, Ich liebe es. :) :honte: :pirate:
 
Hors ligne SoftDeath # Posté le 13/08/2009 à 14 h 08
ben...euh...j'sais plus :s
Avatar de SoftDeath
Messages : 37
Membres
Merci, sympa d'avoir répondu :)

Never trust user input - Pensez à sécuriser votre site
 
Hors ligne SoftDeath # Posté le 14/09/2009 à 19 h 14
ben...euh...j'sais plus :s
Avatar de SoftDeath
Messages : 37
Membres
Je suppose que le tutoriel est arrivé à la zCorrection, bonne correction :)

Never trust user input - Pensez à sécuriser votre site
 

Retour au forum Vos questions aux zCorrecteurs… ou à la liste des forums