Czym jest Dispatcher Servlet na wiosnę?

W Spring MVC wszystkie przychodzące żądania przechodzą przez jeden servlet. Ten servlet - DispatcherServlet - jest kontrolerem przednim. Front controller jest typowym wzorcem projektowym w tworzeniu aplikacji internetowych. W takim przypadku pojedynczy servlet odbiera wszystkie żądania i przekazuje je do wszystkich innych komponentów aplikacji.

Zadaniem {[0] } jest wysłanie żądania do określonego kontrolera Spring MVC.

Zazwyczaj mamy dużo kontrolerów i DispatcherServlet odnosi się do jednego z następujące mapery w celu określenia kontrolera docelowego:

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

Jeśli nie zostanie wykonana żadna konfiguracja, DispatcherServlet domyślnie używa BeanNameUrlHandlerMapping i DefaultAnnotationHandlerMapping.

Gdy kontroler docelowy zostanie zidentyfikowany, DispatcherServlet wysyła do niego żądanie. Kontroler wykonuje pewne prace zgodnie z żądaniem (lub delegować go do inne obiekty) i zwraca z powrotem do {[0] } z modelem i nazwą widoku.

Nazwa widoku jest tylko nazwą logiczną. Ta logiczna nazwa jest następnie używana do wyszukiwania rzeczywistego widoku (aby uniknąć powiązania z kontrolerem i określonym widokiem). Wtedy DispatcherServlet odnosi się do ViewResolver i mapuje logiczną nazwę widoku do konkretnej implementacji widoku.

Niektóre możliwe implementacje ViewResolver są:

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

Gdy DispatcherServlet określa widok, który będzie wyświetlał wyniki to będzie renderowane jako odpowiedź.

Wreszcie, DispatcherServlet zwraca obiekt Response z powrotem do klienta.

Wiem, że to pytanie jest już oznaczone jako rozwiązane, ale chcę dodać nowszy obraz wyjaśniający szczegółowo ten wzór (źródło: spring in action 4):

Explanation

Gdy żądanie opuszcza przeglądarkę (1), zawiera informacje o tym, o co prosi użytkownik. Przynajmniej żądanie będzie zawierało żądany adres URL. Ale może również zawierać dodatkowe dane, takie jak informacje przekazane w formie przez użytkownik.

Pierwszy przystanek w podróży żądania jest w dyspozytorni Spring. Podobnie jak większość frameworków internetowych opartych na Javie, Spring MVC wysyła żądania za pośrednictwem jednego serwletu kontrolera. Kontroler frontowy jest powszechnym wzorcem aplikacji webowej, w którym pojedynczy serwlet przekazuje odpowiedzialność za żądanie innym komponentom aplikacji do rzeczywistego przetwarzania za pomocą formularza. W przypadku Spring MVC, DispatcherServlet jest kontrolerem frontowym. Zadaniem dyspozytora jest wysłanie żądanie do kontrolera Spring MVC. Kontroler jest komponentem Spring, który przetwarza żądanie. Ale typowa aplikacja może mieć kilka kontrolerów, a DispatcherServlet potrzebuje pomocy w podjęciu decyzji, do którego kontrolera wysłać żądanie. Tak więc DispatcherServlet konsultuje jeden lub więcej mapowań obsługi(2) aby dowiedzieć się, gdzie będzie następny przystanek. Mapowanie obsługi zwraca szczególną uwagę na adres URL podany przez żądanie podczas podejmowania decyzji. Raz na został wybrany odpowiedni kontroler, DispatcherServlet wysyła żądanie na swój sposób do wybranego kontrolera (3). Przy kontrolerze żądanie zrzuca swój ładunek (Informacje przekazane przez użytkownika) i cierpliwie czeka, aż Administrator przetwarza te informacje. (Właściwie dobrze zaprojektowany kontroler sam w sobie nie tworzy lub nie przetwarza, a zamiast tego przekazuje odpowiedzialność za logikę biznesową jednemu lub kilku obiektom usługowym.) Logika wykonywana przez kontroler często powoduje, że niektóre informacje muszą zostać przeniesione z powrotem do użytkownika i wyświetlone w przeglądarce. Informacje te są określane jako model. Ale wysyłanie surowych informacji z powrotem do użytkownika nie jest wystarczające-musi być sformatowane w przyjaznym dla użytkownika formacie, zazwyczaj HTML. W tym celu informacje muszą być przekazywane do widoku, zazwyczaj strony JavaServer (JSP). Jedną z ostatnich czynności kontrolera jest spakowanie danych modelu i określenie nazwy widoku, który powinien Renderuj wyjście. Następnie wysyła żądanie wraz z modelem i nazwą widoku z powrotem do DispatcherServlet (4). Aby kontroler nie był podłączony do określonego widoku, nazwa widoku przekazywana z powrotem do DispatcherServlet nie identyfikuje bezpośrednio określonego JSP. Nie musi nawet sugerować, że widok jest JSP. Zamiast tego zawiera tylko logiczną nazwę, która zostanie użyta do wyszukania rzeczywistego widoku, który wytworzy wynik. DispatcherServlet konsultuje widok resolver (5) mapowanie nazwy widoku logicznego do implementacji widoku spe-cific, która może być JSP. Teraz, gdy DispatcherServlet wie, który Widok wyrenderuje wynik, zadanie żądania jest prawie skończone. Jego ostatnim przystankiem jest realizacja widoku(6), zazwyczaj JSP, gdzie dostarcza dane modelu. Zadanie prośby zostało w końcu wykonane. Widok użyje danych modelu do renderowania danych wyjściowych, które zostaną przeniesione z powrotem do klienta przez (niezbyt pracowitą) odpowiedź obiekt (7).

