Wie wird das aktive Frühling 3.1-Umgebungsprofil über eine Property-Datei und nicht über eine env-Variable oder Systemeigenschaft festgelegt?

Verwenden wir die neue Umgebung profile feature von spring 3.1. Wir haben derzeit legen Sie das aktive Profil durch das setzen der Umgebungsvariablen Frühjahr.profile.active=xxxxx auf dem server, auf dem wir die Anwendung bereitstellen.

Wir denken, dass dies eine suboptimale Lösung, denn die war-Datei, die wir bereitstellen wollen, sollte nur noch eine weitere properties-Datei und stellt die Umgebung, in der die Frühlings-app-Kontext geladen werden soll, so dass die Implementierung nicht abhängig von einigen env var auf dem server festgelegt.

Ich versucht, herauszufinden, wie zu tun, und gefunden:

ConfigurableEnvironment.setActiveProfiles()

die ich verwenden können, um programmgesteuert das Profil aber dann habe ich immer noch nicht weiß, wo und Wann dieser code ausgeführt. Irgendwo, wo der spring-context geladen? Kann ich laden Sie die parameter, die ich übergeben möchte an die Methode aus einer properties-Datei?

UPDATE: ich habe gerade bei docsdie ich vielleicht in der Lage zu implementieren, legen Sie das aktive Profil?

InformationsquelleAutor der Frage Fabian | 2011-12-21

In `web.xml`

<context-param>
    <param-name>spring.profiles.active</param-name>
    <param-value>profileName</param-value>
</context-param>

Mit `WebApplicationInitializer`

Dieser Ansatz wird verwendet, wenn Sie nicht über eine web.xml - Datei in den Servlet-3.0-Umgebung und bootstrapping der Frühling komplett aus Java:

class SpringInitializer extends WebApplicationInitializer {

    void onStartup(ServletContext container) {
        AnnotationConfigWebApplicationContext rootContext = new AnnotationConfigWebApplicationContext();
        rootContext.getEnvironment().setActiveProfiles("profileName");
        rootContext.register(SpringConfiguration.class);
        container.addListener(new ContextLoaderListener(rootContext));
    }
}

Wo SpringConfiguration Klasse versehen mit @Configuration.

InformationsquelleAutor der Antwort Tomasz Nurkiewicz

Die Antwort von Thomasz ist so lange gültig, wie der name des Profils kann zur Verfügung gestellt werden, die statisch in der web.xml oder verwendet man das neue XML-less configuration geben, wo könnte man programmgesteuert laden des Profils zu setzen, aus einer properties-Datei.

Als wir noch die XML-version, die ich untersuchte weiter und fand folgende schöne Lösung, wo Sie bei der Umsetzung Ihrer eigenen ApplicationContextInitializer wo Sie fügen Sie einfach einen neuen PropertySource mit einer properties-Datei zu der Liste der Quellen zu suchen, die Umwelt-spezifische Einstellungen. im Beispiel unten könnte man die spring.profiles.active Eigenschaft in der env.properties Datei.

public class P13nApplicationContextInitializer implements ApplicationContextInitializer<ConfigurableApplicationContext> {

    private static Logger LOG = LoggerFactory.getLogger(P13nApplicationContextInitializer.class);

    @Override
    public void initialize(ConfigurableApplicationContext applicationContext) {
        ConfigurableEnvironment environment = applicationContext.getEnvironment();
        try {
            environment.getPropertySources().addFirst(new ResourcePropertySource("classpath:env.properties"));
            LOG.info("env.properties loaded");
        } catch (IOException e) {
            //it's ok if the file is not there. we will just log that info.
            LOG.info("didn't find env.properties in classpath so not loading it in the AppContextInitialized");
        }
    }

}

Musst du dann hinzufügen, dass die Initialisierung als parameter an die ContextLoaderListener des Frühlings wie folgt vor, um Ihre web.xml:

<context-param>
    <param-name>contextInitializerClasses</param-name>
    <param-value>somepackage.P13nApplicationContextInitializer</param-value>
</context-param>
<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

Können Sie auch anwenden, um DispatcherServlet:

<servlet>
    <servlet-name>dispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
        <param-name>contextInitializerClasses</param-name>
        <param-value>somepackage.P13nApplicationContextInitializer</param-value>
    </init-param>
</servlet>

InformationsquelleAutor der Antwort Fabian

Aus irgendeinem Grund nur einen Weg, der für mich arbeitet

public class ActiveProfileConfiguration implements ServletContextListener {   
    @Override
    public void contextInitialized(ServletContextEvent sce) {
        System.setProperty(AbstractEnvironment.DEFAULT_PROFILES_PROPERTY_NAME, "dev");
        System.setProperty(AbstractEnvironment.ACTIVE_PROFILES_PROPERTY_NAME, "dev");
    }

....

 <listener>
     <listener-class>somepackahe.ActiveProfileConfiguration</listener-class>
 </listener>
 <listener>
     <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
 </listener>

InformationsquelleAutor der Antwort Michail Nikolaev

Hier ist eine variation auf die P13nApplicationContextInitializer Ansatz. Doch dieses mal erhalten wir den Pfad env Eigenschaften von JNDI. In meinem Fall habe ich ein JNDI-Globale Umgebungsvariable als coacorrect/Feder-Profil = file:/tmp/env.Eigenschaften

In tomcat/tomee server.xml fügen Sie diese: <Environment name="coacorrect/spring-profile" type="java.lang.String" value="/opt/WebSphere/props"/>
Weiter, in tomcat/tomee, hinzufügen, das war ' s META-INF/context.xml <ResourceLink global="coacorrect/spring-profile" name="coacorrect/spring-profile" type="java.lang.String"/>

In einen Behälter, fügen Sie gegebenenfalls in web.xml

public class SpringProfileApplicationContextInitializer implements ApplicationContextInitializer<ConfigurableApplicationContext>{

public static final Logger log = LoggerFactory.getLogger(SpringProfileApplicationContextInitializer.class);
private static final String profileJNDIName="coacorrect/spring-profile";
private static final String failsafeProfile="remote-coac-dbserver";

@Override
public void initialize(ConfigurableApplicationContext applicationContext) {

    ConfigurableEnvironment environment = applicationContext.getEnvironment();

    try {
        InitialContext ic = new InitialContext();
        Object r1 = ic.lookup(profileJNDIName);
        if (r1 == null) {
            //try the tomcat variant of JNDI lookups in case we are on tomcat/tomee
            r1 = ic.lookup("java:comp/env/"+profileJNDIName);
        }
        if (r1 == null) {
            log.error("Unable to locate JNDI environment variable {}", profileJNDIName);
            return;
        }

        String profilePath=(String)r1;
        log.debug("Found JNDI env variable {} = {}",r1);
        environment.getPropertySources().addFirst(new ResourcePropertySource(profilePath.trim()));
        log.debug("Loaded COAC dbprofile path. Profiles defined {} ", Arrays.asList(environment.getDefaultProfiles()));

    } catch (IOException e) {
        //it's ok if the file is not there. we will just log that info.
        log.warn("Could not load spring-profile, defaulting to {} spring profile",failsafeProfile);
        environment.setDefaultProfiles(failsafeProfile);
    } catch (NamingException ne) {
        log.error("Could not locate JNDI variable {}, defaulting to {} spring profile.",profileJNDIName,failsafeProfile);
        environment.setDefaultProfiles(failsafeProfile);
    }
}

}

InformationsquelleAutor der Antwort Jim Doyle

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.

In web.xml

Mit WebApplicationInitializer

In `web.xml`

Mit `WebApplicationInitializer`