Comment implémenter des services de fichiers et de stockage via Spring Boot

Avec le développement de la technologie Internet, les services de fichiers et de stockage sont devenus des composants nécessaires de diverses applications. Spring Boot, en tant que cadre permettant de créer rapidement des applications Java au niveau de l'entreprise, présente également des avantages uniques dans la réalisation de services de fichiers et de stockage. Cet article explique comment implémenter les services de fichiers et de stockage via Spring Boot.

1. Traitement des fichiers dans Spring Boot

Spring Boot fournit un ensemble de méthodes de traitement de fichiers grâce aux interfaces Resource et ResourceLoader de Spring, nous pouvons obtenir des fichiers locaux, des fichiers sous classpath, des ressources réseau, etc.

1.1 Opération sur les fichiers locaux

Dans le processus de développement Spring Boot, nous utilisons la méthode getResource de l'interface ResourceLoader pour obtenir l'objet Resource du fichier spécifié. L'exemple de code est le suivant :

@ResourceLoader
ResourceLoader resourceLoader;

File file = new File("D:/image.jpg"); //指定文件路径（绝对路径）
Resource resource = resourceLoader.getResource("file:" + file.getAbsolutePath()); //获取文件Resource对象
InputStream inputStream = resource.getInputStream(); //获取文件输入流

Parmi eux, ResourceLoader est le. interface de chargeur de ressources fournie par Spring Vous pouvez marquer l'annotation @ResourceLoader pour injecter automatiquement des instances de ses classes d'implémentation via Autowired. La méthode getResource() est utilisée pour obtenir l'objet Resource du chemin de fichier spécifié. Ici, nous spécifions le chemin absolu via le protocole "file:".

1.2 Opération sur le fichier Classpath

Dans l'application Spring Boot, nous pouvons placer les fichiers de ressources liés au projet Web (tels que les fichiers de configuration) sous le classpath et obtenir la référence de ressource via ClassPathResource.

ClassPathResource classPathResource = new ClassPathResource("config.properties"); //获取配置文件Resource对象
InputStream inputStream = classPathResource.getInputStream(); //获取配置文件输入流

La classe ClassPathResource est en cours de chargement. Les ressources du chemin de classe de l'application sont prises en charge avec les préfixes du système de fichiers tels que "classpath:" et "file:". Ce code montre l'utilisation du préfixe du système de fichiers par rapport au préfixe de chemin par défaut "file:" lorsqu'il est utilisé. n'est pas précisé.

1.3 Fonctionnement des fichiers réseau

En plus des fichiers dans les chemins locaux et de chemin de classe, Spring Boot peut également exploiter des fichiers sur le réseau via des objets URLResource. L'exemple de code est le suivant :

String url = "http://img.iplaysoft.com/wp-content/uploads/2019/free-images/free_stock_photo.jpg";
Resource resource = new UrlResource(url); //获取网络资源Resource对象
InputStream inputStream = resource.getInputStream(); //获取网络资源输入流

Parmi eux, la classe UrlResource peut obtenir des ressources. à partir du fichier réseau, vous devez transmettre l'URL de l'adresse réseau en tant que paramètre du constructeur.

2. Téléchargement de fichiers dans Spring Boot

Dans le développement réel d'applications Spring Boot, le téléchargement de fichiers est une exigence courante dans Spring Boot, nous pouvons utiliser la classe MultipartFile et l'analyseur MultipartResolver pour terminer l'opération de téléchargement de fichiers.

2.1 Classe MultipartFile

La classe MultipartFile de Spring offre un moyen simple et cohérent de télécharger un ou plusieurs fichiers. Il s'agit du type de paramètre de la méthode de traitement MVC utilisée sous l'annotation @RequestParam, tel que :

@PostMapping("/upload")
@ResponseBody
public String upload(@RequestParam("file") MultipartFile file) {
    //具体文件上传操作
    return "success";
}

Lors du téléchargement d'un fichier, vous devez spécifier l'opération de téléchargement spécifique et définir les paramètres associés tels que le chemin d'enregistrement du fichier. L'exemple de code. est la suivante :

@PostMapping("/upload")
@ResponseBody
public String upload(@RequestParam("file") MultipartFile file) {
    // 获取文件名
    String fileName = file.getOriginalFilename();
    // 设置保存路径
    String filePath = "D:/upload/";
    File dest = new File(filePath + fileName);
    try {
        file.transferTo(dest);
        // 具体业务操作
        return "success";
    } catch (IOException e) {
        e.printStackTrace();
        return "failure";
    }
}

