Mais si...

null certainement pas puisque available retourne un entier.

available c'est une méthode de bas niveau. Tu l'as dans les Stream, pas dans les Reader qui sont des classes de plus haut niveau.
Faut adapter un peu ton code (je te rapelle que je ne l'avais pas lu en détail).

Donc quelque chose comme:

InputStream is = sClient.getInputStream()
in=new BufferedReader(new InputStreamReader(is);
//etc
// etc
 
while(req!=null && is.available()) // is hein ? pas in :)
{
// etc, etc
} 

Hello,

J'ai bien regardé ton code et il n'y a "aucun" problème pour la partie réseau.

En fait comme ton serveur ferme bien sa connexion après avoir envoyé ttes ses lignes, même si le client reste en mode "read" avec in "in.readLine()", le fait de fermer la connexion va lui faire lancer une SocketException "Connexion reset"

La ou ca ne va pas par contre c est quand tu ajoutes tes éléments dans la liste coté client (Extrait de ton code):

String req=in.readLine(); 
DefaultListModel dlm=new DefaultListModel(); 
lpseudo.setModel(dlm); 
while(req!=null) 
{ 
     req=in.readLine();  
     lpseudo.setModel(dlm); 
     dlm.addElement(req);    
     lpseudo=new JList(dlm);        
}

dlm représente ta liste mais tu lis d'abord un élément que tu n'ajoutes pas à ta liste.

A la louche je dirais que le code corrigé doit etre celui ci (sans tester):

String req=in.readLine(); 
DefaultListModel dlm=new DefaultListModel(); 
lpseudo.setModel(dlm); 
// ici on ajoute le premier élément
dlm.addElement(req);  
while(req!=null) 
{ 
     req=in.readLine();  
     lpseudo.setModel(dlm); 
     dlm.addElement(req);    
     lpseudo=new JList(dlm);        
}

Pour le deuxième point, si tu relances un client il ne se passe rien, c est normal puisque ton instance de serveur une fois qu elle a fini son boulot, elle s arrete.

Pour que ca marche il faudrait que tu lances en boucle des instances de ton Thread serveur.

Bonne chance,
Niroken

Hello,

Voici ce qu'il se passe :
- Ton instance serveur écrit dans le flux sortant attaché à la socket ouverte... puis une fois qu'elle a fini, le thread meurt et la socket se ferme, sans se soucier de ce qui a été lu coté client.
- Ton instance client lit à son rythme sur le flux entrant lié à la socket ouverte ce que le serveur lui envoit, le hic c'est que si la socket est fermé avant que le client aie tt lu, et bien tu vas avoir une exception qui va ressortir.

Ce que je te suggère, c'est d'implémenter une mini conversation client-serveur. dès que le serveur envoie une ligne, le client lui en renvoit une pour dire qu'il la bien lu, de cette facon quand le serveur fermera la socket, le client aura bien tt recu.

Coté implémentation, ca donnerait qq chose comme ca :

Cote client :

BufferedReader in=new BufferedReader(new InputStreamReader(sClient.getInputStream())); 
            String req=in.readLine(); 
            System.out.println(req);
            DefaultListModel dlm=new DefaultListModel(); 
            JList lpseudo = new JList(); 
            // ici on ajoute le premier élément 
            dlm.addElement(req);
            out.write("OK\r\n"); 
            out.flush();
            while(req!=null) 
            { 
                try {
                    req=in.readLine();
                    out.write("OK\r\n"); 
                    out.flush();
                    dlm.addElement(req);
                    System.out.println(req);  
                } catch (SocketException e) {
                    // On met req a null pour sortir de la 
                    // boucle si le serveur interromp la connexion
                    req = null;
                }
            }
            
            lpseudo.setModel(dlm);
            System.out.print(lpseudo.getModel().getSize());
            
            sClient.close(); 

Cote serveur :

while(rst.next()) 
{ 
    out.write(rst.getString(1)+ "\r\n"); 
    out.flush();
    in.readLine(); 
} 
out.flush(); 
sEcoute.close(); 

Bonne chance,
Niroken

Hello,

Juste pour etre sur : j'ai mis des System.out.println() juste pour tester l affichage, est ce qu'il écrit bien le dernier

System.out.print(lpseudo.getModel().getSize()); 

?????

Sinon pour mon test, j'ai crée deux classes distinctes Une qui contient le code serveur, une autre qui contient le code client, je les ai lancé et ca a marché, c'est a dire que j'ai affiché la taille de la liste.

Bon sinon je vais te faire un petit code qui s occupe de faire ca.

Bonne chance,
Niroken

Hello,

Tout d'abord mille excuses, j'ai raconté une grosse c...... :)

Ce qui m'avait troublé dans tout ca c'était le fait que ton client n'affiche à un moment donné qu'une partie ou pas du tt de données, et que le nombre de lignes affichées pouvait être aléatoire.

J'ai donc pensé que c'était parcequ'une fois que le serveur avait tout envoyé il se fermait et le client pouvait ne pas avoir tt lu.

C'est donc pourquoi je me suis dis... le client va dire au serveur a chaque ligne qu il la bien recu, de cette facon une fois que le serveur va fermer sa connexion on est sur que le client a bien tt recu.

Le hik c'est que j'ai refait un test et je n'obtenais pas la même chose, et je me suis apercu, que dans ton code serveur tu faisais :

sEcoute.close();

au lieu de

sClient.close();

Je me suis basé la dessus et tout le problème venait de la. Ce n'était pas la bonne socket que tu as fermé. Du coup dans mes précédents posts je t'ai proposé une usine à gaz, qui marche certes mais qui n'est pas super performante(bcp d envois reception de données inutiles).

Du coup je me rebase sur ce que tu avais fait précédemment et ca donne :

Code serveur :

Thread threadlistpseudo=new Thread() 
                    { 
                        public PrintWriter out=null; 
                        public BufferedReader in=null; 
                        public ServerSocket sEcoute=null; 
                        public Socket sService=null; 
                        
                        public void run() 
                        { 
                            ////////repondre a la requete du client pour lui communiquer la liste des pseudo 
                            try{ 
                                    Class.forName("sun.jdbc.odbc.JdbcOdbcDriver"); 
                                    con = DriverManager.getConnection(url); 
                                    stm = con.createStatement(); 
                                    sEcoute =new ServerSocket(3500); 
                                    sService=sEcoute.accept(); 
                                    out=new PrintWriter(sService.getOutputStream(),true); 
                                    in=new BufferedReader(new InputStreamReader(sService.getInputStream())); 
                                    
                                    String query=in.readLine(); 
                                    rst=stm.executeQuery(query); 
                                    
                                    while(rst.next()) 
                                    { 
                                        out.write(rst.getString(1)+ "\r\n"); 
                                    } 
                                    out.flush(); 
                                    sClient.close();
                                    // et non sEcoute.close(); 
                                
                            }catch(Exception ex){System.out.println(ex.getMessage());} 
                        } 
                    }; 
                    threadlistpseudo.start(); 

Code client :

try { 
            ///state='c' =>connecté 
            String req1="select login from authentification where state='c'"; 
            Socket sClient =new Socket("localhost",3500); 
            PrintWriter out=new PrintWriter(sClient.getOutputStream(),true); 
            out.write(req1+ "\r\n"); 
            out.flush(); 
            
            BufferedReader in=new BufferedReader(new InputStreamReader(sClient.getInputStream())); 
            String req=new String(); 
            DefaultListModel dlm=new DefaultListModel(); 
            while((req=in.readLine()) != null) {
                dlm.addElement(req);
            } 
            JList lpseudo = new JList(dlm);
            System.out.println(dlm.getSize());
            sClient.close(); 
        } catch (Exception ex) {ex.printStackTrace();} 

Bonne chance et dsl encore,
Niroken

Hello,

Dans ce cas c est autre chose, si tu récupères les données quand tu les affiches, le client a bien fait son boulot, c'est au niveau de la couche graphique que ca ne va pas.

Bon je te passe la un code qui fonctionne de mon coté, j'ai réimplémenté le serveur et le client en gros quand tu charges ta fenetre client et que le serveur est lancé... le serveur envoit n fois "Pouet" puis il incrémente n de 1 comme ca quand tu cliques sur refresh, tu affiches un élément de plus à chaque fois.

Pour mettre ta partie base de données il faudra que tu modifies légérement la méthode sendDatasToClient()

Code Serveur :

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;


public class ProgramServer {

	public static int sNbBoucle = 4;
	
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		new ProgramServer().launchServer();
	}
	
	public void launchServer() {
    	try {
			ServerSocket vServerSocket = new ServerSocket(3500);
			while(true) {
				final Socket vSocket = vServerSocket.accept();
				
				Thread vThread = new Thread() {
					
					public void run() {
						try {
							sendDatasToClient(vSocket);
						} catch (Exception e) {
							e.printStackTrace();
						}
					}
					
				};
				
				vThread.start();
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
    }
    
    private void sendDatasToClient(Socket pSocket) throws Exception {
    	// A mettre ici l appel pour la base de donnees.
    	PrintWriter vOutputPrintWriter = new PrintWriter(pSocket.getOutputStream(),true);; 
        BufferedReader vInputBufferedReader = new BufferedReader(new InputStreamReader(pSocket.getInputStream()));
        String vDatasFromClient = vInputBufferedReader.readLine();
        
        for (int i = 0; i < sNbBoucle; i++) { 
        	vOutputPrintWriter.write(i + "Pouet\r\n");
        	vOutputPrintWriter.flush();
        }
        
        vOutputPrintWriter.flush();
        pSocket.close();
        sNbBoucle++;
    }

}

Code Client :

import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;

import javax.swing.DefaultListModel;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JList;

import net.ProcessClient;


public class ProgramClient extends JFrame {
	
	private JList mList;

	public ProgramClient() {
		setSize(200, 200); 
        setLayout(new FlowLayout()); 
        
        mList = new JList(); 
                
        JButton vButton = new JButton("Refresh"); 
        vButton.addActionListener(new ActionListener() { 

            public void actionPerformed(ActionEvent pE) { 
                displayDatasFromServer(); 
            } 
            
        });
        
        addWindowListener(new WindowAdapter() {
        	
        	public void windowOpened(WindowEvent pEvent) {
        		displayDatasFromServer(); 
        	}
        	
        });
        
        add(mList); 
        add(vButton); 
        
        setVisible(true); 
        setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE); 
	}

	public void displayDatasFromServer() {
		Thread vThread = new Thread() { 
            
            public void run () { 
                try { 
                	String req1="select login from authentification where state='c'"; 
                    Socket sClient =new Socket("localhost",3500); 
                    PrintWriter out=new PrintWriter(sClient.getOutputStream(),true); 
                    out.write(req1+ "\r\n"); 
                    out.flush(); 
                    
                    BufferedReader in=new BufferedReader(new InputStreamReader(sClient.getInputStream())); 
                    String req=new String(); 
                    DefaultListModel dlm=new DefaultListModel(); 
                    while((req=in.readLine()) != null) {
                        dlm.addElement(req);
                    } 
                    System.out.println(dlm.getSize());
                    sClient.close(); 
                	mList.setModel(dlm); 
                } catch (Exception e) { 
                    e.printStackTrace(); 
                }                
            } 
            
        }; 
        vThread.start(); 
	}
	
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		new ProgramClient();
	}

}

