Spring: полное руководство по скачиванию файлов из контроллера

@GetMapping("/download-file")
public ResponseEntity<Resource> downloadFile() throws IOException {
Path filePath = Paths.get("files/document.pdf");
Resource resource = new FileSystemResource(filePath);

return ResponseEntity.ok()
.header(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=\"" + resource.getFilename() + "\"")
.contentType(MediaType.APPLICATION_PDF)
.contentLength(resource.contentLength())
.body(resource);
}

String encodedFilename = URLEncoder.encode(originalFilename, StandardCharsets.UTF_8.toString())
.replaceAll("\\+", "%20");

return ResponseEntity.ok()
.header(HttpHeaders.CONTENT_DISPOSITION, 
"attachment; filename=\"" + encodedFilename + "\"; filename*=UTF-8''" + encodedFilename)
.body(resource);

// Предотвращение кэширования для динамических файлов
ResponseEntity.ok()
.header(HttpHeaders.CACHE_CONTROL, "no-cache, no-store, must-revalidate")
.header(HttpHeaders.PRAGMA, "no-cache")
.header(HttpHeaders.EXPIRES, "0")
.body(resource);

// Разрешение кэширования для статических файлов
ResponseEntity.ok()
.header(HttpHeaders.CACHE_CONTROL, "max-age=31536000")
.body(resource);

@GetMapping("/download-cached")
public ResponseEntity<Resource> downloadWithCaching(
@RequestHeader(value = HttpHeaders.IF_NONE_MATCH, required = false) String ifNoneMatch
) throws IOException {
Resource resource = new FileSystemResource("files/document.pdf");
String eTag = "\"" + DigestUtils.md5DigestAsHex(resource.getInputStream()) + "\"";

if (eTag.equals(ifNoneMatch)) {
return ResponseEntity.status(HttpStatus.NOT_MODIFIED).build();
}

return ResponseEntity.ok()
.eTag(eTag)
.contentType(MediaType.APPLICATION_PDF)
.body(resource);
}

@GetMapping("/download/disk-file/{fileName:.+}")
public ResponseEntity<Resource> downloadFileFromDisk(@PathVariable String fileName) {
try {
Path filePath = Paths.get("storage").resolve(fileName).normalize();
Resource resource = new FileSystemResource(filePath.toFile());

if (!resource.exists()) {
return ResponseEntity.notFound().build();
}

String contentType = Files.probeContentType(filePath);
if (contentType == null) {
contentType = "application/octet-stream";
}

return ResponseEntity.ok()
.contentType(MediaType.parseMediaType(contentType))
.header(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=\"" + resource.getFilename() + "\"")
.body(resource);

} catch (Exception e) {
return ResponseEntity.internalServerError().build();
}
}

@GetMapping("/download/database/{fileId}")
public ResponseEntity<Resource> downloadFileFromDatabase(@PathVariable Long fileId) {
Optional<FileEntity> fileEntityOpt = fileRepository.findById(fileId);

if (fileEntityOpt.isEmpty()) {
return ResponseEntity.notFound().build();
}

FileEntity fileEntity = fileEntityOpt.get();
ByteArrayResource resource = new ByteArrayResource(fileEntity.getData());

return ResponseEntity.ok()
.contentType(MediaType.parseMediaType(fileEntity.getContentType()))
.header(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=\"" + fileEntity.getFileName() + "\"")
.contentLength(resource.contentLength())
.body(resource);
}

@GetMapping("/download/dynamic-report")
public ResponseEntity<Resource> generateAndDownloadReport() {
try {
// Генерируем отчёт (например, PDF)
byte[] reportData = reportService.generatePdfReport();

ByteArrayResource resource = new ByteArrayResource(reportData);
LocalDateTime now = LocalDateTime.now();
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyyMMdd_HHmmss");
String filename = "report_" + formatter.format(now) + ".pdf";

return ResponseEntity.ok()
.contentType(MediaType.APPLICATION_PDF)
.header(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=\"" + filename + "\"")
.contentLength(reportData.length)
.body(resource);
} catch (Exception e) {
return ResponseEntity.internalServerError().build();
}
}

