Wat is Dispatcher Servlet in de lente?

In deze afbeelding (die ik heb gekregen van hier), HTTP-verzoek stuurt iets naar Dispatcher Servlet.

Mijn vraag is wat doet Dispatcher Servlet?

Is het zoiets als het krijgen van de informatie die van de webpagina wordt gegooid en naar de controller wordt gegooid?

Antwoord 1, autoriteit 100%

De taak van de DispatcherServletis om een ​​inkomende URI te nemen en de juiste combinatie te vinden van handlers (meestal methoden op Controller-klassen) en views (meestal JSP’s) die combineren om de pagina of bron te vormen die op die locatie zou moeten worden gevonden.

Misschien heb ik

• een bestand /WEB-INF/jsp/pages/Home.jsp

• en een methodevoor een klas

  @RequestMapping(value="/pages/Home.html")
  private ModelMap buildHome() {
      return somestuff;
  }
  

De Dispatcher-servletis het bit dat “weet” om die methode aan te roepen wanneer een browser de pagina opvraagt, en om de resultaten ervan te combineren met het overeenkomende JSP-bestand om een ​​html-document te maken.

Hoe het dit bereikt, verschilt sterk per configuratie en Spring-versie.

Er is ook geen reden waarom het eindresultaat webpagina’s moet zijn. Het kan hetzelfde doen om RMI-eindpunten te lokaliseren, SOAP-verzoeken af ​​te handelen, alles wat in een servlet kan komen.

Antwoord 2, autoriteit 40%

In Spring MVC gaan alle inkomende verzoeken via één enkele servlet. Deze servlet – DispatcherServlet– is de frontcontroller. Frontcontroller is een typisch ontwerppatroon in de ontwikkeling van webapplicaties. In dit geval ontvangt een enkele servlet alle verzoeken en stuurt deze door naar alle andere componenten van de applicatie.

De taak van de DispatcherServletis om een ​​verzoek naar de specifieke Spring MVC-controller te sturen.

Meestal hebben we veel controllers en DispatcherServletverwijst naar een van de volgende mappers om de doelcontroller te bepalen:

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

Als er geen configuratie wordt uitgevoerd, gebruikt de DispatcherServletstandaard BeanNameUrlHandlerMappingen DefaultAnnotationHandlerMapping.

Als de doelcontroller is geïdentificeerd, stuurt de DispatcherServleteen verzoek ernaar. De controller voert wat werk uit volgens het verzoek
(of delegeer het aan de andere objecten), en keert terug naar de DispatcherServletmet het Model en de naam van de View.

De naam van de weergave is slechts een logische naam. Deze logische naam wordt vervolgens gebruikt om te zoeken naar de werkelijke View (om koppeling met de controller en specifieke View te voorkomen). Vervolgens verwijst DispatcherServletnaar de ViewResolveren wijst de logische naam van de View toe aan de specifieke implementatie van de View.

Enkele mogelijke implementaties van de ViewResolverzijn:

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

Wanneer de DispatcherServletde weergave bepaalt die de resultaten zal weergeven, wordt deze weergegeven als het antwoord.

Ten slotte retourneert de DispatcherServlethet Response-object terug naar de client.

Antwoord 3, autoriteit 29%

Ik weet dat deze vraag al als opgelost is gemarkeerd, maar ik wil een nieuwere afbeelding toevoegen waarin dit patroon in detail wordt uitgelegd (bron: spring in action 4):

Uitleg

Als het verzoek de browser (1)verlaat, bevat het informatie over waar de gebruiker om vraagt. Het verzoek zal in ieder geval de gevraagde URL bevatten. Maar het kan ook aanvullende gegevens bevatten, zoals de informatie die door de gebruiker in een formulier is ingediend.