En principe la communication dans un chat passe par le serveur. Mais bon pourquoi pas ?

Non mais tu peux tester qui s'est connecté.
accept te retourne un objet Socket. Là tu appelles getInetEddress. Et après de l'objet InetAddress tu appelles getHostAdress et là tu regardes qu'elle IP c'est. Si ça te convient tu continues, sinon tu fermes le socket.

Hello,

Je te posterais un bout de code qui s'occupera de ca :) D ici la, patience :)

Niroken

Hello,

Alala, il est très bien ce Java :D

Bon indépendamment de ca, l'avantage d un chat c'est que l'on a pas besoin de faire des conversations très rapprochées dans le temp, une conversation relancée toutes les (500 ms) est bien suffisante à mon avis.

Du coup dans ton instance serveur, tu gardes la liste des connectés, et a chaque fois qu un client envoit au serveur un potentiel nouveau message puis récupère les messages des autres clients, le serveur envoie aussi la liste actualisées des clients connectés.

De plus j'insiste lourdement sur le fait que tu ferais mieux de séparer ton code client et serveur dans au moins deux fichiers de classes distincts.

D'une part c'est plus propre, et tu as une architecture plus simple à gérer.

Un serveur qui conserve la liste des clients connectés et des nouveaux messages en attente, et les clients qui viennent faire des requetes sur ce serveur pour envoyer de nouveaux messages puis récupérer les messages et la liste des clients connectés :)