@GetMapping("/download/stream-large-file")
public ResponseEntity<Resource> streamLargeFile() throws IOException {
File file = new File("large_files/huge_dataset.zip");
InputStreamResource resource = new InputStreamResource(new FileInputStream(file));

return ResponseEntity.ok()
.contentType(MediaType.APPLICATION_OCTET_STREAM)
.header(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=\"huge_dataset.zip\"")
.contentLength(file.length())
.body(resource);
}

@GetMapping("/download/external/{resourceId}")
public ResponseEntity<Resource> downloadFromExternalService(
@PathVariable String resourceId,
@RequestParam(required = false) boolean inline) {

try {
// Получаем метаданные о файле
ExternalFileMetadata metadata = externalService.getFileMetadata(resourceId);
// Получаем поток с данными
InputStream dataStream = externalService.getFileStream(resourceId);

// Настраиваем заголовок Content-Disposition
String disposition = inline ? "inline" : "attachment";
String encodedFilename = URLEncoder.encode(metadata.getFilename(), StandardCharsets.UTF_8.toString())
.replaceAll("\\+", "%20");

InputStreamResource resource = new InputStreamResource(dataStream);

return ResponseEntity.ok()
.contentType(MediaType.parseMediaType(metadata.getContentType()))
.header(HttpHeaders.CONTENT_DISPOSITION, disposition + "; filename=\"" + 
encodedFilename + "\"; filename*=UTF-8''" + encodedFilename)
.body(resource);
} catch (Exception e) {
return ResponseEntity.status(HttpStatus.SERVICE_UNAVAILABLE)
.body(null);
}
}

@GetMapping("/view-pdf/{documentId}")
public ResponseEntity<Resource> viewPdf(@PathVariable Long documentId) {
try {
Document document = documentService.findById(documentId);
ByteArrayResource resource = new ByteArrayResource(document.getContent());

// Настройка для просмотра в браузере
return ResponseEntity.ok()
.contentType(MediaType.APPLICATION_PDF)
.header(HttpHeaders.CONTENT_DISPOSITION, "inline; filename=\"" + document.getFileName() + "\"")
.body(resource);
} catch (Exception e) {
return ResponseEntity.internalServerError().build();
}
}

@GetMapping("/export/excel")
public ResponseEntity<Resource> exportExcel() {
try {
byte[] excelData = reportService.generateExcelReport();
ByteArrayResource resource = new ByteArrayResource(excelData);

MediaType mediaType = MediaType.parseMediaType(
"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");

return ResponseEntity.ok()
.contentType(mediaType)
.header(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=\"report.xlsx\"")
.body(resource);
} catch (Exception e) {
return ResponseEntity.internalServerError().build();
}
}

@GetMapping("/images/{imageId}")
public ResponseEntity<Resource> getImage(
@PathVariable Long imageId,
@RequestParam(defaultValue = "true") boolean view) {

try {
ImageEntity image = imageRepository.findById(imageId)
.orElseThrow(() -> new ResourceNotFoundException("Image not found"));

ByteArrayResource resource = new ByteArrayResource(image.getData());

// Определяем Content-Type на основе типа изображения
String contentType = image.getContentType(); // например, "image/jpeg" или "image/png"

// Настраиваем отображение или скачивание
String disposition = view ? "inline" : "attachment";

return ResponseEntity.ok()
.contentType(MediaType.parseMediaType(contentType))
.header(HttpHeaders.CONTENT_DISPOSITION, 
disposition + "; filename=\"" + image.getFileName() + "\"")
.body(resource);
} catch (Exception e) {
return ResponseEntity.internalServerError().build();
}
}

// Определение MIME-типа с использованием Files.probeContentType
String contentType = Files.probeContentType(filePath);
if (contentType == null) {
contentType = "application/octet-stream"; // Тип по умолчанию
}

