AbstractDetectingurlHandlerMapping Registres Handler par balayage et est distribué par le Gethandlerinternal de AbstractUrlHerLermapping lors de la réception de la demande.
Il y a 5 sous-classes et une classe abstraite.
Semblable à SimpleUrlHandlerMapping, il est initialisé en écrasant l'initApplicationContext, puis en appelant Detecthandlers.
Les détectiseurs scannent l'objet d'application via beanfactoryutils, puis réservez le déterminurlsforhandler pour la sous-classe pour générer l'URL correspondante en fonction du gestionnaire.
Le registre enregistré est toujours fourni par AbstractUrlHandlerMapping.
// AbstractDetectingurlHandlermapping / *** appelle la méthode {@link #detecthandlers ()} en plus de l'initialisation de * superclass.*/@overridepublic void initapplicationContext () lance ApplicationContextexception {super.initApplicationContext (); DetecThandlers ();} Ceci est également appelé l'intercepteur d'initialisation initapplicationContext de l'abstracthandlermapping.
Le protagoniste apparaît, les détecteurs et les gestionnaires de scan
// AbstractDetectIngurlHandlerMapping / *** Enregistrez tous les gestionnaires trouvés dans l'application actuelle. * <p> La détermination réelle de l'URL pour un gestionnaire est à la hauteur du béton * {@link #DeterMineUrlsForHandler (String)} implémentation. Un bean pour * qu'aucune URL de ce type n'a pu être déterminée n'est tout simplement pas considérée comme un gestionnaire. * @Throws org.springframework.beans.beansexception si le gestionnaire ne pouvait pas être enregistré * @see #DeterMineurlsForHandler (String) * / Protected Void Detecthandlers () lance le honesexception {if (logger.isdebugenabled () {Logger. Pour les mappages d'URL dans le contexte de l'application: "+ getApplicationContext ());} string [] beanNames = (this.detecthandlersInancestorContexts? beanfactoryutils.beanNamesFortyClumedanceStors (getApplicationContext (), object.class): GetApplicationConT (). Urls for.for (string beanname: beanNames) {string [] urls = déterminerurlSForHandler (beanname); if (! ObjectUtils.isempty (urls)) {// chemins d'url trouvés: considérons-le comme un gestionnaire.registerHandler (urls, beanname);} else {if (logger.isdebugeabled ()) {logger.debug ("rejeté de haricots" La méthode de modèle réservée ici est définie comme suit:
/ *** Déterminez les URL pour le handler GEAN GORIGHT. * @Param beanname Le nom du bean candidat * @return les URL déterminées pour le bean, * ou {@code null} ou un tableau vide si aucun * / une chaîne abstraite protégé [] déterminent. Jetons un coup d'œil à l'implémentation de la méthode du modèle dans beannameurlHandlermapping et abstractControllerUrlHandlermapping. BeannameUrlHandlerMapping est très simple, il met donc en œuvre déterminée. L'alias dedans doit être configuré dans le fichier de configuration via beanname.// beannameUrlHandlermapping / *** vérifie le nom et les alias du bean donné pour les URL, en commençant par "/".*/@overrideprotected String [] déterminurLSForHandler (String Beanname) {list <string> urls = new ArrayList <String> (); {urls.add (beanname);} string [] aliases = getApplicationContext (). getaliases (beanname); for (String alias: aliases) {if (aliaS.startswith ("/")) {urls.add (alias);}} return stringUtils.toStringArray (urls);} Jetons un œil à la mise en œuvre dans AbstractControllerUrlHandlermapping
Isteligible Formaping détermine si le contrôleur est exclu (exclu via le package de package ou la classe de classe).
BuildUrlsForHandler implémente des règles de génération d'URL spécifiques à partir des sous-classes
IsControllerType détermine si la sous-classe du contrôleur
BuildUrlsForHandler réserve la méthode du modèle pour les URL de production de sous-classe.
// AbstractControllerUrlHandlerMapping / *** Cette implémentation délève {@link #buildUrlSForHandler}, * a fourni que {@link #iselibleformapapping} renvoie {@code true }.*/@overrideprotected string [] déterminent. getApplicationContext (). getType (beanname); if (iseligibleFormApping (beanname, beanclass)) {return buildUrlsForHandler (beanname, beanclass);} else {return null;}} // abstractControllerrlandLermapping / ** déterminer si le contrôleur est exclu de ce masque. @param beanclass La classe en béton du contrôleur bean * @return si la classe spécifiée est exclue * @see # setExCludPackages * @see # SetExCludClass * / Protected boolean iseligibleFormapping {logger.debug ("Exclure le contrôleur du contrôleur '" + beanname + "' From Class Name Mapping" + "parce que son type de bean n'a pas pu être déterminé");} return false;} if (this.excludedClassmes.contains (beanclass)) {if (logger.isdebugenabled () {Logger.Debug ("Excré mappage de nom "+" parce que sa classe de bean est explicitement exclue: "+ beanclass.getName ());} return false;} string beanclassname = beanclass.getName (); for (String PackageName: this.excludedPackages) {if (beanclassName.startswith (packagegeName)) {if (logger.isdebugeable ())) {Logger.debug ("Exclure le contrôleur" "+ beanname +" 'From Class Name Mapping "+" parce que sa classe de bean est définie dans un package exclu: "+ beearclass.getName ());} Retour False;}} RETOUR ISCONTROLLERTYPE (BeanClass);} // ContractContrerlHandlerming est pris en charge par cette stratégie de mappage. * @param beanclass the class to introspective * / protected boolean isControllerType (classe beanclass) {return this.predicate.isControllerType (beanclass);} // ControllerTypePredicate fournit 2 API pour déterminer s'il s'agit d'une sous-casse ou d'une sous-cllasse de multi-cllasse de MultiActionCorter. Identifie les types de contrôleur. ** @Author Juergen Hoeller * @Since .. * / class ControllerTypePredicate {public boolean isControllerType (class beanclass) {return Controller.class.isassignableFrom (beanclass);} public booléen iSmultiactionConTrollerType (Class Beanclass) {return booléen IsmultiactionConTrolleryPe (Class Beanclass) {Retour Boolean MultiActionController.class.issignableFrom (BeanClass);}} Réservez la méthode du modèle pour générer une URL
// AbstractControllerUrlHandlermapping / *** Méthode de modèle abstraite à implémenter par sous-classes. * @Param beanname Le nom du bean * @param beanclass le type de bean * @return les URL déterminés pour la casse de bean * / abstraite protégé [] BuildUrlSfor
Jetons un coup d'œil aux deux implémentations de AbstractControllerUrlHandlerMapping ControllerBeanNameUrlHandlermapping et ControperClassNameUrlHandlerMapping.
En fait, ces deux sont très simples. L'un consiste à produire une URL basée sur le nom de haricot, et l'autre est de produire une URL basée sur ClassName.
// ControllerBeAnNameUrlHandlerMapping @ OverRideProtected String [] buildUrlsForHandler (String beanname, classe beanclass) {list <string> urls = new ArrayList <string> (); urls.add (générationPathMapping (beanname)); string [] aliases = GetApplicationContext (). Getaliases (beanname); alias: aliases) {urls.add (generatePathmapping (alias));} return stringUtils.toStringArray (urls);} // ControllerBeanNameUrlHandlermapping / ** Ajouter un '/' si obligatoire et ajout (beanname.startswith ("/")? beanname: "/" + beanname); stringBuilder path = new StringBuilder (); if (! name.startswith (this.urlprefix)) {path.append (this.urlprefix);} path.append (name); if (! name.endswith (this.urlsuff)) ot Déléguez directement pour générer la mise en œuvre de Pathmappings
@OverRideProtected String [] BuildUrLSForHandler (String Beanname, classe BeanClass) {return GeneratePathMappings (BeanClass);} // ControperCLassNameUrlHandlerMapping Obtenez le préfixe du chemin via BuildPathPrefix
Obtenez ClassName via ClassUtils, comme BookController (sans nom de package), et utilisez CGLIB Proxy pour résoudre le problème ensemble.
Convertir ClassName en fonction de la question de savoir si le cas est sensible (par défaut CaseSensitive = false;)
IsmultialctionControllerType détermine si le contrôleur est une sous-classe de MultiActionController, c'est-à-dire si le contrôleur contient plusieurs gestionnaires.
/ *** Générer les chemins URL réels pour la classe de contrôleur donnée. * <p> Les sous-classes peuvent choisir de personnaliser les chemins générés * en remplaçant cette méthode. * @Param beanclass the contrôleur Class Bean pour générer un mappage pour * @return les mappages de chemins URL pour la contrôleur donnée * / Stringbuder) buildPathPrefix (beanclass); string className = classUtils.getShortName (beanclass); string path = (className.endswith (contrôleur_suffix)? className.substring (, className.LastIndexof (contrôleur_suffix)): className); if (path.Length ()>) {if (this.CasesSensitive); {pathmapping.append (path.substring (,) .tolowercase ()). APPEND (path.substring ());} else {pathmapping.append (path.tolowercase ());}} if (ismultiacyControllerTrollerType (beanclass)) {return new String [] {pathmapp "/ *"};} else {return new String [] {pathmapping.toString () + "*"};}} // ControcerClassNameUrlHandlermapping / *** Créez un préfixe de chemin pour la classe de bean contrôleur donnée. StringBuilder buildPathPrefix (class beanclass) {stringBuilder pathmapping = new StringBuilder (); if (this.pathprefix! = Null) {pathmapping.append (this.pathprefix); pathmapping.append ("/");} else {pathmapping) {String packageName = classutils.getPackageName (beanclass); if (packageName.startswith (this.basepackage)) {string subpackage = packageName.substring (this.basepackage.length ()). Remplace ('.', '/' ''. subpackage: subpackage.tolowercase ()); pathmapping.append ("/");}} return pathmapping;} // abstractControllerUrlHandlermapping Predicat.ismulticectionControllerType Implémentation spécifique
/ *** Déterminez si la classe de bean donnée indique un type de contrôleur * qui envoie à plusieurs méthodes d'action. * @Param beanclass the class to introspective * / protected booléen isMultiaCTIALControllerType (classe beanclass) {return this.predicate.ismultiatectionControllerType (BeanClass);}Ce qui précède est la connaissance pertinente de l'initialisation de l'interprétation du code source SpringMVC de la série Handlermapping - AbstractDetectInTurlHandlerMapping que l'éditeur vous a introduit. J'espère que ce sera utile à tous!