Bonne chance,
Niroken

Hmmm je t'avoue que pour moi il était question que A, B , C, D coomuniquent tous avec le même serveur S. et que c'est le serveur S qui renvoit les données au(x) client(s).

Dans le cas ou c'est vraiment A et B qui parlent entre eux et C et D aussi, alors on peut peut être envisager de déclarer un attribut statique dans sa classe, il sera commun à toutes les instances, ensuite ben je sais pas trop j'ai pas réfléchi :D

Niroken

Hello,

Non rassures toi, j'ai réussit a me débrouiller, sauf que comme cela est un peu complexe.. je pense qu'on va procéder par étape.

D'une part, la base de données pour l'instant ce n'est pas une bonne idée..puisqu'elle ne fait que contenir des infos style "login" "password".
Mais créer un compte ne nous apporte rien puisqu on peut en créer un à chaque fois et comme aucune autre info n'est persistée du genre "amis ou contacts" favoris... c'est inutile.

Le serveur seul va gérer les connexions et savoir qui est connecté ou pas.

Donc la première étape, c'est justement la facon dont le serveur gère les connexions :
1) On allume le serveur en attente de connexions et garde en mémoire une liste de noms qui correspond au nom de chaque client.
2) Un client se connecte : L'utilisateur saisit un nom pour la durée de son tchat et l'envoit au serveur.
3)Le serveur recoit le nom, si le nom est deja présent dans la liste, alors le serveur dit que c'est pas bon au client et le socket se ferme. Si c est bon le serveur rajoute son nom a cette liste
4)Le client connecté envoit périodiquement une requete au serveur pour lui demander de reactualiser sa liste de connectés.
5)Le serveur renvoit au client cette liste.

