TOC

Téléchargement de fichier avec Spring MVC

Téléchargement de fichier avec Spring MVC

1. Vue d'ensemble

Dans les articles précédents, nous avonsintroduced the basics de gestion de formulaire et exploré lesform tag library dans Spring MVC.

Dans cet article, nous nous concentrons sur ce que Spring propose pour lesmultipart (file upload) support dans les applications Web.

Spring nous permet d'activer ce support en plusieurs parties avec des objetsMultipartResolverenfichables. Le framework fournit une implémentation deMultipartResolver à utiliser avecCommons FileUpload et une autre à utiliser avec l'analyse des requêtes en plusieurs parties deServlet 3.0.

Après avoir configuré lesMultipartResolver, nous verrons comment importer un seul fichier et plusieurs fichiers.

Nous aborderons égalementSpring Boot.

2. Fichier Commons

Pour utiliserCommonsMultipartResolver pour gérer le téléchargement du fichier, nous devons ajouter la dépendance suivante: 


    commons-fileupload
    commons-fileupload
    1.3.1

Nous pouvons maintenant définir le beanCommonsMultipartResolver dans notre configuration Spring.

CeMultipartResolver est livré avec une série de méthodesset pour définir des propriétés telles que la taille maximale des téléchargements: 

@Bean(name = "multipartResolver")
public CommonsMultipartResolver multipartResolver() {
    CommonsMultipartResolver multipartResolver = new CommonsMultipartResolver();
    multipartResolver.setMaxUploadSize(100000);
    return multipartResolver;
}

Ici, nous devons contrôler différentes propriétés deCommonsMultipartResolver dans la définition de Bean elle-même.

3. With Servlet 3.0

Afin d'utiliser l'analyse en plusieurs parties deServlet 3.0, nous devons configurer quelques éléments de l'application. First, we need to set a MultipartConfigElement in our DispatcherServlet registration: 

public class MainWebAppInitializer implements WebApplicationInitializer {

    private String TMP_FOLDER = "/tmp";
    private int MAX_UPLOAD_SIZE = 5 * 1024 * 1024;

    @Override
    public void onStartup(ServletContext sc) throws ServletException {

        ServletRegistration.Dynamic appServlet = sc.addServlet("mvc", new DispatcherServlet(
          new GenericWebApplicationContext()));

        appServlet.setLoadOnStartup(1);

        MultipartConfigElement multipartConfigElement = new MultipartConfigElement(TMP_FOLDER,
          MAX_UPLOAD_SIZE, MAX_UPLOAD_SIZE * 2, MAX_UPLOAD_SIZE / 2);

        appServlet.setMultipartConfig(multipartConfigElement);
    }
}

Dans l'objetMultipartConfigElement, nous avons configuré l'emplacement de stockage, la taille maximale du fichier individuel, la taille maximale de la demande (dans le cas de plusieurs fichiers dans une seule demande) et la taille à laquelle la progression du téléchargement du fichier est renvoyée emplacement de stockage.

Ces paramètres doivent être appliqués au niveau d'enregistrement de la servlet, carServlet 3.0 ne leur permet pas d'être enregistrés dans lesMultipartResolver comme c'est le cas avecCommonsMultipartResolver.

Une fois cela fait,we can add the StandardServletMultipartResolver to our Spring configuration: 

@Bean
public StandardServletMultipartResolver multipartResolver() {
    return new StandardServletMultipartResolver();
}

4. Uploading a File **

Pour télécharger notre fichier, nous pouvons créer un formulaire simple dans lequel nous utilisons une balise HTMLinput avectype='file'.

Quelle que soit la configuration de gestion du téléchargement que nous avons choisie, nous devons définir l'attribut d'encodage du formulaire surmultipart/form-data. Cela permet au navigateur de savoir comment encoder le formulaire: 


    

        

            Select a file to upload

To store the uploaded file we can use a MultipartFile variable. Nous pouvons récupérer cette variable à partir du paramètre de requête dans la méthode de notre contrôleur: 

@RequestMapping(value = "/uploadFile", method = RequestMethod.POST)
public String submit(@RequestParam("file") MultipartFile file, ModelMap modelMap) {
    modelMap.addAttribute("file", file);
    return "fileUploadView";
}

The MultipartFile class provides access to details about the uploaded file, y compris le nom de fichier, le type de fichier, etc. Nous pouvons utiliser une simple page HTML pour afficher ces informations: 

