web-dev-qa-db-fra.com

Qu'est-ce que Dispatcher Servlet au printemps?

Dans cette image (que j'ai obtenue de ici), HTTP request envoie quelque chose à Dispatcher Servlet.

enter image description here

Ma question est ce que fait Dispatcher Servlet ?

Est-ce quelque chose comme obtenir les informations émises depuis la page Web et les envoyer au contrôleur?

javaspringspring-mvc
172
Kevin

Le travail de DispatcherServlet consiste à prendre un URI entrant et à trouver la bonne combinaison de gestionnaires (généralement des méthodes sur Controller classes) et de vues (généralement des JSP) qui se combinent pour former le page ou ressource qui est censé être trouvé à cet endroit.

Je pourrais avoir

  • un fichier /WEB-INF/jsp/pages/Home.jsp

  • et un méthode sur une classe

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

Le servlet de répartiteur est le bit qui "sait" appeler cette méthode lorsqu'un navigateur demande la page et associer ses résultats au fichier JSP correspondant pour créer un document HTML.

La manière dont cela accomplit cela varie grandement avec la configuration et la version Spring.

Il n'y a pas non plus de raison que le résultat final doive être des pages Web. Il peut faire la même chose pour localiser RMI extrémités, manipuler SOAP demandes, tout ce qui peut entrer dans une servlet.

186
Affe

Au printemps MVC, toutes les demandes entrantes passent par un seul servlet. Cette servlet - DispatcherServlet - est le contrôleur frontal. Le contrôleur frontal est un modèle de conception typique dans le développement d'applications Web. Dans ce cas, un seul servlet reçoit toutes les demandes et les transfère à tous les autres composants de l'application.

La tâche DispatcherServlet consiste à envoyer une demande au contrôleur Spring MVC spécifique.

Nous avons généralement beaucoup de contrôleurs et DispatcherServlet fait référence à l'un des mappeurs suivants afin de déterminer le contrôleur cible:

Si aucune configuration n'est effectuée, DispatcherServlet utilise BeanNameUrlHandlerMapping et DefaultAnnotationHandlerMapping par défaut.

Lorsque le contrôleur cible est identifié, DispatcherServlet lui envoie une requête. Le contrôleur effectue un travail en fonction de la demande (ou le délègue aux autres objets), puis revient à DispatcherServlet avec le modèle et le nom de la vue.

Le nom de la vue n'est qu'un nom logique. Ce nom logique est ensuite utilisé pour rechercher la vue réelle (pour éviter le couplage avec le contrôleur et une vue spécifique). Ensuite, DispatcherServlet fait référence à ViewResolver et mappe le nom logique de la vue à l'implémentation spécifique de la vue.

Certaines implémentations possibles de ViewResolver sont les suivantes:

Lorsque DispatcherServlet détermine la vue qui affichera les résultats, elle sera restituée sous forme de réponse.

Enfin, DispatcherServlet renvoie l'objet Response au client.

59
Aleksey Bykov

DispatcherServlet est l'implémentation de Spring MVC du modèle du contrôleur frontal .

Voir la description dans la documentation de printemps ici .

Il s'agit essentiellement d'un servlet qui prend la demande entrante et en délègue le traitement à l'un des nombreux gestionnaires dont le mappage est spécifique dans la configuration DispatcherServlet.

46
skaffman

Je sais que cette question est déjà marquée comme résolue, mais je souhaite ajouter une nouvelle image expliquant ce motif en détail (source: spring in action 4):

enter image description here

Explication

Lorsque la demande quitte le navigateur (1) , elle contient des informations sur ce que l'utilisateur demande. Au minimum, la demande portera l'URL demandée. Mais il peut également contenir des données supplémentaires, telles que les informations soumises dans un formulaire par l'utilisateur.

Le premier arrêt des déplacements de la demande est à Spring’s DispatcherServlet. Comme la plupart des infrastructures Web basées sur Java, Spring MVC répartit les demandes via un seul servlet de contrôleur frontal. Un contrôleur frontal est un modèle d'application Web commun dans lequel un seul servlet délègue la responsabilité d'une demande à d'autres composants d'une application pour effectuer le traitement réel. Dans le cas de Spring MVC, DispatcherServlet est le contrôleur frontal. Le travail de DispatcherServlet consiste à envoyer la demande à un contrôleur Spring MVC. Un contrôleur est un composant Spring qui traite la demande. Mais une application typique peut avoir plusieurs contrôleurs et DispatcherServlet a besoin d'aide pour choisir le contrôleur auquel envoyer la demande. Ainsi, DispatcherServlet consulte un ou plusieurs mappages de gestionnaires (2) pour déterminer l’endroit où la requête sera placée. Le mappage du gestionnaire accorde une attention particulière à l'URL véhiculée par la demande lors de la prise de décision. Une fois qu'un contrôleur approprié a été choisi, DispatcherServlet envoie la demande joyeusement au contrôleur choisi (3) . Sur le contrôleur, la demande laisse tomber sa charge utile (les informations soumises par l'utilisateur) et attend patiemment pendant que le contrôleur traite ces informations. (En réalité, un contrôleur bien conçu effectue lui-même peu ou pas de traitement et délègue plutôt la responsabilité de la logique métier à un ou plusieurs objets de service.) La logique exécutée par un contrôleur entraîne souvent le renvoi d'informations à l'utilisateur et affiché dans le navigateur. Cette information est appelée modèle. Mais renvoyer des informations brutes à l’utilisateur n’est pas suffisant: elles doivent être formatées dans un format convivial, généralement HTML. Pour cela, les informations doivent être données à une vue, généralement une page JavaServer (JSP). Une des dernières choses que fait un contrôleur est de regrouper les données de modèle et d’identifier le nom d’une vue qui doit restituer la sortie. Il envoie ensuite la demande, ainsi que le modèle et le nom de la vue, à DispatcherServlet (4) . Pour que le contrôleur ne soit pas couplé à une vue particulière, le nom de la vue renvoyé à DispatcherServlet n'identifie pas directement un JSP spécifique. Cela ne signifie même pas nécessairement que la vue est un fichier JSP. Au lieu de cela, il ne porte qu'un nom logique qui sera utilisé pour rechercher la vue réelle qui produira le résultat. DispatcherServlet consulte un résolveur de vues (5) pour mapper le nom de la vue logique sur une implémentation de vue spécifique, qui peut ou non être un JSP. Maintenant que DispatcherServlet sait quelle vue rendra le résultat, le travail de la requête est presque terminé. Son arrêt final est lors de la mise en œuvre de la vue (6) , généralement une JSP, dans laquelle il fournit les données du modèle. Le travail de la demande est enfin terminé. La vue utilisera les données de modèle pour restituer la sortie qui sera renvoyée au client par l'objet de réponse (pas si laborieux) (7) .