Pour l'instant aucune partie envoie reception de message de tchat n'est gérée, mais tu verras bien que la liste d'affichage des clients est bien reactualisée a chaque fois qu 'un client se connecte/déconecte.

Code client (a partir du tien) :

import javax.swing.SwingUtilities;
import java.awt.BorderLayout;
import javax.swing.JPanel;
import javax.swing.JFrame;

import java.awt.Color;
import java.awt.GridBagLayout;
import java.awt.GridBagConstraints;

import javax.swing.DefaultListModel;
import javax.swing.JDialog;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JTextArea;
import javax.swing.JButton;
import javax.swing.JList;
import java.awt.Insets;
//////////
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.*;

////////

public class client extends JFrame {

	private static final long serialVersionUID = 1L;
	private JPanel jContentPane = null;
	private JPanel jPanel = null;
	private JTextArea tenvoi = null;
	private JTextArea trecuArea = null;
	private JButton vButton = null;
	private JLabel jLabel1 = null;
	private JButton benvoyer = null;
	private JList lpseudo = null;    
////////Socket.......
	private Socket mClient = null;
	private String mNomClient;
	
/////////	

	
	private JPanel getJPanel() {
		if (jPanel == null) {
			GridBagConstraints gridBagConstraints = new GridBagConstraints();
			gridBagConstraints.gridx = 2;
			gridBagConstraints.gridy = 2;
			GridBagConstraints gridBagConstraints1 = new GridBagConstraints();
			gridBagConstraints1.fill = GridBagConstraints.BOTH;
			gridBagConstraints1.gridy = 0;
			gridBagConstraints1.weightx = 9.0;
			gridBagConstraints1.weighty = 1.0;
			gridBagConstraints1.gridwidth = 1;
			gridBagConstraints1.insets = new Insets(0, 0, 0, 0);
			gridBagConstraints1.ipadx = 0;
			gridBagConstraints1.gridx = 0;
			GridBagConstraints gridBagConstraints11 = new GridBagConstraints();
			gridBagConstraints11.fill = GridBagConstraints.BOTH;
			gridBagConstraints11.gridy = 0;
			gridBagConstraints11.weightx = 1.0;
			gridBagConstraints11.weighty = 1.0;
			gridBagConstraints11.ipadx = 0;
			gridBagConstraints11.ipady = 0;
			gridBagConstraints11.anchor = GridBagConstraints.WEST;
			gridBagConstraints11.gridwidth = 1;
			gridBagConstraints11.insets = new Insets(0, 1, 0, 0);
			gridBagConstraints11.gridx = 2;
			GridBagConstraints gridBagConstraints10 = new GridBagConstraints();
			gridBagConstraints10.gridx = 1;
			gridBagConstraints10.anchor = GridBagConstraints.NORTH;
			gridBagConstraints10.gridy = 2;
			GridBagConstraints gridBagConstraints9 = new GridBagConstraints();
			gridBagConstraints9.gridx = 1;
			gridBagConstraints9.gridy = 0;
			jLabel1 = new JLabel();
			jLabel1.setText("            ");
			GridBagConstraints gridBagConstraints8 = new GridBagConstraints();
			gridBagConstraints8.fill = GridBagConstraints.HORIZONTAL;
			gridBagConstraints8.gridy = 2;
			gridBagConstraints8.weightx = 1.0;
			gridBagConstraints8.weighty = 0.0;
			gridBagConstraints8.gridwidth = 1;
			gridBagConstraints8.anchor = GridBagConstraints.NORTH;
			gridBagConstraints8.gridheight = 1;
			gridBagConstraints8.insets = new Insets(6, 4, 5, 0);
			gridBagConstraints8.gridx = 0;
			GridBagConstraints gridBagConstraints6 = new GridBagConstraints();
			gridBagConstraints6.gridx = 0;
			gridBagConstraints6.gridy = 1;
			//jLabel = new JLabel();
			//jLabel.setText("            ");
			jPanel = new JPanel();
			jPanel.setLayout(new GridBagLayout());
			//jPanel.add(jLabel, gridBagConstraints6);
			jPanel.add(getTenvoi(), gridBagConstraints8);
			jPanel.add(jLabel1, gridBagConstraints9);
			jPanel.add(getBenvoyer(), gridBagConstraints10);
			jPanel.add(getLpseudo(), gridBagConstraints11);
			jPanel.add(getTrecuArea(), gridBagConstraints1);
			jPanel.add(getVButton(), gridBagConstraints);
			
			

		}
			return jPanel;
	}
	
