Spring Bootで簡単にファイルアップロードとダウンロードを実装する方法

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
}

spring.servlet.multipart.max-file-size=5MB
spring.servlet.multipart.max-request-size=5MB

@RestController
@RequestMapping("/api/files")
public class FileUploadController {

    @PostMapping("/upload")
    public ResponseEntity<String> uploadFile(@RequestParam("file") MultipartFile file) {
        if (file.isEmpty()) {
            return ResponseEntity.status(HttpStatus.BAD_REQUEST).body("ファイルが選択されていません");
        }

        try {
            // ファイルを保存する処理
            String fileName = file.getOriginalFilename();
            Path path = Paths.get("uploads/" + fileName);
            Files.write(path, file.getBytes());

            return ResponseEntity.status(HttpStatus.OK).body("ファイルがアップロードされました: " + fileName);
        } catch (IOException e) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("ファイルの保存に失敗しました");
        }
    }
}

mkdir uploads

@RestController
@RequestMapping("/api/files")
public class FileDownloadController {

    @GetMapping("/download/{fileName}")
    public ResponseEntity<Resource> downloadFile(@PathVariable String fileName) {
        try {
            // ファイルのパスを取得
            Path path = Paths.get("uploads/" + fileName);
            Resource resource = new UrlResource(path.toUri());

            if (!resource.exists()) {
                return ResponseEntity.status(HttpStatus.NOT_FOUND).body(null);
            }

            // ファイルをダウンロード可能にするためのレスポンスを作成
            return ResponseEntity.ok()
                    .contentType(MediaType.APPLICATION_OCTET_STREAM)
                    .header(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=\"" + fileName + "\"")
                    .body(resource);

        } catch (MalformedURLException e) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(null);
        }
    }
}

String mimeType = Files.probeContentType(path);
return ResponseEntity.ok()
    .contentType(MediaType.parseMediaType(mimeType))
    .header(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=\"" + fileName + "\"")
    .body(resource);

@RestController
@RequestMapping("/api/files")
public class MultiFileUploadController {

    @PostMapping("/upload-multiple")
    public ResponseEntity<String> uploadMultipleFiles(@RequestParam("files") MultipartFile[] files) {
        StringBuilder message = new StringBuilder();

        for (MultipartFile file : files) {
            if (file.isEmpty()) {
                message.append("ファイルが選択されていません: ").append(file.getOriginalFilename()).append("\n");
                continue;
            }

            try {
                // ファイルを保存
                String fileName = file.getOriginalFilename();
                Path path = Paths.get("uploads/" + fileName);
                Files.write(path, file.getBytes());
                message.append("アップロード成功: ").append(fileName).append("\n");
            } catch (IOException e) {
                message.append("ファイルの保存に失敗しました: ").append(file.getOriginalFilename()).append("\n");
            }
        }

        return ResponseEntity.status(HttpStatus.OK).body(message.toString());
    }
}

@RestController
@RequestMapping("/api/files")
public class MultiFileDownloadController {

