Pobieranie pliku z paskiem postępu

import com.sun.net.httpserver.HttpServer;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetSocketAddress;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardCopyOption;
import java.time.Duration;
import java.util.Arrays;

/**
 * Strumieniowe pobieranie pliku z postępem — skryptyJAVA.pl
 * Zapisz jako: PobieranieZPostepem.java
 */
public class PobieranieZPostepem {

    private static final HttpClient KLIENT = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(5))
            .followRedirects(HttpClient.Redirect.NORMAL)
            .build();

    /** Pobiera adres do pliku, nie trzymając całej odpowiedzi w pamięci. */
    public static Path pobierz(URI adres, Path cel) throws IOException, InterruptedException {
        Path bezwzglednyCel = cel.toAbsolutePath();
        Path katalog = bezwzglednyCel.getParent();
        if (katalog != null) { Files.createDirectories(katalog); }
        Path czesciowy = bezwzglednyCel.resolveSibling(bezwzglednyCel.getFileName() + ".part");
        Files.deleteIfExists(czesciowy);

        HttpRequest zadanie = HttpRequest.newBuilder(adres)
                .timeout(Duration.ofMinutes(5)).GET().build();
        HttpResponse<InputStream> odpowiedz = KLIENT.send(
                zadanie, HttpResponse.BodyHandlers.ofInputStream());

        if (odpowiedz.statusCode() < 200 || odpowiedz.statusCode() > 299) {
            odpowiedz.body().close();
            throw new IOException("Serwer zwrócił HTTP " + odpowiedz.statusCode());
        }

        long rozmiar = odpowiedz.headers().firstValueAsLong("Content-Length").orElse(-1);
        long pobrano = 0;
        int ostatniProcent = -1;
        try (InputStream wejscie = odpowiedz.body();
             OutputStream wyjscie = Files.newOutputStream(czesciowy)) {
            byte[] bufor = new byte[16 * 1024];
            int liczba;
            while ((liczba = wejscie.read(bufor)) != -1) {
                wyjscie.write(bufor, 0, liczba);
                pobrano += liczba;
                if (rozmiar > 0) {
                    int procent = (int) Math.min(100, pobrano * 100 / rozmiar);
                    if (procent != ostatniProcent) {
                        System.out.printf("\rPobieranie: %3d%% (%d/%d bajtów)",
                                procent, pobrano, rozmiar);
                        ostatniProcent = procent;
                    }
                }
            }
        } catch (IOException blad) {
            Files.deleteIfExists(czesciowy);
            throw blad;
        }

        if (rozmiar >= 0 && pobrano != rozmiar) { // 0 to znany rozmiar, nie brak nagłówka
            Files.deleteIfExists(czesciowy);
            throw new IOException("Niepełny plik: oczekiwano " + rozmiar + ", odebrano " + pobrano);
        }
        System.out.println(ostatniProcent >= 0 ? "" : "Pobrano " + pobrano + " bajtów.");
        przeniesGotowyPlik(czesciowy, bezwzglednyCel);
        return bezwzglednyCel;
    }

    /** Najpierw próbuje ruchu atomowego; po dowolnym IOException ponawia zwykłe zastąpienie. */
    private static void przeniesGotowyPlik(Path zrodlo, Path cel) throws IOException {
        try {
            Files.move(zrodlo, cel, StandardCopyOption.ATOMIC_MOVE);
        } catch (IOException atomowy) {
            try {
                Files.move(zrodlo, cel, StandardCopyOption.REPLACE_EXISTING);
            } catch (IOException zwykly) {
                zwykly.addSuppressed(atomowy);
                throw zwykly;
            }
        }
    }

    /** Lokalny serwer testowy udostępnia dane w pamięci i nie korzysta z internetu. */
    private static HttpServer serwerTestowy(byte[] dane) throws IOException {
        HttpServer serwer = HttpServer.create(new InetSocketAddress("127.0.0.1", 0), 0);
        serwer.createContext("/plik.bin", wymiana -> {
            if (!wymiana.getRequestMethod().equalsIgnoreCase("GET")) {
                wymiana.sendResponseHeaders(405, -1);
                wymiana.close();
                return;
            }
            wymiana.getResponseHeaders().set("Content-Type", "application/octet-stream");
            wymiana.sendResponseHeaders(200, dane.length);
            try (OutputStream wyjscie = wymiana.getResponseBody()) {
                wyjscie.write(dane);
            }
        });
        return serwer;
    }

    // ── PRZYKŁADY ───────────────────────────────────────────
    public static void main(String[] args) throws Exception {
        byte[] dane = new byte[256 * 1024];
        for (int i = 0; i < dane.length; i++) { dane[i] = (byte) (i * 31); }
        HttpServer serwer = serwerTestowy(dane);
        Path katalog = Files.createTempDirectory("pobieranie-demo-");
        Path cel = katalog.resolve("pobrany-plik.bin");
        serwer.start();

        try {
            URI adres = URI.create("http://127.0.0.1:" + serwer.getAddress().getPort() + "/plik.bin");
            Path zapisany = pobierz(adres, cel);
            boolean zgodny = Arrays.equals(dane, Files.readAllBytes(zapisany));
            System.out.println("Zapisano: " + zapisany + "; dane zgodne: " + zgodny);
        } finally {
            serwer.stop(0);
            Files.deleteIfExists(cel);
            Files.deleteIfExists(cel.resolveSibling(cel.getFileName() + ".part"));
            Files.deleteIfExists(katalog);
        }
    }
}