	private JTextArea getTenvoi() {
		if (tenvoi == null) {
			tenvoi = new JTextArea();
			//tenvoi.WIDTH=5.0;
		}
		return tenvoi;
	}

	private JButton getBenvoyer() {
		if (benvoyer == null) {
			benvoyer = new JButton();
			benvoyer.setText("Envoyer");
			benvoyer.addActionListener(new java.awt.event.ActionListener() {
				public void actionPerformed(java.awt.event.ActionEvent e) {
					
				}
			}); 
		}
		return benvoyer;
	}

	
	private JList getLpseudo() {
		if (lpseudo == null) {
			lpseudo = new JList();
		}
		return lpseudo;
	}

	
	
	private JTextArea getTrecuArea() {
		if (trecuArea == null) {
			trecuArea = new JTextArea();
			trecuArea.setEnabled(false);
		}  
		return trecuArea;
	}

	 
	private JButton getVButton() {
		if (vButton == null) {
			vButton = new JButton();
			vButton.setText("Tchatter");
			vButton.addActionListener(new java.awt.event.ActionListener() {
				public void actionPerformed(java.awt.event.ActionEvent e) {
					communicateWithServer();
				}
			});
		} 
		return vButton;    
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		JFrame.setDefaultLookAndFeelDecorated(true);
		JDialog.setDefaultLookAndFeelDecorated(true);  
		/////////////////////////////////////
		
		////////////////////////////////////////////:
		
		SwingUtilities.invokeLater(new Runnable() { 
			public void run() {
				client thisClass = new client(); 
				thisClass.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
				thisClass.setVisible(true);
			}
		});
	}

