Réutilisez une nouvelle fois un client Java Socket

Le problème est que la déclaration de socket declient = serveur.accept (); code> sur le serveur est à l'intérieur de la portée du pour code> boucle. Donc, à la fin du pour code> boucle (après ServerOutput.flush (); code>) Le fromClient code> La variable est détruite et une nouvelle est créée le La prochaine fois que la boucle commence. Vous devrez vous restructurer comme ceci si vous souhaitez que la même connexion soit capable d'envoyer / recevoir plusieurs messages:

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.HashMap

public class User extends Runnable
{
    public String username;
    public Socket socket;
    public TestServer testServerReference;
    ObjectInputStream clientInput;
    ObjectOutputStream serverOutput;

    public User(Socket s, TestServer tS)
    {
        socket = s;
        testServerReference = tS;
    }

    /**
     *  Creates the in/out Streams, returns the username
     */
    public String init()
    {
        serverOutput = new ObjectOutputStream (fromClient.getOutputStream());
        clientInput = new ObjectInputStream (fromClient.getInputStream());
        this.username = (String)clientInput.readObject();  //the first thing the client should send is a username

    }

    public void run()
    {
        try
        {
            //add send/receive logic here for connected client
        }
        catch (Exception ex)
        {
        }
        finally
        {
            testServerReference.removeUser(username);
        }
    }
}

public class TestServer {

    public static HashMap<String,User> userList = new HashMap<String,User>();
    public static void main(String[] args) 
    {

        try {

              ServerSocket server = new ServerSocket(5555, 100);

              while (true) //start accepting new connections
              {
                  System.out.println ("Listening for connections");
                  Socket fromClient = server.accept();
                  User newUser = new User(fromClient,this);
                  String newUsername = newUser.init();
                  userList.add(newUsername,newUser);
                  (new Thread(newUser)).start();
              }


        } catch (ClassNotFoundException ex) {
            Logger.getLogger(TestServer.class.getName()).log(Level.SEVERE, null, ex);
        } catch (IOException ex) {
            Logger.getLogger(TestServer.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    public static void removeUser(String username)
    {
        userList.remove(username);
    }

}

Je pense que la réponse est ici: http://docs.oracle.com/javase/1.4.2/docs/apl /java/net/serversion.html#accept%28%29 .

Il ne peut tout simplement pas être fait lorsque vous avez un serveur assistant à plusieurs clients. Server.accept crée une nouvelle prise de sorte que le client perd la connexion avec la prise du serveur créé à première instance, car cela écrase l'objet de la prise.

Vous ne pouvez pas accepter l'acceptation de la boucle car cela signifie que le serveur n'écoute qu'un seul client. Vous pourrez peut-être jouer avec deux instances, mais cette solution ne serait disponible que pour un serveur en écoutant plusieurs demandes d'un client uniquement.

En résumé, il ne peut pas être fait d'où tout l'exemple sur le Net utilise un nouveau socket () au client à tout moment, il tente d'envoyer de nouvelles informations au serveur, même si le client est identique.

Vous devez utiliser un serveur fileté.

Il est possible qu'un serveur assister à plusieurs clients. Chaque prise de serveur doit être traitée par son propre thread. Le serveur écoute sur une prise connu et chaque client se connecte à l'aide d'une prise distincte (de sorte que plusieurs clients peuvent s'exécuter sur le même hôte).

Tout d'abord, les Javadocs sont l'un des pires endroits pour comprendre comment ou pourquoi vous devez utiliser une bibliothèque, ils ne vous disent vraiment que ce que la bibliothèque fait .

Votre message que ce n'est pas possible n'est vrai que si vous restez avec un serveur à filetage unique .

Oracle a une page sur sockets de serveur Java qui explique plusieurs clients (avec réutilisation) avec un seul serveur.

Ils ont aussi un Page des sockets avancés qui passe plus en détail.