Download Programm - Download endet vorzeitig (bricht ab)

tommey

Mitglied
Hi, ich hab eien kleines Downloadprogramm und den Dateidownload nach dieser Vorlage implementiert:

Java:
package downloader;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.ProtocolException;
import java.net.URL;

public class Downloader {
        public static void downloadFile(String url_str, OutputStream os)
            throws IllegalStateException, MalformedURLException,
            ProtocolException, IOException {

        URL url = new URL(url_str.replace(" ", "%20"));

        HttpURLConnection conn = (HttpURLConnection) url.openConnection();

        conn.setRequestMethod("GET");

        conn.connect();

        int responseCode = conn.getResponseCode();

        if (responseCode == HttpURLConnection.HTTP_OK) {

            byte tmp_buffer[] = new byte[4096];

            InputStream is = conn.getInputStream();

            int n;

            while ((n = is.read(tmp_buffer)) > 0) {
                os.write(tmp_buffer, 0, n);
                os.flush();
            }

        } else {
            throw new IllegalStateException("HTTP response: " + responseCode);
        }
    }

    public static void main(String[] args) {
        try {
            final String url = "http://www.ich.de/derBeste.bin";

            FileOutputStream fos = new FileOutputStream(System
                    .getProperty("user.home")
                    + File.separator + "derBeste.bin");

            downloadFile(url, fos);

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

            e.printStackTrace();
        }
    }
}



Da ich Paralleldownloads haben wollte, habe ich das ganze auf Threads aufgeteilt.

Mein Problem: Die Dateien werden manchmal, aber nicht immer abgebrochen. Der Download hört einfach auf, ohne Exception oder irgendwas.
Hat jemand eine Ahnung warum? Wird vielleicht die Verbindung Serverseitig unterbrochen?
 
Zuletzt bearbeitet:
Java:
throws IllegalStateException, MalformedURLException, ProtocolException, IOException


😕
 
Deine While-Schleife ist falsch. Mach >= 0 statt > 0. Wenn die Daten mal verzögert ankommen, dann durchaus zwischendrin auch mal 0 von read zurückgegeben werden.
 
[JAVA=9]import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.i😵utputStream;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.ProtocolException;
import java.net.URL;[/code]

Das sind viel zu viele Importe, das ganze geht viel kürzer.

[JAVA=2]import java.io.*;
import java.net.*;[/code]

Ansonsten sieht der Quellcode mit der Verbesserung von irgendjemand gut aus.
 
[JAVA=9]import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.i😵utputStream;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.ProtocolException;
import java.net.URL;[/code]

Das sind viel zu viele Importe, das ganze geht viel kürzer.

[JAVA=2]import java.io.*;
import java.net.*;[/code]

Ansonsten sieht der Quellcode mit der Verbesserung von irgendjemand gut aus.

1. Das Thema feiert demnächst sein 3 monatiges Jubiläum.
2. Was erhoffst du dir durch das "kürzen" der Import's?
 
Tommey
du hast incorrecter weise in der loop progammiert. die method int read() kann jede negative wert zurueckgeben. Nur da -1 bedeuted EOF. Korrect waere:
Java:
            while ((n = is.read(tmp_buffer)) != -1) {
                os.write(tmp_buffer, 0, n);
                os.flush();
            }
 
Zuletzt bearbeitet:
Tommey
du hast incorrecter weise in der loop progammiert. die method int read() kann jede negative wert zurueckgeben. Nur da -1 bedeuted EOF. Korrect waere:
Java:
            while ((n = is.read(tmp_buffer)) != -1) {
                os.write(tmp_buffer, 0, n);
                os.flush();
            }
Falsch, das ist völlig inkorrekt (mit k). Denn _würde_ read den Wert -2 zurückgeben, dann würdest du so auch write mit der Länge -2 aufrufen.... von dem her ist es korrekt die Schleife nur bei >=0 zu durchlaufen und sonst abzubrechen. Wenn irgendwas < -1 kommen sollte dann ist das ein undefinierter Zustand in dem abgebrochen werden sollte.
 

Zurück
Oben