[JAVA] Evitare la chiusura del server al termine dello scambio dati

[AtoXx]

Salve a tutti, ho un piccola(grande)problema. Vorrei inviare un file(in questo caso un xml ma non ha importanza)dal server al client ma una volta inviato mi si chiude la connessione ed io non voglio che si chiuda. Qui vi posto i codici del server e poi del cliente

OutputStream s1out = socket.getOutputStream();
FileInputStream fin = new FileInputStream(parametri.get(3) + nome);
DataOutputStream doss = new DataOutputStream(s1out);
DataInputStream diss = new DataInputStream(fin);
byte buffer[] = new byte[diss.available()];   
diss.readFully(buffer);
doss.write(buffer);  
doss.close();
diss.close();
System.out.println("File Inviato!");

PrintWriter out = null;
String line,nomefile;
nomefile=(String) parametri.get(2) + new Random().nextInt(1000) + ".xml";
File file=new File(nomefile);
out = new PrintWriter(new FileWriter(nomefile))
while (true) {
line = br.readLine();
if (line==null) {
break;                 }
//Stampa a video del contenuto del file di testo
//System.out.println(line);
//Scrive il contenuto su un file
out.println(line);}
try {
out.close();
return file;}

ho capito che il problema è quando faccio la doss.close nel server ma se non la faccio il client resta in attesa della fine del file
sapete dirmi qualcosa???grazie

[andbin]

Originariamente inviato da AtoXx
mi si chiude la connessione ed io non voglio che si chiuda.

Domanda: e perché non vuoi che si chiuda? Forse .... perché vuoi gestire più trasferimenti con la stessa connessione? Allora bene, ok. Ma devi stabilire un "protocollo" di comunicazione, anche minimale.

E la cosa più semplice in questi casi è quella di inviare prima dello stream di dati del file una informazione sulla lunghezza di questo stream. Questa comunque è una regola abbastanza generale, quella cioè di anticipare al destinatario quanti byte si deve aspettare.

Visto che usi DataOutputStream, semplicemente scrivi un int che indica la lunghezza del file. E il destinatario (l'altro host nel tuo caso il client) saprà da subito quanti byte aspettarsi e quindi potrà operare di conseguenza.

E nota che a meno tu sappia che i file sono relativamente piccoli, NON dovresti istanziare un array per l'intero file! In questi casi basta leggere/scrivere a blocchi di N byte (in genere un buffer di lunghezza fissa, es. 1024 byte o giù di lì ...).

[AtoXx]

Originariamente inviato da andbin
Domanda: e perché non vuoi che si chiuda? Forse .... perché vuoi gestire più trasferimenti con la stessa connessione? Allora bene, ok. Ma devi stabilire un "protocollo" di comunicazione, anche minimale.

E la cosa più semplice in questi casi è quella di inviare prima dello stream di dati del file una informazione sulla lunghezza di questo stream. Questa comunque è una regola abbastanza generale, quella cioè di anticipare al destinatario quanti byte si deve aspettare.

Visto che usi DataOutputStream, semplicemente scrivi un int che indica la lunghezza del file. E il destinatario (l'altro host nel tuo caso il client) saprà da subito quanti byte aspettarsi e quindi potrà operare di conseguenza.

E nota che a meno tu sappia che i file sono relativamente piccoli, NON dovresti istanziare un array per l'intero file! In questi casi basta leggere/scrivere a blocchi di N byte (in genere un buffer di lunghezza fissa, es. 1024 byte o giù di lì ...).

Ti ringrazio per l'aiuto intanto.
Si, non voglio chiudere la connessione perchè voglio esguire un paio di cose nella stessa connessione.

I file non arrivano ai 500kb quindi creo un vettore di 1024 elementi?
Il server sarà così allora?

byte buffer[] = new byte[1024];
dos.writeBytes(String.valueOf(fin.available())+"\n");
dis.readFully(buffer);
dos.write(buffer);

non ho capito come fare il client :S

[andbin]

Originariamente inviato da AtoXx

byte buffer[] = new byte[1024];
dos.writeBytes(String.valueOf(fin.available())+"\n");
dis.readFully(buffer);
dos.write(buffer);

No, devi anche fare un ciclo da eseguire finché hai qualcosa e nota, senza usare readFully. Guarda ed osserva bene il ciclo while nel mio esempio FileCopy. Quello è il modo appropriato.

[AtoXx]

Originariamente inviato da andbin
No, devi anche fare un ciclo da eseguire finché hai qualcosa e nota, senza usare readFully. Guarda ed osserva bene il ciclo while nel mio esempio FileCopy. Quello è il modo appropriato.

Grazie ancora per la risposta quindi questa parte di codice è quelal riferita al server(chi la invia)

byte[] buffer = new byte[4096];
int len;
while ((len = fis.read(buffer)) > 0) { 
fos.write(buffer, 0, len);}

Per la parte in ricezione devo leggere la grandezza del file che invio e poi devo fermarmi a leggere quando ho raggiunto la grandezza del file. Quello che non capisco è come e cosa devo usare per capire quando ho raggiunta la dimensione del file. Spero di essermi spiegato bene

[andbin]

Originariamente inviato da AtoXx
Quello che non capisco è come e cosa devo usare per capire quando ho raggiunta la dimensione del file. Spero di essermi spiegato bene

Leggi la dimensione e quindi ce l'hai chiaramente in una variabile es. byteRimanenti. Devi di nuovo fare un ciclo, simile a quello che ti ho indicato ma con una differenza molto importante: devi evitare che si legga di più di quella dimensione, cioè non devi "sforare". E questo lo fai con una logica banalissima (basta .... ragionare!).

Se istanzi un buffer di es. 4096 (o altro che ti pare) se byteRimanenti é maggiore di 4096, allora puoi richiedere 4096 byte, altrimenti devi richiedere il numero di byte indicati da byteRimanenti.
Quindi è anche evidente che non puoi usare la read(byte[]) ma devi usare l'altra versione che riceve offset (sarà sempre 0, l'inizio del buffer) e la lunghezza (che gestisci con la logica descritta).

E ovviamente man mano che leggi, il read ti dice quanto ha letto davvero e lo scali dalla variabile.

Ripeto ... basta ragionare ....

[AtoXx]

Originariamente inviato da andbin
Leggi la dimensione e quindi ce l'hai chiaramente in una variabile es. byteRimanenti. Devi di nuovo fare un ciclo, simile a quello che ti ho indicato ma con una differenza molto importante: devi evitare che si legga di più di quella dimensione, cioè non devi "sforare". E questo lo fai con una logica banalissima (basta .... ragionare!).

Se istanzi un buffer di es. 4096 (o altro che ti pare) se byteRimanenti é maggiore di 4096, allora puoi richiedere 4096 byte, altrimenti devi richiedere il numero di byte indicati da byteRimanenti.
Quindi è anche evidente che non puoi usare la read(byte[]) ma devi usare l'altra versione che riceve offset (sarà sempre 0, l'inizio del buffer) e la lunghezza (che gestisci con la logica descritta).

