Как скачать и сохранить файлы из интернета в Java: полное руководство

import java.io.BufferedInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.net.URL;
import java.net.URLConnection;

public class FileDownloader {
public static void downloadFile(String fileURL, String saveDir) throws IOException {
// Получаем имя файла из URL
String fileName = fileURL.substring(fileURL.lastIndexOf("/") + 1);

// Создаем соединение
URL url = new URL(fileURL);
URLConnection connection = url.openConnection();

// Устанавливаем таймаут
connection.setConnectTimeout(5000);
connection.setReadTimeout(5000);

// Открываем потоки для чтения и записи
try (BufferedInputStream in = new BufferedInputStream(connection.getInputStream());
FileOutputStream fileOutputStream = new FileOutputStream(saveDir + fileName)) {

byte[] dataBuffer = new byte[1024];
int bytesRead;

// Читаем данные из входного потока и записываем в файл
while ((bytesRead = in.read(dataBuffer, 0, 1024)) != -1) {
fileOutputStream.write(dataBuffer, 0, bytesRead);
}
}

System.out.println("Файл успешно загружен: " + fileName);
}
}

URL url = new URL(fileURL);
HttpURLConnection httpConnection = (HttpURLConnection) url.openConnection();
httpConnection.setRequestMethod("GET");

// Можно добавить заголовки
httpConnection.setRequestProperty("User-Agent", "Mozilla/5.0");

// Проверить код ответа
int responseCode = httpConnection.getResponseCode();
if (responseCode != HttpURLConnection.HTTP_OK) {
throw new IOException("HTTP error code: " + responseCode);
}

import java.io.FileOutputStream;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.file.Path;
import java.time.Duration;

public class ModernFileDownloader {
public static void downloadFile(String fileUrl, String saveDir) throws Exception {
String fileName = fileUrl.substring(fileUrl.lastIndexOf("/") + 1);
Path filePath = Path.of(saveDir, fileName);

HttpClient client = HttpClient.newBuilder()
.version(HttpClient.Version.HTTP_2)
.connectTimeout(Duration.ofSeconds(10))
.build();

HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(fileUrl))
.timeout(Duration.ofMinutes(2))
.GET()
.build();

// Загрузка файла в память (подходит для небольших файлов)
HttpResponse<byte[]> response = client.send(request, HttpResponse.BodyHandlers.ofByteArray());

if (response.statusCode() == 200) {
try (FileOutputStream outputStream = new FileOutputStream(filePath.toFile())) {
outputStream.write(response.body());
}
System.out.println("Файл успешно загружен: " + fileName);
} else {
throw new RuntimeException("Ошибка загрузки: HTTP код " + response.statusCode());
}
}
}

HttpResponse<InputStream> response = client.send(request, HttpResponse.BodyHandlers.ofInputStream());

if (response.statusCode() == 200) {
try (InputStream in = response.body();
FileOutputStream out = new FileOutputStream(filePath.toFile())) {

byte[] buffer = new byte[8192];
int bytesRead;
while ((bytesRead = in.read(buffer)) != -1) {
out.write(buffer, 0, bytesRead);
}
}
}

// Асинхронная загрузка
CompletableFuture<HttpResponse<Path>> future = client.sendAsync(
request,
HttpResponse.BodyHandlers.ofFile(filePath)
);

future.thenAccept(response -> {
if (response.statusCode() == 200) {
System.out.println("Файл успешно загружен асинхронно: " + filePath.getFileName());
} else {
System.err.println("Ошибка загрузки: HTTP код " + response.statusCode());
}
});

import java.io.InputStream;
import java.security.MessageDigest;

public String calculateMD5(InputStream input) throws Exception {
MessageDigest md = MessageDigest.getInstance("MD5");
byte[] buffer = new byte[8192];
int read;

while ((read = input.read(buffer)) != -1) {
md.update(buffer, 0, read);
}

byte[] digest = md.digest();
StringBuilder sb = new StringBuilder();

for (byte b : digest) {
sb.append(String.format("%02x", b));
}

return sb.toString();
}

// Использование
String expectedMD5 = "a1b2c3d4e5f6..."; // Ожидаемый хеш
String actualMD5 = calculateMD5(new FileInputStream(downloadedFile));

if (!expectedMD5.equals(actualMD5)) {
throw new SecurityException("Контрольная сумма файла не совпадает!");
}

import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;

public void unzipFile(String zipFilePath, String destDirectory) throws IOException {
File destDir = new File(destDirectory);
if (!destDir.exists()) {
destDir.mkdir();
}

try (ZipInputStream zipIn = new ZipInputStream(new FileInputStream(zipFilePath))) {
ZipEntry entry = zipIn.getNextEntry();

while (entry != null) {
String filePath = destDirectory + File.separator + entry.getName();
if (!entry.isDirectory()) {
extractFile(zipIn, filePath);
} else {
File dir = new File(filePath);
dir.mkdir();
}
zipIn.closeEntry();
entry = zipIn.getNextEntry();
}
}
}

private void extractFile(ZipInputStream zipIn, String filePath) throws IOException {
try (BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(filePath))) {
byte[] bytesIn = new byte[4096];
int read;
while ((read = zipIn.read(bytesIn)) != -1) {
bos.write(bytesIn, 0, read);
}
}
}

