Dans le développement Web quotidien, de grandes et de petites exceptions sont souvent rencontrées.À l'heure actuelle, un mécanisme unifié de gestion des exceptions est souvent nécessaire pour garantir que le client puisse recevoir des invites plus conviviales. Spring Boot fournit également un ensemble de mécanismes de gestion des exceptions par défaut, qui seront présentés en détail dans cette section.
Mécanisme de gestion des exceptions par défaut de Spring Boot
Spring Boot fournit un ensemble de mécanismes de gestion des exceptions par défaut. Une fois qu'une exception se produit dans le programme, Spring Boot identifie automatiquement le type de client (client navigateur ou client machine) et, selon le client, affiche l'exception informations sous différentes formes.
- Pour les clients de navigateur, Spring Boot répondra avec une vue d'erreur « en marque blanche », présentant les informations d'erreur au format HTML, comme illustré à la figure 1 ;
Figure 1: Page blanche d'erreur par défaut de Spring Boot
- Pour les clients de la machine, Spring Boot générera une réponse JSON affichant le message d'exception.
{ "timestamp": "2021-07-12T07:05:29.885+00:00", "status": 404, "error": "Not Found", "message": "Aucun message disponible", "path": "/m1ain.html" } Principe de configuration automatique de la gestion des exceptions Spring Boot Spring Boot fournit une configuration automatique pour la gestion des exceptions via la classe de configuration ErrorMvcAutoConfiguration, qui injecte les quatre composants suivants dans le conteneur. ErrorPageCustomizer : ce composant transmettra la demande à "/error" par défaut après qu'une exception se soit produite dans le système. BasicErrorController : gère la requête "/error" par défaut. DefaultErrorViewResolver : le résolveur de vue d'erreur par défaut, qui résout les informations d'exception dans la vue d'erreur correspondante. DefaultErrorAttributes : utilisé pour partager des informations sur les exceptions sur la page.
Ci-dessous, nous présenterons ces quatre composants en détail.
ErrorPageCustomizer
ErrorMvcAutoConfiguration injecte un composant appelé ErrorPageCustomizer dans le conteneur, qui est principalement utilisé pour personnaliser les règles de réponse de la page d'erreur.
@Bean
public ErrorPageCustomizer errorPageCustomizer(DispatcherServletPath dispatcherServletPath) { return new ErrorPageCustomizer(this.serverProperties, dispatcherServletPath); }
ErrorPageCustomizer enregistre les règles de réponse de la page d'erreur via la méthode registerErrorPages(). Lorsqu'une exception se produit dans le système, le composant ErrorPageCustomizer prend automatiquement effet, transmet la demande à "/error" et la transmet à BasicErrorController pour traitement. Une partie du code est la suivante.
@Override
public void registerErrorPages(ErrorPageRegistry errorPageRegistry) { //Transférer la requête à /error (this.properties.getError().getPath()) ErrorPage errorPage = new ErrorPage(this.dispatcherServletPath.getRelativePath(this.properties.getError( ) .getPath())); // enregistrer la page d'erreur errorPageRegistry.addErrorPages(errorPage); } BasicErrorController ErrorMvcAutoConfiguration injecte également un composant de contrôleur d'erreur BasicErrorController dans le conteneur, le code est le suivant. @Bean @ConditionalOnMissingBean(value = ErrorController. class, search = SearchStrategy. CURRENT)
public BasicErrorController basicErrorController(ErrorAttributes errorAttributes,
ObjectProvider errorViewResolvers) { return new BasicErrorController(errorAttributes, this.serverProperties.getError(), errorViewResolvers.orderedStream().collect(Collectors.toList())); }
BasicErrorController est défini comme suit.
//BasicErrorController est utilisé pour gérer la requête "/error"
@Controller
@RequestMapping(“ KaTeX parse error: Expected '}', got 'EOF' at end of input: …ver.error.path: {error.path:/ error} }")
public class BasicErrorController extend AbstractErrorController { … /** * Cette méthode est utilisée pour gérer les exceptions dans les requêtes du client du navigateur * Générer des pages html pour afficher les informations sur les exceptions * @param request * @param response * @return / @RequestMapping( produit = MediaType.TEXT_HTML_VALUE) public ModelAndView errorHtml (demande HttpServletRequest, réponse HttpServletResponse) { // Obtenir le code d'état d'erreur HttpStatus status = getStatus (request);
//getErrorAttributes encapsule certaines données de modèle en fonction des informations d'erreur pour l'affichage de la page
Map<String, Object> model = Collections
.unmodifiableMap(getErrorAttributes(request, getErrorAttributeOptions(request, MediaType.TEXT_HTML)));
//Définir les erreurs pour l'objet de réponse Code d'état
response.setStatus(status.value());
//Appelez la méthode resolveErrorView() et utilisez l'analyseur de vue d'erreur pour générer un objet ModelAndView (y compris l'adresse de la page d'erreur et le contenu de la page)
ModelAndView modelAndView = resolveErrorView(request, response , status, model );
return (modelAndView != null) ? modelAndView : new ModelAndView("error", model);
}
/ *
* Cette méthode permet de gérer l'erreur survenue dans la requête de la machine cliente
* Générer des données dans Format JSON pour afficher les informations d'erreur
* @param request
* @return
*/
@RequestMapping
public ResponseEntity<Map<String, Object>> error(HttpServletRequest request) { HttpStatus status = getStatus(request); if (status == HttpStatus.NO_CONTENT) { return new ResponseEntity<>(status); } Map<String, Object> body = getErrorAttributes(request, getErrorAttributeOptions(request, MediaType.ALL)); renvoie une nouvelle ResponseEntity<>(corps, statut); } … }
Spring Boot effectue une gestion unifiée des erreurs via BasicErrorController (telle que la requête "/error" par défaut). Spring Boot identifiera automatiquement le type de client faisant la demande (client navigateur ou client machine), et selon le type de client, la demande sera transmise aux méthodes errorHtml() et error() pour traitement.
En d'autres termes, lors de l'utilisation d'un navigateur pour accéder à une exception, il entrera la méthode errorHtml() dans le contrôleur BasicErrorController pour le traitement ; lors de l'utilisation d'Android, IOS, Postman et d'autres clients de machine pour accéder à une exception, il entrera l'erreur ( ) méthode de traitement .
Dans la méthode errorHtml(), la méthode resolveErrorView() de la classe parent (AbstractErrorController) sera appelée, le code est le suivant.
protected ModelAndView resolveErrorView(HttpServletRequest request, HttpServletResponse response, HttpStatus status,
Map<String, Object> model) { // Obtient tous les résolveurs de vue d'erreur dans le conteneur pour gérer les informations d'exception pour (ErrorViewResolver resolver : this.errorViewResolvers) { / /Call le resolveErrorView du résolveur de vue d'erreur pour résoudre la page de vue d'erreur ModelAndView modelAndView = resolver.resolveErrorView(request, status, model); if (modelAndView != null) { return modelAndView; } } return null; }
Comme le montre le code source ci-dessus, lors de la réponse à la page, tous les objets ErrorViewResolver (résolveurs de vue d'erreur, y compris DefaultErrorViewResolver) dans le conteneur seront obtenus dans la méthode resolveErrorView de la classe parente, et les informations d'exception seront résolues ensemble .
DefaultErrorViewResolver
ErrorMvcAutoConfiguration injecte également un composant de résolution de vue d'erreur par défaut DefaultErrorViewResolver dans le conteneur, le code est le suivant.
@Bean
@ConditionalOnBean(DispatcherServlet.class)
@ConditionalOnMissingBean(ErrorViewResolver.class)
DefaultErrorViewResolver conventionErrorViewResolver() { return new DefaultErrorViewResolver(this.applicationContext, this.resources); }
Lorsque le client demandeur est un navigateur, Spring Boot obtient tous les objets ErrorViewResolver (résolveurs de vue d'erreur) dans le conteneur et appelle leur méthode resolveErrorView() pour résoudre les informations d'exception, qui incluent naturellement également DefaultErrorViewResolver (analyseur de message d'erreur par défaut).
Une partie du code de DefaultErrorViewResolver est la suivante.
public class DefaultErrorViewResolver implémente ErrorViewResolver, Ordered { private static final Map<HttpStatus.Series, String> SERIES_VIEWS; static { Map<HttpStatus.Series, String> views = new EnumMap<>(HttpStatus.Series.class); views.put( . CLIENT_ERROR, « 4xx »); views.put(Series.SERVER_ERROR, « 5xx »); SERIES_VIEWS = Collections.unmodifiableMap(views); } … @Override public ModelAndView resolveErrorView(HttpServletRequest request, HttpStatus status, Map<String, Object> model ) { //Essayez de résoudre avec le code d'état d'erreur comme nom de page d'erreur ModelAndView modelAndView = resolve(String.valueOf(status.value()), model);
if (modelAndView == null && SERIES_VIEWS.containsKey(status.series())) { //Essayez de résoudre avec 4xx ou 5xx comme page d'erreur modelAndView = resolve(SERIES_VIEWS.get(status.series()), model); } return modelAndView ; } private ModelAndView resolve(String viewName, Map<String, Object> model) { //Pages de modèle d'erreur, telles que error/404, error/4xx, error/500, error/5xx String errorViewName = "error/ ” + viewName ; //Lorsque le moteur de modèle peut analyser ces pages de modèle, utilisez le moteur de modèle pour analyser TemplateAvailabilityProvider provider = this.templateAvailabilityProviders.getProvider(errorViewName, this.applicationContext); if (provider != null) { //Peut être analysé dans le modèle Dans le cas de la page de modèle, renvoie la vue spécifiée par errorViewName return new ModelAndView(errorViewName, model); }
//Si le moteur de modèle ne peut pas résoudre, accédez au dossier de ressources statiques pour trouver la page correspondant à errorViewName
return resolveResource(errorViewName, model);
}
private ModelAndView resolveResource(String viewName, Map<String, Object> model) { //traverse all static Resource folder for (String location : this.resources.getStaticLocations()) { try { Resource resource = this.applicationContext.getResource(location); //Pages d'erreur sous le dossier de ressources statiques, telles que error/404.html, error /4xx.html, error/500.html, error/5xx.html resource = resource.createRelative(viewName + ".html"); //Si les pages d'erreur ci-dessus existent dans le dossier de ressources statiques, retournez directement if (resource .existe ()) { return new ModelAndView (nouveau DefaultErrorViewResolver. HtmlResourceView (ressource), modèle); } } catch (Exception ex) { }
}
retourne nul ;
}
…
}
Les étapes de DefaultErrorViewResolver pour résoudre les informations d'exception sont les suivantes :
selon le code d'état d'erreur (tel que 404, 500, 400, etc.), générer une erreur/état d'affichage d'erreur, tel que erreur/404, erreur/500, erreur /400.
Essayez d'utiliser le moteur de modèle pour analyser la vue error/status, c'est-à-dire, essayez de trouver error/status.html dans le répertoire templates sous le classpath, comme error/404.html, error/500.html, error/400 .html.
Si le moteur de modèle peut résoudre la vue d'erreur/d'état, encapsulez la vue et les données dans un ModelAndView pour renvoyer et terminer l'ensemble du processus d'analyse, sinon passez à l'étape 4.
Recherchez error/status.html à partir de chaque dossier de ressources statiques à tour de rôle. Si la page d'erreur se trouve dans le dossier statique, renvoyez et terminez tout le processus d'analyse, sinon passez à l'étape 5.
Convertissez les codes d'état d'erreur (tels que 404, 500, 400, etc.) en 4xx ou 5xx, puis répétez les 4 premières étapes. Si l'analyse est réussie, revenez et terminez tout le processus d'analyse, sinon passez à l'étape 6.
Gérez la requête "/error" par défaut à l'aide de la page d'erreur par défaut de Spring Boot (page d'erreur Whitelabel).
DefaultErrorAttributes
ErrorMvcAutoConfiguration injecte également un outil de traitement des attributs d'erreur par défaut du composant DefaultErrorAttributes dans le conteneur, le code est le suivant.
@Haricot
@ConditionalOnMissingBean(value = ErrorAttributes.class, search = SearchStrategy.CURRENT)
public DefaultErrorAttributes errorAttributes() { return new DefaultErrorAttributes(); }
DefaultErrorAttributes est l'outil de traitement des attributs d'erreur par défaut de Spring Boot. Il peut obtenir des informations sur les exceptions ou les erreurs à partir de la demande et les encapsuler en tant qu'objet Map à renvoyer. Une partie de son code est la suivante.
public class DefaultErrorAttributes implements ErrorAttributes, HandlerExceptionResolver, Ordered { … @Override public Map<String, Object> getErrorAttributes(WebRequest webRequest, ErrorAttributeOptions options) { Map<String, Object> errorAttributes = getErrorAttributes(webRequest, options.isIncluded(Include.STACK_TRACE)) ; si (!options.isIncluded(Include.EXCEPTION)) { errorAttributes.remove("exception"); } if (!options.isIncluded(Include.STACK_TRACE)) { errorAttributes.remove("trace"); } if (! options.isIncluded(Include.MESSAGE) && errorAttributes.get("message") != null) {
errorAttributes.remove("message");
}
if (!options.isIncluded(Include.BINDING_ERRORS)) { errorAttributes.remove("errors"); } renvoie les attributs d'erreur ; } private Map<String, Object> getErrorAttributes(WebRequest webRequest, boolean includeStackTrace) { Map<String, Object> errorAttributes = new LinkedHashMap<>(); errorAttributes.put("horodatage", nouvelle Date()); addStatus(errorAttributes, webRequest); addErrorDetails (errorAttributes, webRequest, includeStackTrace); addPath(errorAttributes, webRequest); renvoie les attributs d'erreur ; } … }
Lorsque le contrôleur d'erreurs par défaut de Spring Boot (BasicErrorController) gère les erreurs, il appelle la méthode getErrorAttributes() de DefaultErrorAttributes pour obtenir des informations sur les erreurs ou les exceptions, les encapsule dans des données de modèle (objet Map) et les renvoie à la page ou aux données JSON. Les données du modèle incluent principalement les attributs suivants :
horodatage : horodatage ;
état : code d'état d'
erreur erreur : invite d'erreur
exception : objet d'exception qui a provoqué l'échec du traitement de la demande
message : erreur/exception
suivi du message : erreur/exception
chemin d'information de la pile : erreur/exception Chemin d'URL demandé lors de la levée
Tous les attributs encapsulés dans les données du modèle via DefaultErrorAttributes peuvent être obtenus directement sur la page ou dans JSON.