Socket serveur qui attend les message provenant client à lire

J'ai le texte suivant serveur socket en java,

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 MiddleSocket {
    private ServerSocket middleman;
    private int port = 1027;
    private Socket client;


    protected void createSocketServer()
    {
        try
        {
            middleman = new ServerSocket(port);
            client = middleman.accept();
            middleman.close();
            PrintWriter out = new PrintWriter(client.getOutputStream(),true);
            BufferedReader in = new BufferedReader(new InputStreamReader(client.getInputStream()));
            BufferedReader stdIn = new BufferedReader(new InputStreamReader(System.in));
            while(true)
            {
                System.out.println("echo: " + in.readLine());
                out.println("test");
            }
        }
        catch(IOException e)
        {
            System.out.println(e);
        }
    }

}

Il fonctionne correctement dans la façon dont il lit à partir du client et tout et tout. Cependant, je veux que le serveur socket pour seulement essayer et de le lire quand il y a un message de la part du client depuis dans la boucle, on continue la lecture, même lorsque aucun message de la part du client sont reçus cette fonction génère un tas de

echo: null

Est-il un mécanisme de court d'un wait() d'avoir la boucle while de savoir tout simplement s'asseoir et d'attendre, et puis le feu lorsqu'un message est envoyé par le client à lire ce message, et une fois que le message est lu, et une réponse est envoyée, il vous suffira ensuite de ralenti jusqu'à ce que le message suivant de la part du client est reçu?

OriginalL'auteur jgr208 | 2014-10-20

Vous pouvez simplement faire quelque chose comme comme suit:

String line;
while ((line = in.readLine()) != null) {
   \\Do stuff
}

Ce qui devrait avoir le comportement attendu.

Edit:

voici un exemple complet de ce dont je parlais dans les commentaires à l'aide de votre code:

package javaapplication12;

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 SocketExample {
    private ServerSocket middleman;
    private int port = 8080;
    private Socket client;


    protected void createSocketServer()
    {
        try
        {
            while (true){
                middleman = new ServerSocket(port);
                client = middleman.accept();
                middleman.close();
                PrintWriter out = new PrintWriter(client.getOutputStream(),true);
                BufferedReader in = new BufferedReader(new InputStreamReader(client.getInputStream()));
                BufferedReader stdIn = new BufferedReader(new InputStreamReader(System.in));
                String line;
                while((line = in.readLine()) != null)
                {
                    System.out.println("echo: " + line);
                    out.println("test");
                }
            }
        }
        catch(IOException e)
        {
            System.out.println(e);
        }
    }

    public static void main(String[] args){
        SocketExample test = new SocketExample();
        test.createSocketServer();
    }
}

Cependant je veux la boucle pour ne pas quitter, car je veux le serveur Socket en marche tout le temps.
Alors vous devriez boucle sur les .accept de commande, qui doit alors gérer ce que l'entrée est reçu par le client de connexion, puis ferme la connexion, et attend un nouveau. Je vais modifier ma réponse avec un exemple.
édité ma réponse à refléter ce que j'ai mentionné ci-dessus. Bien sûr, gardez à l'esprit, ce ne peut gérer qu'une seule connexion à la fois, mais c'est une fonctionnelle exemple. Notez que le while(true) en boucle autour d'une autre partie du code, ce qui lui permet d'accepter un nombre infini de connexions, mais a une quantité limitée de temps passé à gérer chaque connexion, qui est ce que vous voulez.
donc ce qui arrive si je veux n connexions à un moment? sera-ce en mémoire tampon les autres messages d'alors et les envoyer après le dernier message est reçu de la précédente client?
à peu près! essentiellement, tout ce qui à l'intérieur du while(true) boucle (pas la boucle elle-même) serait le "contenu" de la fil, et vous auriez quelques autres de la classe avec le " while(true)' boucle qui a la .méthode accept() et engendre arrêt d'un thread pour gérer la connexion, puis remonte à l'écoute pour de nouvelles connexions. Consultez ce lien: baptiste-wicht.com/posts/2010/09/...

OriginalL'auteur WillBD

2

Vous pouvez utiliser InputStream.read(), ou InputStream.read(byte[]). Les deux bloc

Voici un exemple

OriginalL'auteur ControlAltDel
1

Je veux que le serveur socket pour seulement essayer et de le lire quand il y a un message de la part du client depuis dans la boucle, on continue la lecture, même lorsque aucun message de la part du client sont reçus cette fonction génère un tas de
```
echo: null
```
C'est parce que vous êtes ignorant la fin du flux, qui est ce que la valeur null signifie. Cela ne signifie pas qu'il n'y a pas de messages de la part du client. Cela signifie que le peer a fermé la connexion.

OriginalL'auteur user207421

Vous devez vous connecter pour publier un commentaire.