[java]socket channel lettura del canale problemi

[romaluca]

Abbiamo una applicazione client-server tramite la quale ci scambiamo "messaggi". Il problema è che quando leggiamo dal canale (non bloccante) un messaggio troppo lungo questo ci viene restituito spezzato in più pacchetti di varia dimensione. Come possiamo riottenere il messaggio intero distinguendolo da quelli successivi?

[LeleFT]

La cosa è abbastanza strana: per spezzettare il emssaggio servono delle politiche apposite; se non si specifica niente, in una connessione client/server via Socket non ha importanza la dimensione del messaggio da inviare, ma esso non viene spezzettato.

Se questo messaggio viene spezzettato significa che qualcuno ha deciso di spezzettarlo: è compito suo assicurarsi che i vari pacchetti vengano spediti nell'ordine giusto e far si che il client li riceva e possa gestirli nel modo corretto (magari tramite indicizzazione, o cose simili).

Senza il codice si riesce a faer ben poco. Prova a postarlo così si può vedere come è stata gestita la cosa.


Ciao.

[romaluca]

Innanzi tutto stiamo usando le nio con i canali in modalità non bloccante. il problema è che se noi scriviamo sul canale un ByteBuffer "grande" questi viene spedito tutto ( la write ci indica che vendono scritti tutti i byte), ma quando andiamo a leggere dal canale con la read(ByteBuffer) questa ci indica che abbiamo letto un numero di byte inferiore, e solo dopo più letture ( a seconda della dimensione del buffer spedito) riceviamo l'intero numero di byte

[LeleFT]

Ok, non ho mai usato le librerie NIO: non le conosco ancora.


Ciao.

[mcolombara]

non credo sia questione di NIO.
Devi leggere fin che non è finito lo stream.
Qualcosa del tipo:

int num = 0;
byte[] buffer = new byte[256];

while ((num = stream.read(buffer)) > -0) {
...
}

[LeleFT]

Quindi, non sarebbe meglio realizzare una classe (chiamata, ad esempio, Messaggio), che contenga tutti i byte e utilizzare un ObjectInputStream per leggere dalla socket un oggetto di questo tipo? In questo modo non ci sono problemi di letture consecutive e tutti i dati possono essere incapsulati in un unico oggetto. Ad esempio, con questa classe:

public class Messaggio implements Serializable {

   private byte[] dati;

   public Messaggio(byte [] dati) {
      this.dati = dati;
   }

   public byte[] getDati() { return dati; }
}

si può scrivere qualcosa del genere:

// Da parte di chi riceve:
ObjectInputStream ois = new ObjectInputStream( socket.getInputStream() );

Messaggio msg = (Messaggio) ois.readObject()  // Qui leggo tutto il messaggio

byte [] datiRicevuti = msg.getDati();



// Da parte di chi invia:
ObjectOutputStream oos = new ObjectOutputStream( socket.getOutputStream() );

byte [] daInviare = ...;

Messaggio msg = new Messaggio( daInviare );

oos.writeObject( msg );

A me sembra più semplice e facile da gestire questa struttura...


Ciao.