Java Programmation Socket

Je suis la construction d'une application client/serveur simple à l'aide de sockets java et d'expérimenter le ObjectOutputStream etc.

J'ai suivi le tutoriel à cette adresse http://java.sun.com/developer/technicalArticles/ALT/sockets partir de la moitié du chemin vers le bas quand il parle de transporter des objets sur les sockets.

Voir mon code pour le client http://pastebin.com/m37e4c577 Toutefois, cela ne semble pas fonctionner et je ne peux pas comprendre ce qui ne fonctionne pas. Le code en commentaire en bas est directement copié du tutoriel et cela fonctionne quand je viens de l'utiliser à la place de la création de l'objet client.

Peut-on voir rien de ce que je fais de mal?

Vous devez décommenter. Bah sérieusement, qu'est-ce que l'erreur de compilation?
Il n'y a pas d'erreur, il ne fonctionne tout simplement pas avec mon décommenté code et je ne vois pas pourquoi? Le code commenté des œuvres - je viens de séparation et de le placer dans un objet réel... ça me rend fou.

OriginalL'auteur Malachi | 2009-01-22

7

Le problème est de l'ordre de la création du flux:

Dans le serveur de l'article (ce qui je suppose est ce que vous utilisez), lorsqu'une nouvelle connexion est ouverte, le serveur s'ouvre d'abord un flux d'entrée, puis un flot de sortie:
```
public Connect(Socket clientSocket) {
 client = clientSocket;
 try {
  ois = new ObjectInputStream(client.getInputStream());
  oos = new ObjectOutputStream(client.getOutputStream());
 } catch(Exception e1) {
     //...
 }
 this.start();
}
```
Le commentaire de l'exemple de code utilise l'ordre inverse, en établissant d'abord le flux de sortie, puis le flux d'entrée:
```
//open a socket connection
socket = new Socket("localhost", 2000);
//open I/O streams for objects
oos = new ObjectOutputStream(socket.getOutputStream());
ois = new ObjectInputStream(socket.getInputStream());
```
Mais votre code est-il dans l'autre sens:
```
server = new Socket(host, port);
in = new ObjectInputStream(server.getInputStream());
out = new ObjectOutputStream(server.getOutputStream());
```
L'établissement d'un flux de sortie/d'entrée de flux paire de décrochage jusqu'à ce qu'ils ont échangé leur serrer la main de l'information, de sorte que vous doit correspondre à l'ordre de la création. Vous pouvez le faire simplement en échangeant les lignes 34 et 35 dans votre exemple de code.

OriginalL'auteur Mike Houston
5

Vous n'êtes pas de l'écriture de l'objet n'importe où.

Voir que le lien de nouveau, quelque chose que vous avez à écrire:
```
 oos.writeObject( new Date() );
```
Dans votre code, vous n'avez
```
ois.readObject();
```
C'est pourquoi

Le code affiché n'inclut que le client, de sorte qu'il n'a pas besoin d'écrire un objet.

OriginalL'auteur OscarRyz
2

Juste un rappel.

Lorsque vous utilisez ObjectOutputStream garder à l'esprit qu'il garde une référence de cache. Si vous écrivez un objet, modifiez l'objet, le contenu, et ensuite envoyer le même objet nouveau, vous obtiendrez des données en double. Par exemple:
```
List list = new ArrayList();
list.add("value1");
out.writeObject(list);
list.clear();
list.add("value2");
out.writeObject(list);
```
Produira dans le côté client deux listes à la chaîne "valeur1".

Pour éviter cela, la méthode de réinitialisation doit être appelé pour réinitialiser le cache de flux lors de l'écriture de la même référence de l'objet à plusieurs reprises:
```
List list = new ArrayList();
list.add("value1");
out.writeObject(list);
out.reset();
list.clear();
list.add("value2");
out.writeObject(list);
```
Cheers - ce sera un rappel utile!

OriginalL'auteur jassuncao

Probablement que vous les aimerez à apprendre les principes de base en premier.

Voici un exemple que je viens de coder.

Démarrez une serveur, qui ne s'occupe que d'UN seul client, et il envoie un objet et d'en mourir.

Lorsque l'utilisateur ( vous ), appuyez sur entrer, un nouveau client est créé, il se connecte sur le serveur et de lire l'objet que le serveur va envoyer.

Pas une exception est traitée ici. Juste pour rendre les choses plus simples, mais ce n'est PAS la voie de l'exception doit être traitée.

Lorsque vous comprendre tous les concepts, ici, il sera plus facile de comprendre ceux dans le tutoriel.

import java.io.*;
import java.net.*;
import java.util.*;
public class SimpleServer implements Runnable { 
//Creates the server, send a "date" and die.
public void run() { 
try {
ServerSocket server = new ServerSocket( 8090 );
Date creationDate = new Date();
System.out.println("(Server) Server is ready " 
+ "and running at " + creationDate );
Socket uniqueClient = server.accept();
//We will write using this "chained" object.
ObjectOutputStream out = new ObjectOutputStream( 
uniqueClient.getOutputStream());
out.writeObject( creationDate );
//close all, at this point forget about the exceptions.
//this is lesson #1      
out.close();
uniqueClient.close();
server.close();        
System.out.println("(Server) The server is down");
}catch( IOException ioe ) {}
}
public static void main ( String [] args ) throws IOException ,
ClassNotFoundException { 
Thread serverThread = new Thread( new SimpleServer() );
serverThread.start(); //start the server thread ... doh..
System.out.println("(Client) Press enter when you want "+ 
" to connect to the server...");
Scanner scanner = new Scanner( System.in );
scanner.nextLine();
Socket client = new Socket("localhost", 8090 );
//Read from this object.
ObjectInputStream in = new ObjectInputStream( client.getInputStream() );
Date date = ( Date ) in.readObject();
System.out.println("(Client) Current time is:          " + new Date() );
System.out.println("(Client) Object read from server : " + date );
in.close();
client.close();
}
}

J'espère que cette aide.

OriginalL'auteur OscarRyz

1

Si vous avez essayé un débogueur, il aurait dit où était le problème.(Peut-être pas pourquoi)

Le problème que vous avez est que ObjectOutputStream écrit un en-tête et ObjectInputStream lit que d'en-tête. Vous avez créé le ObjectInputStream d'abord ce qui signifie qu'il est tentant de lire un en-tête qui ne sera jamais écrit.

Solution: Toujours créer la ObjectOutputStream premier et flush() avant de créer le ObjectInputStream.

OriginalL'auteur Peter Lawrey
1

C'est mieux d'ouvrir un outputStream car un flux de sortie ne sont pas bloquées. Ensuite, vous avez le flux d'entrée qui attend un Stream. Après tous les cours d'eau, de vous écrire dans le flux et le ras - la - outputStream.flush() pour envoyer les octets de données. Vous aurez également besoin d'une méthode à l'autre extrémité à lire l'entrée, si c'est simplement inputStream.read() qui lit chaque octet comme un entier pour un char, ou à l'aide d'un BufferedReader ou Scanner. J'ai utilisé presque toutes les méthodes possibles, mais la méthode la plus efficace pour l'envoi est outputStream.write(String) qui écrit une séquence de chars comme bytes dans le flux et la lecture inputStream.read() lit une seule char. J'espère que cette aide.

OriginalL'auteur kyle england

Vous devez vous connecter pour publier un commentaire.