De eerste stop tijdens de reis van het verzoek is bij Spring’s DispatcherServlet. Zoals de meeste op Java gebaseerde webframeworks, leidt Spring MVC verzoeken door een enkele frontcontrollerservlet. Een frontcontroller is een algemeen patroon voor webtoepassingen waarbij een enkele servlet de verantwoordelijkheid voor een verzoek delegeert aan andere componenten van een toepassing om de daadwerkelijke verwerking uit te voeren. In het geval van Spring MVC is DispatcherServlet de frontcontroller.
De taak van de DispatcherServlet is om het verzoek door te sturen naar een Spring MVC-controller. Een controller is een Spring-component die de aanvraag verwerkt. Maar een typische toepassing kan meerdere controllers hebben, en DispatcherServlet heeft wat hulp nodig om te beslissen naar welke controller het verzoek moet worden verzonden. Dus de DispatcherServlet raadpleegt een of meer handlertoewijzingen (2)om erachter te komen waar de volgende stop van het verzoek zal zijn. De handlertoewijzing besteedt bijzondere aandacht aan de URL die door het verzoek wordt gedragen bij het nemen van zijn beslissing.
Zodra een geschikte controller is gekozen, stuurt DispatcherServlet het verzoek op zijn vrolijke manier naar de gekozen controller (3). Bij de controller laat het verzoek zijn payload vallen (de informatie die door de gebruiker wordt ingediend) en wacht geduldig terwijl de controller die informatie verwerkt. (Eigenlijk voert een goed ontworpen verwerkingsverantwoordelijke zelf weinig of geen verwerkingen uit en delegeert in plaats daarvan de verantwoordelijkheid voor de bedrijfslogica aan een of meer serviceobjecten.)
De logica die door een controller wordt uitgevoerd, resulteert vaak in bepaalde informatie die naar de gebruiker moet worden teruggevoerd en in de browser moet worden weergegeven. Deze informatie wordt het model genoemd. Maar onbewerkte informatie terugsturen naar de gebruiker is niet voldoende – het moet worden opgemaakt in een gebruiksvriendelijk formaat, meestal HTML. Daarvoor moet de informatie worden gegeven aan een weergave, meestal een JavaServer Page (JSP).
Een van de laatste dingen die een controller doet, is de modelgegevens inpakken en de naam identificeren van een weergave die de uitvoer moet weergeven. Het stuurt dan het verzoek, samen met de naam van het model en de weergave, terug naar de DispatcherServlet (4).
Om ervoor te zorgen dat de controller niet aan een bepaalde weergave wordt gekoppeld, identificeert de weergavenaam die wordt doorgegeven aan DispatcherServlet niet direct een specifieke JSP. Het suggereert niet eens dat de weergave een JSP is. In plaats daarvan heeft het alleen een logische naam die zal worden gebruikt om de werkelijke weergave op te zoeken die het resultaat zal opleveren. De DispatcherServlet raadpleegt een view-resolver (5)om de logische viewnaam toe te wijzen aan een specifieke view-implementatie, al dan niet een JSP.
Nu DispatcherServlet weet welke weergave het resultaat zal weergeven, is de taak van het verzoek bijna voorbij. De laatste stop is bij de weergave-implementatie (6), meestal een JSP, waar het de modelgegevens levert. De taak van het verzoek is eindelijk gedaan. De weergave gebruikt de modelgegevens om uitvoer weer te geven die door het (niet zo hardwerkende) responsobject (7)naar de klant wordt teruggestuurd.

Antwoord 4, autoriteit 22%

DispatcherServletis Spring MVC’s implementatie van de frontcontroller patroon.

Zie de beschrijving in de Spring-documenten hier.

In wezen is het een servlet die het binnenkomende verzoek opneemt en de verwerking van dat verzoek delegeert aan een van een aantal handlers, waarvan de toewijzing specifiek is in de DispatcherServlet-configuratie.

Antwoord 5, autoriteit 3%

We kunnen zeggen dat DispatcherServletvoor alles zorgt in Spring MVC.

Bij opstarten webcontainer:

1. DispatcherServletwordt geladen en geïnitialiseerd door aan te roepen
   init()methode
2. init()van DispatcherServletzal proberen de lente te identificeren
   Configuratiedocument met naamgevingsconventies zoals
   "servlet_name-servlet.xml"dan kunnen alle bonen worden geïdentificeerd.

Voorbeeld:

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

Dus, in het algemeen DispatcherServletvang verzoek-URI op en overhandig aan HandlerMapping. HandlerMappingsearch mapping bean met methode van controller, waarbij controller logische naam (view) retourneert. Vervolgens wordt deze logische naam naar DispatcherServletgestuurd door HandlerMapping. Vervolgens vertelt DispatcherServletViewResolverom de volledige locatie van de weergave te geven door een voor- en achtervoegsel toe te voegen, en DispatcherServletgeeft de client de weergave.

Antwoord 6

Je kunt zeggen dat Dispatcher Servlet fungeert als een ingangs- en uitgangspunt voor elk verzoek. Telkens wanneer een verzoek binnenkomt, gaat het eerst naar de Dispatcher Servlet (DS) waar de DS vervolgens zijn handlermethode probeert te identificeren (de methoden die u in de controller definieert om de verzoeken af ​​​​te handelen), zodra de handler-mapper (de DS vraagt ​​de handler-mapper) retourneert de controller de dispatcher-servlet kent de controller die dit verzoek kan behandelen en kan nu naar deze controller gaan om de verwerking van het verzoek verder te voltooien. Nu kan de controller reageren met een gepast antwoord en dan gaat de DS naar de view resolver om te bepalen waar de view zich bevindt en zodra de view resolver de DS vertelt, pakt hij die view en stuurt het terug naar jou als het laatste antwoord. Ik voeg een afbeelding toe die ik van YouTube heb gehaald van het kanaal Java Guides.

Antwoord 7

Dispatcher Controller worden weergegeven in de afbeelding, alle inkomende verzoeken worden onderschept door de dispatcher-servlet die als frontcontroller werkt.
De servlet van de dispatcher krijgt een invoer voor handlertoewijzing uit het XML-bestand en stuurt het verzoek door naar de controller.

Antwoord 8

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