// Определение MIME-типа с использованием MimetypesFileTypeMap
MimetypesFileTypeMap fileTypeMap = new MimetypesFileTypeMap();
String contentType = fileTypeMap.getContentType(fileName);

// Определение MIME-типа с использованием Apache Tika
Tika tika = new Tika();
String contentType = tika.detect(file);

@GetMapping("/download/optimized/{fileId}")
public void downloadFileOptimized(
@PathVariable Long fileId,
HttpServletResponse response) throws IOException {

FileEntity file = fileRepository.findById(fileId)
.orElseThrow(() -> new ResourceNotFoundException("File not found"));

// Настройка заголовков ответа
response.setContentType(file.getContentType());
response.setHeader(HttpHeaders.CONTENT_DISPOSITION, 
"attachment; filename=\"" + URLEncoder.encode(file.getFileName(), StandardCharsets.UTF_8.toString()) + "\"");

// Использование потоков и буферизации для эффективной передачи
try (InputStream fileInputStream = fileStorage.getFileStream(file.getStoragePath());
OutputStream outputStream = response.getOutputStream()) {

byte[] buffer = new byte[8192]; // 8KB buffer
int bytesRead;
while ((bytesRead = fileInputStream.read(buffer)) != -1) {
outputStream.write(buffer, 0, bytesRead);
}
outputStream.flush();
}
}

@GetMapping("/secure-download/{fileId}")
public ResponseEntity<Resource> secureDownload(
@PathVariable Long fileId,
@RequestParam String token,
Authentication authentication) {

// Проверка токена доступа к файлу
if (!fileSecurityService.validateDownloadToken(fileId, token)) {
return ResponseEntity.status(HttpStatus.FORBIDDEN).build();
}

FileEntity file = fileRepository.findById(fileId)
.orElseThrow(() -> new ResourceNotFoundException("File not found"));

// Проверка прав доступа пользователя
UserDetails userDetails = (UserDetails) authentication.getPrincipal();
if (!filePermissionService.hasReadAccess(userDetails.getUsername(), file)) {
return ResponseEntity.status(HttpStatus.FORBIDDEN).build();
}

try {
Resource resource = fileStorageService.loadFileAsResource(file.getStoragePath());

// Очистка имени файла от специальных символов
String safeFilename = file.getFileName().replaceAll("[^a-zA-Z0-9.-]", "_");
String encodedFilename = URLEncoder.encode(safeFilename, StandardCharsets.UTF_8.toString())
.replaceAll("\\+", "%20");

return ResponseEntity.ok()
.contentType(MediaType.parseMediaType(file.getContentType()))
.header(HttpHeaders.CONTENT_DISPOSITION, 
"attachment; filename=\"" + encodedFilename + "\"")
.body(resource);
} catch (Exception e) {
return ResponseEntity.internalServerError().build();
}
}

@GetMapping("/async-download/{fileId}")
public DeferredResult<ResponseEntity<Resource>> asyncDownload(@PathVariable Long fileId) {
DeferredResult<ResponseEntity<Resource>> deferredResult = new DeferredResult<>(30000L); // 30-секундный таймаут

CompletableFuture.supplyAsync(() -> {
try {
FileEntity file = fileRepository.findById(fileId)
.orElseThrow(() -> new ResourceNotFoundException("File not found"));

Resource resource = fileStorageService.loadFileAsResource(file.getStoragePath());

return ResponseEntity.ok()
.contentType(MediaType.parseMediaType(file.getContentType()))
.header(HttpHeaders.CONTENT_DISPOSITION, 
"attachment; filename=\"" + file.getFileName() + "\"")
.body(resource);
} catch (Exception e) {
throw new CompletionException(e);
}
}).whenComplete((result, throwable) -> {
if (throwable != null) {
deferredResult.setErrorResult(
ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build());
} else {
deferredResult.setResult(result);
}
});

return deferredResult;
}