	public client (){
		super();
		initialize();
		this.setBackground(Color.GREEN);
	}

	private void initialize() {
		this.setSize(648, 441);
		this.setContentPane(getJContentPane());
		this.setTitle("CLIENT");
		this.addWindowListener(new java.awt.event.WindowAdapter() { 
			
			public void windowClosing(java.awt.event.WindowEvent e) {      
				try {
						mClient.close(); 
					} catch (Exception ex) {
						System.out.println(ex.getMessage());
					}
			}                                                                    
			                                        
			public void windowOpened(java.awt.event.WindowEvent e) {
				if (mClient == null || mClient.isClosed()) {
					communicateWithServer();
				}
			}   
		});    
	}

	private JPanel getJContentPane() {         
		if (jContentPane == null) {
			jContentPane = new JPanel();
			jContentPane.setLayout(new BorderLayout());
			jContentPane.add(getJPanel(), BorderLayout.CENTER);
		}
		return jContentPane;
	}
	
	private void communicateWithServer() {
		Thread vThread = new Thread() {
	           
            public void run () {
                try {
                	mClient = new Socket("localhost", 3500);
                    
                	if (authentificateWithServer(mClient)) {
                		while (true) {
                			displayClientsConnected(mClient);
                			
                			Thread.sleep(1000);
                		}
                	}
                	
                	mClient.close();
    			} catch (Exception e) {
                    e.printStackTrace(); 
                }               
            }
      
        };
        
        vThread.start();
	}
	
	public boolean authentificateWithServer(Socket pSocket) throws Exception {
		mNomClient = JOptionPane.showInputDialog(this , "Veuillez enter un nom pour tchatter :");
		
		if (mNomClient != null) {
			PrintWriter out= new PrintWriter(pSocket.getOutputStream(), true);
	        out.write(mNomClient + "\r\n");
	        out.flush();
	        
	        BufferedReader in=new BufferedReader(new InputStreamReader(pSocket.getInputStream()));
	        String vReponse = in.readLine();
	        
	        if (vReponse.startsWith("OK")) {
	        	return true;
	        } else {
	        	JOptionPane.showMessageDialog(this, "Ce nom existe deja !", "Warning", JOptionPane.WARNING_MESSAGE);
			}
		}
		
		return false;
	}
	
	public void displayClientsConnected(Socket pSocket) throws Exception {
		PrintWriter out= new PrintWriter(pSocket.getOutputStream(), true);
        out.write("DISPLAYCLIENTS\r\n");
        out.flush();
        
        BufferedReader in=new BufferedReader(new InputStreamReader(pSocket.getInputStream()));
        String req=new String();
        
        DefaultListModel dlm=new DefaultListModel();
        while(!(req=in.readLine()).startsWith("ENDCOMMAND")) {
        	System.out.println(req);
        	dlm.addElement(req);
        }
        
        lpseudo.setModel(dlm);
	}

}  //  @jve:decl-index=0:visual-constraint="10,10"

Code serveur (Refondu complètement) :

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;

import java.util.HashMap;
//////////////////
public class serveur {
	
	private static String sEndCommand = "ENDCOMMAND\r\n";
	
	private HashMap<String, Object> mClients;

	public static void main(String[] args) {
		new serveur().launchServer();
	} 

