Überblick
Für Webentwickler ist das MVC -Modell allen sehr vertraut. In SpringMVC tritt die Anfrage, die den Bedingungen erfüllt, in den für die Verteilung der Anfrage verantwortlichen DispatcherServlet ein. Der DispatcherServlet ordnet die Anforderungs -URL an den Controller ab (speichern Sie in HandleMapping). Handlermapping gibt schließlich die HandlexexexexexexcutionChain zurück, die den spezifischen Verarbeitungsobjekt -Handler enthält (das heißt, was wir geschrieben haben, wenn wir es programmieren). Controller) und eine Reihe von Interceptors. Zu diesem Zeitpunkt findet der DispatcherServlet einen Handleradapter, der diesen Prozessortyp basierend auf dem Handler im Handler im zurückgegebenen HandlexexexexexexexexcutionChain unterstützt. Im Prozessoradapter wird schließlich die Anforderungsantwortmethode des Controllers aufgerufen und die Ergebnisansicht (modelAndview) zurückgegeben. Nach dem Erhalt der Ergebnisansicht wird das Ergebnis durch die Render -Methode angezeigt.
Handge -Erbschaftssystem:
SpringMVC fordert die Verbreitung an den Handler -Prozessor an. Dieser Schritt wird durch das Handlermapping -Modul gelöst. Handlermapping behandelt auch Interceptors.
Schauen wir uns zuerst den Erbbaum des Handlermaps an
Sie können eine solche Klassifizierung grob vornehmen:
1. Eine Schnittstellenhandlermapping, Definieren Sie eine API: HandlexexexexexexcutionChain Gethandler (httpServletRequest -Anforderung) Ausnahme;
2. Eine grundlegende abstrakte Klasse: Vorbereitet haupt
3. Verwendung von @Controller, @RequestMapping basierend auf Annotation
4. Konfigurieren Sie das SimpleUrlHandlermaping von der URL in der Konfigurationsdatei an den Handler
5. BeannameurlHandlermaping wird standardmäßig implementiert
6. Zuordnung von Controller -Unterklassen
Werfen wir einen Blick auf Handlermapping, nur eine Gethandler -API ist sehr einfach.
// Handlermapingpackage org.springframework.web.servlet; öffentliche Schnittstelle Handlermaping {HandlexexexecutionChain Gethandler (httpServletRequest) löst Ausnahme aus;} AbstractHandlermaping ist nicht so einfach
Schauen Sie sich zunächst die Klasse an, die durch AbstractHandLermaping und die implementierte Schnittstelle erbte
Paket org.springframework.web.servlet.handler; öffentliche abstrakte Klasse AbstractHandLermaping erweitert WebApplicationObjectSupportimplements Handlermapping, geordnet {// ...} WebApplicationObjectSupport wird verwendet, um Context ApplicationContext und ServletContext bereitzustellen.
Hier gibt es auch die InitApplicationContext -Methode, die häufig in Zukunft verwendet wird. AbstractHandlermaping wird direkt überschrieben.
Die Schnittstellen von ApplicationContextaware und ServletContextaware werden in der übergeordneten Klasse weiterhin implementiert, und das Frühlingskonzept ist sehr einheitlich.
Bestellt wird für die Sammlungssortierung verwendet.
Betrachten wir weiter
// AbstractHandlermaping // Order weist den maximalen Wert zu, und die Priorität ist die kleinste private int order = Integer.max_value; // Standard: Wie nicht angeordnet // Der Standardhandler, der hier verwendete Obejct und die Implementierung von Unterklassen, verwenden Sie HandleMethod, HandlexexexexcutionChain und andere private Objekte Defaulthandler; // Auxiliary-Klasse für Url-Berechnungen private Urlpathhelper-Urlpathohhelper = New Urlpathhelchmatel. AntpathMatcher (); // Interceptor -Konfiguration:, HandleMapping -Eigenschaftseinstellung;, ExtendInterceptors setzen die private endgültige Liste <Object> interceptors = new ArrayList <Object>; // Parse von Interceptors und fügen Sie es direkt zu allen Handlern -Federlisten <HandleInterceptor> adaptedinterceNceptors zu. Die Übergabe wird übergeben.
Schauen Sie sich die Initialisierung des Interceptors an:
// AbstractHandlermaping@überschreibete void initApplicationContext () löst Beansexception aus {ExtendInterceptors (this.Interceptors); detectMappedInterceptors (this.mappedInterceptors); initinterceptors ();}/***, die den Subklassen -Erweiterungs -Interceptors (ungerecht "-Stjekte verwendet haben, sind jedoch nicht verwendet. Oder Falsch) .Values ());}/*** MADPAPDInTInterceptor sammeln und an HandlerInterceptor und WebRequestInterceptor*/Protected void initinterceptors () {if (! this.Interceptors.isempty ()) {für (int i =; i <this.interceptors (); NULL) {Neue IllegalArgumentException ("Eintragsnummer" + i + "in Interceptors -Array ist null"); adaptInterceptor(Object interceptor) {if (interceptor instanceof HandlerInterceptor) {return (HandlerInterceptor) interceptor;}else if (interceptor instanceof WebRequestInterceptor) {return new WebRequestHandlerInterceptorAdapter((WebRequestInterceptor) interceptor);}else {throw new IllegalArgumentException("Interceptor type not supported: " + interceptor.getClass (). getName ());}}Anschließend gibt es die Implementierung von Gethandler (HttpServletRequest -Anfrage), und behält sich hier auch die GetHandlerinternale (httpServletRequest -Anfrage) für die Implementierung von Unterklassen vor.
// AbstractHandLermapingPublic Final HandleRexexexexexexcutionChain GetHandler (httpServletRequest -Anfrage) löst Ausnahme aus {Object Handler = GetHandlerinternal (Anfrage); if (Handler == null) {Handler = GetDefaulthandler (); Instanceof String) {String Handlername = (String) Handler; Handler = GetApplicationContext (). getBean (Handlername);} return getHanderexexCutionChain (Handler, Anforderung);} geschütztes abstraktes Objekt GetHanderinternal (httpServletrequest) lehnt Ausnahme aus; Schließlich verkapulieren Sie den Interceptor in HandlexexexexexexexexcutionChain
Fügen Sie angepasste Interzeptoren direkt hinzu
Zuhörer müssen nach dem Matching gemäß der URL hinzugefügt werden
// AbstractHandLermapping -geschütztes HandlexexexexexexCutionChain GetHandRerexexeCutionChain (Objekthandler, httpServletRequest -Anforderung) {HandlexexexexCutionChain Chain = (Handlerinstanz von HandlexexexexexCutionChain) Handler: New HandleRexexexexexexcutionChain (Handler); ketten.addinterceptors (getAdAtAtTEnterceptors ()); String -Lookuppath = urlpathHelper.getLookuppathForRequest (Request); für (MattedInterceptor MaptingInterceptor: MattedInterceptors) {if (mapPedInterceptor.Matches (Lookuppath, PathMather) {{CHACKS.AdDInterce.} {caintor.adDinterceptor (mappedinterceptor (mappercedinterceptor) (mappedDinterceptor (mappedizes} (ashinterceptor Kette;} Durch die Zuordnung von Controller -Unterklassen befasst sich dieser Zweig zunächst mit der Klassenvererbung
Sprechen wir hier über die Hauptaufgaben jeder Kategorie
1.. AbstractHandlermaping Bereiten Sie die Kontextumgebung vor; Gethandlerinternal Haken zur Verfügung stellen; Einkapselende Interceptor zu HandlexexexexexcutionChain
2. AbstracturlHandlermaping implementiert die Methode zur Registrierung von Handler für die Verwendung von Unterklassen; Implementiert GetHandlerinternal und findet Handler basierend auf den durch Unterklassen initiierten Konfigurationsinformationen.
8. AbstractDetektingurlhandlermaping Scans das Objekt unter der Anwendung und nach der Iteration die Hakenmethode bestimmen, um zu bestimmen, wie es filtert.
V. Gleichzeitig beurteilt die Unterklasse des Controllers
5. ControllerbeAnnameHandlermaping Generieren Sie URL basierend auf dem Bean -Namen
ControllerClassNameHandlermaping generiert URL basierend auf dem Klassennamen
Beginnen wir mit AbstracturlHandlermaping. Hier schauen wir uns den Code ungefähr ungefähr an. Wenn Sie es sorgfältig analysieren müssen, wechseln Sie bitte zu <SpringMVC -Quellcode -Interpretation - HandleMapping - AbstracturLHandlermaping Series Request Distribution>
Registrierung von Handler
Protected Void RegisterHandler (String [] UrlPaths, String beanname) löst Beansexception, IllegalStateException {} Protected Void RegisterHandler (String urlPath, Object Handler) aus. Die Suche nach Handler
Protected Object GetHandlerinternal (httpServletRequest -Anforderung) löst Ausnahme aus {} // Handler -Protected -Objekt -LookupHandler (String urlPath, httpServletRequest) aus der Ausnahme {} // Verifizieren von HandlerProtected Void Validehandler (Object Handler, httpServeSchara) Throws -Ausnahme {{{using thttpServeSture thttpServequest) Throws -Ausnahme {{{{{Unentschieden. HandlexexexexexexcutionChain -Protected -Objekt -BuildPatPoSitingHandler (Objekt RawHandler, String BESTMATCHINGPATTERN, STRING PATHWITHINMAPPING, MAP <STRING, STRING> URITEMPLETVARIABLE) {}AbstractDeTectingUrlHandlermaping, dies wird nicht erweitert. Bitte bewegen Sie sich im Detail <SpringMVC -Quellcode -Interpretation - HandleMapping - AbstractDeTectingurlHandlermaping -Serie Initialisierung> Initialisierung>
Was zu tun:
1. Rufen Sie die Detektionaler auf, um OBJCT durch Überschreiben von InitApplicationContext zu scannen
2. Geben Sie die Hakenmethode bestimmen, um die Unterklasse nach Handler zu generieren
3. Rufen Sie den RegisterHandler der übergeordneten Klasse an, um sich zu registrieren
@Overridepublic void initApplicationContext () löst applicationContexception {Super.initApplicationContext (); DetectHandlers ();} geschützte void detecthandlers () aus. Beanname); AbstractControllerUrlHandlermaping, dies wird nicht erweitert. Bitte bewegen Sie sich im Detail <SpringMVC -Quellcode -Interpretation - HandleMapping - AbstractDeTectingurlHandlermaping -Serie -Initialisierung> Initialisierung> Was speziell zu tun ist;
1. Schreiben Sie die Bestimmung überschreiben, um Logik hinzuzufügen, um einige Klassen zu entfernen, und verwenden Sie ausgeschlossene Klassen und ausgeschlossene Packages, die in der Konfigurationsdatei konfiguriert sind.
2. Bestimmen Sie, ob die Unterklasse des Controllers
3.. Reserve BuildurlsForHandler, um URLs für Unterklassen zu generieren
@OverrideProtected String [] bestteileForHandler (String beanname) {class beanclass = getApplicationContext (). GettType (Beanname); if (isLigibleFormapping (BeAnName, BeanClass)) {return BuildurlsForHandler (BeanName, BeanName); isLigibleFormapping (String -Beanname, Klasse Beanclass) {} geschützte boolean isControllerType (Klasse BeanClass) {} geschützte abstrakte String [] BuildurlsforHandler (String Beanname, Klasse BeanClass); ControllerBeannNameHandlermaping und ControllerClassNameHandlermaping -Blick auf den Quellcode direkt oder fordern SimpleUrlHandlermaping Konfiguriert URL direkt für Handler in der Konfigurationsdatei. Dabei werden Registerhandler verwendet, um den Handler im Konfigurationsdokument zu registrieren, den Code direkt zu lesen oder <springMVC -Quellcode -Interpretation - Handlermaping - SimpleUrlHandlermaping -Initialisierung> zu verschieben> Initialisierung> Initialisierung>
BeannameUrlHandlermaping -Geräte bestimmen BestimmungsforHandler, um URLs zu generieren, den Code direkt anzusehen oder <SpringMVC -Quellcode -Interpretation zu bewegen - Handlermaping - AbstractDectingurlHandlermaping -Serie -Initialisierung> Initialisierung> Initialisierung>
Verwendung von @Controller, @RequestMapping basierend auf Annotation
Der härteste Knochen
Schauen wir uns zuerst die Erbschaft der Klasse an
Besprechen wir über die Verantwortlichkeiten jeder Kategorie. Für eine spezifische Analyse wechseln Sie bitte in den folgenden Artikel
<SpringMVC -Quellcode -Interpretation - HandleMapping - RequestMapingHandlermaping Initialisierung>
<SpringMVC -Quellcode -Interpretation - HandleMapping - RequestMapingHandlermaping -Anforderungsverteilung>
1.. AbstractHandlermethodmaping definiert den Initialisierungsprozess und die Abbindung bei Anforderung
Initialisierung:
1.1.1 Scannen Sie das Objekt unter der Anwendung
1.1.2 Reservieren Sie die IsHandler -Hook -Methode der Unterklasse, um festzustellen, ob das Objekt Handler ist
1.1.3 Scannen Sie iterativ jeden Handler, um eine Methode zu finden, die den Anforderungen entspricht. Das Urteil hier bleibt der Unterklasse noch überlassen, GetMapingFormethod zu implementieren
1.1.4 Bei der Registrierung des gefundenen Prozessors müssen Sie sicherstellen
1.1.5 Erhalten Sie die URL gemäß den Übereinstimmungsbedingungen, und dies gilt nur, um den Prozess zu definieren. Der spezifische Algorithmus bleibt der Unterklasse, um GetmapingPathPatterns zu implementieren
Verteilungsverarbeitung Anfrage:
1.2.1 Direct String Matching -Methode, schauen Sie auf Handler nach
1.2.2 Übereinstimmungsbedingungssuche wird der spezifische Algorithmus hier an die Unterklasse übergeben, um GetMatchingMapping zu erhalten
1.2.3 Sortieren Sie den besten passenden Handler. Die Sortiermethode hier ist immer noch die Subklassenverarbeitung GetmapingConparator
1.2.4 Kapselung von passenden bzw. nicht passenden Handlern
2. RequestMappingInfoHandlermaping verwendet RequestMappingInfo, um die Übereinstimmungsbedingungen zu implementieren, und die Initialisierung von RequestMapingInfo bleibt der Unterklasse überlassen
2.1 URL generieren -> GetmapingPathPatterns gemäß RequestMapingInfo
2.2 Handler mit Übereinstimmungsbedingungen finden -> getMatchingMapping
2.3 Komparatoralgorithmus -> GetMapping Comparator
2.4 Überschreiben Sie Handlematch- und Cache -N -Mehrfachinformationen, um sie anzufordern
Registermuster, bestes Übereinstimmungsmuster, analysierte Parameter in URL, Multi-Wert
2.1.5 Überschreiben Sie Handlernomatch, versuchen Sie nach dem letzten Kampf erneut, es zu erreichen
3.. RequestMappingHandlermaping Generieren Sie RequestMapingInfo gemäß der Annotation @Controller @RequestMapping und überprüfen Sie IsHandler
3.1 Überschreibe nach dem Propertiesset und fügen Sie das Dateisuffix zum Richter hinzu
3.2 Ishandler implementieren, und eine der Anmerkungen der Klasse ist korrekt.
3.3 Analyse des Annotationsinhalts und erstellen Sie RequestMappingInfo -Instanzen