[Java] Problema con streams

[TM-Nite]

questo è il codice,

// Sender
try {
File localFile = new File("shared/"+fileName);
OutputStream out = socket.getOutputStream();
InputStream fis = new FileInputStream(localFile);

int length;
byte[] buffer = new byte[4096];
while((length = fis.read(buffer)) != -1)
out.write(buffer, 0, length);

fis.close();
out.close();
}
catch(Exception e){}

// Receiver
try {
File downloadFile = new File("incoming/"+fileName);
IntputStream ois = connectedSocket.getIntputStream();
OutputStream fos = new FileOutputStream(downloadFile);

int length;
byte[] buffer = new byte[4096];
while((length = ois.read(buffer)) != -1){
fos.write(buffer, 0, length);

fos.close();
ois.close();
}
catch(Exception e){}

Il problema è che il sender manda quasi tutto il file ad eccezione dell'ultimo pezzo che non riesce a riempire completamente il buffer... quindi il receiver non prende mai il -1 nella sua read e non esce mai dal ciclo.
Da quanto ho capito il sender si blocca nell ultima read...

cosa sbaglio? : (

anche mettendo il buffer ad 1, il sender non prende mai -1, tantomeno il receiver : (



grazie dell aiuto

[TM-Nite]

pare che il problema fosse legato al fatto che il sender chiudeva le stream prima che il receiver potesse finire di leggere... il fatto è che ora il sender esce dal while correttamente ma non tenta una nuova lettura, quindi il receiver non riceve il -1 e non esce dal loop.

ho risolto mettendo un break nel loop del receiver che si attiva se i byte totali letti sono >= del file size.

è normale?

nelle api è scritto che la read legge -1 se la stream è finita, ma cosi non pare avvenire

[andbin]

Originariamente inviato da TM-Nite
nelle api è scritto che la read legge -1 se la stream è finita, ma cosi non pare avvenire

Sì, ma se ci pensi un attimo per un file esiste un end-of-file fisico, cioè più della lunghezza del file non puoi leggere. Quindi puoi ottenere il fatidico -1 che segnala eof.

Ma per un socket TCP è diverso, è uno stream "continuo". Una volta stabilita la connessione, i due host possono scambiarsi miliardi di byte! Cioè non c'è mai un eof. Al massimo uno dei due può eventualmente chiudere la connessione.

Quando si usano i socket è importante stabilire un certo formato dei dati. Se uno dei due host deve mandare un file all'altro una soluzione è leggere la dimensione del file locale e inviarla sottoforma di 4 byte all'altro prima di inviare i dati, in modo che l'altro sappia quanti byte deve leggere.
Se la comunicazione fosse "line oriented" come in certi protocolli, allora si legge "a righe" di testo e si stabilisce ad esempio che la fine può essere una linea vuota o contenente un certo testo.

Quindi invece di perdere tempo ad aspettare un -1, pensa ad un formato dei dati.