Dividere applicationContext su più file

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

  •  03-07-2019
  •  | 
  •  

Domanda

Qual è il modo corretto di dividere la configurazione di Spring in più file XML?

Al momento l'ho

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

Il mio web.xml ha il seguente: 

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

Le domande attuali:

  • Questo approccio è corretto / migliore ?
  • Devo davvero specificare le posizioni di configurazione sia nelle sezioni DispatcherServlet AND che nelle context-param?

Cosa devo tenere a mente per poter fare riferimento ai bean definiti in foo-servlet.xml da foo-service.xml? Ciò ha a che fare con la specifica di contextConfigLocation in <=>?

Aggiornamento 1:

Sto usando Spring framework 3.0. Comprendo che non ho bisogno di importare risorse in questo modo: 

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

È un presupposto corretto?

È stato utile?

Soluzione

Trovo la seguente configurazione la più semplice.

Utilizza il meccanismo di caricamento dei file di configurazione predefinito di DispatcherServlet :

  

Il framework sarà, all'inizializzazione   di un DispatcherServlet, cercare a   file denominato [nome servlet] -servlet.xml   nella directory WEB-INF del tuo Web   applicazione e creare i fagioli   definito lì (ignorando il   definizioni di tutti i bean definiti con   lo stesso nome nell'ambito globale).

Nel tuo caso, è sufficiente creare un file intrafest-servlet.xml nella directory WEB-INF e non è necessario specificare alcuna informazione specifica in web.xml.

Nel file context-param puoi usare import per comporre la tua configurazione XML. 

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

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

Si noti che il team di Spring in realtà preferisce caricare più file di configurazione durante la creazione di ApplicationContext (Web). Se vuoi ancora farlo in questo modo, penso che non sia necessario specificare entrambi i parametri di contesto (init-param) e i parametri di inizializzazione del servlet (<=>). Uno dei due farà. Puoi anche utilizzare le virgole per specificare più percorsi di configurazione.

Altri suggerimenti

Mike Nereson ha questo da dire sul suo blog all'indirizzo:

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

  

Ci sono un paio di modi per farlo.

     

1. web.xml contextConfigLocation

     

La prima opzione è caricarli tutti nell'applicazione Web   contesto tramite l'elemento ContextConfigLocation. & # 8217; stai già andando   per avere qui l'applicazione principaleContesto principale, supponendo che & # 8217; stai scrivendo   un'applicazione web. Tutto quello che devi fare è mettere uno spazio bianco tra   la dichiarazione del prossimo contesto. 

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

Quanto sopra utilizza i ritorni a capo. In alternativa, potresti semplicemente inserire un   spazio. 

  <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 risorsa di importazione

     

L'altra opzione è aggiungere semplicemente il file applicationContext.xml primario   su web.xml e quindi utilizzare le istruzioni di importazione in quel contesto primario.

     

In applicationContext.xml potresti avere & # 8230; 

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

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

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

Quale strategia dovresti usare?

     

1. Preferisco sempre caricare tramite web.xml .

     

Perché, questo mi permette di mantenere tutti i contesti isolati da ciascuno   altro. Con i test, possiamo caricare solo i contesti che dobbiamo eseguire   quei test. Ciò rende lo sviluppo anche più modulare come componenti   rimanere loosely coupled, in modo che in futuro possa estrarre un pacchetto   o livello verticale e spostarlo nel proprio modulo.

     

2. Se si caricano contesti in un non-web application, utilizzare la import risorsa.

Esistono due tipi di contesti di cui ci occupiamo:

1 : contesto principale (contesto principale. In genere include tutte le inizializzazioni jdbc (ORM, Hibernate) e altre configurazioni relative alla sicurezza delle molle)

2 : contesto servlet individuale (contesto figlio. Contesto servlet tipicamente Dispatcher e inizializzazione di tutti i bean relativi a spring-mvc (controller, mappatura URL ecc.))

Ecco un esempio di web.xml che include più file di contesto dell'applicazione 

<?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 xml di contesto per l'applicazione web verrà utilizzato se l'applicazione utilizza SPRING WEB MVC.

Altrimenti la configurazione di @kosoant va bene.

Esempio semplice se non si utilizza SPRING WEB MVC, ma si desidera utilizzare IOC SPRING:

In web.xml: 

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

Quindi, application-context.xml conterrà: <import resource="foo-services.xml"/> queste istruzioni di importazione per caricare vari file di contesto dell'applicazione e metterli nel principale application-context.xml.

Grazie e spero che questo aiuti.

Sono l'autore di modular-spring-contesti .

Questa è una piccola libreria di utilità per consentire un'organizzazione più modulare dei contesti primaverili di quella che si ottiene usando Composizione di metadati di configurazione basati su XML . modular-spring-contexts funziona definendo i moduli, che sono fondamentalmente contesti applicativi autonomi e consentendo ai moduli di importare bean da altri moduli, che vengono esportati & # 237; nel loro modulo di origine.

I punti chiave quindi sono

  • controllo sulle dipendenze tra i moduli
  • controllo su quali bean vengono esportati e dove vengono utilizzati
  • possibilità ridotta di denominare le collisioni di fagioli

Un semplice esempio sarebbe simile al seguente:

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

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

File 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>
Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top