Wie kann ich eine Datei mit Java aus dem Internet herunterladen und speichern?

Es gibt eine Online-Datei (z. B. http://www.example.com/information.asp), die ich abrufen und in einem Verzeichnis speichern muss. Ich weiß, dass es verschiedene Methoden gibt, um Online-Dateien (URLs) zeilenweise abzurufen und zu lesen, aber gibt es eine Möglichkeit, die Datei einfach mit Java herunterzuladen und zu speichern?

Probieren Sie Java NIO aus :

URL website = new URL("http://www.website.com/information.asp");
ReadableByteChannel rbc = Channels.newChannel(website.openStream());
FileOutputStream fos = new FileOutputStream("information.html");
fos.getChannel().transferFrom(rbc, 0, Long.MAX_VALUE);

Die Verwendung transferFrom()ist möglicherweise viel effizienter als eine einfache Schleife, die aus dem Quellkanal liest und in diesen Kanal schreibt. Viele Betriebssysteme können Bytes direkt vom Quellkanal in den Dateisystem-Cache übertragen, ohne sie tatsächlich zu kopieren.

Lesen Sie hier mehr darüber .

Hinweis : Der dritte Parameter in transferFrom ist die maximale Anzahl der zu übertragenden Bytes. Integer.MAX_VALUEüberträgt höchstens 2 ^ 31 Bytes, Long.MAX_VALUEerlaubt höchstens 2 ^ 63 Bytes (größer als jede existierende Datei).

Verwenden Sie Apache Commons-Io , nur einen Zeilencode:

FileUtils.copyURLToFile(URL, File)

Einfachere Verwendung:

URL website = new URL("http://www.website.com/information.asp");
try (InputStream in = website.openStream()) {
    Files.copy(in, target, StandardCopyOption.REPLACE_EXISTING);
}

public void saveUrl(final String filename, final String urlString)
        throws MalformedURLException, IOException {
    BufferedInputStream in = null;
    FileOutputStream fout = null;
    try {
        in = new BufferedInputStream(new URL(urlString).openStream());
        fout = new FileOutputStream(filename);

        final byte data[] = new byte[1024];
        int count;
        while ((count = in.read(data, 0, 1024)) != -1) {
            fout.write(data, 0, count);
        }
    } finally {
        if (in != null) {
            in.close();
        }
        if (fout != null) {
            fout.close();
        }
    }
}

Sie müssen Ausnahmen behandeln, wahrscheinlich außerhalb dieser Methode.

Es ist eine alte Frage, aber hier ist eine übersichtliche, lesbare Lösung nur für JDK mit ordnungsgemäß geschlossenen Ressourcen:

public static void download(String url, String fileName) throws Exception {
    try (InputStream in = URI.create(url).toURL().openStream()) {
        Files.copy(in, Paths.get(fileName));
    }
}

Zwei Codezeilen und keine Abhängigkeiten.

Um eine Datei herunterzuladen, müssen Sie sie lesen. In beiden Fällen müssen Sie die Datei auf irgendeine Weise durchgehen. Anstelle von Zeile für Zeile können Sie es einfach in Bytes aus dem Stream lesen:

BufferedInputStream in = new BufferedInputStream(new URL("http://www.website.com/information.asp").openStream())
    byte data[] = new byte[1024];
    int count;
    while((count = in.read(data,0,1024)) != -1)
    {
        out.write(data, 0, count);
    }

Verwenden Sie bei Java 7+Verwendung die folgende Methode, um eine Datei aus dem Internet herunterzuladen und in einem Verzeichnis zu speichern:

private static Path download(String sourceURL, String targetDirectory) throws IOException
{
    URL url = new URL(sourceURL);
    String fileName = sourceURL.substring(sourceURL.lastIndexOf('/') + 1, sourceURL.length());
    Path targetPath = new File(targetDirectory + File.separator + fileName).toPath();
    Files.copy(url.openStream(), targetPath, StandardCopyOption.REPLACE_EXISTING);

    return targetPath;
}

Dokumentation hier .

Diese Antwort entspricht fast genau der ausgewählten Antwort, weist jedoch zwei Verbesserungen auf: Es handelt sich um eine Methode, mit der das FileOutputStream-Objekt geschlossen wird:

    public static void downloadFileFromURL(String urlString, File destination) {    
        try {
            URL website = new URL(urlString);
            ReadableByteChannel rbc;
            rbc = Channels.newChannel(website.openStream());
            FileOutputStream fos = new FileOutputStream(destination);
            fos.getChannel().transferFrom(rbc, 0, Long.MAX_VALUE);
            fos.close();
            rbc.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

import java.io.*;
import java.net.*;

public class filedown {
    public static void download(String address, String localFileName) {
        OutputStream out = null;
        URLConnection conn = null;
        InputStream in = null;

        try {
            URL url = new URL(address);
            out = new BufferedOutputStream(new FileOutputStream(localFileName));
            conn = url.openConnection();
            in = conn.getInputStream();
            byte[] buffer = new byte[1024];

            int numRead;
            long numWritten = 0;

            while ((numRead = in.read(buffer)) != -1) {
                out.write(buffer, 0, numRead);
                numWritten += numRead;
            }

            System.out.println(localFileName + "\t" + numWritten);
        } 
        catch (Exception exception) { 
            exception.printStackTrace();
        } 
        finally {
            try {
                if (in != null) {
                    in.close();
                }
                if (out != null) {
                    out.close();
                }
            } 
            catch (IOException ioe) {
            }
        }
    }

    public static void download(String address) {
        int lastSlashIndex = address.lastIndexOf('/');
        if (lastSlashIndex >= 0 &&
        lastSlashIndex < address.length() - 1) {
            download(address, (new URL(address)).getFile());
        } 
        else {
            System.err.println("Could not figure out local file name for "+address);
        }
    }

    public static void main(String[] args) {
        for (int i = 0; i < args.length; i++) {
            download(args[i]);
        }
    }
}

Persönlich habe ich festgestellt, dass Apaches HttpClient mehr als fähig ist, alles zu tun, was ich dazu tun muss. Hier ist ein großartiges Tutorial zur Verwendung von HttpClient

Dies ist eine weitere Java7-Variante, die auf der Antwort von Brian Risk unter Verwendung der Try- With-Anweisung basiert :

public static void downloadFileFromURL(String urlString, File destination) throws Throwable {

      URL website = new URL(urlString);
      try(
              ReadableByteChannel rbc = Channels.newChannel(website.openStream());
              FileOutputStream fos = new FileOutputStream(destination);  
              ){
          fos.getChannel().transferFrom(rbc, 0, Long.MAX_VALUE);
      }

  }

Es ist möglich, die Datei mit Apache's HttpComponentsanstelle von herunterzuladen Commons-IO. Mit diesem Code können Sie eine Datei in Java entsprechend ihrer URL herunterladen und am jeweiligen Ziel speichern.

public static boolean saveFile(URL fileURL, String fileSavePath) {

    boolean isSucceed = true;

    CloseableHttpClient httpClient = HttpClients.createDefault();

    HttpGet httpGet = new HttpGet(fileURL.toString());
    httpGet.addHeader("User-Agent", "Mozilla/5.0 (Windows NT 6.3; WOW64; rv:34.0) Gecko/20100101 Firefox/34.0");
    httpGet.addHeader("Referer", "https://www.google.com");

    try {
        CloseableHttpResponse httpResponse = httpClient.execute(httpGet);
        HttpEntity fileEntity = httpResponse.getEntity();

        if (fileEntity != null) {
            FileUtils.copyInputStreamToFile(fileEntity.getContent(), new File(fileSavePath));
        }

    } catch (IOException e) {
        isSucceed = false;
    }

    httpGet.releaseConnection();

    return isSucceed;
}

Im Gegensatz zur einzelnen Codezeile:

FileUtils.copyURLToFile(fileURL, new File(fileSavePath),
                        URLS_FETCH_TIMEOUT, URLS_FETCH_TIMEOUT);

Dieser Code wird Ihnen mehr Kontrolle über einen Prozess geben und lassen Sie sich nicht nur Auszeiten geben aber User-Agentund RefererWerte, die für Websites , Web-many kritisch sind.

Hier gibt es viele elegante und effiziente Antworten. Aber die Prägnanz kann dazu führen, dass wir einige nützliche Informationen verlieren. Insbesondere möchte man einen Verbindungsfehler oft nicht als Ausnahme betrachten , und man möchte möglicherweise einige netzwerkbezogene Fehler anders behandeln - zum Beispiel, um zu entscheiden, ob wir den Download wiederholen sollten.

Hier ist eine Methode, die keine Ausnahmen für Netzwerkfehler auslöst (nur für wirklich außergewöhnliche Probleme wie fehlerhafte URLs oder Probleme beim Schreiben in die Datei).

/**
 * Downloads from a (http/https) URL and saves to a file. 
 * Does not consider a connection error an Exception. Instead it returns:
 *  
 *    0=ok  
 *    1=connection interrupted, timeout (but something was read)
 *    2=not found (FileNotFoundException) (404) 
 *    3=server error (500...) 
 *    4=could not connect: connection timeout (no internet?) java.net.SocketTimeoutException
 *    5=could not connect: (server down?) java.net.ConnectException
 *    6=could not resolve host (bad host, or no internet - no dns)
 * 
 * @param file File to write. Parent directory will be created if necessary
 * @param url  http/https url to connect
 * @param secsConnectTimeout Seconds to wait for connection establishment
 * @param secsReadTimeout Read timeout in seconds - trasmission will abort if it freezes more than this 
 * @return See above
 * @throws IOException Only if URL is malformed or if could not create the file
 */
public static int saveUrl(final Path file, final URL url, 
  int secsConnectTimeout, int secsReadTimeout) throws IOException {
    Files.createDirectories(file.getParent()); // make sure parent dir exists , this can throw exception
    URLConnection conn = url.openConnection(); // can throw exception if bad url
    if( secsConnectTimeout > 0 ) conn.setConnectTimeout(secsConnectTimeout * 1000);
    if( secsReadTimeout > 0 ) conn.setReadTimeout(secsReadTimeout * 1000);
    int ret = 0;
    boolean somethingRead = false;
    try (InputStream is = conn.getInputStream()) {
        try (BufferedInputStream in = new BufferedInputStream(is); OutputStream fout = Files
                .newOutputStream(file)) {
            final byte data[] = new byte[8192];
            int count;
            while((count = in.read(data)) > 0) {
                somethingRead = true;
                fout.write(data, 0, count);
            }
        }
    } catch(java.io.IOException e) { 
        int httpcode = 999;
        try {
            httpcode = ((HttpURLConnection) conn).getResponseCode();
        } catch(Exception ee) {}
        if( somethingRead && e instanceof java.net.SocketTimeoutException ) ret = 1;
        else if( e instanceof FileNotFoundException && httpcode >= 400 && httpcode < 500 ) ret = 2; 
        else if( httpcode >= 400 && httpcode < 600 ) ret = 3; 
        else if( e instanceof java.net.SocketTimeoutException ) ret = 4; 
        else if( e instanceof java.net.ConnectException ) ret = 5; 
        else if( e instanceof java.net.UnknownHostException ) ret = 6;  
        else throw e;
    }
    return ret;
}

Unten finden Sie den Beispielcode zum Herunterladen von Filmen aus dem Internet mit Java-Code:

URL url = new 
URL("http://103.66.178.220/ftp/HDD2/Hindi%20Movies/2018/Hichki%202018.mkv");
    BufferedInputStream bufferedInputStream = new  BufferedInputStream(url.openStream());
    FileOutputStream stream = new FileOutputStream("/home/sachin/Desktop/test.mkv");


    int count=0;
    byte[] b1 = new byte[100];

    while((count = bufferedInputStream.read(b1)) != -1) {
        System.out.println("b1:"+b1+">>"+count+ ">> KB downloaded:"+new File("/home/sachin/Desktop/test.mkv").length()/1024);
        stream.write(b1, 0, count);
    }

Es gibt ein Problem mit der einfachen Verwendung von:

org.apache.commons.io.FileUtils.copyURLToFile(URL, File) 

Wenn Sie sehr große Dateien herunterladen und speichern müssen oder wenn Sie im Allgemeinen automatische Wiederholungsversuche benötigen, falls die Verbindung unterbrochen wird.

Was ich in solchen Fällen vorschlage, ist Apache HttpClient zusammen mit org.apache.commons.io.FileUtils. Zum Beispiel:

GetMethod method = new GetMethod(resource_url);
try {
    int statusCode = client.executeMethod(method);
    if (statusCode != HttpStatus.SC_OK) {
        logger.error("Get method failed: " + method.getStatusLine());
    }       
    org.apache.commons.io.FileUtils.copyInputStreamToFile(
        method.getResponseBodyAsStream(), new File(resource_file));
    } catch (HttpException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
    method.releaseConnection();
}

Um frühere Antworten zusammenzufassen (und irgendwie zu polieren und zu aktualisieren). Die drei folgenden Methoden sind praktisch gleichwertig. (Ich habe explizite Zeitüberschreitungen hinzugefügt, weil ich denke, dass sie ein Muss sind. Niemand möchte, dass ein Download für immer einfriert, wenn die Verbindung unterbrochen wird.)

public static void saveUrl1(final Path file, final URL url,
   int secsConnectTimeout, int secsReadTimeout)) 
    throws MalformedURLException, IOException {
    // Files.createDirectories(file.getParent()); // optional, make sure parent dir exists
    try (BufferedInputStream in = new BufferedInputStream(
       streamFromUrl(url, secsConnectTimeout,secsReadTimeout)  );
        OutputStream fout = Files.newOutputStream(file)) {
        final byte data[] = new byte[8192];
        int count;
        while((count = in.read(data)) > 0)
            fout.write(data, 0, count);
    }
}

public static void saveUrl2(final Path file, final URL url,
   int secsConnectTimeout, int secsReadTimeout))  
    throws MalformedURLException, IOException {
    // Files.createDirectories(file.getParent()); // optional, make sure parent dir exists
    try (ReadableByteChannel rbc = Channels.newChannel(
      streamFromUrl(url, secsConnectTimeout,secsReadTimeout) 
        );
        FileChannel channel = FileChannel.open(file,
             StandardOpenOption.CREATE, 
             StandardOpenOption.TRUNCATE_EXISTING,
             StandardOpenOption.WRITE) 
        ) {
        channel.transferFrom(rbc, 0, Long.MAX_VALUE);
    }
}

public static void saveUrl3(final Path file, final URL url, 
   int secsConnectTimeout, int secsReadTimeout))  
    throws MalformedURLException, IOException {
    // Files.createDirectories(file.getParent()); // optional, make sure parent dir exists
    try (InputStream in = streamFromUrl(url, secsConnectTimeout,secsReadTimeout) ) {
        Files.copy(in, file, StandardCopyOption.REPLACE_EXISTING);
    }
}

