probleme ihm et socket

bonjour a tous,

tout d'abord désolé si mon post est mal placé, mais je ne savez pas très bien ou poster.

Je suis en train de développer un jeu de poker multi-joueurs, pour se faire, j'ai un client et un serveur, mon serveur crée un thread a chaque nouvelle connexion a un client.

Je possède une ihm pour le client, et une ihm pour le serveur. Lorsque je crée un serveur et un client, les ihm et les boutons fonctionnent normalement, mais lorsque je lance mon serveur, apres l'ihm de serveur est figée, je ne peux plus cliquer sur les boutons, et si je connecte le client au serveur, pareil, je ne peux plus utiliser l'ihm du client.

Dans mon client, j'ai une méthode :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 public void ecoute ( ) { while( true ) { try { String phrase = lecture.readLine ( ) ; String mots[] = phrase.split ( "#" ) ; traitement suivant mots[0] ; } catch ( Exception e ) { System.out.println ( "erreur" + e ) ; } }
elle me permet de recevoir des données du serveur,

et j'ai une méthode similaire dans mon serveur.
je pense que mon problème vient du while(true) mais je ne suis pas sûr, je bloque sur ça, je n'arrive pas a trouver d'idée pour résoudre ce problème.

merci a vous pour votre aide.

Soit tu utilises les sockets non bloquantes avec le package NIO.

Soit (j'imagine que c'est ta technique), tu utilises les sockets bloquantes.
Il te faut donc un thread comme tu as fait pour écouter les connexions des clients, il te faudra egalement sur ton serveur un thread pour chaque client pour les faire communiquer, la même chose sera nécessaire côté client.

merci pour tes informations, je n'ai pas très bien compris ou je dois rajouter des threads. En fait j'ai 3 classes, client, serveur, connexion, je me sert de connexion pour faire le lien entre serveur et clients.

classe serveur :

Code:

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
public class Serveur
{
   static final int port = 2345 ;
   private ServerSocket s ;
   private Socket soc ;
 
   private Fenetre_Serveur fenetre ;   
   private int nbr_connexions = 0 ;
 
    public Serveur ( )
    {
    fenetre = new Fenetre_Serveur ( this ) ;
    }
 
    public void lancement ( )
    {     
    try
       {
            s = new ServerSocket ( port ) ;
            while ( true )
            {
                soc = s.accept ( ) ;
                nbr_connexions ++ ;
                Connexion c = new Connexion ( this , soc , nbr_connexions ) ;
                c.start ( ) ;
            }
       }
       catch ( Exception e ) { System.out.println ( " erreur : " + e ) ; }
   }

classe Client :

Code:

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
 
public class Client implements java.io.Serializable 
{
   static final int port = 2345 ;
   private Socket socket ;
   private PrintWriter ecriture ;
   private BufferedReader lecture ;
   private ObjectOutputStream oos ;
   private ObjectInputStream ois;
 
   private Fenetre_Client fenetre ;
 
   public Client ( )
   {
   fenetre = new Fenetre_Client ( this ) ;
   }
 
    public Client ( String s , int v)
   {
   fenetre = new Fenetre_Client ( this ) ;
   }
 
   public void connexion ( ) throws Exception 
   {
    socket = new Socket ( "127.0.0.1" , port ) ; 
    oos = new ObjectOutputStream ( socket.getOutputStream ( ) ) ; 
    ois = new ObjectInputStream ( socket.getInputStream ( ) ) ;
    ecriture = new PrintWriter ( new BufferedWriter ( new OutputStreamWriter ( socket.getOutputStream ( ) ) ) , true ) ;
    lecture = new BufferedReader ( new InputStreamReader ( socket.getInputStream ( ) ) ) ;
    ecoute(); 
   }
 
   public void ecoute ( )
   { 
   while( true ) 
         {
           try
           {
           String phrase = lecture.readLine ( ) ;          
           String mots[] = phrase.split ( "#" ) ;
 
           switch ( Integer.parseInt ( mots[0] ) )
              {
              case ( 0 ) : ; break ;           
              default : System.out.println ( "le client recoit qqch" ) ; break ;
              }
           }   
           catch ( Exception e ) { System.out.println ( "erreur" + e ) ; }
         }
   }
 
    public void rejoindre ( ) throws Exception
   {
    ecriture.println("1#");
   }

et enfin la classe connexion :

Code:

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
 
import java.net.*;
import java.io.*;
 
public class Connexion extends Thread implements Serializable 
{
    private PrintWriter ecriture;
    private BufferedReader lecture;
    private ObjectInputStream ois;
    private ObjectOutputStream oos ;    
    private Socket connexion ;
    private int numero ; 
    private Serveur serveur ;
    private Client client ;
 
    public Connexion ( Serveur s , Socket c , int n )
    {
     serveur = s ;
     connexion = c ;
     numero = n ;
    }
 
    public void run ( ) 
    {
        try
        {
           oos = new ObjectOutputStream(connexion.getOutputStream()) ;             
           ois = new ObjectInputStream(connexion.getInputStream());
           lecture = new BufferedReader ( new InputStreamReader( connexion.getInputStream ( ) ) ) ;  
           ecriture = new PrintWriter ( new BufferedWriter ( new OutputStreamWriter ( connexion.getOutputStream ( ) ) ) , true ) ; 
           while ( true ) 
           {
               int fin = 0 ;
               String phrase = lecture.readLine() ;   
               String mots[]=phrase.split("#") ;
 
               switch ( Integer.parseInt ( mots[0] ) ) 
               {
                case ( 0 ) : fin = 1 ; break ;   
                case ( 1 ) : System.out.println ( "nouveau joueur : "+numero ) ;
                             ecriture.println ( "1#"+numero ) ;
                             break ; 
                case ( 2 ) : client = ( Client ) ois.readObject( ) ;
                             break ;              
                default : System.out.println ( "le serveur recoit qqch" ) ; break ;
               }
               if ( fin == 1 ) break ;
            }
            connexion.close ( ) ;
        }
        catch ( Exception e ) { System.out.println ( "erreur : " + e ) ; }
    }
 
    public void distribuer ( ) throws Exception
    {
     ecriture.println ( "2#" ) ;   
     sleep ( 5000) ;
     oos.writeObject( serveur.get_deck ( ).piocher ( ) ) ;   
    }
 
    public void init_carte ( ) throws Exception
    {
     ecriture.println ( "3#" ) ;   
    }
 
    public void envoyer_joueurs ( ) throws Exception
    {  
    for ( Connexion connexion : serveur.get_joueurs() )
        {
        ecriture.println ( "4#" ) ;
        oos.writeObject( connexion ) ;
        sleep(50);
        }
    }
 
    public int get_numero ( ) { return numero ; }
 
    public Client get_client() throws Exception
    {
        ecriture.println ( "5#" ) ;
        sleep(50) ;
        return client ;
    }    
}

Si tu pouvais m'expliquer exactement ou mettre des thread, mais je vais regarder des infos sur les sockets non bloquantes.

merci beaucoup

Tu dois mettre tes opérations de lecture (du client et du serveur) dans un nouveau thread, car la méthode readline attend que des données arrivent par la socket.
Il faut également que tu mettes les opérations de connexion de client de ton serveur (méthode accept) dans un thread, car là aussi c'est une méthode bloquante qui va figer ton interface.
C'est plus clair ?

oui je te remercie, j'avais regarder le package java.nio, mais je restais bloqué, la c'est plus clair, merci beaucoup :)

Ayé j'ai réussi, tout fonctionne parfaitement maintenant, je te remercie vraiment beaucoup :P