Discussion :

[SpIrIt505050]

Bonjour,

Je dois réaliser un projet en cours de java qui consiste à créer un serveur multithread pour jouer au poker, le tout sous l'interface Eclipse (une console serveur et des consoles clients)

Le probleme est que l'on souhaite avoir seulement une table de 4 joueurs, je veux donc tuer le 5éme thread après sa connection.

Voila notre code (ressemblant à votre serveur multi-thread simple ici), mais avec une classe client en plus pour lancer chaque client.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
81
82
83
84
85
86
87
88
89
90
import java.io.PrintWriter;
import java.net.*;
import java.util.Vector;
 
public class Serveur {
 
	/**
         * Arguments
         */
	private static final int port = 8888;
	private int nbJoueurs = 0;
	private Vector<PrintWriter> listeJoueurs = new Vector<PrintWriter>();
 
 
	/**
         * main
         * @param args
         */
	public static void main (String[] args) {
 
		Serveur s = new Serveur();
		try {
			ServerSocket serveur = new ServerSocket (port);
			printWelcome(port);
 
			while (true) {
				new thread(serveur.accept(),s);
			}
 
		} catch (Exception e) {
			System.err.println(e.toString());
		}
 
	}
 
	  /**
           * 
           * @param port
           */
	  static private void printWelcome (Integer port)
	  {
	    System.out.println("****************");
	    System.out.println("*** CROUPIER ***");
	    System.out.println("****************");
	    System.out.println(" -> Demarré sur le port " + port.toString());
	  }
 
 
	/**
          * Methode : envoie le message à tous les clients
          */ 
	synchronized public void sendAll(String message) {
 
		for (int i = 0; i < listeJoueurs.size(); i++) {
	    	listeJoueurs.elementAt(i).print(message);
	    	listeJoueurs.elementAt(i).flush(); // envoi dans le flux de sortie
	    }
 
	}
 
 
	/**
          * Methode : détruit le client no i
          */ 
	synchronized public void delClient(int i) {
 
		nbJoueurs--; // un client en moins ! snif
		listeJoueurs.removeElementAt(i); // ... on le supprime
	}
 
	/**
         * Methode : ajoute un nouveau client dans la liste
         */  
	synchronized public int addClient(PrintWriter out) {
 
		nbJoueurs++; // un client en plus ! ouaaaih
		listeJoueurs.addElement(out); // on ajoute le nouveau flux de sortie au tableau
 
		return listeJoueurs.size()-1; // on retourne le numéro du client ajouté (size-1)
	}
 
	/**
         * Methode : retourne le nombre de clients connectés
         */  
	synchronized public int getNbJoueurs() {
 
		return nbJoueurs; // retourne le nombre de clients connectés
	}
 
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
81
82
83
import java.io.*;
import java.net.Socket;
 
public class thread implements Runnable {
 
	/**
         * Arguments
         */
	private Serveur serveur;
	private Thread t;
 
	private Socket joueur;
	private BufferedReader entree;
	private PrintWriter sortie;
	private int id;
 
	/**
         * Constructeur
         * 
         * @param joueur
         * @param croupier
         */
	public thread (Socket joueur, Serveur croupier) {
		this.joueur = joueur;
		this.serveur = croupier;
 
 
		try {
			entree =  new BufferedReader(new InputStreamReader(joueur.getInputStream()));
			sortie = new PrintWriter(joueur.getOutputStream());
			id = croupier.addClient(sortie);		
		} catch (IOException e) {
			e.printStackTrace();
		}
 
		t = new Thread(this);
		t.start();
 
	}
 
