Quelle est la différence entre ApplicationContext et WebApplicationContext dans Spring MVC?

Quelle est la différence entre le contexte d'application et le contexte d'application Web?

Je sais que cela WebApplicationContextest utilisé pour les applications orientées architecture Spring MVC?

Je veux savoir à quoi sert les ApplicationContextapplications MVC? Et dans quel type de haricots sont définis ApplicationContext?

Contexte d'application Web étendu Contexte d'application conçu pour fonctionner avec le javax.servlet.ServletContext standard afin qu'il puisse communiquer avec le conteneur.

public interface WebApplicationContext extends ApplicationContext {
    ServletContext getServletContext();
}

Les beans, instanciés dans WebApplicationContext pourront également utiliser ServletContext s'ils implémentent l'interface ServletContextAware

package org.springframework.web.context;
public interface ServletContextAware extends Aware { 
     void setServletContext(ServletContext servletContext);
}

Il y a beaucoup de choses possibles à faire avec l'instance ServletContext, par exemple accéder aux ressources WEB-INF (configs xml et etc.) en appelant la méthode getResourceAsStream (). En général, tous les contextes d'application définis dans web.xml dans une application Spring de servlet sont des contextes d'application Web, cela va à la fois au contexte webapp racine et au contexte d'application du servlet.

En outre, selon les capacités du contexte de l'application Web, votre application peut être un peu plus difficile à tester et vous devrez peut-être utiliser MockServletContext classe pour les tests.

Différence entre le servlet et le contexte racine Spring vous permet de créer des hiérarchies de contexte d'application à plusieurs niveaux, de sorte que le bean requis sera extrait du contexte parent s'il n'est pas présent dans le contexte d'application actuel. Dans des applications Web par défaut , il y a deux niveaux de la hiérarchie, les contextes de racines et servlet: .

Cela vous permet d'exécuter certains services en tant que singletons pour l'application entière (les beans Spring Security et les services d'accès à la base de données de base résident généralement ici) et un autre en tant que services séparés dans les servlets correspondants pour éviter les conflits de noms entre les beans. Par exemple, un contexte de servlet servira les pages Web et un autre implémentera un service Web sans état.

Cette séparation à deux niveaux est prête à l'emploi lorsque vous utilisez les classes de servlet Spring: pour configurer le contexte de l'application racine, vous devez utiliser la balise context-param dans votre web.xml

<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>
        /WEB-INF/root-context.xml
            /WEB-INF/applicationContext-security.xml
    </param-value>
</context-param>

(le contexte de l'application racine est créé par ContextLoaderListener qui est déclaré dans web.xml

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

) et la balise servlet pour les contextes d'application de servlet

<servlet>
   <servlet-name>myservlet</servlet-name>
   <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
   <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>app-servlet.xml</param-value>
   </init-param>
</servlet>

Veuillez noter que si init-param sera omis, alors spring utilisera myservlet-servlet.xml dans cet exemple.

Voir aussi: Différence entre applicationContext.xml et spring-servlet.xml dans Spring Framework

Pour en revenir aux jours Servlet, web.xml ne peut en avoir qu'un <context-param> , donc un seul objet de contexte est créé lorsque le serveur charge une application et que les données de ce contexte sont partagées entre toutes les ressources (Ex: Servlets et JSP). C'est la même chose que d'avoir le nom du pilote de base de données dans le contexte, qui ne changera pas. De la même manière, lorsque nous déclarons le paramètre contextConfigLocation dans <contex-param>Spring crée un objet Contexte d'application.

 <context-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>com.myApp.ApplicationContext</param-value>
 </context-param>

Vous pouvez avoir plusieurs servlets dans une application. Par exemple, vous voudrez peut-être gérer les demandes / secure / * d'une manière et / non-seucre / * d'une autre manière. Pour chacun de ces servlets, vous pouvez avoir un objet contextuel, qui est un WebApplicationContext.

<servlet>
    <servlet-name>SecureSpringDispatcher</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
        <param-name>contextClass</param-name>
        <param-value>com.myapp.secure.SecureContext</param-value>
    </init-param>
</servlet>
<servlet-mapping>
    <servlet-name>SecureSpringDispatcher</servlet-name>
    <url-pattern>/secure/*</url-pattern>
</servlet-mapping>
<servlet>
    <servlet-name>NonSecureSpringDispatcher</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
        <param-name>contextClass</param-name>
        <param-value>com.myapp.non-secure.NonSecureContext</param-value>
    </init-param>
</servlet>
<servlet-mapping>
    <servlet-name>NonSecureSpringDispatcher</servlet-name>
    <url-pattern>/non-secure/*</url-patten>
</servlet-mapping>

La réponse acceptée est terminée mais il y a une explication officielle à ce sujet:

Le WebApplicationContext est une extension du simple ApplicationContext qui a quelques fonctionnalités supplémentaires nécessaires pour les applications Web. Il diffère d'un ApplicationContext normal en ce qu'il est capable de résoudre des thèmes (voir Utilisation de thèmes) et qu'il sait à quel Servlet il est associé (en ayant un lien vers le ServletContext). Le WebApplicationContext est lié dans le ServletContext et en utilisant des méthodes statiques sur la classe RequestContextUtils, vous pouvez toujours rechercher le WebApplicationContext si vous avez besoin d'y accéder.

Cité à partir de la référence du framework Web Spring

Par ailleurs, le servlet et le contexte racine sont tous deux webApplicationContext:

ApplicationContext (Root Application Context): chaque application Web Spring MVC possède un fichier applicationContext.xml qui est configuré comme racine de la configuration du contexte. Spring charge ce fichier et crée un ApplicationContext pour l'ensemble de l'application. Ce fichier est chargé par ContextLoaderListener qui est configuré en tant que paramètre de contexte dans le fichier web.xml. Et il n'y aura qu'un seul applicationContext par application web.

WebApplicationContext: WebApplicationContext est un contexte d'application Web, c'est-à-dire qu'il contient des informations de contexte de servlet. Une seule application Web peut avoir plusieurs WebApplicationContext et chaque servlet Dispatcher (qui est le contrôleur frontal de l'architecture Spring MVC) est associé à un WebApplicationContext. Le fichier de configuration webApplicationContext * -servlet.xml est spécifique à un DispatcherServlet. Et comme une application Web peut avoir plusieurs servlets de répartiteur configurés pour répondre à plusieurs demandes, il peut y avoir plusieurs fichiers webApplicationContext par application Web.

Le contexte d'application Web , spécifié par l' WebApplicationContextinterface, est un contexte d'application Spring pour une application Web. Il possède toutes les propriétés d'un contexte d'application Spring normal, étant donné que l' WebApplicationContextinterface étend l' ApplicationContextinterface et ajoute une méthode pour récupérer l'API Servlet standardServletContext pour l'application Web.

En plus des étendues standard du bean Spring singletonet prototype, trois étendues supplémentaires sont disponibles dans un contexte d'application Web:

• request- étend une définition de bean unique au cycle de vie d'une seule requête HTTP; c'est-à-dire que chaque requête HTTP a sa propre instance d'un bean créé à l'arrière d'une définition de bean unique
• session - étend une définition de bean unique au cycle de vie d'une session HTTP
• application - étend une définition de bean unique au cycle de vie d'un ServletContext