chargement d'une variable de printemps applicationContext.xml fichier basé sur une propriété spécifiée en dehors de l'app fichier war?

J'ai besoin de changer le printemps applicationContext.xml fichier qui est utilisé, basé sur une propriété, cette propriété DOIT être défini quelque part à l'extérieur de la guerre de fichier (c'est à dire. il ne peut pas être dans web.xml). Actuellement, j'en suis arrivé à la solution suivante (voir ma réponse ci-dessous), vous vous demandez si il ya une meilleure façon de le faire?

InformationsquelleAutor shsteimer | 2010-10-28

2

Avez-vous considéré l'utilisation de la beanRefContext approche. (ContextSingletonBeanFactoryLocator). De cette façon, vous pouvez configurer votre printemps des fichiers de configuration (et leurs noms) via une autre source de fichier de config.

Alors vous pouvez paramaterise ce fichier par quelque moyen que ce soit vous le jugez approprié et de changer le noms de fichier de cette façon.

Le fichier ressemble à ceci:
```
<beans>
    <bean id="businessBeanFactory" class="org.springframework.context.support.ClassPathXmlApplicationContext">
        <constructor-arg value="${NameOfBeanConfigFile}" />
    </bean>
</beans>
```
Et vous pouvez utiliser PropertyPlaceHolderConfigurer pour définir la valeur de NameOfBeanConfigFile.

J'aime cette approche car il me permet de mélange statique bean config noms de fichiers avec dynamique de haricots config noms de fichier et donc de ne pas avoir à dupliquer bean config.

Lorsque j'ai eu à faire quelque chose de similaire, je voudrais paramétrer via un fichier de configuration chargé comme une ressource URL (via jndi)

InformationsquelleAutor Michael Wiles

il y a 4 parties de ma solution. tout d'abord, dans web.xml de mon application, j'définir les éléments suivants:

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

Puis-je prolonger 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();
    }
}

et 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);
        }


    }
}

et enfin, dans mon démarrage de tomcat, j'définir la variable d'environnement dans setenv.chauve-souris

set MY_CONTEXT_LOAD_PARAM=contextConfigLocation1

cette solution de charge à partir d'une variable d'environnement, mais le code est flexible et permet d'être installé dans un système de propriété plutôt.

InformationsquelleAutor shsteimer

-2

Si vous chargez votre contexte de l'application à travers le chemin de la classe, vous pouvez le remplacer en plaçant une autre version de la applicationContext.xml dans le serveur de classpath.

Ma solution serait d'avoir un très simple applicationContext, qui comprend le vrai contexte de l'application :

applicationContext.xml :
```
<beans>
    <import resource="classpath:realContext.xml"/>
</beans>
```
Si vous souhaitez un autre contexte, ajouter un applicationContext.xml de votre serveur classpath avec :
```
<beans>
    <import resource="classpath:realContext2.xml"/>
</beans>
```
Et ont realContext.xml et realContext2.xml emballé dans votre GUERRE. Pas besoin de fantaisie contexte de l'auditeur.

Juste mon avis, mais je suis assez d'aversion aux Guerres qui ne sont pas autonomes. Je trouve qu'il est très pratique d'avoir une seule unité de déploiement. Donc, je préfère créer 2 versions différentes de ma GUERRE pendant le processus de génération, un pour chaque configuration nécessaires.

Une autre solution, si vous souhaitez charger une autre bean en fonction d'une propriété donnée, vous pouvez utiliser un PropertyPlaceholderConfigurer et de mettre le nom de la fève à la propriété :
```
<beans>
  <bean id="bean1" .../>
  <bean id="bean2" .../>
  <bean id="otherBean">
    <property name="injectDifferentBean" ref="${property.containing.bean.name" />
  </bean>
</beans>
```
et un fichier de propriétés avec :
```
property.containing.bean.name=bean1
```
ou
```
property.containing.bean.name=bean2
```
InformationsquelleAutor Guillaume

Vous devez vous connecter pour publier un commentaire.