DispatcherServlet jest implementacją Spring MVC wzorca front controller pattern .

Zobacz opis w dokumentach źródłowych TUTAJ .

Zasadniczo jest to servlet, który pobiera przychodzące żądanie i przekazuje przetwarzanie tego żądania do jednego z wielu programów obsługi, których mapowanie jest specyficzne w konfiguracji DispatcherServlet.

Możemy powiedzieć jak DispatcherServlet dbanie o wszystko na wiosnę MVC.

Przy uruchomieniu kontenera internetowego:

1. DispatcherServlet zostanie załadowany i zainicjalizowany przez wywołanie init() metoda
2. init() z DispatcherServlet spróbuje zidentyfikować sprężynę Dokument konfiguracyjny z konwencjami nazw, takimi jak "servlet_name-servlet.xml" wtedy wszystkie fasole mogą być zidentyfikowane.

Przykład:

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);
    }
    ...
}

Więc ogólnie DispatcherServlet przechwyć URI żądania i przekazać HandlerMapping. HandlerMapping wyszukiwanie map z metoda kontrolera, gdzie kontroler zwraca logiczną nazwę (widok). Następnie ta logiczna nazwa jest wysyłana do DispatcherServlet przez HandlerMapping. Następnie DispatcherServlet powiedz ViewResolver, aby podać pełną lokalizację widoku przez dodanie prefiksu i sufiksu, a następnie DispatcherServlet podaj widok klientowi.

Kontrolery dyspozytora są wyświetlane na rysunku wszystkie przychodzące żądania są przechwytywane przez serwlet dyspozytora, który działa jako kontroler frontowy. Serwlet dyspozytora pobiera z pliku XML wpis do mapowania obsługi i wysyła żądanie do kontrolera.

Można powiedzieć, że Dispatcher Servlet działa jako punkt wejścia i wyjścia dla każdego żądania. Ilekroć pojawia się żądanie, najpierw trafia ono do Servletu dyspozytora(DS), gdzie DS próbuje zidentyfikować swoją metodę obsługi ( metody definiowane w kontrolerze do obsługi żądań), gdy maper obsługi (DS pyta mapera obsługi) zwróci kontroler, Servlet dyspozytora zna kontroler, który może obsłużyć to żądanie i może teraz przejść do tego kontrolera, aby dalej wypełniać żądania. rozpatrzenie wniosku. Teraz kontroler może odpowiedzieć odpowiednią odpowiedzią, a następnie DS przechodzi do rozdzielacza widoku, aby określić, gdzie znajduje się widok, A gdy rozdzielacz widoku powie DS, chwyta ten widok i zwraca go do Ciebie jako ostateczną odpowiedź. Dodaję zdjęcie, które zrobiłem z YouTube z kanału Java Guides.

<?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>