[Java]Bestand oversturen via socket: wanneer EoF?

[RvL]

Hallo allemaal,

ik zit al de hele dag te zoeken naar een oplossing voor het volgende probleem. Ik een een server en een client applicatie. De Client verstuurd een bestand naar de server. Hiervoor heb ik de volgende code:

Java:

public void fileSender(String fileName) {
        File file = new File(fileName);
        int intFileSize = (int) file.length();
        System.out.println("FileSize: " + intFileSize);
        String strResponse = run("sendfile_" + intFileSize);

        System.out.println(strResponse);

        if (strResponse.equals("STARTSENDING")) {
            try {
                BufferedInputStream input = new BufferedInputStream(new
                        DataInputStream(new FileInputStream(
                                file)));
                BufferedOutputStream output = new BufferedOutputStream(new
                        DataOutputStream(socSocket.
                                         getOutputStream()));
                
                byte b[] = new byte[512];
                while (input.available() > 512) {
                    input.read(b);
                    output.write(b);
                    output.flush();
                }
                //strResponse = breReceiver.readLine();
                //System.out.println("Response: " + strResponse);

            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

De client verstuurd dus een commando + filesize naar de server: "SENDFILE_filesize". De server splitst dit commando, welke als string binnen komt, op in string strCommando en int fileSize. De fileSize wordt meegestuurd naar de volgende methode:

Java:

private void getFile(int intFileSize) {
        try {
            File file = new File("c:/temp/newFile/small.mp3");
            BufferedInputStream  in = new BufferedInputStream(socSocket.getInputStream());
            BufferedInputStream input = new BufferedInputStream(new DataInputStream(in));
            BufferedOutputStream output = new BufferedOutputStream(new DataOutputStream(new FileOutputStream(
                    file)));
            //boolean blnTrue = true;
            while (true) {
                output.write(input.read()); 
            }
            //System.out.println(file.length());
        } catch (Exception e) {
            System.out.println("ERROR: " + e);
        }
    }

Bovenstaande methode is natuurlijk niet zo netjes (while(true)) en levert ook een foutmelding op. Namelijk, zodra de client klaar is met verzenden kapt hij er mee.

Nu zou het zo moeten zijn dat de Server na het afronden van bovenstaande methode getFile() een string "TRANSFERCOMPLETE" terug stuurt naar de client (staat in een andere methode). Om te zorgen dat deze methode uberhaupt kan eindigen had ik

Java:

while (true) {
                output.write(input.read()); 
            }

veranderd in

Java:

while (file.length() < (long)(intFileSize -1000)) {
                output.write(input.read()); 
           }

maar op een of andere manier bereikt de file die op de server weg wordt geschreven nooit de filesize van de file op de server.

Is er een makkelijkere manier om dit te doen? Ik zat zelf te denken aan iets van een EoF, maar heb geen flauw idee hoe dit aan te pakken.

[Kwistnix]

Ik zou sowieso van de NIO lib gebruik maken.
Misschien een nuttige link: http://javaalmanac.com/egs/java.nio/pkg.html

[RvL]

Er moet toch ook een manier zijn om het op deze manier op te lossen?

Ik heb eerlijk gezegd geen tijd meer (project, slechte planning van de projectleiders, achterstand etc.) om me helemaal in de NIO lib in te lezen

[momania]

Een filesize lijkt me sowieso overbodig... zolang er data komt, komt er data

Verder zou ik dit:

Java:

byte b[] = new byte[512]; 

while (input.available() > 512) { 
  input.read(b); 
  output.write(b); 
  output.flush(); 
} 

Vervangen door:

Java:

byte b[] = new byte[512]; 

while (input.read(b) != -1) { 
  output.write(b); 
  output.flush(); 
} 

de read() method blijft nml. gewoon lezen tot er een -1 terug komt. De -1 betekend hier EOF

Voor het lezen van je bestand bij je server zal je dus ook even een byte[] als buffertje moeten maken en die meegeven in je read method();

Dus geen:

Java:

while (true) { 
  output.write(input.read());  
} 

want nu lees je byte voor byte, aangezien de read() method maar 1 byte terug geeft

maar:

Java:

byte b[] = new byte[512]; 

while (input.read(b)) { 
  output.write(b);  
} 
output.flush();

[Robtimus]

momania schreef op woensdag 15 juni 2005 @ 21:24:

Java:

byte b[] = new byte[512]; 

while (input.read(b)) { 
  output.write(b);  
} 
output.flush();

input.read(b) geeft geen boolean terug maar een int die het aantal gelezen bytes inhoudt. Dat kun je dan meteen gebruiken:

Java:

while ((num = input.read(b)) != -1) {
    output.write(b, 0, num);
}

Zo voorkom je dat je net wat teveel data wegschrijft als de laatste keer het array niet volledig ingelezen wordt.

[momania]

IceManX schreef op woensdag 15 juni 2005 @ 21:30:
[...]
input.read(b) geeft geen boolean terug maar een int die het aantal gelezen bytes inhoudt.

mmm, dat had ik in het eerste voorbeeld ook wel gebruikt.. maar het idee was duidelijk dacht ik

[farlane]

momania schreef op woensdag 15 juni 2005 @ 21:24:
Een filesize lijkt me sowieso overbodig... zolang er data komt, komt er data

Mja, maar hoort die data nog bij het bestand?

[Verwijderd]

Of een bestand met heel veel null-en in het midden...

[Voutloos]

farlane schreef op donderdag 16 juni 2005 @ 11:37:
[...]


Mja, maar hoort die data nog bij het bestand?

Er gaat iets fout (of niet 100% naar verwachting), maar precies de lengte pakken voor je bestand is niet de oplossing. Het einde van de stream mag je gewoon niet negeren.

Verwijderd schreef op donderdag 16 juni 2005 @ 12:09:
Of een bestand met heel veel null-en in het midden...

Wat er gelezen wordt maakt niet uit, als je maar geen fouten maakt als minder/meer kopieren dan er in je buffer zit oid.

Een stream is een stream.

[ Voor 3% gewijzigd door Voutloos op 16-06-2005 12:17 ]