public static InputStream streamFromUrl(URL url,int secsConnectTimeout,int secsReadTimeout) throws IOException {
    URLConnection conn = url.openConnection();
    if(secsConnectTimeout>0) conn.setConnectTimeout(secsConnectTimeout*1000);
    if(secsReadTimeout>0) conn.setReadTimeout(secsReadTimeout*1000);
    return conn.getInputStream();
}

Ich finde keine signifikanten Unterschiede, alle scheinen mir richtig zu sein. Sie sind sicher und effizient. (Geschwindigkeitsunterschiede scheinen kaum relevant zu sein - ich schreibe 180 MB vom lokalen Server auf eine SSD-Festplatte in Zeiten, die zwischen 1,2 und 1,5 Segmenten schwanken). Sie benötigen keine externen Bibliotheken. Alle arbeiten mit beliebigen Größen und (meiner Erfahrung nach) HTTP-Umleitungen.

Darüber hinaus werden alle ausgelöst, FileNotFoundExceptionwenn die Ressource nicht gefunden wird (normalerweise Fehler 404) und java.net.UnknownHostExceptionwenn die DNS-Auflösung fehlgeschlagen ist. andere IOException entsprechen Fehlern während der Übertragung.

(Als Community-Wiki markiert, können Sie gerne Informationen oder Korrekturen hinzufügen.)