2.2 MultipartResolver Resolver

MultipartResolver est une interface du framework Spring MVC, utilisée pour analyser les données de téléchargement de fichiers dans les requêtes POST. Dans Spring Boot, nous pouvons utiliser la classe CommonsMultipartResolver intégrée pour implémenter les opérations d'analyse de téléchargement de fichiers. Dans le projet Spring Boot, il vous suffit de configurer l'objet MultipartResolver dans le fichier de configuration Spring. L'exemple de code spécifique est le suivant :

@Configuration
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {

    @Bean
    public MultipartResolver multipartResolver() {
        CommonsMultipartResolver multipartResolver = new CommonsMultipartResolver();
        multipartResolver.setMaxUploadSize(1000000);
        return multipartResolver;
    }
}

Cet exemple configure une instance de classe CommonsMultipartResolver et limite la taille maximale du fichier téléchargé à 1 000 000 octets. . Notez que nous devons activer @EnableWebMvc pour activer le comportement adaptatif de Spring MVC, permettant à l'instance de classe CommonsMultipartResolver de fonctionner correctement.

3. Téléchargement de fichiers dans Spring Boot

Dans le développement d'applications Spring Boot, le téléchargement de fichiers est également une exigence courante. Spring Boot fournit un ResponseEntity pour représenter l'intégralité de la réponse HTTP, qui contient le code d'état, l'en-tête et le corps correspondants. Nous pouvons spécifier le nom et le type du fichier téléchargé en définissant Content-Disposition.

3.1 Implémenter le téléchargement de fichiers

Nous pouvons utiliser l'annotation @ResponseBody pour traiter le contenu du fichier représenté par le tableau d'octets renvoyé par la méthode, puis utiliser ResponseEntity pour renvoyer l'intégralité du corps de la réponse HTTP.

@GetMapping("/download")
public ResponseEntity<byte[]> download() throws IOException {
    String filePath = "D:/image.jpg";
    File file = new File(filePath);
    HttpHeaders headers = new HttpHeaders();
    headers.add("Content-Disposition", "attachment;filename=" + file.getName());
    headers.setContentType(MediaType.APPLICATION_OCTET_STREAM);
    byte[] bytes = FileUtils.readFileToByteArray(file);
    ResponseEntity<byte[]> responseEntity = new ResponseEntity<>(bytes, headers, HttpStatus.OK);
    return responseEntity;
}

Dans le code ci-dessus, nous utilisons FileUtils pour lire le fichier sous forme de tableau d'octets, définir le tableau sur une HttpEntity et le renvoyer. Dans le HttpEntity renvoyé, nous spécifions également le nom et le type du fichier afin que le navigateur client puisse afficher ces informations dans la fenêtre de téléchargement.

3.2 Réaliser un téléchargement multi-fichiers

Dans certains cas, nous devons télécharger plusieurs fichiers, nous pouvons regrouper plusieurs fichiers dans un fichier zip pour réaliser un téléchargement multi-fichiers. Spring Boot utilise la classe ZipOutputStream fournie par le package java.util.zip pour implémenter facilement les opérations sur les fichiers zip. L'exemple de code est le suivant :

@GetMapping("/download_multi")
public ResponseEntity<byte[]> downloadMulti() throws IOException {
    String base = "D:/test/";
    File directoryToZip = new File(base);
    List<File> fileList = new ArrayList<>();
    getAllFiles(directoryToZip, fileList);
    byte[] zipBytes = getZipBytes(fileList, base);
    HttpHeaders headers = new HttpHeaders();
    headers.setContentType(MediaType.APPLICATION_OCTET_STREAM);
    headers.add("Content-Disposition", "attachment; filename="files.zip"");
    headers.setContentLength(zipBytes.length);
    ResponseEntity<byte[]> responseEntity = new ResponseEntity<>(zipBytes, headers, HttpStatus.OK);
    return responseEntity;
}