34
Eduardo

On peut dire comme DispatcherServlet s'occuper de tout dans Spring MVC.

Au démarrage du conteneur Web:

  1. DispatcherServlet sera chargé et initialisé en appelant la méthode init()
  2. init() sur DispatcherServlet essaiera d'identifier le document de configuration Spring avec des conventions de dénomination telles que "servlet_name-servlet.xml" pour que tous les beans puissent être identifiés.

Exemple:

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

Donc, généralement DispatcherServlet URI de demande de capture et remise à HandlerMapping. HandlerMapping recherche un bean de mappage avec une méthode de contrôleur, contrôleur renvoyant un nom logique (vue). Ensuite, ce nom logique est envoyé à DispatcherServlet par HandlerMapping. Ensuite, DispatcherServlet indique à ViewResolver de donner l'emplacement complet de la vue en ajoutant un préfixe et un suffixe, puis DispatcherServlet donne la vue au client.

7
user2663609

Les contrôleurs de répartiteur sont affichés sur la figure; toute la demande entrante est interceptée par le servlet de répartiteur qui fonctionne en tant que contrôleur frontal. Le servlet de distributeur obtient une entrée du mappage de gestionnaire à partir du fichier XML et prévient la demande adressée au contrôleur.

0
anjali shrivas
<?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>
0
kartik