Was ist das Dispatcher-Servlet im Frühjahr?

In Spring MVC durchlaufen alle eingehenden Anforderungen ein einzelnes Servlet. Dieses Servlet - DispatcherServlet - ist der Front-Controller. Der Front-Controller ist ein typisches Entwurfsmuster bei der Entwicklung von Webanwendungen. In diesem Fall empfängt ein einzelnes Servlet alle Anforderungen und überträgt sie an alle anderen Komponenten der Anwendung.

Die Aufgabe von DispatcherServlet besteht darin, eine Anforderung an den spezifischen Spring MVC-Controller zu senden.

Normalerweise haben wir viele Controller und DispatcherServlet verweist auf einen der folgenden Mapper, um den Ziel-Controller zu bestimmen:

• BeanNameUrlHandlerMapping ;
• ControllerBeanNameHandlerMapping ;
• ControllerClassNameHandlerMapping ;
• DefaultAnnotationHandlerMapping ;
• SimpleUrlHandlerMapping .

Wenn keine Konfiguration durchgeführt wird, verwendet der DispatcherServlet standardmäßig BeanNameUrlHandlerMapping und DefaultAnnotationHandlerMapping.

Wenn der Ziel-Controller identifiziert ist, sendet der DispatcherServlet eine Anfrage an ihn. Der Controller führt einige Arbeiten gemäß der Anforderung aus (oder delegiert sie an die anderen Objekte) und kehrt mit dem Modell und dem Namen der Ansicht zum DispatcherServlet zurück.

Der Name der Ansicht ist nur ein logischer Name. Dieser logische Name wird dann verwendet, um nach der tatsächlichen Ansicht zu suchen (um eine Kopplung mit der Steuerung und einer bestimmten Ansicht zu vermeiden). Dann verweist DispatcherServlet auf ViewResolver und ordnet den logischen Namen der Ansicht der spezifischen Implementierung der Ansicht zu.

Einige mögliche Implementierungen von ViewResolver sind:

• BeanNameViewResolver ;
• ContentNegotiatingViewResolver ;
• FreeMarkerViewResolver ;
• InternalResourceViewResolver ;
• JasperReportsViewResolver ;
• ResourceBundleViewResolver ;
• TilesViewResolver ;
• UrlBasedViewResolver ;
• VelocityLayoutViewResolver ;
• VelocityViewResolver ;
• XmlViewResolver ;
• XsltViewResolver .

Wenn DispatcherServlet die Ansicht bestimmt, in der die Ergebnisse angezeigt werden, wird sie als Antwort gerendert.

Schließlich gibt das Objekt DispatcherServlet das Objekt Response an den Client zurück.

DispatcherServlet ist Spring MVCs Implementierung des Front Controller Pattern .

Siehe Beschreibung in den Spring-Dokumenten hier .

Im Wesentlichen handelt es sich um ein Servlet, das die eingehende Anforderung entgegennimmt und die Verarbeitung dieser Anforderung an einen von mehreren Handlern delegiert, deren Zuordnung in der Konfiguration DispatcherServlet spezifisch ist.

Ich weiß, dass diese Frage bereits als gelöst markiert ist, möchte aber ein neueres Bild hinzufügen, das dieses Muster ausführlich erläutert (Quelle: Frühling in Aktion 4):

Erklärung

Wenn die Anforderung den Browser verlässt (1) , enthält sie Informationen darüber, wonach der Benutzer fragt. Zumindest trägt die Anfrage die angeforderte URL. Es können jedoch auch zusätzliche Daten enthalten sein, beispielsweise die vom Benutzer in einem Formular übermittelten Informationen.

