Explication détaillée de l'utilisation d'intercepteur intercepteur dans Springmvc

L'intercepteur intercepteur dans SpringMVC est également très important et utile. Sa fonction principale est d'intercepter les demandes des utilisateurs et d'effectuer un traitement correspondant. Par exemple, il peut effectuer une vérification de l'autorisation ou déterminer si l'utilisateur est connecté ou déterminer si l'heure actuelle est le temps d'achat de billets comme 12306.

1. Définir la classe de mise en œuvre de l'intercepteur

Les demandes d'interception interceptor dans SpringMVC sont implémentées via HandlerInterceptor. La définition d'un intercepteur dans SpringMVC est très simple. Il y a deux façons principales. La première façon consiste à définir la classe d'interceptor qui implémente l'interface Spring HandlerInterceptor, ou cette classe hérite de la classe qui met en œuvre l'interface HandlerInterceptor, telles que la classe abstraite que Spring a fourni qui implémente l'interface de gestionnaire Intreport, qui est déjà fournie par Spring; La deuxième façon est d'implémenter l'interface Spring WebRequestInterceptor, ou hérite de la classe qui implémente l'interface WebRequestInterceptor.

(I) Implémentation de l'interface HandlerInterceptor

Il existe trois méthodes définies dans l'interface HandlerInterceptor, et nous utilisons ces trois méthodes pour intercepter les demandes des utilisateurs.

(1) PREHANDLE (HttpServLetRequest Request, HttpServletResponse Response, Handle) Méthode, comme le nom l'indique, sera appelé avant le traitement de la demande. L'intercepteur dans SpringMVC est appelé sous forme de chaîne. Plusieurs intercepteurs peuvent exister en même temps dans une application ou dans une demande. Chaque appel intercepteur sera exécuté en séquence en fonction de son ordonnance de déclaration, et les premiers sont exécutés sont la méthode de pré-maintenance dans l'intercepteur, de sorte que certaines opérations de pré-initialisation peuvent être effectuées dans cette méthode ou un prétraitement de la demande actuelle, ou certains jugements peuvent être portés dans cette méthode pour décider si la demande doit continuer.

La valeur de retour de cette méthode est de type booléen booléen. Lorsqu'il revient à False, cela signifie que la demande se termine et que l'intercepteur et le contrôleur ultérieur ne seront plus exécutés; Lorsque la valeur de retour est vraie, la méthode de pré-maintenance du prochain intercepteur continuera d'être appelé. S'il s'agit déjà du dernier intercepteur, la méthode du contrôleur de la demande actuelle sera appelée.

(2) Posthandle (HttpServLetRequest Request, HttpServletResponse Response, Handle, objet, modelandView ModelandView). D'après l'explication de la méthode de pré-maintenance, nous savons que cette méthode, y compris la méthode AfterCompletion à mentionner plus loin, ne peut être appelée que lorsque la valeur de retour de la méthode de pré-main de l'intercepteur actuel est vraie.

La méthode posthandle, comme le nom l'indique, est exécutée après le traitement de la demande actuelle, c'est-à-dire une fois la méthode du contrôleur, mais elle sera appelée avant que DispatcherServLET renvoie et rend la vue, afin que nous puissions fonctionner sur l'objet ModelAndView après le processus de contrôleur dans cette méthode. La direction de l'appel de la méthode de post-allonge est l'opposé de la pré-haine, ce qui signifie que la méthode post-poste de l'intercepteur déclaré en premier sera exécutée plus tard, ce qui est quelque peu similaire au processus d'exécution de l'intercepteur dans Struts2. Le processus d'exécution de l'intercepteur dans Struts2 est également enchaîné, mais dans Struts2, la méthode d'action d'action invoquée doit être appelée manuellement pour déclencher l'appel vers l'intercepteur ou l'action suivante. Ensuite, le contenu de chaque intercepteur avant la méthode invoquée est exécuté dans l'ordre déclaré, et le contenu après la méthode invoquée est inversé.

(3) AfterCompletion (HttpServLetRequest Request, HttpServletResponse Response, Handle, Exception Ex) Méthode, cette méthode doit être exécutée lorsque la valeur de retour de la méthode de pré-Gandle de l'intercepteur correspondant actuelle est vraie. Comme son nom l'indique, cette méthode sera exécutée une fois la demande entière terminée, c'est-à-dire une fois que Dispatcherservlet a rendu la vue correspondante. La fonction principale de cette méthode est de nettoyer les ressources.

