Interprétation du code source de SpringMVC: Handlermapping - AbstractUrlHandlermapping Series Distribution des demandes

AbstracthandLermapping implémente le Gethandler spécifié par l'interface de la main-d'œuvre

1. Fournir une méthode de modèle Gethandlerinternal pour la sous-classe d'implémentation

2. Si le gestionnaire n'est pas obtenu, la défaillante par défaut est utilisée.

3. Si le gestionnaire est de type de chaîne, obtenez l'instance à partir du contexte

4. encapsuler le gestionnaire via GethandlerexecutionChain et ajouter l'intercepteur

 // AbstrathandLermapping / *** Recherchez un gestionnaire pour la demande donnée, retombant au Handler par défaut * Si aucun spécifique n'est trouvé. * @Param demande de demande http actuelle * @return l'instance de gestionnaire correspondant, ou le gestionnaire par défaut * @see # gethandlerinternal * / public final handlerexecutionChain Gethandler (httpsservlatest request request request throws exception = exception = exception = handlerredre exception = handreler = httpsservlatest request request request throws exception = exception = handlerrered = exception = exception = hretrac GethandleRinternal (demande); if (handler == null) {handler = getDefaulthandler ();} if (handler == null) {return null;} // name bean ou handler résolu? if (Handler instance de string) {string handlername = (string) handler; handler = getApplicationContext (). GetBean (handlerName); GethandlereXecutionChain (gestionnaire, demande);} // abstracthandlermapping / *** construit une handlerexecutionChain pour le gestionnaire donné, y compris les intercepteurs applicables. * <p> L'implémentation par défaut construit simplement un handlerexecutionchain standard avec * le gestionnaire donné, la cartographie du gestionnaire de la mappage et le mateloir de la mappage et la mappator} et le mappator} et le mapporteur de @link URL. Les sous-classes peuvent * remplacer cela afin d'étendre / réorganiser la liste des intercepteurs. * <p> <b> Remarque: </b> L'objet de gestionnaire adopté peut être un gestionnaire brut ou un HandlereXecutionChain pré-construit. Cette méthode doit gérer ces deux cas explicitement *, soit construire une nouvelle handlerexecutionchain ou étendre la chaîne existante. * <p> pour simplement ajouter un intercepteur, envisager {@code super.GethandlereXecutionChain} * et invoquer {@link handlerexecutionchain # addinterceptor} sur le handler never. null}) * @param demande de demande http actuelle * @return le handlereXecutionChain (jamais {@code null}) * @see #getAdaptedInterceptors () * / HandlerexecutionChain Protected GethandlereXecutionChain (Object Handler, HttpServletRequest request) {handlerexecucutionchain Chain = (Handler InaceFes HandleReXecutionChain) Handler: New HandlereXecutionChain (gestionnaire); chain.addinterceptors (getAdaptedInterceptors ()); String lookuppath = urlpathhelper.getLookuppathForRequest (request); for (mappedInterceptor mappedInterceptor: mapedInterceptors) {if (mappedInterceptor.matches (lookuppath, pathmatcher))) {chain.addinterceptor (mappedInterceptor.getInterceptor ());}} Chaîne de retour;}