    @GetMapping("/download-multiple")
    public void downloadMultipleFiles(HttpServletResponse response) {
        String[] fileNames = {"file1.txt", "file2.txt"}; // ダウンロードするファイル名のリスト

        try (ZipOutputStream zipOut = new ZipOutputStream(response.getOutputStream())) {
            response.setContentType("application/zip");
            response.setHeader("Content-Disposition", "attachment; filename=files.zip");

            for (String fileName : fileNames) {
                Path filePath = Paths.get("uploads/" + fileName);
                if (Files.exists(filePath)) {
                    // ファイルをZIPに追加
                    zipOut.putNextEntry(new ZipEntry(fileName));
                    Files.copy(filePath, zipOut);
                    zipOut.closeEntry();
                }
            }

            zipOut.finish();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

@PostMapping("/upload")
public ResponseEntity<String> uploadFile(@RequestParam("file") MultipartFile file) {
    if (file.isEmpty()) {
        return ResponseEntity.status(HttpStatus.BAD_REQUEST).body("ファイルが選択されていません");
    }

    if (file.getSize() > 5000000) { // 5MBのサイズ制限
        return ResponseEntity.status(HttpStatus.PAYLOAD_TOO_LARGE).body("ファイルサイズが大きすぎます");
    }

    try {
        // ファイル保存処理
        String fileName = file.getOriginalFilename();
        Path path = Paths.get("uploads/" + fileName);
        Files.write(path, file.getBytes());

        return ResponseEntity.status(HttpStatus.OK).body("ファイルがアップロードされました: " + fileName);
    } catch (IOException e) {
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("ファイルの保存に失敗しました");
    }
}

@PostMapping("/upload")
public ResponseEntity<String> uploadFileWithValidation(@RequestParam("file") MultipartFile file) {
    String fileType = file.getContentType();
    if (!fileType.equals("image/png") && !fileType.equals("image/jpeg")) {
        return ResponseEntity.status(HttpStatus.UNSUPPORTED_MEDIA_TYPE).body("サポートされていないファイル形式です");
    }

    try {
        String fileName = file.getOriginalFilename();
        Path path = Paths.get("uploads/" + fileName);
        Files.write(path, file.getBytes());

        return ResponseEntity.status(HttpStatus.OK).body("ファイルがアップロードされました: " + fileName);
    } catch (IOException e) {
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("ファイルの保存に失敗しました");
    }
}

@GetMapping("/download/{fileName}")
public ResponseEntity<Resource> downloadFile(@PathVariable String fileName) {
    try {
        Path filePath = Paths.get("uploads/" + fileName);
        if (!Files.exists(filePath)) {
            return ResponseEntity.status(HttpStatus.NOT_FOUND).body(null);
        }

        Resource resource = new UrlResource(filePath.toUri());
        return ResponseEntity.ok()
                .contentType(MediaType.APPLICATION_OCTET_STREAM)
                .header(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=\"" + fileName + "\"")
                .body(resource);

    } catch (IOException e) {
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(null);
    }
}

@PostMapping("/upload")
public ResponseEntity<String> uploadFile(@RequestParam("file") MultipartFile file) {
    if (!file.isEmpty()) {
        try {
            String fileName = file.getOriginalFilename();
            Path path = Paths.get("uploads/" + fileName);
            Files.write(path, file.getBytes());
            return ResponseEntity.status(HttpStatus.OK).body("ファイルが保存されました: " + fileName);
        } catch (IOException e) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("ファイル保存に失敗しました");
        }
    } else {
        return ResponseEntity.status(HttpStatus.BAD_REQUEST).body("ファイルが選択されていません");
    }
}

<dependency>
    <groupId>software.amazon.awssdk</groupId>
    <artifactId>s3</artifactId>
</dependency>

import software.amazon.awssdk.core.sync.RequestBody;
import software.amazon.awssdk.services.s3.S3Client;
import software.amazon.awssdk.services.s3.model.PutObjectRequest;

@Service
public class S3StorageService {

    private final S3Client s3Client;

    @Autowired
    public S3StorageService(S3Client s3Client) {
        this.s3Client = s3Client;
    }

    public void uploadFile(String bucketName, String fileName, MultipartFile file) throws IOException {
        PutObjectRequest putObjectRequest = PutObjectRequest.builder()
                .bucket(bucketName)
                .key(fileName)
                .build();

        s3Client.putObject(putObjectRequest, RequestBody.fromBytes(file.getBytes()));
    }
}

@RestController
@RequestMapping("/api/files")
public class FileUploadController {

    @Autowired
    private S3StorageService s3StorageService;

    @PostMapping("/upload")
    public ResponseEntity<String> uploadFileToS3(@RequestParam("file") MultipartFile file) {
        try {
            String fileName = file.getOriginalFilename();
            s3StorageService.uploadFile("your-bucket-name", fileName, file);
            return ResponseEntity.status(HttpStatus.OK).body("ファイルがS3にアップロードされました: " + fileName);
        } catch (IOException e) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("ファイルの保存に失敗しました");
        }
    }
}

@Entity
public class FileEntity {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String fileName;

    @Lob
    private byte[] fileData;