Voici une description de code simple:

 Importer javax.servlet.http.httpservletRequest; import javax.servlet.http.httpservletResponse; import org.springframework.web.servlet.handlerInterceptor; import org.springframework.web.servlet.modelandView; La classe publique SpringMvCInterceptor implémente HandlerInterceptor {/ ** * La méthode de pré-houle est utilisée pour l'interception du processeur. Comme son nom l'indique, cette méthode sera appelée avant le processus du contrôleur. L'intercepteur intercepteur dans SpringMVC est enchaîné et plusieurs intercepteurs peuvent exister en même temps. Ensuite, SpringMVC en exécutera un par un selon l'ordre de la déclaration, et toutes les méthodes de pré-halte dans l'intercepteur seront appelées avant que la méthode du contrôleur ne soit appelée. La structure de la chaîne intercepteur de SpringMVC peut également être interrompue. Cette méthode d'interruption rend la valeur de retour de la pré-halte à false. Lorsque la valeur de retour de la pré-houle est fausse, la demande entière se termine. * / @Override public boolean prehandle (requette httpservletRequest, réponse httpservletResponse, gestionnaire d'objets) lève l'exception {// la méthode générée automatiquement de TODO return false; } / ** * Cette méthode ne sera exécutée que lorsque la valeur de retour actuelle de la méthode de pré-halte de l'intercepteur est vraie. La posthandle est utilisée pour l'interception du processeur. Son temps d'exécution est après le traitement du processeur *, c'est-à-dire une fois la méthode du contrôleur, mais il sera exécuté avant que DispatcherServlet ne rende la vue, ce qui signifie que dans cette méthode, vous pouvez utiliser ModelandView *. La structure de la chaîne de cette méthode est l'opposé de la direction d'accès normale, c'est-à-dire que la méthode déclarée d'abord sera appelée plus tard. Ceci est un peu similaire au processus d'exécution de l'intercepteur dans Struts2. * Seulement dans la méthode d'interception dans Struts2, la méthode d'invoque d'action en action doit être appelée manuellement. La méthode d'invoquer d'actionInvocation dans Struts2 est d'appeler l'intercepteur suivant * ou d'appeler l'action, puis le contenu qui doit être appelé avant l'intercepteur est écrit avant l'appel à invoquer, et le contenu qui doit être appelé après l'intercepteur est écrit après l'appel à la méthode invoquée. * / @Override public void posthandle (httpservletRequest request, httpservletResponse Response, objet Handler, ModelandView ModelAndView) lève l'exception {// TODO Stub de la méthode générée automatiquement} / ** * Cette méthode doit également être exécutée lorsque la valeur de retour de la méthode pré-châtrice de l'intercepteur correspondant actuelle est vraie. Cette méthode sera exécutée une fois la demande entière terminée, c'est-à-dire que DispatcherServlet rend l'exécution de la vue. * La fonction principale de cette méthode est de nettoyer les ressources. Bien sûr, cette méthode ne peut être exécutée que lorsque la valeur de retour actuelle de la méthode de pré-maintenance de l'intercepteur est vraie. * / @Override public void AfterCompletion (demande httpservletRequest, réponse httpservletResponse, gestionnaire d'objets, exception ex) lève l'exception {// TODO Méthode générée automatiquement Stub}}

(Ii) implémenter l'interface WebRequestInterceptor

Il existe également trois méthodes définies dans WebRequestInterceptor, et nous utilisons également ces trois méthodes pour implémenter l'interception. Les trois méthodes transmettent le même paramètre WebRequest, alors qu'est-ce que cette WebRequest? Ce WebRequest est une interface définie par Spring. Les définitions de méthode y sont fondamentalement les mêmes que HttpServLetRequest. Toutes les opérations effectuées sur WebRequestInterceptor dans WebRequestInterceptor seront synchronisées sur httpservletRequest, puis passent dans la demande actuelle.

(1) Méthode de pré-halte (demande WebRequest). Cette méthode sera appelée avant le traitement de la demande, c'est-à-dire qu'elle sera appelée avant que la méthode du contrôleur ne soit appelée. Cette méthode est différente de la pré-haine dans HandlerInterceptor. La principale différence est que la valeur de retour de la méthode est vide, ce qui signifie qu'il n'y a pas de valeur de retour. Par conséquent, nous l'utilisons généralement pour préparer des ressources. Par exemple, lorsque nous utilisons Hibernate, nous pouvons préparer un objet de session Hibernate dans cette méthode, puis utiliser le setAttribute (nom, valeur, portée) de WebRequest pour le mettre dans la propriété WebRequest. Ici, nous pouvons parler de la troisième portée des paramètres de la méthode SetAttribute, qui est de type entier. Trois constantes sont définies pour l'interface de couche parent de WebRequest requestAttributes:

Scope_Request: sa valeur est 0, ce qui signifie qu'il n'est accessible que dans la demande.

SCOPE_SESSION: sa valeur est 1. Si l'environnement le permet, il représente une session isolée locale, sinon il représente une session normale et peut être accessible dans le cadre de la session.

SCOPE_GLOBAL_SESSION: sa valeur est 2. Si l'environnement le permet, il représente une session partagée globalement, sinon elle représente une session normale et peut être accessible dans le cadre de la session.

(2) Méthode Posthandle (WebRequest Request, ModelMap Model). Cette méthode sera appelée après le traitement de la demande, c'est-à-dire une fois la méthode du contrôleur, mais sera appelée avant que les rendements de la vue ne soient rendus, vous pouvez donc modifier l'affichage des données en modifiant le modèle de modèle ModelMap dans cette méthode. Cette méthode a deux paramètres. L'objet WebRequest est utilisé pour transmettre toutes les données de demande. Par exemple, les données préparées dans la pré-houle peuvent être transmises et accessibles via WebRequest; ModelMap est l'objet modèle renvoyé après le processus de contrôleur. Nous pouvons modifier le modèle retourné en modifiant ses propriétés.

(3) Méthode AfterCompletion (WebRequest, exception ex) Méthode. Cette méthode sera exécutée après le traitement de la demande entière, c'est-à-dire une fois la vue retournée et rendue. Par conséquent, dans cette méthode, l'opération de libération de ressources peut être effectuée. Le paramètre WebRequest peut transmettre les ressources que nous avons préparées dans PreHandle ici pour la version. Le paramètre d'exception représente l'objet d'exception actuellement demandé. Si l'exception lancée dans le contrôleur a été traitée par le processeur d'exception Spring, l'objet d'exception est nul.

Voici une description de code simple:

 import org.springframework.ui.modelmap; import org.springframework.web.context.request.webRequest; import org.springframework.web.context.request.webRequestInterceptor; classe publique AllInterceptor implémente WebRequestInterceptor {/ ** * exécuter avant le traitement de la demande. Cette méthode est principalement utilisée pour préparer des données de ressources, puis elles peuvent être placées dans WebRequest en tant qu'attributs de demande * / @Override public void prehandle (webRequest request) lève une exception {// TODO Méthode générée automatiquement Stub System.out.println ("AllInterceptor .................."); request.setAttribute ("demande", "requête", webrequest.scope_request); // Ceci est placé dans le cadre de la demande, afin que vous ne puissiez obtenir que demande.setAttribute ("Session", "Session", dans la demande dans la demande actuelle. Si l'environnement le permet, il ne peut être accessible que dans une session isolée localement. Sinon, il est accessible dans la session actuelle normale. Request.setAttribute ("GlobalSession", "GlobalSession", webrequest.scope_global_session); // Si l'environnement le permet, il est accessible dans une session partagée globale, sinon elle peut être accessible dans la session actuelle normale} / ** * Cette méthode sera exécutée après l'exécution du contrôleur et avant de revenir à la vue. ModelMap représente l'objet modèle renvoyé après que le contrôleur est invité à traiter le contrôleur, de sorte que les propriétés du ModelMap peuvent être modifiées dans cette méthode pour réaliser l'effet de la modification du modèle retourné. * / @Override public void posthandle (webRequest request, modelmap map) lève l'exception {// todo marde générée automatiquement un stub pour (clé de chaîne: map.keyset ()) System.out.println (key + "----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- AfterCompletion (WebRequest Request, Exception Exception) lève l'exception {// TODO Méthode générée automatique Stub System.out.println (Exception + "-=-=--=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = "); }}

2. Ajouter la classe d'intercepteur définie au système d'interception de SpringMVC

1. Ajouter un schéma qui prend en charge MVC dans le fichier de configuration de SpringMVC

 xmlns: mvc = "http://www.springframework.org/schema/mvc" xsi: scheMalocation = "http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd "

Voici un exemple de ma déclaration:

 <Beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" xmlns: context = "http://www.springframework xmlns: mvc = "http://www.springframework.org/schema/mvc" xsi: scheMalocation = "http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsddd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd ">

De cette façon, vous pouvez utiliser la balise MVC dans le fichier de configuration SpringMVC. Il y a un MVC: intercepteurs dans la balise MVC qui est utilisé pour déclarer l'intercepteur de SpringMVC.

(Ii) Utilisez le tag MVC: Interceptors pour déclarer l'intercepteur qui doit être ajouté à la chaîne d'intercepteur SpringMVC

 <MVC: Interceptors> <! - Utilisez du bean pour définir un intercepteur. L'intercepteur directement défini sous la racine de MVC: les intercepteurs intercepteront toutes les demandes -> <Bean /> <mvc: interceptor> <mvc: mapping path = "/ test / numéro.do" /> <! - La représentation définie sous MVC: Interceptor est à intercepter une demande spécifique -> <Bean /> </ MVC: Interceptor> </mvc: interceptor>

D'après l'exemple ci-dessus, nous pouvons voir qu'une série d'intercepteurs peut être déclarée en utilisant la balise MVC: Interceptors, puis ils peuvent former une chaîne d'intercepteur. L'ordre d'exécution de l'intercepteur est exécuté dans l'ordre des déclarations. La méthode de pré-halte dans l'intercepteur déclaré sera exécutée en premier, mais sa méthode post-althandle et la méthode aprèscomplétion seront exécutées ultérieurement.

Il existe deux façons principales de déclarer Interceptor sous le Tag MVC: Interceptors:

(1) Définissez directement un objet de haricot de la classe d'implémentation interceptrice. Interceptor Interceptor déclaré de cette manière interceptera toutes les demandes.

(2) Utilisez la balise MVC: Interceptor pour déclarer. L'intercepteur déclaré de cette manière peut définir le chemin de demande qui doit être intercepté via la sous-tag MVC: mappage.

Après les deux étapes ci-dessus, l'intercepteur défini agira pour intercepter les demandes spécifiques.

Ce qui précède est tout le contenu de cet article. J'espère que cela sera utile à l'apprentissage de tous et j'espère que tout le monde soutiendra davantage Wulin.com.