[Java] Bestand versturen via DatagramPacket

[Verwijderd]

Hoi allemaal.

Ik heb een client en een server geschreven waarmee ik pakketjes heen en weer wil sturen. Pakketjes worden gemaakt van een byte array. Het probleem is dat volgens TCP je geen pakketjes groter dan 1500 bytes mag sturen.
Als ik een String wil sturen lukt het allemaal wel (ik maak er een byte array van met getBytes()). Alleen wil ik een groter bestand versturen. Deze moet ik dus zien te verkleinen naar pakketjes. Weet iemand hoe je dit het beste kan doen?

Dit is de code:

code:

    private DatagramPacket createPacket(byte[] outData)
    {
        DatagramPacket sendPacket = new DatagramPacket(outData,
                outData.length, serverAddress, SERVER_PORT);

        return sendPacket;
    }

Dit pakketje wordt vervolgens via een DatagramSocket verzonden:

code:

    private void sendPacket(DatagramPacket sendPacket)
    {
        try
        {
            socket.send(sendPacket);
        }
        catch (Exception e)
        {
            System.out.println(e.getMessage());
        }
    }

[JaWi]

Ehm, de maximale grootte van één TCP-pakketje mag niet meer dan 1500 bytes zijn; je kunt echter zoveel TCP-pakketjes achter elkaar sturen als je wilt. Over het opdelen in pakketjes zorgt je TCP-stack zelf voor, dat hoef jij niet meer te doen...

[Verwijderd]

Dat bedoel ik ook, ik wil ze acher elkaar versturen. Alleen dat opdelen moet je volgens mij wel zelf doen. Ik heb hnergens gevonden in het java doc dat DatagramPacket dit voor je doet.
En als ik een byte array van laten we zeggen 1,8MB dan krijg ik een exception dat het pakketje te groot is.

[JaWi]

Hmm, ik lees net je openingspost eens goed en een DatagramPacket is equivalent aan een UDP pakketje (en heeft dus een max.grootte van 65535 bytes); maar zorgen normale Java-streams niet voor automatische fragmentatie van je data?

[Verwijderd]

JaWi schreef op zondag 05 juni 2005 @ 15:53:
Hmm, ik lees net je openingspost eens goed en een DatagramPacket is equivalent aan een UDP pakketje

Sowieso wil je geen bestanden versturen met UDP.

[CubicQ]

Ach waarom niet? De halve Unix wereld doet/deed het met NFS. Zolang je maar weet waar je mee bezig bent en je er voor zorgt dat je ergens controles inbouwd of datgene wat je verstuurd hebt datgene is wat je ontvangen hebt; er is geen enkele reden om dat perse in je transportlaag te willen doen.

[Verwijderd]

CubicQ schreef op zondag 05 juni 2005 @ 16:43:
Ach waarom niet?

Omdat je misschien niet het wiel opnieuw wilt uitvinden?

[CubicQ]

Als je het wiel niet opnieuw wilt uitvinden ga je het ook niet direct over TCP doen Dan pak je een bestaand component.

Maar om toch nog een beetje constructief te zijn: Roux, kijk eens naar java.net.Socket, getOutputStream() en getInputStream().

[Eelke Spaak]

Ik zal het even kort samenvatten voor de TS .

Je hebt twee (belangrijke) netwerkprotocollen die in Java makkelijk gebruikt kunnen worden: UDP en TCP. UDP gebruik je voor dataverkeer direct op basis van pakketjes, daar ben je nu dus mee bezig. UDP biedt ook geen garantie dat bepaalde data aankomt. TCP werkt op basis van Sockets. Deze Sockets vertalen onderliggend automatisch naar IP-pakketjes, maar jij kan gewoon willekeurige hoeveelheden data in de streams van een socket stoppen, die komen er aan de andere kant weer uit. Tevens biedt TCP garantie dat alle data die verstuurd wordt, ook daadwerkelijk aankomt. Dat wil je dus gebruiken.

Zoals CubicQ dus al zei: kijk naar de java.net.Socket class.

Edit: De stelregel is: tenzij je goede reden hebt om UDP te gebruiken (streaming zooi etc.), gebruik TCP.

[ Voor 8% gewijzigd door Eelke Spaak op 06-06-2005 10:13 . Reden: stelregel ]

[Janoz]

Tevens biedt TCP garantie dat alle data die verstuurd wordt, ook daadwerkelijk aankomt.

...en ook in dezelfde volgorde.

[Swinnio]

Kijk anders een hier: http://java.sun.com/docs/...orking/sockets/index.html

[Soultaker]

Een aanvulling op Eelke Spaak: TCP en UDP zijn allebei gemodelleerd over IP; voor IP pakketjes geldt een maximumgrootte (MTU), die in principe variabel is (dat wil zeggen, de effectieve MTU is gelijk aan de kleinste MTU op het pad van verzender naar ontvanger) en alleen voor ethernetverbindingen standaard 1500 bytes is.

Hoe dan ook heb je hier als applicatieprogrammeur niets mee te maken aangezien IP pakketjes automatisch gefragmenteerd worden (opgesplitst in meerdere kleinere pakketjes dus) en bij de ontvanger weer worden samengevoegd. Toch is het versturen van hele grote pakketten geen goed idee omdat het hele pakket verloren gaat als er een enkel fragment verloren gaat; de kans op verlies neemt dus flink toe naarmate een pakket in meer fragmenten opgebroken moet worden.

CubicQ schreef op zondag 05 juni 2005 @ 16:43:
Ach waarom niet? De halve Unix wereld doet/deed het met NFS.

NFS stopt geen hele bestanden in UDP pakketjes hoor; in NFS zit een heleboel functionaliteit die overlapt met TCP. NFS is absoluut niet te vergelijken met de methode die de TS voorstaat en de TS kan dus beter gewoon TCP gebruiken.

NFS is ook een raar voorbeeld in de context van het versturen van bestanden, want op het internet (en dus niet binnen een LAN, waar NFS vooral gebruikt wordt) gebruikt iedereen HTTP en FTP, die de bestanden ook (bijna) naakt over een TCP-verbinding gooien.