Le blog indique l'utilisation des intercepteurs sous la forme d'une démo
La structure du projet est montrée sur la figure:
Pot nécessaire: il y a des pots requis pour la configuration de Springmvc et les pots requis pour JSTL
Description de la fonction du package Springmvc:
aopalliance.jar: Ce package est un package API AOP Alliance, qui contient des interfaces pour les facettes. Habituellement, d'autres cadres tels que le printemps qui ont des fonctions de tissage dynamique reposent sur ce pot
Spring-Core.jar: Ce fichier JAR contient les classes d'outils de base de base du framework Spring. Tous les autres composants de Spring doivent utiliser les classes de ce package, qui est le noyau de base des autres composants. Bien sûr, vous pouvez également utiliser ces classes d'outils dans votre propre système d'application.
Dépendance externe Commons Logging, (log4j).
Spring Beans.jar: Ce fichier JAR est utilisé par toutes les applications. Il comprend l'accès aux fichiers de configuration, la création et la gestion des haricots et l'exécution de l'inversion de contrôle /
Les opérations d'injection de dépendance (IOC / DI) sont toutes des classes liées. Si l'application ne nécessite que le support IOC / DI de base, introduisez les fichiers Spring-Core.jar et Spring Beans.jar.
Spring-aop.jar: Ce fichier JAR contient la prise en charge des métadonnées au niveau de la classe et de la source requise lors de l'utilisation de la fonction AOP de Spring dans votre application. Utilisez des fonctionnalités de printemps basées sur AOP, telles que la gestion des transactions déclaratives, et incluez également ce package JAR dans l'application.
Dépendances externes Spring-Core, (Spring-Beans, AOP Alliance, CGLIB, Commons Attributes).
Spring-Context.jar: Ce fichier JAR fournit de nombreuses extensions au noyau de printemps. Toutes les classes dont vous avez besoin pour utiliser la fonction Spring ApplicationContext peuvent être trouvées, JDNI
Toutes les classes requises, les composants d'instrumentation et les classes connexes pour la validation de vérification.
Dépendance externe-Breas de printemps, (printemps-AOP).
Spring-Context-Support: Spring-Context Extension Support, utilisé pour MVC
Spring-web.jar : Ce fichier JAR contient les classes de base requises pour une utilisation dans Spring Framework lors du développement d'applications Web, y compris des classes qui chargent automatiquement les fonctionnalités du contexte de l'application Web, les classes d'intégration JSF, les classes de support pour les téléchargements de fichiers, les classes de filtrage et un grand nombre de classes auxiliaires d'outils.
Dépendance externe Spring-Context, Servlet API, (JSP API, JSTL, Commons Fileupload, COS).
Spring-webmvc.jar: Ce fichier JAR contient toutes les classes liées au framework Spring MVC. Comprend les servlets, le framework Web MVC, le contrôleur et la prise en charge de la vue pour le cadre. Bien sûr, si votre application utilise un framework MVC autonome, vous n'avez pas besoin de classes dans ce fichier JAR.
Dépendance externe Spring-Web, (Support de ressort, carreaux, itext, poi).
Spring-aspects.jar: fournit une prise en charge de l'aspectj afin que les fonctions orientées vers l'aspect puissent être facilement intégrées dans des IDE, tels que Eclipse AJDT.
Dépendances externes.
Spring-jdbc.jar: Ce fichier JAR contient toutes les classes qui résument l'accès aux données JDBC de Spring.
Dépendance externe-Breas de printemps, Spring-Dao.
Spring-test.jar: Encapsulation simple de cadres de test tels que JUnit
printemps-tx.jar: le pot de Spring pour le traitement des transactions TX
printemps-expression.jar: langage d'expression printanier
Écrivez un contrôleur:
package com.mvc.action; Importer javax.servlet.http.httpSession; import org.springframework.sterreotype.Controller; import org.springframework.web.bind.annotation.requestmapping; / ** * Contrôleur authentifié de connexion * / @Controller Classe publique LoginControl {/ ** * Login * @param Session * httpSession * @param username * username * @param mot de passe * mot de passe * @return * / @RequestMapping (Value = "/ Login") Public Login (HTTPSession Session, String userAmame, String Motway session.setAttribute ("nom d'utilisateur", nom d'utilisateur); // Redirection Retour "Redirection: Hello.Action"; } / ** * Quittez le système * @param session * Session * @return * @throws exception * / @requestmapping (value = "/ logout") public String Logout (httpSession session) lève une exception {// clear session session.invalidate (); Retour "Redirection: Hello.Action"; }} Écrivez un intercepteur:
package com.mvc.interceptor; Importer javax.servlet.http.httpservletRequest; import javax.servlet.http.httpservletResponse; Importer javax.servlet.http.httpSession; import org.springframework.web.servlet.handlerInterceptor; import org.springframework.web.servlet.modelandView; / ** * Intercepteur d'authentification de connexion * / classe publique LoginInterceptor implémente le gestionnaire de gestion Renvoie * / public void Posthandle (HttpServLetRequest Request, HttpservletResponse Response, objet Handler, ModelAndView ModelAndView) exception {} / ** * Cette méthode est appelée avant l'exécution du gestionnaire * / public booléen prehledle (httpservletRequest demande, httpleservletResponse réponse, handler d'objet) exception {// requierre la chaîne UrlPonse, handler d'objet) request.getRequeSturi (); //Url:login.jsp est accessible au public; Cette démo est interceptée sauf login.jsp, d'autres URL sont interceptées if (url.indexof ("login.action")> = 0) {return true; } // Obtenir la session httpSession session = request.getSession (); String username = (string) session.getAttribute ("nom d'utilisateur"); if (username! = null) {return true; } // Si les conditions ne remplissent pas les conditions, passez à l'interface de connexion request.getRequestDispatcher ("/ web-inf / jsp / login.jsp"). Forward (demande, réponse); retourne false; }} Fichier de configuration de Springmvc:
<? xml version = "1.0" Encoding = "utf-8"?> <beans xmlns = "http://www.springframework.org/schema/beans" xmlns: aop = "http://www.springframework.org/schema/aop" xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" xmlns: context = "http://www.springframework.org/schema/context" xmlns: mvc = "http://www.springfrrame xsi: schemalocation = "http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/springframeworks-4.0.xsd http://www.springframework.org/schema/aop: http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd http://www.springframework.org/schema/context/spring-context-4.0.xsdd http://www.springframework.org/schema/context/spring-context-4.0.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring Composant Scan -> <! - Scannez l'action, enregistrez-la dans le conteneur de ressort et configurez automatiquement l'action dans le conteneur de printemps -> <Context: Component-Scan Base-Package = "com.mvc.Action" /> <! - Project Handler <helpold Name => <e Bean /> <Bean> <prewaftamed = "Propertys Name =" Messagcorder -> <peleft <anan> </ bean> </ list> </ propriété> </ bean> <! - Afficher le résolver -> <! - Parse jsp, prise en charge par défaut pour JSTL -> <ank> <propriété named = "ViewClass" valuey = "org.springframework.web.servlet.view.jstlview"> </ / propriété name = "prefix" value = " name = "suffixe" value = ". jsp" /> </bant> <! - Dans le développement réel, vous devez généralement configurer la balise MVC: annotation. Cette balise consiste à activer l'annotation -> <mvc: annotation-entraînée> </ mvc: annotation-driven> <! - Interceptor -> <mvc: interceptor> <! - plusieurs intercepteurs, exécutés séquentiellement -> <mvc: interceptor> <mvc: mapping path = "/ **" /> </ean> </ mvc: intercepteurs> </bans>
Interface de connexion:
<% @ Page Language = "Java" import = "java.util. *" Pageencoding = "utf-8"%> <% @ taglib uri = "http://java.sun.com/jsp/jstl/core" prefix = "c"%> <% String Path = request.getConTpath (); String basepath = request.getscheme () + ": //" + request.getServerName () + ":" + request.getServerport () + path + "/"; %> <! Doctype html public "- // w3c // dtd html 4.01 transitional // en"> <html> <adread> <base href = "<% = basepath%>"> <itle> mon jsp 'Login.jsp' Page de départ </ title> <meta http-equiv = "Pragma" Contenu = "NO-CACHI http-equiv = "cache-control" contenu = "no-cache"> <meta http-equiv = "expires" contenu = "0"> <meta http-equiv = "keywords" contenu = "keyword1, keyword2, keyword3"> <meta http-equiv = "description" contenu = "c'est ma page"> <! type = "text / css" href = "Styles.css"> -> </ head> <body> <form action = "$ {pageContext.Request.ContextPath} /login.action" Method = "Post"> UserName: <entrée Type = "Text" Name = "Username" /> <br> Type de type = "TEXT" Value = "Login" /> </ Form> </ Body> </html> Après avoir enregistré avec succès, passez à l'interface
bonjour.jsp
<% @ Page Language = "Java" Import = "Java.util. *" Pageencoding = "UTF-8"%> <% @ Taglib uri = "http://www.springframework.org/tags" prefix = "Spring"%> <% @ taglib uri = "http://www.springframeworks prefix = "form"%> <% @ taglib uri = "http://java.sun.com/jsp/jstl/core" prefix = "c"%> <% String path = request.getContextPath (); String basepath = request.getscheme () + ": //" + request.getServerName () + ":" + request.getServerport () + path + "/"; %> <! Doctype html public "- // w3c // dtd html 4.01 transitional // en"> <html> <adread> <base href = "<% = basepath%>"> <titre> mon jsp 'hello.jsp' daram gage </ title> <meta http-equiv = "pragma" contenu = "contenu =" no-cache "> http-equiv = "cache-control" contenu = "no-cache"> <meta http-equiv = "expires" contenu = "0"> <meta http-equiv = "keywords" contenu = "keyword1, keyword2, keyword3"> <meta http-equiv = "description" contenu = "c'est ma page"> <! type = "text / css" href = "Styles.css"> -> </ head> <body> utilisateur actuel: $ {nom d'utilisateur} <c: if test = "$ {username! = null}"> <a href = "$ {pagecontex </ body> </html> HelloControl.java, je l'écris sous forme Helloworld, et je dois le modifier selon le projet.
package com.mvc.action; import org.springframework.sterreotype.Controller; import org.springframework.ui.model; import org.springframework.web.bind.annotation.requestmapping; // Tag cette classe en tant que processeur de gestionnaire @Controller public class helloAction {@RequestMapping ("/ Hello") // Développez l'URL correspondant à cette classe de contrôle publique Hello (modèle modèle) {String Message = "SpringMvc"; // Ajouter un attribut pour le modèle modèle.addAttribute ("message", message); retourner "bonjour"; } // public ModelAndView handleRequest (requête HttpServletRequest, // réponse httpservletResponse) lève une exception {// // // invite une ligne d'informations sur la page // string message = "Hello world!"; // // // Affichez les informations sur la page via l'objet de demande // //request.setAttribute("Message ", message); // // ModelAndView ModelAndView = new ModelAndView (); // // équivalent à request.setAttribute (), transmettez les données à la page pour afficher // // modèle de données // modélistewiew.addObject ("message", message); // // set View // ModelAndView.SetViewName ("Hello"); // // return ModelandView; //}} 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.