	public void launchServer() {
		mClients = new HashMap<String, Object>();
		
		try {
			ServerSocket vServerSocket = new ServerSocket(3500);
		    while(true) {
		        final Socket vSocket = vServerSocket.accept();
		        
		        Thread vThread = new Thread() {
		           private String mCurrentThreadNomClient;
		        	
		           public void run() {
		        	   try {
		        		   mCurrentThreadNomClient = receiveAuthentificationFromClient(vSocket);
		        		   
		        		   while (!vSocket.isClosed()) {
		        			   sendListClientsConnectedToClient(vSocket);
		        		   }
		        		   
		        		   vSocket.close();
		        	   } catch (Exception e) {
		        		   mClients.remove(mCurrentThreadNomClient);
		        		   e.printStackTrace();
		        	   }
		           }
		           
		       };
		        
		       vThread.start();
		    }
		} catch (Exception e) { 
			e.printStackTrace();
		}
	}	
	
	private String receiveAuthentificationFromClient(Socket pSocket) throws Exception {
		BufferedReader vInputBufferedReader = new BufferedReader(new InputStreamReader(pSocket.getInputStream()));
        String vNomClient = vInputBufferedReader.readLine();
        
        PrintWriter out= new PrintWriter(pSocket.getOutputStream(), true);
                
        if (mClients.containsKey(vNomClient)) {
        	out.write("KO\r\n");
            out.flush();
            pSocket.close();
            return null;
        } else {
        	mClients.put(vNomClient, null);
        	out.write("OK\r\n");
            out.flush();
        }
        
        return vNomClient;
	}
	
	private void sendListClientsConnectedToClient(Socket pSocket) throws Exception {
		BufferedReader vInputBufferedReader = new BufferedReader(new InputStreamReader(pSocket.getInputStream()));
		String vRequest = vInputBufferedReader.readLine();
				
		if (vRequest.startsWith("DISPLAYCLIENTS")) {
			PrintWriter out= new PrintWriter(pSocket.getOutputStream(), true);
	        
			for (String vClientNomTmp : mClients.keySet()) {
				out.write(vClientNomTmp + "\r\n");
			}
			
			out.write(sEndCommand);
			out.flush();
		}		
	}
	
}  //  @jve:decl-index=0:visual-constraint="10,10"

Je te laisse regarder ce code, si tu as tt compris tu me dis et on passera à l étape deux : l'envoi reception de données de tchat.

Bonne chance,
Niroken

Hmmm

J'ai de mon coté fait le test suivant :

- Serveur sur un poste et client sur le même poste.
- Client sur un autre poste

Je n'ai eu aucun soucis.

Cependant, ton erreur "Connection timed out" me ferait davantage penser, à un firewall qui bloque l échange de données sur le réseau.

--------------------------------------------------------------------------------

Ensuite il est vrai que mettre les infos de connexions en dur dans le code, c'est moyen donc je te passe ceci :

C'est une classe utilitaire crée par moi :) qui permet de lire les fichiers de configuration (.properties) en java

import java.io.FileInputStream;
import java.io.IOException;
import java.util.Properties;

public class ConfigReader {
    
    private Properties mProperties;
    private static ConfigReader sInstance;
        
    private ConfigReader(String pFilePropertiesName) throws IOException {
        readConfig(pFilePropertiesName);
    }
    
    public static ConfigReader getInstance(String pFilePropertiesName) {
        if (sInstance == null) {
            try {
                sInstance = new  ConfigReader(pFilePropertiesName);
            } catch (IOException e) {
                e.printStackTrace();
                throw new RuntimeException("Impossible de lire le fichier " + pFilePropertiesName);
            }
        }
        
        return sInstance;
    }
        
    private void readConfig(String pFilePropertiesName) throws IOException {
        mProperties = new Properties();
        FileInputStream vFileInputStream = new FileInputStream(pFilePropertiesName);
        mProperties.load(vFileInputStream);
        vFileInputStream.close();
    }

    public String getProperty(String pKey) {
        return mProperties.getProperty(pKey);
    }
    
    public Properties getProperties() {
        return mProperties;
    }
    