Es gibt die Methode U.fetch (url) in der Unterstrich-Java- Bibliothek.

pom.xml:

  <groupId>com.github.javadev</groupId>
  <artifactId>underscore</artifactId>
  <version>1.45</version>

Codebeispiel:

import com.github.underscore.lodash.U;

public class Download {
    public static void main(String ... args) {
        String text = U.fetch("https://stackoverflow.com/questions"
        + "/921262/how-to-download-and-save-a-file-from-internet-using-java").text();
    }
}

public class DownloadManager {

    static String urls = "[WEBSITE NAME]";

    public static void main(String[] args) throws IOException{
        URL url = verify(urls);
        HttpURLConnection connection = (HttpURLConnection) url.openConnection();
        InputStream in = null;
        String filename = url.getFile();
        filename = filename.substring(filename.lastIndexOf('/') + 1);
        FileOutputStream out = new FileOutputStream("C:\\Java2_programiranje/Network/DownloadTest1/Project/Output" + File.separator + filename);
        in = connection.getInputStream();
        int read = -1;
        byte[] buffer = new byte[4096];
        while((read = in.read(buffer)) != -1){
            out.write(buffer, 0, read);
            System.out.println("[SYSTEM/INFO]: Downloading file...");
        }
        in.close();
        out.close();
        System.out.println("[SYSTEM/INFO]: File Downloaded!");
    }
    private static URL verify(String url){
        if(!url.toLowerCase().startsWith("http://")) {
            return null;
        }
        URL verifyUrl = null;

        try{
            verifyUrl = new URL(url);
        }catch(Exception e){
            e.printStackTrace();
        }
        return verifyUrl;
    }
}

