Division de l'applicationContext en plusieurs fichiers

Question

Quelle est la bonne façon de diviser la configuration de Spring en plusieurs fichiers xml ? Pour l'instant, j'ai

• /WEB-INF/foo-servlet.xml
• /WEB-INF/foo-service.xml
• /WEB-INF/foo-persistance.xml

Mon web.xml contient les éléments suivants :

<servlet>
    <description>Spring MVC Dispatcher Servlet</description>
    <servlet-name>intrafest</servlet-name>
    <servlet-class>
        org.springframework.web.servlet.DispatcherServlet
    </servlet-class>
    <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>
            /WEB-INF/foo-*.xml
        </param-value>
    </init-param>
    <load-on-startup>2</load-on-startup>
</servlet>

<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>
            /WEB-INF/foo-*.xml
    </param-value>
</context-param>

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

Les vraies questions :

• Cette approche est-elle "correcte"/"meilleure" ?
• Dois-je vraiment spécifier les emplacements de la configuration à la fois dans le DispatcherServlet ET dans les sections context-param ?

Que dois-je garder à l'esprit pour pouvoir référencer les beans définis dans foo-servlet.xml à partir de foo-service.xml ? Cela a-t-il un rapport avec la spécification de contextConfigLocation dans web.xml ?

Mise à jour 1 :

J'utilise Spring framework 3.0. Si j'ai bien compris, il n'est pas nécessaire d'importer les ressources comme suit

 <import resource="foo-services.xml"/>".

Cette hypothèse est-elle correcte ?

Answer 1

Je trouve que la configuration suivante est la plus facile.

Utiliser le mécanisme de chargement du fichier de configuration par défaut de DispatcherServlet :

Le framework, lors de l'initialisation d'un DispatcherServlet, cherchera un fichier fichier nommé [servlet-name]-servlet.xml dans le répertoire WEB-INF de votre application web application web et créera les beans qui y sont définis (en remplaçant les définitions de tous les beans définis avec le le même nom dans la portée globale).

Dans votre cas, il suffit de créer un fichier intrafest-servlet.xml dans le WEB-INF et il n'est pas nécessaire de spécifier des informations spécifiques dans le fichier web.xml .

En intrafest-servlet.xml vous pouvez utiliser import pour composer votre configuration XML.

<beans>
  <bean id="bean1" class="..."/>
  <bean id="bean2" class="..."/>

  <import resource="foo-services.xml"/>
  <import resource="foo-persistence.xml"/>
</beans>

Notez que l'équipe Spring préfère en fait charger plusieurs fichiers de configuration lors de la création du (Web)ApplicationContext. Si vous voulez toujours procéder de cette manière, je pense que vous n'avez pas besoin de spécifier les deux paramètres de contexte ( context-param ) y les paramètres d'initialisation du servlet ( init-param ). L'un des deux fera l'affaire. Vous pouvez également utiliser des virgules pour spécifier plusieurs emplacements de configuration.

Answer 2

Voici la référence http://blog.codehangover.com/load-multiple-contexts-into-spring/

Il y a plusieurs façons de procéder.

1. web.xml contextConfigLocation

Votre première option est de les charger tous dans le contexte de votre application Web via la fonction élément ContextConfigLocation. Vous allez déjà avoir votre applicationContext primaire ici, en supposant que vous écrivez une application Web. Tout ce que vous avez à faire est de mettre un peu d'espace blanc entre la déclaration du contexte suivant.

<context-param>
    <param-name> contextConfigLocation </param-name>
    <param-value>
    applicationContext1.xml
    applicationContext2.xml
    </param-value>
</context-param>

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

Le texte ci-dessus utilise des retours de chariot. Sinon, vous pouvez simplement mettre un espace.

<context-param>
    <param-name> contextConfigLocation </param-name>
    <param-value> applicationContext1.xml applicationContext2.xml </param-value>
</context-param>

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

2. applicationContext.xml importation de ressources

L'autre option consiste à ajouter votre applicationContext.xml primaire au web.xml, puis à utiliser des instructions d'importation dans ce contexte primaire.

En applicationContext.xml vous pourriez avoir

<!-- hibernate configuration and mappings -->
<import resource="applicationContext-hibernate.xml"/>

<!-- ldap -->
<import resource="applicationContext-ldap.xml"/>

<!-- aspects -->
<import resource="applicationContext-aspects.xml"/>

Quelle stratégie utiliser ?

1. Je préfère toujours charger via web.xml .