	/**
         * run
         */
	public void run() {
		String message = ""; // déclaration de la variable qui recevra les messages du client
	    // on indique dans la console la connection d'un nouveau client
	    System.out.println("Un nouveau client s'est connecte, no "+id);
 
	    if ( serveur.getNbJoueurs() <= 4 ) {
		    try {
				do {
					message=entree.readLine();
					System.out.println("client "+id+" : "+message);
				} while (!message.equals("exit"));
 
		    } catch (Exception e) { 
 
		    } finally {
		      try {
		      	// on indique à la console la deconnexion du client
		        System.out.println("Le client no "+id+" s'est deconnecte");
		        serveur.delClient(id); // on supprime le client de la liste
		        joueur.close(); // fermeture du socket si il ne l'a pas déjà été (à cause de l'exception levée plus haut)
		      }
		      catch (IOException e){ }
		    }	
	    } else {
	    	 System.out.println("La table est pleine.");
	    	 serveur.delClient(id); // on supprime le client de la liste
			 try {
				joueur.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
 
			 System.out.println("Le client no "+id+" s'est deconnecte");
 
	    }
 
 
	}
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
import java.io.*;
import java.net.Socket;
import java.net.UnknownHostException;
 
 
public class client {
 
	/**
         * Arguments
         */
	private static final int port = 8888;
 
	public static Socket client;
	private static PrintStream sortie;
	private static BufferedReader entree;
	private static BufferedReader stdIn;
	private static String requete;
 
	public static void main(String args[]) throws Exception {
 
		System.out.println("*** JOUEUR ***");
 
		try {
			client = new Socket("localhost",port);
 
			sortie = new PrintStream(client.getOutputStream());
			entree = new BufferedReader(new InputStreamReader(client.getInputStream()));
			stdIn = new BufferedReader(new InputStreamReader(System.in));
		} catch (UnknownHostException e) {
			System.err.println(e.toString());
		} catch (IOException e) {
			System.err.println(e.toString());
		} 
 
		System.out.println(" -> Connexion au serveur sur le port " + port);	
 
		do {
			System.out.println("Taper votre requete : "); 
			requete = stdIn.readLine(); // Lecture de la requete
		    sortie.println(requete); // Envoi de la requete   
		} while ( !requete.equals("exit"));
 
	}	
 
}

Je suis débutant, donc il y a peut etre des choses que je n'ai pas comprise, c'est pourtant je pense la seule solution pour faire fonctionner mon appication sur Eclipse.

Merci d'avance.

++

[AliLoU`]

pourquoi le tuer lorsqu'il est déjà connecté?

tu mets un compteur dans le serveur qui accepte les connexions tant que le nombre de clients est inférieur ou égal à 4

tu pourrais tuer tes threads serveur seulement si tu les stockaient (dans un tableau par exemple?), dans ton code tu peux pas, car tu fais un simple "new thread"

[SpIrIt505050]

D'accord, je comprend ...
Mais j'aimerais que lorsque le client se connecte, le serveur puisse lui envoyer un message "la table est pleine, ressayez plus tard" dans la console spécifique à ce 5éme client, et après, enfin, le tuer.

Merci pour ta réponse.

[AliLoU`]

bon! alors on le laisse se connecter! mais on l'ejecte vite fait donc :

il te faut une méthode (dans Serveur) qui retourne le flux de sortie par rapport à l'id de connexion!

public PrintWriter getFluxFromId(int id){
//retourne le printwriter correspondant à l'id de connexion
}

et dans thread tu modifies comme ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
	    } else {
	    	 serveur.getFluxFromId(id).print("c'est plein!! désolé!");
	    	 serveur.getFluxFromId(id).flush(); //(le mieux c'est de stocker le printwriter temporairement que de réappeler deux fois la méthode..
	    	 serveur.delClient(id); // on supprime le client de la liste
			 try {
				joueur.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
 
			 System.out.println("Le client no "+id+" s'est deconnecte");
 
	    }

[SpIrIt505050]

Bonjour et merci pour ta réponse, j'ai donc bien créer ma méthode getFluxFromId(id) dans serveur qui retourne le Printwriter du joueur (qui se trouve dans le vecteur listeJoueurs), ainsi que ajouter les 2 ligne dans thread qui permette d'envoyer le message au client, mais le client ne reçoit rien.

Faut-il que je créer un flux d'entré dans mon client qui recevrais ce message ?

Merci.

[AliLoU`]

si ton client est comme celui présent ici ça devrait marcher car les flux sont crées (etc...)

as tu modifié ton client?