Dividir applicationContext en varios archivos

StackOverflow https://stackoverflow.com/questions/600095

  •  03-07-2019
  •  | 
  •  

Pregunta

¿Cuál es la forma correcta de dividir la configuración de Spring en varios archivos xml?

De momento tengo

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

Mi web.xml tiene lo siguiente:

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

Las preguntas reales:

  • ¿Es este enfoque correcto/mejor?
  • ¿Realmente necesito especificar las ubicaciones de configuración tanto en el DispatcherServlet Y el context-param secciones?

¿Qué debo tener en cuenta para poder hacer referencia a los beans definidos en foo-servlet.xml de foo-service.xml?¿Tiene esto algo que ver con especificar contextConfigLocation en web.xml?

Actualización 1:

Estoy usando Primavera marco 3.0.Tengo entendido que no necesito importar recursos de esta manera:

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

¿Es esta una suposición correcta?

¿Fue útil?

Solución

La siguiente configuración me parece la más sencilla.

Utilice el mecanismo de carga de archivos de configuración predeterminado de DespachadorServlet:

El marco, en la inicialización de un desplazador, buscará un archivo llamado [servlet-name] -servlet.xml en el directorio web-INF de su aplicación web y creará los frijoles definidos allí (anulando las definiciones de cualquier granos definidos con el mismo nombre en el alcance global).

En su caso, simplemente cree un archivo intrafest-servlet.xml en el WEB-INF dir y no es necesario especificar ninguna información específica en web.xml.

En intrafest-servlet.xml archivo que puedes usar importar para componer su configuración XML.

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

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

Tenga en cuenta que el equipo de Spring en realidad prefiere cargar varios archivos de configuración al crear el (Web)ApplicationContext.Si aún desea hacerlo de esta manera, creo que no necesita especificar ambos parámetros de contexto (context-param) y parámetros de inicialización del servlet (init-param).Uno de los dos servirá.También puede utilizar comas para especificar varias ubicaciones de configuración.

Otros consejos

Mike Nereson tiene esto que decir en su blog en:

http://blog.codehangover.com/load-multiple-contexts-into-spring/

  

Hay un par de formas de hacer esto.

     

1. web.xml contextConfigLocation

     

Su primera opción es cargarlos todos en su aplicación web   contexto a través del elemento ContextConfigLocation. & # 8217; ya vas   para tener su aplicación principal Contexto aquí, suponiendo que & # 8217; está escribiendo   Una aplicación web. Todo lo que necesitas hacer es poner algo de espacio en blanco entre   la declaración del próximo contexto. 

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

Lo anterior usa retornos de carro. Alternativamente, podrías poner un   espacio. 

  <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. recurso de importación applicationContext.xml

     

Su otra opción es simplemente agregar su applicationContext.xml principal   al web.xml y luego use las declaraciones de importación en ese contexto primario.

     

En applicationContext.xml puede que tenga & # 8230; 

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

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

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

¿Qué estrategia debes usar?

     

1. Siempre prefiero cargar a través de web.xml .

     

Porque, esto me permite mantener todos los contextos aislados de cada   otro. Con las pruebas, podemos cargar solo los contextos que necesitamos para ejecutar   Esas pruebas. Esto hace que el desarrollo sea más modular también como componentes.   permanecer loosely coupled, para que en el futuro pueda extraer un paquete   o capa vertical y moverlo a su propio módulo.

     

2. Si está cargando contextos en un non-web application, usaría el recurso import.

Hay dos tipos de contextos con los que estamos tratando:

1 : contexto raíz (contexto padre. Normalmente incluye todas las inicializaciones jdbc (ORM, Hibernate) y otras configuraciones relacionadas con la seguridad de primavera)

2 : contexto de servlet individual (contexto hijo. Contexto de servlet de despachador típico e inicializar todos los beans relacionados con spring-mvc (controladores, mapeo de URL, etc.)).

Aquí hay un ejemplo de web.xml que incluye múltiples archivos de contexto de aplicación 

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

@eljenso: intrafest-servlet.xml webapplication context xml se usará si la aplicación usa SPRING WEB MVC.

De lo contrario, la configuración de @kosoant está bien.

Ejemplo simple si no utiliza SPRING WEB MVC, pero desea utilizar SPRING IOC:

En web.xml: 

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

Entonces, su application-context.xml contendrá: <import resource="foo-services.xml"/> estas declaraciones de importación para cargar varios archivos de contexto de aplicación y poner en application-context.xml principal.

Gracias y espero que esto ayude.

soy el autor de contextos-de-primavera-modulares.

Esta es una pequeña biblioteca de utilidades que permite una organización más modular de contextos de primavera que la que se logra mediante el uso Componer metadatos de configuración basados ​​en XML. modular-spring-contexts funciona definiendo módulos, que son básicamente contextos de aplicación independientes y permitiendo que los módulos importen beans de otros módulos, que se exportan en su módulo de origen.

Los puntos clave entonces son

  • control sobre las dependencias entre módulos
  • Control sobre qué granos se exportan y dónde se utilizan.
  • posibilidad reducida de nombrar colisiones de frijoles

Un ejemplo sencillo se vería así:

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

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

Archivo 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>
Licenciado bajo: CC-BY-SA con atribución
No afiliado a StackOverflow
scroll top