En effet, cela me permet de garder tous les contextes isolés les uns des autres. Avec les tests, nous pouvons charger uniquement les contextes dont nous avons besoin pour exécuter ces tests. Cela rend également le développement plus modulaire, car les composants restent loosely coupled Ainsi, à l'avenir, je pourrai extraire un paquet ou une couche verticale et le déplacer vers son propre module.

2. Si vous chargez des contextes dans un non-web application j'utiliserais le import ressource.

Answer 3

Il y a deux types de contextes auxquels nous avons affaire :

1 : Contexte racine (contexte parent. Inclut typiquement toute l'initialisation de jdbc (ORM, Hibernate) et toute autre configuration liée à la sécurité de Spring).

2 Contexte de servlet : contexte de servlet individuel (contexte enfant, contexte de servlet typiquement dispatcher et initialiser tous les beans liés à spring-mvc (contrôleurs, URL Mapping etc.)).

Voici un exemple de web.xml qui inclut un fichier de contexte d'application multiple

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://java.sun.com/xml/ns/javaee"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
                            http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">

    <display-name>Spring Web Application example</display-name>

    <!-- Configurations for the root application context (parent context) -->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>
            /WEB-INF/spring/jdbc/spring-jdbc.xml <!-- JDBC related context -->
            /WEB-INF/spring/security/spring-security-context.xml <!-- Spring Security related context -->
        </param-value>
    </context-param>

    <!-- Configurations for the DispatcherServlet application context (child context) -->
    <servlet>
        <servlet-name>spring-mvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>
                /WEB-INF/spring/mvc/spring-mvc-servlet.xml
            </param-value>
        </init-param>
    </servlet>
    <servlet-mapping>
        <servlet-name>spring-mvc</servlet-name>
        <url-pattern>/admin/*</url-pattern>
    </servlet-mapping>

</web-app>

Answer 4

@eljenso : intrafest-servlet.xml webapplication context xml sera utilisé si l'application utilise SPRING WEB MVC.

Sinon, la configuration de @kosoant est parfaite.

Exemple simple : vous n'utilisez pas SPRING WEB MVC, mais vous voulez utiliser SPRING IOC :

Dans web.xml :

<context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:application-context.xml</param-value>
</context-param>

Ensuite, votre application-context.xml contiendra : <import resource="foo-services.xml"/> ces déclarations d'importation pour charger divers fichiers de contexte d'application et les placer dans le fichier principal application-context.xml.

Merci et j'espère que cela vous aidera.

Answer 5

Je suis l'auteur de Contextes modulaires à ressort .

Il s'agit d'une petite bibliothèque utilitaire permettant une organisation plus modulaire des contextes spring que celle obtenue par l'utilisation de Composer des métadonnées de configuration basées sur XML . modular-spring-contexts fonctionne en définissant des modules, qui sont essentiellement des contextes d'application autonomes, et en permettant aux modules d'importer des beans d'autres modules, qui sont exportés dans leur module d'origine.

Les points clés sont donc

• le contrôle des dépendances entre les modules
• le contrôle des haricots exportés et de leur utilisation.
• possibilité réduite de collisions de noms de haricots

Un exemple simple ressemblerait à ceci :

Fichier moduleDefinitions.xml :

<?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:module="http://www.gitlab.com/SpaceTrucker/modular-spring-contexts"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                        http://www.gitlab.com/SpaceTrucker/modular-spring-contexts xsd/modular-spring-contexts.xsd
                        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    <context:annotation-config />

    <module:module id="serverModule">
        <module:config location="/serverModule.xml" />
    </module:module>

    <module:module id="clientModule">
        <module:config location="/clientModule.xml" />
        <module:requires module="serverModule" />
    </module:module>

</beans>

Fichier serverModule.xml :

<?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:module="http://www.gitlab.com/SpaceTrucker/modular-spring-contexts"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                        http://www.gitlab.com/SpaceTrucker/modular-spring-contexts xsd/modular-spring-contexts.xsd
                        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    <context:annotation-config />

    <bean id="serverSingleton" class="java.math.BigDecimal" scope="singleton">
        <constructor-arg index="0" value="123.45" />
        <meta key="exported" value="true"/>
    </bean>

</beans>

Fichier clientModule.xml

<?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:module="http://www.gitlab.com/SpaceTrucker/modular-spring-contexts"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                        http://www.gitlab.com/SpaceTrucker/modular-spring-contexts xsd/modular-spring-contexts.xsd
                        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    <context:annotation-config />

    <module:import id="importedSingleton" sourceModule="serverModule" sourceBean="serverSingleton" />

</beans>