E ovviamente man mano che leggi, il read ti dice quanto ha letto davvero e lo scali dalla variabile.

Ripeto ... basta ragionare ....

Ho provato a farlo così il client ma niente

File file=new File(nomefile);
int n;
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(nomefile));
br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
byte[] rc = new byte[4096];
while ((n=br.read())==-1) {              
bos.write(rc,0,n);              }
bos.close

[andbin]

Originariamente inviato da AtoXx

BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(nomefile));
br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
byte[] rc = new byte[4096];
while ((n=br.read())==-1) {              
bos.write(rc,0,n);              }
bos.close

No, mi spiace, non va bene e per diversi motivi:
a) Stai trattando byte, non caratteri. Quindi non devi usare BufferedReader ma al massimo un DataInputStream (visto che centra anche la scrittura/lettura di un int per la lunghezza).
b) Se il mittente scrive una "intestazione" con un int che indica la lunghezza, nel destinatario devi leggerlo (appunto con DataInputStream).
c) Poi comunque dovresti usare la lettura a blocchi e con la logica che ho esposto prima (rileggi, prego).

[AtoXx]

Originariamente inviato da andbin
No, mi spiace, non va bene e per diversi motivi:
a) Stai trattando byte, non caratteri. Quindi non devi usare BufferedReader ma al massimo un DataInputStream (visto che centra anche la scrittura/lettura di un int per la lunghezza).
b) Se il mittente scrive una "intestazione" con un int che indica la lunghezza, nel destinatario devi leggerlo (appunto con DataInputStream).
c) Poi comunque dovresti usare la lettura a blocchi e con la logica che ho esposto prima (rileggi, prego).

Sai che ti dico, per oggi basta va. Domani mattina se ne parla grazie ancora per l'aiuto mi farò sentire domani mi sento un

[AtoXx]

ho risolto così:
parte di codice per inviare un file

OutputStream s1out = socket.getOutputStream();
FileInputStream fin = new FileInputStream(nome);
dos = new DataOutputStream(s1out);
dis = new DataInputStream(fin);
byte buffer[] = new byte[dis.available()]; 
ObjectOutputStream oos = new ObjectOutputStream( socket.getOutputStream() );             
fin.read(buffer);             
oos.writeObject( buffer );             
System.out.println("File Inviato!");

parte per ricevere

 
ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());             
File file = new File(nome);             
byte[] pacchetto = null; 
// Ricevo il pacchetto dati             
try {                 
pacchetto = (byte[]) ois.readObject();             
} catch (Exception e) {                 
System.err.println("Errore nel byte[]" + e.getMessage());             
}  
// Lo scrivo nel file di destinazione             
FileOutputStream fos = new FileOutputStream(ricevuti + nome + ".xml");
fos.write(pacchetto);             
fos.close();

Grazie per l'aiuto andbin