Sie können dies mit Netloader für Java in einer Zeile tun :

new NetFile(new File("my/zips/1.zip"), "https://example.com/example.zip", -1).load(); //returns true if succeed, otherwise false.

Wenn Sie sich hinter einem Proxy befinden, können Sie die Proxys im Java-Programm wie folgt festlegen:

        Properties systemSettings = System.getProperties();
        systemSettings.put("proxySet", "true");
        systemSettings.put("https.proxyHost", "https proxy of your org");
        systemSettings.put("https.proxyPort", "8080");

Wenn Sie sich nicht hinter einem Proxy befinden, fügen Sie die obigen Zeilen nicht in Ihren Code ein. Vollständiger Arbeitscode zum Herunterladen einer Datei, wenn Sie sich hinter einem Proxy befinden.

public static void main(String[] args) throws IOException {
        String url="https://raw.githubusercontent.com/bpjoshi/fxservice/master/src/test/java/com/bpjoshi/fxservice/api/TradeControllerTest.java";
        OutputStream outStream=null;
        URLConnection connection=null;
        InputStream is=null;
        File targetFile=null;
        URL server=null;
        //Setting up proxies
        Properties systemSettings = System.getProperties();
            systemSettings.put("proxySet", "true");
            systemSettings.put("https.proxyHost", "https proxy of my organisation");
            systemSettings.put("https.proxyPort", "8080");
            //The same way we could also set proxy for http
            System.setProperty("java.net.useSystemProxies", "true");
            //code to fetch file
        try {
            server=new URL(url);
            connection = server.openConnection();
            is = connection.getInputStream();
            byte[] buffer = new byte[is.available()];
            is.read(buffer);

                targetFile = new File("src/main/resources/targetFile.java");
                outStream = new FileOutputStream(targetFile);
                outStream.write(buffer);
        } catch (MalformedURLException e) {
            System.out.println("THE URL IS NOT CORRECT ");
            e.printStackTrace();
        } catch (IOException e) {
            System.out.println("Io exception");
            e.printStackTrace();
        }
        finally{
            if(outStream!=null) outStream.close();
        }
    }

1. Methode mit dem neuen Kanal

ReadableByteChannel aq = Channels.newChannel(new url("https//asd/abc.txt").openStream());
FileOutputStream fileOS = new FileOutputStream("C:Users/local/abc.txt")
FileChannel writech = fileOS.getChannel();

2. Methode mit FileUtils

FileUtils.copyURLToFile(new url("https//asd/abc.txt",new local file on system("C":/Users/system/abc.txt"));

3. Methode mit

InputStream xy = new ("https//asd/abc.txt").openStream();

Auf diese Weise können wir Dateien mithilfe von Java-Basiscode und anderen Bibliotheken von Drittanbietern herunterladen. Diese dienen nur als Kurzreferenz. Bitte googeln Sie mit den oben genannten Schlüsselwörtern, um detaillierte Informationen und andere Optionen zu erhalten.