Die erste Station auf dem Weg der Anfrage ist das DispatcherServlet von Spring. Wie die meisten Java-basierten Webframeworks führt Spring MVC Anfragen über ein einzelnes Front-Controller-Servlet aus. Ein Front-Controller ist ein gängiges Muster für Webanwendungen, bei dem ein einzelnes Servlet die Verantwortung für eine Anforderung an andere Komponenten einer Anwendung delegiert, um die eigentliche Verarbeitung durchzuführen. Bei Spring MVC ist DispatcherServlet der Front-Controller. Die Aufgabe des DispatcherServlet besteht darin, die Anforderung an einen Spring MVC-Controller weiterzuleiten. Ein Controller ist eine Spring-Komponente, die die Anforderung verarbeitet. Eine typische Anwendung kann jedoch mehrere Controller haben, und DispatcherServlet benötigt Hilfe bei der Entscheidung, an welchen Controller die Anforderung gesendet werden soll. Das DispatcherServlet verwendet daher eine oder mehrere Handlerzuordnungen (2) , um herauszufinden, wo der nächste Stopp der Anforderung sein wird. Bei der Handlerzuordnung wird der URL, die von der Anforderung bei der Entscheidung mitgeführt wird, besondere Aufmerksamkeit geschenkt. Sobald ein geeigneter Controller ausgewählt wurde, sendet das DispatcherServlet die Anfrage auf seinem fröhlichen Weg an den ausgewählten Controller (3) . An der Steuerung wird die Nutzlast der Anforderung (die vom Benutzer übermittelten Informationen) gelöscht und geduldig gewartet, während die Steuerung diese Informationen verarbeitet. (Tatsächlich führt ein gut konzipierter Controller selbst nur eine geringe oder gar keine Verarbeitung durch und delegiert stattdessen die Verantwortung für die Geschäftslogik an ein oder mehrere Serviceobjekte.) Die von einem Controller ausgeführte Logik führt häufig dazu, dass einige Informationen zurückübertragen werden müssen der Benutzer und im Browser angezeigt. Diese Informationen werden als Modell bezeichnet. Das Zurücksenden von Rohdaten an den Benutzer ist jedoch nicht ausreichend. Sie müssen in einem benutzerfreundlichen Format formatiert sein, in der Regel HTML. Zu diesem Zweck müssen die Informationen einer Ansicht übergeben werden, in der Regel einer JavaServer Page (JSP). Eines der letzten Dinge, die ein Controller tut, ist das Packen der Modelldaten und das Identifizieren des Namens einer Ansicht, die die Ausgabe rendern soll. Anschließend sendet er die Anforderung zusammen mit dem Modell- und Ansichtsnamen zurück an das DispatcherServlet (4) . Damit der Controller nicht mit einer bestimmten Ansicht verbunden wird, identifiziert der an DispatcherServlet zurückgegebene Ansichtsname eine bestimmte JSP nicht direkt. Dies deutet nicht unbedingt darauf hin, dass es sich bei der Ansicht um eine JSP handelt. Stattdessen enthält es nur einen logischen Namen, der zum Nachschlagen der tatsächlichen Ansicht verwendet wird, aus der das Ergebnis hervorgeht. Das DispatcherServlet verwendet einen View Resolver (5) , um den logischen View-Namen einer bestimmten View-Implementierung zuzuordnen, die eine JSP sein kann oder nicht. Nachdem DispatcherServlet weiß, welche Ansicht das Ergebnis liefert, ist der Auftrag für die Anforderung fast abgeschlossen. Die letzte Station ist die View-Implementierung (6) , in der Regel eine JSP, in der die Modelldaten bereitgestellt werden. Die Anfrage ist nun erledigt. Die Ansicht verwendet die Modelldaten, um die Ausgabe zu rendern, die vom (nicht so arbeitsintensiven) Antwortobjekt (7) an den Client zurückgesendet wird. .

Wir können sagen, wie DispatcherServlet sich um alles in Spring MVC kümmert.

Beim Start des Webcontainers:

1. DispatcherServlet wird geladen und durch Aufrufen der init() -Methode initialisiert
2. init() von DispatcherServlet versucht, das Spring-Konfigurationsdokument mit Namenskonventionen wie "servlet_name-servlet.xml" zu identifizieren, dann können alle Beans identifiziert werden.

Beispiel:

public class DispatcherServlet extends HttpServlet {

    ApplicationContext ctx = null;

    public void init(ServletConfig cfg){
        // 1. try to get the spring configuration document with default naming conventions
        String xml = "servlet_name" + "-servlet.xml";

        //if it was found then creates the ApplicationContext object
        ctx = new XmlWebApplicationContext(xml);
    }
    ...
}

Also, in der Regel DispatcherServlet Anfrage-URI erfassen und an HandlerMapping übergeben. HandlerMapping Search Mapping Bean mit Methode des Controllers, wobei der Controller den logischen Namen (View) zurückgibt. Dann wird dieser logische Name von DispatcherServlet an HandlerMapping gesendet. Dann DispatcherServlet weist ViewResolver an, den vollständigen Standort der Ansicht anzugeben, indem Präfix und Suffix angehängt werden. Dann DispatcherServlet gibt die Ansicht an den Client weiter.

Dispatcher-Controller werden in der Abbildung angezeigt. Alle eingehenden Anforderungen werden vom Dispatcher-Servlet abgefangen, das als Front-Controller fungiert. Das Dispatcher-Servlet erhält einen Eintrag für die Handlerzuordnung aus der XML-Datei und leitet die Anforderung an den Controller weiter.

<?xml version='1.0' encoding='UTF-8' ?>
<!-- was: <?xml version="1.0" encoding="UTF-8"?> -->
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
       http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
       http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
        http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd
               http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">

    <bean class="org.springframework.web.servlet.mvc.support.ControllerClassNameHandlerMapping"/>
    <context:component-scan base-package="com.demo" />
    <context:annotation-config />

    <mvc:annotation-driven />


    <bean id="viewResolver"
          class="org.springframework.web.servlet.view.InternalResourceViewResolver"
          p:prefix="/WEB-INF/jsp/"
          p:suffix=".jsp" />

    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="datasource" />
    </bean> 

          <bean id="datasource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver" />  
        <property name="url" value="jdbc:mysql://localhost:3306/employee" />
        <property name="username" value="username" />
        <property name="password" value="password" />
    </bean> 

</beans>