public class FileMetadata {
private String fileName;
private String originalUrl;
private long fileSize;
private String contentType;
private LocalDateTime downloadTime;
private String md5Checksum;

// Геттеры, сеттеры и конструкторы
}

// Сохранение метаданных в JSON
public void saveMetadata(FileMetadata metadata, String filePath) throws IOException {
ObjectMapper mapper = new ObjectMapper();
mapper.registerModule(new JavaTimeModule()); // Для поддержки LocalDateTime
mapper.writeValue(new File(filePath + ".meta.json"), metadata);
}

import java.io.RandomAccessFile;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class MultiThreadedDownloader {

public void downloadFileWithMultipleThreads(String fileUrl, String outputPath, int threadCount) throws Exception {
URL url = new URL(fileUrl);
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setRequestMethod("HEAD");
long fileSize = conn.getContentLengthLong();
conn.disconnect();

// Создаем файл нужного размера
RandomAccessFile outputFile = new RandomAccessFile(outputPath, "rw");
outputFile.setLength(fileSize);
outputFile.close();

// Вычисляем размер каждой части
long partSize = fileSize / threadCount;

ExecutorService executorService = Executors.newFixedThreadPool(threadCount);
List<Future<?>> futures = new ArrayList<>();

// Запускаем загрузку каждой части в отдельном потоке
for (int i = 0; i < threadCount; i++) {
long startByte = i * partSize;
long endByte = (i == threadCount – 1) ? fileSize – 1 : (i + 1) * partSize – 1;

futures.add(executorService.submit(() -> {
try {
downloadPart(fileUrl, outputPath, startByte, endByte);
} catch (Exception e) {
throw new RuntimeException("Ошибка при загрузке части: " + e.getMessage(), e);
}
}));
}

// Дожидаемся завершения всех задач
for (Future<?> future : futures) {
future.get();
}

executorService.shutdown();
}

private void downloadPart(String fileUrl, String outputPath, long startByte, long endByte) throws Exception {
URL url = new URL(fileUrl);
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setRequestMethod("GET");
conn.setRequestProperty("Range", "bytes=" + startByte + "-" + endByte);

try (RandomAccessFile outputFile = new RandomAccessFile(outputPath, "rw")) {
outputFile.seek(startByte);

try (InputStream inputStream = conn.getInputStream()) {
byte[] buffer = new byte[8192];
int bytesRead;

while ((bytesRead = inputStream.read(buffer)) != -1) {
outputFile.write(buffer, 0, bytesRead);
}
}
}

conn.disconnect();
}
}

public class ProgressInputStream extends FilterInputStream {
private final ProgressListener listener;
private final long totalSize;
private long downloadedBytes;

public ProgressInputStream(InputStream in, long totalSize, ProgressListener listener) {
super(in);
this.listener = listener;
this.totalSize = totalSize;
this.downloadedBytes = 0;
}

@Override
public int read() throws IOException {
int b = super.read();
if (b != -1) {
downloadedBytes++;
notifyListener();
}
return b;
}

@Override
public int read(byte[] b, int off, int len) throws IOException {
int bytesRead = super.read(b, off, len);
if (bytesRead != -1) {
downloadedBytes += bytesRead;
notifyListener();
}
return bytesRead;
}

private void notifyListener() {
if (listener != null) {
listener.onProgress(downloadedBytes, totalSize);
}
}

public interface ProgressListener {
void onProgress(long downloaded, long total);
}
}

// Использование с Swing-интерфейсом
public void downloadWithProgress(String fileUrl, String outputPath) throws Exception {
URL url = new URL(fileUrl);
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
long fileSize = conn.getContentLengthLong();

JFrame frame = new JFrame("Загрузка файла");
JProgressBar progressBar = new JProgressBar(0, 100);
frame.add(progressBar);
frame.setSize(300, 80);
frame.setVisible(true);

ProgressInputStream.ProgressListener listener = (downloaded, total) -> {
int percentage = (int) (downloaded * 100 / total);
SwingUtilities.invokeLater(() -> progressBar.setValue(percentage));
};

try (ProgressInputStream inputStream = new ProgressInputStream(conn.getInputStream(), fileSize, listener);
FileOutputStream outputStream = new FileOutputStream(outputPath)) {
byte[] buffer = new byte[8192];
int bytesRead;

while ((bytesRead = inputStream.read(buffer)) != -1) {
outputStream.write(buffer, 0, bytesRead);
}
}

frame.dispose();
}

ExecutorService executorService = Executors.newFixedThreadPool(3); // Максимум 3 файла одновременно
List<String> filesToDownload = List.of(
"https://example.com/file1.zip",
"https://example.com/file2.pdf",
"https://example.com/file3.jpg"
);

List<Future<?>> downloadTasks = new ArrayList<>();

for (String fileUrl : filesToDownload) {
Future<?> future = executorService.submit(() -> {
try {
downloadFile(fileUrl, "/downloads/");
} catch (Exception e) {
System.err.println("Ошибка загрузки " + fileUrl + ": " + e.getMessage());
}
});
downloadTasks.add(future);
}

// Ожидание завершения всех загрузок
for (Future<?> task : downloadTasks) {
try {
task.get();
} catch (Exception e) {
// Обработка ошибки
}
}

executorService.shutdown();