Dividindo applicationContext para vários arquivos

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

  •  03-07-2019
  •  | 
  •  

Pergunta

O que é a maneira correta de dividir a configuração do Spring para vários arquivos xml?

No momento eu tenho

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

Meu web.xml tem o seguinte: 

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

As questões reais:

  • É esta abordagem correta / melhor ?
  • Será que eu realmente preciso especificar os locais de configuração tanto no DispatcherServlet e as seções context-param?

O que preciso ter em mente para ser capaz de feijão de referência definidos no foo-servlet.xml de foo-service.xml? Será que isso tem algo a ver com a especificação contextConfigLocation em web.xml?

Update 1:

Eu estou usando Spring framework 3.0. É meu entendimento que eu não preciso fazer recurso importando como esta: 

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

Isso é uma suposição correta?

Foi útil?

Solução

Eu acho o seguinte configuração o mais fácil.

Use o mecanismo de carregamento arquivo de configuração padrão do DispatcherServlet :

A vontade quadro, na inicialização de um DispatcherServlet, procure um arquivo chamado [servlet-name] -servlet.xml no diretório WEB-INF do seu web aplicativo e criar o feijão definido lá (substituindo o definições de qualquer feijão definidos com o mesmo nome no escopo global).

No seu caso, basta criar um intrafest-servlet.xml arquivo no dir WEB-INF e não precisa especificar as informações de alguma coisa específica em web.xml.

No arquivo intrafest-servlet.xml você pode usar import para compor sua configuração XML. 

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

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

Note que a equipe Primavera realmente prefere carregar vários arquivos de configuração ao criar o (Web) ApplicationContext. Se você ainda quer fazê-lo desta maneira, eu acho que você não precisa especificar ambos os parâmetros de contexto (context-param) e parâmetros de inicialização do servlet (init-param). Um dos dois vai fazer. Você também pode usar vírgulas para especificar vários locais de configuração.

Outras dicas

Mike Nereson tem a dizer em seu blog em:

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

Há um par de maneiras de fazer isso.

1. web.xml contextConfigLocation

Sua primeira opção é para carregá-los todos em sua aplicação Web contexto através do elemento ContextConfigLocation. Você já está indo para ter seu applicationContext principal aqui, supondo que você está escrevendo uma aplicação web. Tudo que você precisa fazer é colocar um pouco de espaço em branco entre a declaração do 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>

As utilizações acima retornos de carro. Alternativamente, yo poderia apenas colocar em um espaço. 

  <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 recurso de importação

Sua outra opção é apenas para adicionar seu applicationContext.xml primária no web.xml e depois de importação uso declarações em que contexto primário.

Em applicationContext.xml você pode ter ... 

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

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

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

Qual estratégia você deve usar?

1. Eu sempre prefiro para carregar via web.xml .

Porque, isso me permite manter todos os contextos isolados uns dos de outros. Com os testes, nós podemos carregar apenas os contextos que precisamos para executar esses testes. Isso torna o desenvolvimento mais modular também como componentes ficar loosely coupled, de modo que no futuro eu posso extrair um pacote ou camada vertical e movê-lo para seu próprio módulo.

2. Se você é contextos de carregamento em um non-web application, eu usaria o recurso import.

Existem dois tipos de contextos que estamos a tratar:

1 : contexto raiz (. Contexto pai Tipicamente incluem todos JDBC (ORM, hibernação) configuração relacionada segurança inicialização e outra mola)

2 :. Contexto servlet indivíduo (criança context.Typically Dispatcher Servlet Contexto e de aplicação de todos os grãos relacionados à spring-mvc (controladores, URL Mapeamento etc))

Aqui está um exemplo de web.xml que inclui múltiplos arquivos contexto de aplicação 

<?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 contexto webapplication xml será usada se o aplicativo usa Spring Web MVC

.

Caso contrário, a configuração @kosoant é bom.

Um exemplo simples, se você não usar Spring Web MVC, mas quer utitlize PRIMAVERA COI:

Em web.xml: 

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

Em seguida, o aplicativo de context.xml conterá: <import resource="foo-services.xml"/> estas declarações de importação para carregar vários arquivos de contexto de aplicação e colocar em aplicação principal-context.xml.

Graças e espero que isso ajude.

Eu sou o autor da modular-spring-contextos .

Esta é uma pequena biblioteca de utilitários para permitir uma organização mais modular de contextos primavera do que é conseguido através de Compor configuração metadados baseada em XML. modular-spring-contexts funciona através da definição de módulos, que são, basicamente, destacam contextos de aplicação sozinho e permitindo módulos de feijão de importação de outros módulos, que são exportados em seu módulo de origem.

Os pontos-chave são então

  • controle sobre dependências entre os módulos
  • controle sobre quais grãos são exportados e onde eles são usados ??
  • reduzida possibilidade de nomear colisões de feijão

Um exemplo simples seria algo como isto:

moduleDefinitions.xml arquivo: 

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

serverModule.xml arquivo: 

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

clientModule.xml Arquivo 

<?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 em: CC-BY-SA com atribuição
Não afiliado a StackOverflow
scroll top