Ensuite, jetez un œil à la Gethandlerinternal mise en œuvre par AbstractUrlHandlermapping

 // AbstractUrlHandlerMapping / *** Recherchez un gestionnaire pour le chemin d'accès URL de la demande donnée. * @Param demande de demande http actuelle * @return l'instance de gestionnaire, ou {@code null} Si aucune ne trouvait * / @ @ overRideProtected Object GethandleRernternal (httSservletRequest request) Throws exception {// get urlstring lookPhy getUrlPathHelper (). getLookuppathForRequest (request); // find handlerObject handler = lookupHandler (lookuppath, demande); if (handler == null) {// s'il n'y a pas de correspondance pour le gestionnaire à // exposer le path_within_handler_mapping_attribute pour cela aussi.object brutshandler = null; if ("/".equals(lookuppath)) {bruthandler = getroothandler ();} if (rawhandler == null) {bruthandler = getDefaulthandler ();} if (rawchandle Handler? if (RawHandler instance of String) {String handlername = (String) rawhandler; rawhandler = getApplicationContext (). getBean (handLername);} // la méthode du modèle de gestion de vérification réservé n'utilise pas ValidateHandler (RawHandler, demande); // ajoute l'attribut de lawhandler de la demande de la request lookuppath, null);}} if (handler! = null && logger.isdebugeNabled ()) {logger.debug ("mapping [" + lookuppath + "] à" + handler);} else if (handler == null && logger.istraceenable "]");} Return Handler;} // AbstractUrlHandlerMapping / *** Recherchez une instance de gestionnaire pour le chemin d'url donné. * <p> prend en charge les matchs directs, par exemple une "/ Test" Matches "/ Test", * et diverses matchs de modèle de fourmi, par exemple un enregistré "/ t *" Matches * à la fois "/ test" et "/ équipe". For details, see the AntPathMatcher class.* <p>Looks for the most exact pattern, where most exact is defined as* the longest path pattern.* @param urlPath URL the bean is mapped to* @param request current HTTP request (to expose the path within the mapping to)* @return the associated handler instance, or {@code null} if not found* @see #exposePathWithinMapping* @see org.springframework.util.antpathmatcher * / recherche d'objet protégé (string urlPath, httpservletRequest) lève une exception {// match direct? Recherche directement HandlerObject Handler = this.handlermap.get (urlPath); if (Handler! = Null) {// Nom de bean ou gestionnaire résolu? If (Handler instanceof String) {String handlername = (string) Handler; Handler = GetApplicationContext (). GetBean (handlername);} validandler (handler, request); rate BuildPathExposi URLPATH, URLPATH, NULL);} // Match Match Match? La correspondance via des expressions est mise en œuvre via antpathmatcher. L'analyse spécifique est donnée ci-dessous Liste <string> MatchingPatterns = new ArrayList <string> (); pour (String RegisterEdPattern: this.handlerMap.KeySet ()) {if (getPathmatcher (). Match (registredPattern, urlPath)) {MatchingPatterns.add (registredPattern);}} string bestpatternmatch = null; Comparator <string> motifcarator = getPathmather (). GetPatternal (Urlpath); if (! MatchingPatterns.Isempty ()) {Collection.Sort (MatchingPatterns, PatternComparator); if (logger.isdebugeabled ()) {logger.debug ("Matchs de correspondance pour la demande [+ UrlPath +"] sont "+ MatchPatterns MatchingPatterns.get ();} if (bestpatternmatch! = null) {handler = this.handlermap.get (bestpatternmatch); // name bean ou handler résolu? if (handler instanceof string) {String handLename = (string) handler; handler = handlerhandler (handler). pathwithinmapp = getPathmatcher (). ExtractPathWithInpattern (bestpatternmatch, urlPath); // il peut y avoir plusieurs «meilleurs modèles», assurez-vous que nous avons les variables de modèle URI appropriées // pour tous, String, String, string> uritemplatevariless = new linkedhashMap <String, String> ();); pour (String MatchingPattern: MatchingPatterns) {if (patterncomparator.compare (bestpatternmatch, matchingPattern) ==) {map <string, string> vars = getPathMatcher (). ExtractUritemplateVariables (correspondant à la fois getUrlPathHelper (). DecodePathVariables (demande, vars); uritemplatevariables.putall (decodedvars);}} if (logger.isdebugeNabled ()) {logger.debug ("Uri Template Variables);} BuildPathexposedHandler (gestionnaire, bestpatternmatch, pathwithinmapping, uritemplatevariables);} // pas de gestionnaire trouvé ... retour null;}

Conçu pour vérifier les gestionnaires, rien n'est fait, y compris les sous-classes.

 / *** Valider le gestionnaire donné par rapport à la demande actuelle. * <p> L'implémentation par défaut est vide. Peut être remplacé dans les sous-classes, * par exemple pour appliquer des conditions préalables spécifiques exprimées dans les mappages d'URL. * @Param Handler l'objet de gestionnaire pour valider * @param demande de demande http actuelle * @throws exception if validation a échoué) lance Void ValidAdler (objet Handler, httpsservletRequest request) Throws exception {}

Encapsuler le gestionnaire comme handlerexecutionchain et ajouter PathexpositingHandlerInterceptor et uritemplatevariabeleshandlerInterceptor interceptor.

 / *** Créez un objet Handler pour le gestionnaire brut donné, exposant le gestionnaire réel *, le {@link #path_within_handler_mapping_attribute}, ainsi que * le {@link #uri_template_variables_attribute} avant d'exécuter le gestionnaire. Expose les variables de modèle d'attribut de chemin et d'URI * @param bruthandler le gestionnaire brut à exposer * @param pathwithinmapping le chemin à exposer avant d'exécuter le gestionnaire * @param uritemplatevariables les variables du modèle URI, peut être {@code null} Si aucune variable est trouvée * @return, le handler objet * / objet protégée protégée BestMatchingPattern, String pathwithinmapping, map <string, string> uritemplatevariables) {handlereXecutionChain chain = new HandlereXecutionChain (rawhandler); chain.addinterceptor (new PathexposedHandlerInterceptor (bestmatchingpattern, pathwithinmapping)); if (! CollectionUtils.isempty (uritemplatevariables)) {chain.addinterceptor (new UritemplateVarialeshandlerInterceptor (uritemplatevariables));} chaîne de retour;}

Le contenu ci-dessus est la connaissance pertinente de l'interprétation du code source de SpringMVC de la distribution de la demande de la série de handlermapping - AbstractUrlHandlermapping. J'espère que ce sera utile à tous!