private byte[] getZipBytes(List<File> fileList, String basePath) throws IOException {
    ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
    ZipOutputStream zipOutputStream = new ZipOutputStream(outputStream);
    for (File file : fileList) {
        String filePath = file.getAbsolutePath().substring(basePath.length());
        ZipEntry zipEntry = new ZipEntry(filePath);
        zipOutputStream.putNextEntry(zipEntry);
        FileInputStream inputStream = new FileInputStream(file);
        IOUtils.copy(inputStream, zipOutputStream);
        inputStream.close();
        zipOutputStream.closeEntry();
    }
    zipOutputStream.close();
    byte[] bytes = outputStream.toByteArray();
    outputStream.close();
    return bytes;
}

private void getAllFiles(File dir, List<File> fileList) {
    File[] files = dir.listFiles();
    for (File file : files) {
        if (file.isDirectory()) {
            getAllFiles(file, fileList);
        } else {
            fileList.add(file);
        }
    }
}

Dans le code ci-dessus, nous utilisons la classe ZipOutputStream et ByteArrayOutputStream pour regrouper plusieurs fichiers dans un. zip et renvoie l'intégralité du corps de la réponse HTTP via ResponseEntity, y compris le tableau d'octets du fichier zip, le nom et le type du fichier, afin que le navigateur client puisse afficher ces informations dans la fenêtre de téléchargement.

4. Stockage de fichiers dans Spring Boot

Dans les applications pratiques, le stockage de fichiers est également un maillon important. Nous pouvons stocker des fichiers dans différents emplacements tels que le stockage local, FTP et objet. Ici, nous utiliserons le stockage local comme exemple pour présenter comment implémenter le stockage de fichiers via Spring Boot.

4.1 Créer un répertoire de stockage

Tout d'abord, nous devons créer un répertoire pour le service de stockage. L'exemple de code est le suivant :

String fileRoot = "/data/files/";
Path rootPath = Paths.get(fileRoot).normalize().toAbsolutePath();
if (!Files.exists(rootPath)) {
    Files.createDirectories(rootPath);
}

Dans le code ci-dessus, nous créons un répertoire racine /data/files/ pour stocker les fichiers. et vérifiez le répertoire. Existe-t-il ? Créez-le s'il n'existe pas.

4.2 实现文件存储服务

在Spring Boot中，实现文件存储服务也非常简单，我们可以创建一个类实现存储服务接口，具体代码示例如下：

@Service
public class FileStorageService {

    private Path fileStorageLocation;

    @Autowired
    public FileStorageService(@Value("${file.upload-dir}") String fileRoot) {
        this.fileStorageLocation = Paths.get(fileRoot).normalize().toAbsolutePath();
        try {
            Files.createDirectories(this.fileStorageLocation);
        } catch (Exception e) {
            throw new FileStorageException("Could not create the directory where the uploaded files will be stored.", e);
        }
    }

    public String storeFile(MultipartFile file) {
        String fileName = StringUtils.cleanPath(file.getOriginalFilename());
        try {
            if (fileName.contains("..")) {
                throw new FileStorageException("Sorry! Filename contains invalid path sequence " + fileName);
            }
            Path targetLocation = this.fileStorageLocation.resolve(fileName);
            Files.copy(file.getInputStream(), targetLocation, StandardCopyOption.REPLACE_EXISTING);
            return fileName;
        } catch (IOException ex) {
            throw new FileStorageException("Could not store file " + fileName + ". Please try again!", ex);
        }
    }

    public Resource loadFileAsResource(String fileName) {
        try {
            Path filePath = this.fileStorageLocation.resolve(fileName).normalize();
            Resource resource = new UrlResource(filePath.toUri());
            if (resource.exists()) {
                return resource;
            } else {
                throw new MyFileNotFoundException("File not found " + fileName);
            }
        } catch (MalformedURLException ex) {
            throw new MyFileNotFoundException("File not found " + fileName, ex);
        }
    }
}

上述代码中，我们创建了一个FileStorageService类，用于实现文件存储服务，包含storeFile()和loadFileAsResource()两个方法，其中：

storeFile()方法用于存储上传的文件，可以获取文件的输入流，将文件存储到指定的存储目录中；

loadFileAsResource()方法用于加载指定文件的Resource对象，通过提供的文件名获取文件的Resource对象。

注意，我们使用@Autowired注解注入了config.properties中对应的配置文件路径，使其自动配置为文件存储的目录。

结语

通过Spring Boot的文件和存储服务，我们可以轻松实现文件操作、上传、下载和存储等操作，简单高效，可以应用于各类企业级Java应用。希望本文对大家对Spring Boot文件和存储服务的理解和实践有所帮助。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!