scénario 1

Dans application client (application is not web application, E. g peut être swing app)

private static ApplicationContext context = new  ClassPathXmlApplicationContext("test-client.xml");

context.getBean(name);

pas besoin de web.xml . Applicationcontexte comme conteneur pour obtenir le service bean. Pas besoin de conteneur de serveur web. Dans test-client.xml il peut y avoir des haricots simples sans remoting, haricots avec remoting.

Conclusion : Dans le scénario 1 applicationcontexte et DispatcherServlet ne sont pas liés.

scénario 2

dans une application Serveur (application déployée dans le serveur E. Tomcat). Accès au service par l'intermédiaire du programme client (E. g Swing app)

définit l'auditeur dans web.xml

<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

Au démarrage du serveur ContextLoaderListener instancie les haricots défini dans applicationcontexte.xml .

en supposant que vous avez défini ce qui suit dans applicationContext.xml :

<import resource="test1.xml" />
<import resource="test2.xml" />
<import resource="test3.xml" />
<import resource="test4.xml" />

les fèves sont instanciées à partir des quatre fichiers de configuration test1.xml , test2.xml , test3.xml , test4.xml .

Conclusion : In Scénario 2 applicationcontexte et DispatcherServlet ne sont pas liés.

scénario 3

dans une application web avec ressort MVC.

Dans "1519190920 web".xml define:

<servlet>
    <servlet-name>springweb</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>    
</servlet>

<servlet-mapping>
    <servlet-name>springweb</servlet-name>
    <url-pattern>*.action</url-pattern>
</servlet-mapping>

lorsque Tomcat commence, haricots définis dans springweb-servlet.les xml sont instanciés. DispatcherServlet s'étend FrameworkServlet . Dans FrameworkServlet l'instanciation de haricot a lieu pour springweb . Dans notre cas springweb est cadre Servlet.

Conclusion : dans le scénario 3, le contexte de l'application et DispatcherServlet ne sont pas liés.

scénario 4

en application web avec MVC printemps. springweb-servlet.xml pour servlet et applicationContext.xml pour accéder au service d'affaires dans le programme du serveur ou pour accéder au service DB dans un autre programme serveur.

Dans "1519190920 web".xml les termes suivants sont définis:

<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

<servlet>
    <servlet-name>springweb</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

</servlet>

<servlet-mapping>
    <servlet-name>springweb</servlet-name>
    <url-pattern>*.action</url-pattern>
</servlet-mapping>

Au démarrage du serveur, ContextLoaderListener instancie les haricots défini dans applicationContext.xml ; en supposant que vous avez déclaré ici:

<import resource="test1.xml" />
<import resource="test2.xml" />
<import resource="test3.xml" />
<import resource="test4.xml" />

les haricots sont tous instanciés à partir des quatre tests 1.xml , test2.XML , test 3.xml , test4.xml . Après l'achèvement de l'instanciation bean défini dans applicationContext.xml , puis les haricots défini dans springweb-servlet.les xml sont instanciés.

ainsi l'ordre d'instanciation est le contexte d'application de root is, puis celui de Framorkservlet.

Maintenant, il est clair pourquoi ils sont importants dans le scénario.

je voudrais ajouter un point. Dans spring-servlet.xml , nous incluons le balayage des composants pour le paquet Controller. Dans l'exemple suivant, nous incluons l'annotation de filtre pour le paquet controller.

<!-- Scans for annotated @Controllers in the classpath -->
<context:component-scan base-package="org.test.web" use-default-filters="false">
    <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

dans applicationcontext.xml , nous ajoutons un filtre pour le reste du paquet, à l'exclusion du contrôleur.

<context:component-scan base-package="org.test">
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

en termes simples,

applicationContext.xml définit les haricots qui sont partagés entre toutes les portions. Si votre application a plus d'un servlet, alors définir les ressources communes dans le applicationContext.xml serait plus logique.

spring-servlet.xml s'entend des haricots qui ne sont apparentés qu'à ce service. Ici, c'est le servlet du répartiteur. Ainsi, vos contrôleurs MVC du printemps doivent être définis dans ce fichier.

il n'y a rien erreur dans la définition de tous les haricots dans le spring-servlet.xml si vous n'utilisez qu'un seul servlet dans votre application web.

Les contextes D'Application

fournissent un moyen de résoudre les messages textes, y compris un support pour i18n de ces messages. Les contextes d'Application fournissent une façon générique de charger des ressources de fichiers, comme des images. Les contextes d'Application peuvent publier des événements à des fèves qui sont enregistrés en tant qu'auditeurs. Certaines opérations sur le conteneur ou les haricots dans le conteneur, qui doivent être manipulés de manière programmée avec une usine de haricots, peuvent être manipulées déclarativement dans un contexte d'application. ResourceLoader prise en charge: L'interface ressource de Spring utilise une abstraction Générique flexible pour gérer les ressources de bas niveau. Un contexte d'application lui-même est un ResourceLoader, donc fournit une application avec accès à des instances de ressources spécifiques au déploiement. Soutien de MessageSource: le contexte d'application implémente MessageSource, une interface utilisée pour obtenir des messages localisés, avec l'implémentation réelle étant pluggable

dans la technologie Servlet si vous voulez passer n'importe quelle entrée à un servlet particulier alors vous devez passer dans init param comme ci-dessous le code.

 <servlet>
    <servlet-name>DBController</servlet-name>
    <servlet-class>com.test.controller.DBController</servlet-class>
    <init-param>
        <param-name>username</param-name>
        <param-value>John</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
</servlet>

<servlet-mapping>
    <servlet-name>DBController</servlet-name>
    <url-pattern>/DBController</url-pattern>
</servlet-mapping>

si vous voulez passer certains en put qui sont communs à tous les servlets, alors cette fois vous devez configurer le contexte param. Exemple

 <context-param>
    <param-name>email</param-name>
    <param-value>admin@example.com</param-value>
</context-param>

donc exactement comme ceci quand nous travaillons avec ressort MVC nous avons besoin de fournir quelques informations à servlet prédéfini fourni par ressort qui est Les répartiteurs passent par init param. Donc la configuration est comme des jachères, ici nous fournissons le ressort-servlet.xml comme init paramètre à DispatcherServlet.

 <?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns="http://java.sun.com/xml/ns/javaee"
        xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
              http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
    id="WebApp_ID" version="3.0">
    <display-name>Spring MVC App</display-name>

    <servlet>
        <servlet-name>SpringController</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>/WEB-INF/spring-servlet.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>

    <servlet-mapping>
        <servlet-name>SpringController</servlet-name>
        <url-pattern>*.htm</url-pattern>
    </servlet-mapping>
</web-app>

encore une fois, nous avons besoin d'un contexte param. Qui est applicable pour l'ensemble de l'application. Nous pouvons donc fournir le contexte racine qui est applicationcontexte.XML La configuration est la suivante:

    <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>/WEB-INF/applicationcontext.xml</param-value>
</context-param>
<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

<servlet>
        <servlet-name>SpringController</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>/WEB-INF/spring-servlet.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>

    <servlet-mapping>
        <servlet-name>SpringController</servlet-name>
        <url-pattern>*.htm</url-pattern>
    </servlet-mapping>