Comment dois-je lire à partir d'un tampon lecteur?

J'ai l'exemple suivant de la lecture à partir d'un tampon de lecture:

while ((inputLine = input.readLine()) != null) {
   System.out.println("I got a message from a client: " + inputLine);
}

Le code dans la boucle println sera exécuté à chaque fois que quelque chose apparaît dans le tampon lecteur (input dans ce cas). Dans mon cas, si un client demande écrit quelque chose de la socket, le code dans la boucle (dans le serveur d'application) sera exécutée.

Mais je ne comprends pas comment il fonctionne. inputLine = input.readLine() attend jusqu'à ce que quelque chose s'affiche dans la mémoire tampon lecteur et lorsque quelque chose apparaît, il y il retourne true et le code de la boucle est exécuté. Mais quand null peuvent être retournés.

Il est une autre question. Le code ci-dessus a été prise à partir d'une méthode qui throws Exception et j'ai utiliser ce code dans la méthode run du Thread. Et quand j'essaie de mettre throws Exception avant la run le compilateur se plaint: méthode de remplacement ne lève pas d'exception. Sans le throws exception j'ai une autre se plaindre du compilateur: non déclarée exception. Alors, que puis-je faire?

vous savez le deal. Placer les différentes questions dans différents DONC des Questions!!
Stephen C, je pense que l'ajout de la partie a été aussi une partie de "comment dois-je lire à partir de la mémoire tampon lecteur?". Mais je vois votre point de vue. J'ai enlevé la partie rajoutée.

OriginalL'auteur Roman | 2010-03-23

5

Lors de la prise de courant à l'autre extrémité est fermée, le lecteur doit retourner une chaîne nulle. C'est à cette condition que vous êtes à la recherche pour. Pour gérer l'exception, enveloppez-la lecture de la boucle dans un bloc try/catch.
```
 try {
   while ((inputLine = input.readLine()) != null) {
     System.out.println("I got a message from a client: " + inputLine);
   }
 }
 catch (IOException e) {
   System.err.println("Error: " + e);
 }
```
Vous trouverez peut-être ce tutoriel sur la lecture et l'écriture dans un socket en Java, utile.

OriginalL'auteur tvanfosson
3

Pour votre première question:

Mais je ne comprends pas comment il fonctionne. inputLine = input.readLine() attend jusqu'à ce que quelque chose s'affiche dans la mémoire tampon lecteur et lorsque quelque chose apparaît, il renvoie la valeur true et le code de la boucle est exécuté. Mais lorsque la valeur null peut être retourné.

BufferedReader.readLine() ne retourne pas true en cas de succès. Elle renvoie une Chaîne contenant la ligne qui a été lu. Si la fin du flux est atteinte, il retourne null.

Votre deuxième question:

Le code ci-dessus a été prise à partir d'une méthode qui déclenche une Exception et j'ai utiliser ce code dans la méthode run du Thread. Et quand j'essaie de mettre throws Exception avant de lancer le compilateur se plaint: méthode de remplacement ne lève pas d'exception. Sans la throws exception, j'ai un autre se plaindre du compilateur: non déclarée exception. Alors, que puis-je faire?

Vous devez envelopper votre code dans un bloc try/catch. Si vous ne voulez pas gérer l'exception interceptée, il suffit de laisser la partie vide (non recommandé)
```
try {
    while ((inputLine = input.readLine()) != null) {
        System.out.println("I got a message from a client: " + inputLine);
    }
} catch (Exception e) {
    //handle exception
}
```
OriginalL'auteur Peter Di Cecco
1

Le lecteur readLine() retourne une chaîne de valeur quand elle a quelque chose de lire, une chaîne vide quand il n'y a pas encore rien, et null si la connexion est fermée.

Je recommanderais l'enveloppant d'un try/catch autour de votre bloc de code avec la fonction d'IO et de gérer les erreurs de façon appropriée.

OriginalL'auteur Bryan Denny
0

input lecteur est connecté à la prise, ce qui est un auditeur, c'est à dire continue d'écouter les messages entrants.

À propos de votre deuxième question, vous devez mettre un bloc try/catch à l'intérieur de la méthode, d'intercepter l'Exception et de la gérer. Ne pas re-jeter.

OriginalL'auteur medopal
0

Mais je ne comprends pas comment il fonctionne. .... attend jusqu'à ce que quelque chose apparaît dans le
tampon lecteur et quand quelque chose
s'y il retourne true

Non, elle renvoie la valeur de l'expression (inputLine = input.readLine()), la inputLine lui-même. Le inputLine est comparée à la valeur null.

OriginalL'auteur PeterMmm
0

valeur null est retournée lorsque le "EOF (Fin De Fichier)" est atteint. Puisque c'est la lecture à partir d'une prise réseau, la fin de fichier est créé lors de la prise est débranchée (soit par le serveur ou le client), mais vous obtiendrez probablement une Exception avant de voir les expressions du FOLKLORE.

OriginalL'auteur M. Jessup
0

Si ce n'est pas les devoirs à la maison, vous voudrez peut-être regarder à Apache Commons IOUtils.

En supposant que vous ne créez pas la BufferedReader, et s'arrêter à la InputStream:
```
String results = IOUtils.toString(inputStream);
System.out.println(results);
```
OriginalL'auteur Dean J
0
```
while ((inputLine = input.readLine()) != null) {
```
Regarder chaque partie de l'expression:
```
input.readLine()
```
Retourne une Chaîne de caractères qui sera null si la fin du flux est atteinte (ou lève une Exception en cas d'erreur).
```
inputLine = input.readLine()
```
Attribue cette Chaîne de inputLine
```
((inputLine = input.readLine()) != null)
```
Vérifie que la Chaîne a été attribuée n'est pas null (la fin du flux).

OriginalL'auteur fgb
0

Vous avez reçu quelques bonnes réponses. Il suffit de prendre l'exception et la traiter localement. Si vous avez besoin de les transmettre à un autre code, mais ne peut pas car le run() méthode ne permet aucune exception de contrôle, vous pouvez envelopper l'exception dans une RuntimeException d'une certaine sorte. Si la méthode est en cours d'exécution directement sur un Thread (car c'est un Exécutable, sans doute), alors vous devez prendre soin de re-jeter un enveloppé exception.

Que pour le résultat de readLine(), il sera de retour null quand il n'y a plus rien à lire. Dans le cas d'un socket, c'est quand l'autre côté proprement ferme le socket (toute la cessation soudaine ou d'impur près entraînerait généralement une exception dans votre code comme le système d'exploitation envoie un autre type de prise électrique à proximité de notification).

J'ai un mot de prudence, car vous êtes l'enveloppant d'un socket dans un java.io.BufferedReader. Vous devriez être très prudent sur l'utilisation de ce type de code de production.

Le danger est que BufferedReader ne traite pas bien les exceptions dans le milieu de la lecture. C'est surtout un problème si vous avez activé un délai d'attente sur le socket de sorte que le code recevrez périodiquement des exceptions automatiquement à partir du système d'exploitation. Le délai d'attente (ou autre exception) pourrait venir alors que la mémoire tampon à l'intérieur du lecteur de remplissage. Si vous essayez de réutiliser l'objet après l'exception, il ignore toutes les données dans la mémoire tampon. Le paquet(s) qui ont été reçus précédemment sont silencieusement perdu et il n'y a aucun moyen de récupérer ces octets.

Noter qu'il existe d'autres types de prise exceptions qui ne signifie pas que le socket a été perdu. Par exemple, regardez la définition de java.io.InterruptedIOException. Cela a un public variable qui indique le nombre d'octets transférés avec succès dans la plus récente d'e/S (lecture ou écriture) demande. Cela signifie que l'opération e /s peut être exécutée de nouveau pour récupérer ou envoyer les octets restants pour le paquet.

Si, à l'exception de votre conception est de fermer immédiatement le lecteur et prise de la méthode fonctionnera correctement.

La bonne façon de lire à partir d'une prise est d'utiliser le socket stream directement, utilisez NIO (ByteBuffers et par exemple), ou d'utiliser un bien écrit, d'une bibliothèque du réseau, avec de bonnes abstractions de plus de plus en plus ces classes de niveau (plusieurs open source sont disponibles).

OriginalL'auteur Kevin Brock

Vous devez vous connecter pour publier un commentaire.