    // ゲッターとセッター
}

String fileType = file.getContentType();
if (!fileType.equals("image/png") && !fileType.equals("image/jpeg")) {
    return ResponseEntity.status(HttpStatus.UNSUPPORTED_MEDIA_TYPE).body("サポートされていないファイル形式です");
}

spring.servlet.multipart.max-file-size=5MB
spring.servlet.multipart.max-request-size=5MB

String fileName = file.getOriginalFilename();
Path path = Paths.get("uploads/" + fileName);
Files.write(path, file.getBytes());

chmod -x uploads/

server.port=8443
server.ssl.key-store=classpath:keystore.p12
server.ssl.key-store-password=yourpassword
server.ssl.key-store-type=PKCS12
server.ssl.key-alias=tomcat

@Override
protected void configure(HttpSecurity http) throws Exception {
    http
        .authorizeRequests()
        .antMatchers("/api/files/upload").authenticated()
        .antMatchers("/api/files/download/**").authenticated()
        .and()
        .httpBasic();
}

@SpringBootTest
@AutoConfigureMockMvc
public class FileUploadControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @Test
    public void testFileUpload() throws Exception {
        MockMultipartFile mockFile = new MockMultipartFile(
                "file", 
                "test.txt", 
                "text/plain", 
                "This is a test file".getBytes());

        mockMvc.perform(multipart("/api/files/upload")
                .file(mockFile))
                .andExpect(status().isOk())
                .andExpect(content().string(containsString("ファイルがアップロードされました")));
    }
}

@SpringBootTest
@AutoConfigureMockMvc
public class FileDownloadControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @Test
    public void testFileDownload() throws Exception {
        // テスト用のファイルをアップロードディレクトリに作成
        Path filePath = Paths.get("uploads/test.txt");
        Files.write(filePath, "Test file content".getBytes());

        mockMvc.perform(get("/api/files/download/test.txt"))
                .andExpect(status().isOk())
                .andExpect(header().string(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=\"test.txt\""))
                .andExpect(content().bytes("Test file content".getBytes()));

        // テスト後にファイルを削除
        Files.delete(filePath);
    }
}

@Test
public void testInvalidFileFormat() throws Exception {
    MockMultipartFile mockFile = new MockMultipartFile(
            "file", 
            "invalid.exe", 
            "application/octet-stream", 
            "Invalid file".getBytes());

    mockMvc.perform(multipart("/api/files/upload")
            .file(mockFile))
            .andExpect(status().isUnsupportedMediaType())
            .andExpect(content().string(containsString("サポートされていないファイル形式です")));
}

@Test
public void testDirectoryTraversalAttempt() throws Exception {
    MockMultipartFile mockFile = new MockMultipartFile(
            "file", 
            "../outside.txt", 
            "text/plain", 
            "This should not be allowed".getBytes());

    mockMvc.perform(multipart("/api/files/upload")
            .file(mockFile))
            .andExpect(status().isBadRequest())
            .andExpect(content().string(containsString("不正なファイル名です")));
}

@PostMapping("/users/{userId}/uploadProfileImage")
public ResponseEntity<String> uploadProfileImage(@PathVariable Long userId, @RequestParam("file") MultipartFile file) {
    // 画像ファイルをサーバーに保存し、ユーザーのプロフィール画像URLを更新
}

@PostMapping("/projects/{projectId}/uploadDocument")
public ResponseEntity<String> uploadDocument(@PathVariable Long projectId, @RequestParam("file") MultipartFile file) {
    // ドキュメントをプロジェクトフォルダに保存し、メタデータをデータベースに保存
}

@GetMapping("/projects/{projectId}/downloadDocument/{fileName}")
public ResponseEntity<Resource> downloadDocument(@PathVariable Long projectId, @PathVariable String fileName) {
    // プロジェクトフォルダからドキュメントをダウンロード
}

@PostMapping("/products/{productId}/uploadImage")
public ResponseEntity<String> uploadProductImage(@PathVariable Long productId, @RequestParam("file") MultipartFile file) {
    // 商品画像を保存し、商品情報に画像URLを追加
}

@PostMapping("/students/{studentId}/submitAssignment")
public ResponseEntity<String> submitAssignment(@PathVariable Long studentId, @RequestParam("file") MultipartFile file) {
    // 課題ファイルを保存し、提出状況を更新
}

@GetMapping("/teachers/{teacherId}/downloadAssignment/{assignmentId}")
public ResponseEntity<Resource> downloadAssignment(@PathVariable Long assignmentId) {
    // 提出された課題ファイルをダウンロード
}