Submitted File



    

        OriginalFileName:
        ${file.originalFilename}
    

    

        Type:
        ${file.contentType}

5. Téléchargement Fichiers multiples

Pour télécharger plusieurs fichiers en une seule demande, nous plaçons simplement plusieurs champs de fichier d'entrée dans le formulaire: 


    

        

            Select a file to upload
            
        

        

            Select a file to upload
            
        

        

            Select a file to upload

Nous devons veiller à ce que chaque champ d'entrée ait le même nom afin qu'il soit accessible sous forme de tableau deMultipartFile: 

@RequestMapping(value = "/uploadMultiFile", method = RequestMethod.POST)
public String submit(@RequestParam("files") MultipartFile[] files, ModelMap modelMap) {
    modelMap.addAttribute("files", files);
    return "fileUploadView";
}

Maintenant, nous pouvons simplement parcourir ce tableau pour afficher les informations sur les fichiers: 

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>

    
        Spring MVC File Upload
    
    
        
Submitted Files

        
                

            

                    OriginalFileName:
                    ${file.originalFilename}
                

                

                    Type:
                    ${file.contentType}

6. Téléchargement de fichiers avec des données de formulaire supplémentaires

Nous pouvons également envoyer des informations supplémentaires au serveur avec le fichier en cours de téléchargement. Nous devons simplement inclure les champs obligatoires dans le formulaire: 


    

        

            Name
            
        

        

            Email
            
        

        

            Select a file to upload

Dans le contrôleur, nous pouvons obtenir toutes les données du formulaire en utilisant l'annotation@RequestParam: 

@PostMapping("/uploadFileWithAddtionalData")
public String submit(
  @RequestParam MultipartFile file, @RequestParam String name,
  @RequestParam String email, ModelMap modelMap) {

    modelMap.addAttribute("name", name);
    modelMap.addAttribute("email", email);
    modelMap.addAttribute("file", file);
    return "fileUploadView";
}

Comme dans les sections précédentes, nous pouvons utiliser la page HTML avec les balisesJSTL pour afficher les informations.

Nous pouvons également encapsuler tous les champs de formulaire dans une classe de modèle et utiliser l'annotation@ModelAttribute dans le contrôleur. Cela serait utile lorsqu'il y a beaucoup de champs supplémentaires avec le fichier. Regardons le code: 

public class FormDataWithFile {

    private String name;
    private String email;
    private MultipartFile file;

    // standard getters and setters
}
@PostMapping("/uploadFileModelAttribute")
public String submit(@ModelAttribute FormDataWithFile formDataWithFile, ModelMap modelMap) {

    modelMap.addAttribute("formDataWithFile", formDataWithFile);
    return "fileUploadView";
}

7. Téléchargement de fichier Spring Boot

[.hps] [result_box]#If we’re using Spring Boot, everything we’ve seen so far still applies. # #

Cependant, Spring Boot facilite encore davantage la configuration et le démarrage de tout.

En particulier,it’s not necessary to configure any servlet, en tant que Boot l'enregistrera et le configurera pour nous, à condition que nous incluions le module Web dans nos dépendances: 


    org.springframework.boot
    spring-boot-starter-web
    2.1.8.RELEASE

Nous pouvons trouver la dernière version despring-boot-starter-web sur Maven Central.

Si nous voulons contrôler la taille maximale de téléchargement de fichiers, nous pouvons éditer nosapplication.properties: 

spring.servlet.multipart.max-file-size=128KB
spring.servlet.multipart.max-request-size=128KB

Nous pouvons également contrôler si le téléchargement de fichier est activé et l'emplacement du téléchargement de fichier: 

spring.servlet.multipart.enabled=true
spring.servlet.multipart.location=${java.io.tmpdir}

Notez que nous avons utilisé$\{java.io.tmpdir} pour définir l'emplacement d'importation afin de pouvoir utiliser l'emplacement temporaire pour différents systèmes d'exploitation.

8. Conclusion

[.hps] [result_box]#In this article, we looked at different ways to configure multipart support in Spring. Using these, we can support file uploads in our web applications. # #

L'implémentation de ce tutoriel peut être trouvée dans unGitHub project. Lorsque le projet s'exécute localement, l'exemple de formulaire est accessible àhttp://localhost:8080/spring-mvc-java/fileUpload

Related