TOC

MaxUploadSizeExceededException au printemps

MaxUploadSizeExceededException au printemps

1. Vue d'ensemble

Dans le framework Spring, unMaxUploadSizeExceededException est lancé lorsqu'une application tente de télécharger un fichier dont la taille dépasse un certain seuil tel que spécifié dans la configuration.

Dans ce tutoriel, nous verrons comment spécifier une taille de téléchargement maximale. Ensuite, nous montrerons un simple contrôleur de téléchargement de fichier et discuterons de différentes méthodes pour gérer cette exception.

2. Définition d'une taille de téléchargement maximale

Par défaut, la taille des fichiers pouvant être téléchargés n’est pas limitée. Afin de définir une taille de téléchargement maximale, vous devez déclarer un bean de typeMultipartResolver.

Voyons un exemple qui limite la taille du fichier à 5 Mo: 

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

3. Contrôleur de téléchargement de fichiers

Ensuite, définissons une méthode de contrôleur qui gère le téléchargement et l'enregistrement sur le serveur d'un fichier: 

@RequestMapping(value = "/uploadFile", method = RequestMethod.POST)
public ModelAndView uploadFile(MultipartFile file) throws IOException {

    ModelAndView modelAndView = new ModelAndView("file");
    InputStream in = file.getInputStream();
    File currDir = new File(".");
    String path = currDir.getAbsolutePath();
    FileOutputStream f = new FileOutputStream(
      path.substring(0, path.length()-1)+ file.getOriginalFilename());
    int ch = 0;
    while ((ch = in.read()) != -1) {
        f.write(ch);
    }

    f.flush();
    f.close();

    modelAndView.getModel().put("message", "File uploaded successfully!");
    return modelAndView;
}

Si l'utilisateur tente de télécharger un fichier d'une taille supérieure à 5 Mo, l'application lèvera une exception de typeMaxUploadSizeExceededException.

4. Gestion deMaxUploadSizeExceededException

Afin de gérer cette exception, nous pouvons demander à notre contrôleur d'implémenter l'interfaceHandlerExceptionResolver, ou nous pouvons créer une classe annotée@ControllerAdvice.

4.1. Implémentation deHandlerExceptionResolver

L'interfaceHandlerExceptionResolver déclare une méthode appeléeresolveException() où des exceptions de différents types peuvent être gérées.

Remplaçons la méthoderesolveException() pour afficher un message au cas où l'exception interceptée est de typeMaxUploadSizeExceededException: 

@Override
public ModelAndView resolveException(
  HttpServletRequest request,
  HttpServletResponse response,
  Object object,
  Exception exc) {

    ModelAndView modelAndView = new ModelAndView("file");
    if (exc instanceof MaxUploadSizeExceededException) {
        modelAndView.getModel().put("message", "File size exceeds limit!");
    }
    return modelAndView;
}

4.2. Création d'un intercepteur d'avis de contrôleur

Il existe quelques avantages à gérer l'exception à l'aide d'un intercepteur plutôt que dans le contrôleur lui-même. La première est que nous pouvons appliquer la même logique de traitement des exceptions à plusieurs contrôleurs.

Une autre est que nous pouvons créer une méthode qui cible uniquement l'exception que nous voulons gérer, permettant au framework de déléguer la gestion des exceptions sans que nous ayons à utiliserinstanceof pour vérifier quel type d'exception a été levé: 

@ControllerAdvice
public class FileUploadExceptionAdvice {

    @ExceptionHandler(MaxUploadSizeExceededException.class)
    public ModelAndView handleMaxSizeException(
      MaxUploadSizeExceededException exc,
      HttpServletRequest request,
      HttpServletResponse response) {

        ModelAndView modelAndView = new ModelAndView("file");
        modelAndView.getModel().put("message", "File too large!");
        return modelAndView;
    }
}

5. Configuration de Tomcat

Si vous déployez sur le serveur Tomcat version 7 et supérieure, il existe une propriété de configuration appeléemaxSwallowSize que vous devrez peut-être définir ou modifier.

Cette propriété spécifie le nombre maximal d'octets que Tomcat «avalera» pour un téléchargement à partir du client lorsqu'il sait que le serveur ignorera le fichier.

La valeur par défaut de la propriété est 2097152 (2 Mo). Si elle reste inchangée ou si elle est définie sous la limite de 5 Mo que nous avons définie dans nosMultipartResolver, Tomcat rejettera toute tentative de téléchargement d'un fichier de plus de 2 Mo, et notre gestion des exceptions personnalisée ne sera jamais invoquée.

Pour que la demande aboutisse et que le message d'erreur de l'application s'affiche, vous devez définir la propriétémaxSwallowSize sur une valeur négative. Ceci indique à Tomcat d'avaler tous les téléchargements ayant échoué, quelle que soit la taille du fichier.

Ceci est fait dans le fichierTOMCAT_HOME/conf/server.xml:

6. Conclusion

Dans cet article, nous avons montré comment configurer une taille de téléchargement de fichier maximale dans Spring et comment gérer lesMaxUploadSizeExceededException qui résultent lorsqu'un client tente de télécharger un fichier dépassant cette limite de taille.

Le code source complet de cet article se trouve dans leGitHub project.

Related