Java - Client ethernet - Socket per ricevere dati di grandi dimensioni

[LupusImprobus]

Buongiorno a tutti.
Il mio problema è il seguente:
Sto realizzando un programma che comunica con un server che rimane in attesa di un comando e mi restituisce una immagine sotto forma di una serie di dati,
Per ricevere i dati dal server ho creato un Socket e utilizzo il metodo Socket.getInputStream();

   Socket sok = new Socket("10.10.0.82", 2006);
   InputStream is = sok.getInputStream();

Tutto funziona fino a che lo stream di dati è relativamente piccolo (< 8.000 Byte circa)
In caso di un flusso di dati di dimensioni maggiori, il .getInputStream() mi restituisce un numero di byte attorno agli 8.000.

Ho provato a sostituire i'InputStream con il DataInputStream ed ottengo un buffer attorno ai 50.000 byte, più grande ma non ancora sufficiente.

Ho provato a realizzare un loop che ripeta l'istruzione di .getInputStream(); sino a quando is.available() è maggiore di zero, ovvero sino a quando c'è qualcosa da leggere, però finisce che ho ricevuto meno dati di quelli che il server mi ha mandato.
A priori so quanti byte mi deve rispondere il server quindi so quando non li ricevo tutti.

Domanda:
Che procedura posso utilizzare per leggere uno stream di circa 400.000 byte?
Mi basta anche solo un suggerimento per capire che strada prendere.

Spero d'essermi spiegato bene.
Se così non fosse vi prego di domandarmi quello che ho omesso.

Ogni aiuto sarà apprezzato.
Grazie in anticipo.

[LeleFT]

Io non ho mai avuto alcun problema a trasferire dati di quella dimensione (anzi, ne trasferisco anche di più grandi).
Solo che devi "pacchettizzare"... ovvero, il file lo devi trasferire a pacchetti di N byte, non tutto in una volta.

In questo mio post c'è un esempio di invio di byte su una socket (a pacchetti).

La lettura (ovvero, la ricezione) è speculare:

// Creo l'InputStream per leggere dalla Socket
InputStream is = socket.getInputStream();

// Strutture dati per la lettura dei byte

// 32 KB di dati per blocco
byte[] dati = new byte[32 * 1024];

// Numero di byte letti dalla socket
int byteLetti = 0;

// Ora leggo un blocco alla volta...
while((byteLetti = is.read(dati)) >= 0) {

   // Nell'array "dati" ho un pacchetto letto dalla socket
   // Ci faccio quello che voglio (lo salvo su un file, lo lavoro...)
   // ... 
  
   // non indispensabile, ma utile: pulisco il buffer di lettura
   Arrays.fill(dati, (byte) 0);
}

// Ho finito di leggere il file dalla socket...
// Chiudo l'InputStream (se necessario)
is.close();

Ciao.

[LupusImprobus]

Per prima cosa GRAZIE

Ora verifico nelle specifiche del server.
Si tratta di un sistema di visione che mi deve mandare l'immagine che ha elaborato.
Quindi non posso operare sul codice del server ma solo sul client, ovvero il mio programma.

Proverò a seguire la strada che mi hai suggerito.
Non so quando potrò lavorarci su ma ti farò sapere com'è andata.

Ancora grazie.

[LeleFT]

Diciamo che, nel tuo caso, quindi non è tanto un problema di invio... il server lavora per i fatti suoi, invia i dati come meglio crede e a te che ricevi poco ti frega. Quello che ti serve è solo la parte di ricezione... il server può anche inviare tutti i dati in un colpo solo, ma tu li puoi comunque ricevere come ti pare e piace. Quindi, vai di pacchettizzazione.


Ciao.