Splitting application, um mehrere Dateien

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

  •  03-07-2019
  •  | 
  •  

Frage

Was ist der richtige Weg Spring Konfiguration auf mehrere XML-Dateien?

aufzuspalten

Im Moment habe ich

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

Meine web.xml hat folgende Möglichkeiten: 

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

Die eigentlichen Fragen:

  • Ist dieser Ansatz richtig / best
  • Muss ich wirklich die Config-Standorten sowohl im DispatcherServlet angeben und die context-param Abschnitte?

Was muss ich im Auge behalten zu können, Bohnen in foo-servlet.xml von foo-service.xml definiert verweisen? Hat dies etwas mit Angabe contextConfigLocation in web.xml zu tun?

Update 1:

Ich bin mit Frühling Framework 3.0. Es ist mein Verständnis, dass ich nicht brauche Ressource Import wie dies zu tun: 

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

Ist das eine richtige Annahme?

War es hilfreich?

Lösung

Ich finde das folgende Setup der einfachste.

Verwenden Sie die Standardkonfigurationsdatei Lademechanismus von DispatcherServlet :

  

Das Framework wird, bei der Initialisierung   ein DispatcherServlet, suchen Sie nach einem   Datei mit dem Namen [Servlet-name] -servlet.xml   im WEB-INF-Verzeichnis Ihrer Web   Anwendung und erstellen Sie die Bohnen   es definiert (das Überschreiben der   Definitionen von irgendwelchen Bohnen definiert mit   die gleichen Namen im globalen Bereich).

In Ihrem Fall, erstellen Sie einfach eine Datei intrafest-servlet.xml im WEB-INF dir und braucht nichts spezifische Informationen in web.xml angeben.

In intrafest-servlet.xml Datei können Sie eine href verwenden <= "http://static.springframework.org/spring/docs/2.5.x/reference/beans.html#beans-factory-xml-import" rel = "noreferrer „> Import XML-Konfiguration zusammenzustellen. 

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

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

Beachten Sie, dass das Frühlings Team mehrere Konfigurationsdateien laden tatsächlich bevorzugt, wenn die (Web) Application zu schaffen. Wenn Sie noch es auf diese Weise tun wollen, ich glaube, Sie nicht beide Kontextparameter angeben müssen (context-param) und Servlet-Initialisierungsparameter (init-param). Einer der beiden tun wird. Sie können auch Kommas verwenden, um mehrere Konfigurationsspeicherorte angeben.

Andere Tipps

Mike Nereson hat dies in seinem Blog sagen an:

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

  

Es gibt ein paar Möglichkeiten, dies zu tun.

     

1. web.xml contextConfigLocation

     

Die erste Möglichkeit ist, sie alle in Ihre Web-Anwendung zu laden   Kontext über das ContextConfigLocation Element. Du wirst schon   haben hier Ihre primäre application, vorausgesetzt, Sie schreiben   eine Web-Anwendung. Alles, was Sie tun müssen, ist etwas Platz setzen zwischen   die Erklärung des nächsten Kontext. 

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

Das oben gezeigte verwendet Wagenrücklauf. Alternativ könnte yo nur in einem setzen   Raum. 

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

     

Die andere Option ist nur Ihre primäre applicationContext.xml hinzufügen   zum web.xml und verwenden Import-Anweisungen dann in diesem primären Kontext.

     

In applicationContext.xml haben Sie vielleicht ... 

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

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

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

Welche Strategie sollten Sie verwenden?

     

1. Ich habe immer lieber über laden, bis web.xml .

     

Da dies ermöglicht es mir, alle Kontexte von jedem getrennt zu halten   andere. Mit Tests können wir nur die Kontexte laden, die wir ausführen müssen   diese Tests. Dies macht auch mehr modulare Entwicklung als Komponenten   bleiben loosely coupled, so dass ich in der Zukunft ein Paket extrahieren   oder vertikale Schicht und sich ihren eigenen Modul bewegen.

     

2. Wenn Sie Kontexte in eine non-web application laden, würde ich die import Ressource verwenden.

Es gibt zwei Arten von Kontexten beschäftigen wir uns mit:

1 : (. Geordneten Kontext weisen typischerweise alle JDBC (ORM, Ruhezustand) Initialisierung und andere Federsicherheitsbezogenen Konfigurations) Stammkontext

2 :. Einzel Servletkontext (Kind context.Typically Dispatcher Servletkontext und initialisiere alle Bohnen im Zusammenhang mit feder mvc (Controller, URL Mapping etc.))

Hier ist ein Beispiel für web.xml, die mehrere Anwendungskontext Datei

enthalten 

<?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 Webapplikation Kontext xml verwendet werden, wenn die Anwendung SPRING WEB verwendet MVC

Ansonsten ist die @kosoant Konfiguration korrekt ist.

Ein einfaches Beispiel, wenn Sie nicht SPRING WEB MVC verwenden, wollen aber SPRING IOC utitlize:

In web.xml: 

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

Dann Ihre applikations context.xml enthält: <import resource="foo-services.xml"/> diese Import-Anweisungen verschiedene Anwendungskontext-Dateien zu laden und in der Hauptanwendung-context.xml.

Danke und hoffen, das hilft.

Ich bin der Autor von modular feder Kontexten .

Dies ist eine kleine Utility-Bibliothek eine modulare Organisation von Feder Kontexte zu ermöglichen, als durch die Verwendung Composing XML-basierte Konfiguration von Metadaten . modular-spring-contexts arbeitet durch Module zu definieren, die im Grunde allein Anwendungskontexte stehen werden und ermöglicht Module Bohnen aus anderen Modulen zu importieren, die in ihrem Ursprung Modul exportiert werden.

Die wichtigsten Punkte sind dann

  • Kontrolle über Abhängigkeiten zwischen den Modulen
  • Kontrolle darüber, welche Bohnen werden exportiert und wo sie verwendet werden
  • reduzierte Möglichkeit von Kollisionen von Bohnen Namensgebung

Ein einfaches Beispiel würde wie folgt aussehen:

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

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

Datei 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>
Lizenziert unter: CC-BY-SA mit Zuschreibung
Nicht verbunden mit StackOverflow
scroll top