laden einer Variablen Frühjahr applicationContext.xml Datei basierend auf einer Eigenschaft angegeben, die außerhalb der app war-Datei?

Ich habe müssen Sie die Feder wechseln applicationContext.xml Datei, die verwendet wird, basierend auf einer Eigenschaft, diese Eigenschaft MUSS definiert werden, die irgendwo außerhalb der war-Datei (dh. es kann nicht in web.xml). Derzeit habe ich kam zu folgender Lösung (siehe meine Antwort unten), Frage mich, ob es einen besseren Weg, dies zu tun?

InformationsquelleAutor shsteimer | 2010-10-28

2

Haben Sie sich überlegt mit dem beanRefContext Ansatz. (ContextSingletonBeanFactoryLocator). Auf diese Weise können Sie Ihr spring config-Dateien (und Ihre Namen) via another spring config-Datei.

Dann können Sie paramaterise, dass die Datei durch welches Mittel Sie für geeignet halten, und schalten Sie die Datei-Namen, die Art und Weise.

Die Datei sieht wie folgt aus:
```
<beans>
    <bean id="businessBeanFactory" class="org.springframework.context.support.ClassPathXmlApplicationContext">
        <constructor-arg value="${NameOfBeanConfigFile}" />
    </bean>
</beans>
```
Und Sie können PropertyPlaceHolderConfigurer, um den Wert NameOfBeanConfigFile.

Ich mag diesen Ansatz, da es bedeutet, dass ich kann mischen statischen bean config-Datei-Namen, die mit der dynamischen bean config-Datei Namen und so nicht zu duplizieren bean config.

Wenn ich hatte eine ähnliche Sache würde ich Parametrierung über eine config-Datei geladen, wie eine URL-Ressource (über jndi)

InformationsquelleAutor Michael Wiles

gibt es 4 Teile für meine Lösung. zuerst in web.xml meine Bewerbung habe ich Folgendes definiert:

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

    <context-param>
        <param-name>contextConfigLocation1</param-name>
        <param-value>classpath:applicationContext-1.xml</param-value>
    </context-param>

    <context-param>
        <param-name>contextConfigLocation2</param-name>
        <param-value>classpath:applicationContext.xml</param-value>
    </context-param>

    <listener>
        <listener-class>com.my.package.MyContextLoaderListener</listener-class>
    </listener>

Dann erweitere ich ContextLoaderListener

package com.my.package;

import org.springframework.web.context.ContextLoader;
import org.springframework.web.context.ContextLoaderListener;

public class MyContextLoaderListener extends ContextLoaderListener {
    @Override
    protected ContextLoader createContextLoader() {
        return new MyContextLoader();
    }
}

und ContextLoader

package com.my.package;

import javax.servlet.ServletContext;

import org.springframework.web.context.ConfigurableWebApplicationContext;
import org.springframework.web.context.ContextLoader;

public class LnvContextLoader extends ContextLoader {

    private static final String APP_CONTEXT_PROP = "MY_CONTEXT_LOAD_PARAM";

    @Override
    protected void customizeContext(ServletContext servletContext,
            ConfigurableWebApplicationContext wac) {

        //check for system property first, if not defined, check for env variable
        String appContextParam = System.getProperty(APP_CONTEXT_PROP);
        if(appContextParam==null)
        {
            appContextParam = System.getenv(APP_CONTEXT_PROP);
        }


        if(appContextParam!=null && !appContextParam.equals("")){

            String initParam = servletContext.getInitParameter(appContextParam);

            wac.setConfigLocation(initParam);
        }


    }
}

werden und schließlich in mein tomcat-Start -, die ich definieren Sie die Umgebungsvariable in setenv.bat

set MY_CONTEXT_LOAD_PARAM=contextConfigLocation1

diese Lösung lädt es aus einer environment-variable ist, aber der code ist flexibel und erlaubt es, in ein-system-Eigenschaft statt.

InformationsquelleAutor shsteimer

-2

Wenn Sie laden Sie Ihre Anwendung Kontext durch die classpath, können Sie überschreiben, indem du eine andere version applicationContext.xml in der server-classpath.

Wäre meine Lösung, eine sehr einfache Datei ApplicationContext, der die realen Anwendungskontext :

applicationContext.xml :
```
<beans>
    <import resource="classpath:realContext.xml"/>
</beans>
```
Wenn Sie möchten, einen anderen Kontext, fügen Sie ein applicationContext.xml auf dem server-classpath mit :
```
<beans>
    <import resource="classpath:realContext2.xml"/>
</beans>
```
Haben und realContext.xml und realContext2.xml verpackt in den KRIEG. Keine Notwendigkeit für fancy-Kontext-listener.

Nur meine Meinung, aber ich ziemlich Abneigung gegen Kriege, die sich nicht selbst enthalten. Ich finde es sehr praktisch, um eine einzige Einheit, Einsatz. Also ich würde lieber 2 verschiedene Versionen von mein KRIEG, während dem build-Prozess, eine für jede benötigte Konfiguration.

Andere Lösung, wenn Sie möchten, laden Sie eine andere bean in Abhängigkeit einer bestimmten Eigenschaft, können Sie eine PropertyPlaceholderConfigurer und setzen Sie den Namen der bean eine Eigenschaft :
```
<beans>
  <bean id="bean1" .../>
  <bean id="bean2" .../>
  <bean id="otherBean">
    <property name="injectDifferentBean" ref="${property.containing.bean.name" />
  </bean>
</beans>
```
und eine property-Datei mit :
```
property.containing.bean.name=bean1
```
oder
```
property.containing.bean.name=bean2
```
InformationsquelleAutor Guillaume

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.