AbstractDeTectingurlHandlermaping registriert den Handler durch Scannen und wird von dem GethandLeNinternal von AbstracturlHandlermaping verteilt, wenn er die Anfrage erhält.
Es gibt 5 Unterklassen und eine abstrakte Klasse.
Ähnlich wie bei SimpleUrlHandlermaping wird es initialisiert, indem der InitApplicationContext überschrieben und dann Detektionsler aufgerufen wird.
DetectHandlers scannen das Anwendungsobjekt über BeanfactoryUtils und behalten Sie sich dann den Bestimmungsschild für die Unterklasse vor, um die entsprechende URL gemäß dem Handler zu erzeugen.
Der registrierte Registerhandler wird weiterhin von AbstracturlHandlermaping bereitgestellt.
// AbstractDeTectingUrlHandlermaping/*** nennt die {@link #DETECTHANDLERS ()} -Methode zusätzlich zur Initialisierung der*SuperClass initialisierung. Dies wird auch als InitAnlicationContext -Initialisierungs -Interceptor von AbstractHandlermaping bezeichnet.
Der Protagonist erscheint, Detektionsleute, Scan -Handler
// AbstractDetektingurlhandlermaping/*** Registrieren Sie alle im aktuellen ApplicationContext gefundenen Handler. Eine Bohne für*, die keine solchen URLs bestimmt werden konnten, wird einfach nicht als Handler angesehen. {logger.debug("Looking for URL mappings in application context: " + getApplicationContext());}String[] beanNames = (this.detectHandlersInAncestorContexts ?BeanFactoryUtils.beanNamesForTypeIncludedAncestors(getApplicationContext(), Object.class) : GetApplicationContext (). getBeannamesForFortype (Object.Class)); // Nehmen Sie einen beliebigen Bean -Namen, für den wir URLs bestimmen können. FOR (String Beanname: Beannames) {String [] urls = besttUrlsForHandler (Beanname); if (! ObjectUtils.isempty (urls)) {// URL -Pfade gefunden: Lassen Sie es uns als Handler betrachten. Die hier reservierte Vorlagenmethode ist wie folgt definiert:
/*** Bestimmen Sie die URLs für die angegebene Handler -Bean. Schauen wir uns die Implementierung der Template -Methode in BeannameurlHandlermaping und AbstractControllerurlHandlermaping an. BeannameurlHandlermaping ist sehr einfach, daher implementiert es Bestimmungen. Der Alias darin sollte in der Konfigurationsdatei über Beanname konfiguriert werden. (Beanname.StartsWith ("/") {urls.add (Beanname);} String [] aliase = getApplicationContext (). getaliases (BeAnName); für (String alias: aliase) {if (aliass.startswith ("/") {urls.add (alias);}} return Stringutils.toStringArray (URLS);};}; Schauen wir uns die Implementierung in AbstractControllerurlHandlermaping an
ISLIELIGIBLEFORMAPING BEWERTUNG BEWERT, ob der Controller ausgeschlossen ist (ausgeschlossen durch Paketpaket oder Klassenklasse).
BuildurlsForHandler implementiert bestimmte URL -Generierungsregeln aus Unterklassen
iscontrollerType bestimmt, ob die Unterklasse des Controllers
BuildurlsForHandler Reserves Template -Methode für URLs der Unterklasse Produktion.
// AbstractControllerUrlHandlermaping/*** Diese Implementierung delegiert an {@link #buildurlsforHandler},*stellte vor, dass {@link #iseligibleFormapping} zurückgegeben {@code true }.*/@overrideProtected String [] stimmhandlsforlsforler (String -BeAnNAnname) {Class Beanclass = GetApplicationContext (). Gettype (Beanname); if (isLigibleFormPing (Beanname, BeanClass) {return BuildurlsforHandler (BeAnName, BeanClass);} else {return null;}} // AbstractControllRoll -markerl -boanning, ob der Versuch von MAGNRORRARMAMMAPPINGPINGPING/** Just -** ** Just -** **, ob die kontrolliernige markaMapping/** @** @** @** @**, ob die kontrolliern. Der Name der Controller Bean* @param Beanclass Die Betonklasse der Controller Bean* @Return Ob die angegebene Klasse ausgeschlossen ist (logger.isdebugenabled ()) {logger.debug ("Controller bean" " + beannname +" 'aus Klassennamen -Mapping " +", da sein Bean -Typ nicht bestimmt werden konnte ");} return false;} if (this.is.xcludedClasses.contains (BEANCLASS) {isDebugudes () () {) {if (logger.isDebugens ()) {) {if (logger.isdi ()) {) {if (logger.isdi ())). {logger.debug ("ausgeschlossener Controller Bean" + Beanname + "'aus Klassenname Mapping" + ", weil seine Bean -Klasse explizit ausgeschlossen ist:" + BeanClass.getName ());} return false;} String beanclassname = beanclass.getname (); (BeanClassName.Startswith (Packagename)) {if (logger.isdebugenabled ()) {logger.debug ("Controller Bean" + BeAnName + "'aus dem Klasse -Namen Mapping" + " +", weil seine Bean -Klasse in einem ausgeschlossenen Paket definiert ist. iscontrollerType (BeanClass);} // AbstractControllerurlHandlermaping/*** Bestimmen Sie, ob die angegebene Bean -Klasse einen Controller -Typ* angibt, der durch diese Zuordnungsstrategie unterstützt wird. this.Predicate.iscontrollerType (Beanclass);} // ControllerTypePredicate enthält 2 APIs, um festzustellen, ob es sich um eine Unterklasse von Controller oder eine Unterklasse von MultiactionController handelt. isControllerType(Class beanClass) {return Controller.class.isAssignableFrom(beanClass);}public boolean isMultiActionControllerType(Class beanClass) {return MultiActionController.class.isAssignableFrom(beanClass);}} Reservieren Sie die Vorlagenmethode, um URL zu generieren
// AbstractControllerurlHandlermaping/*** Abstract -Vorlagenmethode, die durch Unterklassen implementiert werden soll.
Schauen wir uns die beiden Implementierungen von AbstractControllerurlHandlermaping ControllerBeannameurlHandlermaping und ControllerClassNameUrlHandlermaping an.
Tatsächlich sind diese beiden sehr einfach. Einer besteht darin, URL basierend auf Beanname zu produzieren, und das andere ist die Erstellung von URL auf der Grundlage von Klassennamen.
// ControllerBeannNameUrlHandlermaping@OverrideProtected String [] buildurlsforHandler (String -Beanname, Klasse BeanClass) {List <string> urls = new ArrayList <string> (); urls.add (generatePathMapping (BeanName); String [] aliasaSaSaSaSe -GetaPlication (). alias für (String alias: aliase) {urls.add (generatePathMapping (alias));} return Stringutils.toStringArray (urls);} // ControllerBeannNameUrlHandlermaping/** Hinzufügen eines '/' falls erforderlich und appt der url suffix to name. . oder Delegieren Sie direkt, um die Implementierung von PathMappings zu generieren
@OverrideProtected String [] BuildurlsforHandler (String -Beanname, Klasse BeanClass) {return generatePathMappings (BeanClass); Holen Sie sich das Präfix des Pfades über BuildPathprefix
Holen Sie sich Klassenname über Klasentile wie BookController (ohne Packungsname) und verwenden Sie CGGLIB Proxy, um das Problem gemeinsam zu lösen.
Konvertieren Sie den Klassennamen entsprechend, ob der Fall sensibel ist (Standard -Fallsensitiv = Falsch;)
IsmultiactionControllerType bestimmt, ob der Controller eine Unterklasse von MultictionController ist, dh, ob der Controller mehrere Handler enthält.
/*** Generieren Sie die tatsächlichen URL -Pfade für die angegebene Controller -Klasse. BuildPathPrefix (BeanClass); String className = classUtils.getShortName (BeanClass); String path = (className.endswith (Controller_Suffix) classname.substring (, className.lastindexof (controller_suffix): classSturen); {pathMapping.Append (path.substring (,) .tolowerCase ()). append (path.substring ());} else {pathMapping.Append (path.tolowerCase ());}} if (ismultiactionControllerTepe (Beanclasse) {{] {] {] {] {] {] {] {] {] {] {] {] {] {] {] {] {] {] {] {] {] {] {] return New String [] {] newning [] {] {] {] {] {] {] {] {] return New String [] return New String [] {] newnring [] {] {] {] {] {] {] {] {] {] return New String [] {] return New String [] sharping. pathmapping.toString () + "/*"};} else {return New String [] {pathMapping.toString () + "*"};}} // ControllerClassNameUrlHandlermaping/*** Erstellen Sie eine Pfadpräfix für die gegebene Controller -Bohnenklasse. Potenziell Einbeziehung von Subpackage -Namen als Pfadelemente*/private StringBuilder BuildPathprefix (Klasse BeanClass) {StringBuilder pathmapping = new StringBuilder (); if (this.pathprefix! (this.basepackage! '/'); pathMapping.Append(This.CaseSempfindlichkeit? subpackage: subpackage.tolowerCase ()); pathmaping.append ("/");}} return pathmaping;} // AbstractControllerurlHandlermaping Prädikat.ismultiactionControllerType Spezifische Implementierung Siehe oben ControllerTypePredicat
/*** Bestimmen Sie, ob die angegebene Bean -Klasse einen Controller -Typ angibt*, der mehrere Aktionsmethoden sendet.
Das obige ist das relevante Wissen über die Initialisierung der SpringMVC -Quellcode -Interpretation von HandleMapping - AbstractDetektingurlhandlermaping -Serie, die der Editor Ihnen vorgestellt hat. Ich hoffe, es wird für alle hilfreich sein!