    public static String getClasspathResource(String pResourcePath) {
        String vPath = pResourcePath;
        
        if (vPath.startsWith("/")) {
            vPath = vPath.substring(1);
        }
        
        try {
            return Thread.currentThread().getContextClassLoader().getResource(vPath).getPath().replaceAll("%20", " ");
        } catch (Exception pException) {
            throw new RuntimeException("La ressource " + pResourcePath + " n est pas dans le classpath !");
        }
    }
    
}

Je te met ici la méthode à modifier coté client :

private void communicateWithServer() {
		Thread vThread = new Thread() {
	           
            public void run () {
                try {
                	int vPortServeur = Integer.parseInt(ConfigReader.getInstance("client.properties").getProperty("serveur.port"));
                	String vIpServeur = ConfigReader.getInstance("client.properties").getProperty("serveur.ip");
                	mClient = new Socket(vIpServeur, vPortServeur);
                    
                	if (authentificateWithServer(mClient)) {
                		while (true) {
                			displayClientsConnected(mClient);
                			
                			Thread.sleep(1000);
                		}
                	}
                	
                	mClient.close();
    			} catch (Exception e) {
                    e.printStackTrace(); 
                }               
            }
      
        };
        
        vThread.start();
	}

La méthode à modifier coté serveur :

public void launchServer() {
		mClients = new HashMap<String, Object>();
		
		try {
			int vPortServeur = Integer.parseInt(ConfigReader.getInstance("serveur.properties").getProperty("serveur.port"));
			ServerSocket vServerSocket = new ServerSocket(vPortServeur);
		    while(true) {
		        final Socket vSocket = vServerSocket.accept();
		        
		        Thread vThread = new Thread() {
		           private String mCurrentThreadNomClient;
		        	
		           public void run() {
		        	   try {
		        		   mCurrentThreadNomClient = receiveAuthentificationFromClient(vSocket);
		        		   
		        		   while (!vSocket.isClosed()) {
		        			   sendListClientsConnectedToClient(vSocket);
		        		   }
		        		   
		        		   vSocket.close();
		        	   } catch (Exception e) {
		        		   mClients.remove(mCurrentThreadNomClient);
		        		   e.printStackTrace();
		        	   }
		           }
		           
		       };
		        
		       vThread.start();
		    }
		} catch (Exception e) { 
			e.printStackTrace();
		}
	}	

Tu dois donc éditer un fichier de config pour le serveur que tu mettras dans le répertoire ou s executes ton serveur "serveur.properties"

serveur.port=3500

De même pour le fichier de config client "client.properties"

serveur.port=3500
serveur.ip=localhost

C'est plus propre comme ca tu peux modifier la config, sans changer le code.

Pour en finir je vais répondre à ta dernière question : la HashMap

En fait il s'agit d'une structure de données indéxée : ici c'est par nom de client.

Structure de données, oui, mais quelle données??, ici cette HashMap va contenir la liste des messages en attente pour chaque client.

J'avais préparé le terrain pour l'étape 2 :

- Toutes les 1s le client envoit une requete au serveur, dans cette requete on va également envoyer ce que le client a saisi.
- Le serveur va recevoir cette requete et va ajouter le ou les messages du client aux listes de messages en attente de tous les autres clients.
- Puis le serveur renvoit au client sa liste des messages en attente.

La dans le scénario que je viens de décrire, a chaque fois qu un client ecrira un message, il sera vu par tous les autres clients.
Mais si tu veux ecrire un "private message" visible que par un seul client, le serveur ajoutera le message du client seuelement au client destinataire concerné.

L'interet de la HashMap c'est que comme c'est indéxée par nom de client, si tu veux atteindre la liste des messages dun client donné : tu fais :

vHashMap.get("nomDeClient");

Où vHashMap est une instance de HashMap.

Je te passe la partie pour le tchat dem1, faut quand même le temp de la coder :)

Bonne chance,
Niroken

Hello,

Si je n'ai pas encore donné suite, c'est plus par manque de temp en fait, mais je vais m'y atteller ce soir, j'espère avoir fini donc.

Niroken