web-dev-qa-db-fra.com

Comment définir des profils actifs de ressort avec des profils maven

J'ai une application avec Maven comme outil de construction.

J'utilise des profils Maven pour configurer différentes propriétés à partir de différents profils.

Ce que je voudrais faire, c’est que tous les profils actifs dans maven seront portés sur des profils actifs au printemps afin que je puisse les référencer dans la signature de haricot (@profile). mais je ne sais pas comment le faire.

par exemple: considérons la configuration suivante de maven

<profiles>
    <profile>
        <id>profile1</id>
        <activation>
            <activeByDefault>true</activeByDefault>
        </activation>
        <properties>
        </properties>
    </profile>
    <profile>
        <id>profile2</id>
        <properties>
        </properties>
    </profile>
    <profile>
        <id>development</id>
        <activation>
            <activeByDefault>true</activeByDefault>
        </activation>
        <properties>
        </properties>
    </profile>
    <profile>
        <id>production</id>
        <properties>    
        </properties>
    </profile>
</profiles>

en supposant que je lance maven sans spécifier aucun autre profil que je voudrais pour le printemps d'avoir profile1 et development en tant que profils actifs.

javaspringmavenspring-profiles
52
Gleeb

Vous devrez filtrer les ressources de votre application, par exemple un fichier de propriétés, contenant les informations du profil à activer au printemps.

Par exemple

spring.profile = ${mySpringProfile}

Et pour chaque profil, définissez une valeur pour cette variable (mySpringProfile).

Pendant la construction, cela sera filtré en fonction de la valeur définie dans le profil actuellement actif.

Ensuite, pendant le bootstrap de votre application, vous sélectionnerez le profil approprié en fonction de ce fichier (vous ne pouvez pas vous aider davantage car vous ne nous avez pas fourni plus d'informations, mais c'est assez simple).

Note: Je ne trouve pas de moyen d'obtenir le profil actuellement actif en maven (quelque chose comme project.profiles.active contenant vos valeurs -P), c'est pourquoi vous devez définir une nouvelle variable pour chaque profil.

Note 2: si vous exécutez une application Web, au lieu d'utiliser ce fichier intermédiaire, filtrez cette valeur dans votre web.xml

<context-param>
    <param-name>spring.profiles.active</param-name>
    <param-value>${mySpringProfile}</param-value>
</context-param>

Note: Ceci est en fait une mauvaise pratique et vous devez définir le profil au moment de l'exécution avec une propriété système

21
poussma

Il existe un moyen plus élégant de basculer simultanément entre 2 profils maven + ressort.

First, ajoutez des profils à POM (faites attention - le profil maven + spring est activé par une seule variable système):

<profiles>
    <profile>
        <id>postgres</id>
        <activation>
            <activeByDefault>true</activeByDefault>
            <property>
                <name>spring.profiles.active</name>
                <value>postgres</value>
            </property>
        </activation>
        <dependencies>
            <dependency>
                <groupId>postgresql</groupId>
                <artifactId>postgresql</artifactId>
                <version>9.1-901.jdbc4</version>
            </dependency>
        </dependencies>
    </profile>
    <profile>
        <id>h2</id>
        <activation>
            <property>
                <name>spring.profiles.active</name>
                <value>h2</value>
            </property>
        </activation>           
        <dependencies>
            <dependency>
                <groupId>com.h2database</groupId>
                <artifactId>h2</artifactId>
                <version>1.4.191</version>
            </dependency>
        </dependencies>
    </profile>
</profiles>

Second, définit le profil par défaut pour le ressort (pour maven, il est déjà défini dans POM). Pour les applications Web, j’ai inséré les lignes suivantes dans web.xml:

<context-param>
   <param-name>spring.profiles.default</param-name>
   <param-value>postgres</param-value>
</context-param>

Troisième, ajoutez des beans dépendant du profil à votre configuration. Dans mon cas (configuration XML), c'est:

<bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
    <property name="dataSource" ref="mainDataSource" />
    <property name="jpaVendorAdapter">
        <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter" />
    </property>
    <property name="jpaProperties" ref="hibProps"/>
    <property name="packagesToScan">
        <list>
            <value>my.test.model</value>
        </list>
    </property>
</bean>
...
<beans profile="postgres">
    <bean name="mainDataSource"
        class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="org.postgresql.Driver" />
        <property name="url" value="jdbc:postgresql://127.0.0.1:5432/webchat" />
        <property name="username" value="postgres" />
        <property name="password" value="postgres" />
    </bean>
</beans>

<beans profile="h2">
    <bean name="mainDataSource"
        class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="org.h2.Driver" />
        <property name="url" value="jdbc:h2:file:./newsdb;INIT=RUNSCRIPT FROM 'classpath:init.sql';TRACE_LEVEL_FILE=0" />
        <property name="username" value="sa" />
        <property name="password" value="" />
    </bean>
</beans>

Il est maintenant possible de:

  • Exécuter mon application Web sur la base de données Postgres avec mvn jetty:run ou mvn jetty:run -Dspring.profiles.active=postgres commandes
  • Exécuter mon application Web sur H2 DB avec mvn clean jetty:run -Dspring.profiles.active=h2
34
Eugene

La première chose dont vous avez besoin est deux fichiers de propriétés pour conserver vos configurations. Les noms des fichiers doivent correspondre au modèle d'application - {custom_suffix} .properties. Créez-les dans le répertoire src/main/resources de votre projet Maven, à côté du fichier principal application.properties, que vous utiliserez plus tard pour activer l'un des autres et conserver les valeurs partagées par les deux profils.

Ensuite, il est temps de modifier votre fichier pom.xml. Vous devez définir une propriété personnalisée dans chacun de vos profils Maven et définir leurs valeurs afin qu'elles correspondent aux suffixes des fichiers de propriétés correspondants que vous souhaitez charger avec un profil particulier. L'exemple suivant marque également le premier profil à s'exécuter par défaut, mais ce n'est pas obligatoire.

<profile>
    <id>dev</id>
    <properties>
        <activatedProperties>dev</activatedProperties>
    </properties>
    <activation>
        <activeByDefault>true</activeByDefault>
    </activation>
</profile>
<profile>
    <id>release</id>
    <properties>
        <activatedProperties>release</activatedProperties>
    </properties>
</profile>

Ensuite, dans la section de construction du même fichier, configurez le filtrage pour le plug-in de ressources. Cela vous permettra d'insérer les propriétés définies à l'étape précédente dans n'importe quel fichier du répertoire des ressources, qui constitue l'étape suivante.

<build>
    <resources>
        <resource>
            <directory>src/main/resources</directory>
            <filtering>true</filtering>
        </resource>
    </resources>
    …
</build>

Enfin, ajoutez la ligne suivante au fichier application.properties.

spring.profiles.active=@activatedProperties@

Lorsque la génération est exécutée, le plug-in Ressources remplacera l'espace réservé par la valeur de la propriété définie dans le profil Maven actif. Après le démarrage de votre application, l'infrastructure Spring charge le fichier de configuration approprié en fonction du nom du profil Spring actif, décrit par la valeur de la propriété spring.profiles.active. Notez que Spring Boot 1.3 a remplacé la syntaxe par défaut du plug-in Resources pour les valeurs filtrées et utilise @activatedProperties@ au lieu de ${activatedProperties} notation.

Cela a fonctionné à la perfection. J'espère que cela peut vous aider.

20
Sergio Sánchez Sánchez

Je construis actuellement une petite application Web qui (pour des raisons indépendantes de ma volonté) doit pouvoir fonctionner sur un ancien serveur/conteneur ne prenant en charge que Servlet 2.5 et Java 6. Il existe également Pour que la configuration de l'application Web soit entièrement autonome, il est impossible d'utiliser des variables système et/ou des paramètres JVM. L'administrateur souhaite uniquement un fichier .war pour chaque environnement pouvant être déposé dans le conteneur pour le déploiement.

J'utilise Spring 4.x dans mon application Web. Voici comment j'ai configuré mon application pour que le profil Maven actif soit utilisé pour définir le profil Spring 4.x actif.

modifications du fichier pom.xml

J'ai ajouté les bits suivants à mon fichier POM. Mon POM utilise la version 4.0.0 du modèle et j'exécute Maven 3.1.x lorsque je crée mes versions.

<modelVersion>4.0.0</modelVersion>

...

<profiles>
    <profile>
        <id>dev</id>
        <activation>
            <!-- Default to dev so we avoid any accidents with prod! :) -->
            <activeByDefault>true</activeByDefault>
        </activation>
        <properties>
            <!-- This can be a single value, or a comma-separated list -->
            <spring.profiles.to.activate>dev</spring.profiles.to.activate>
        </properties>
    </profile>
    <profile>
        <id>uat</id>
        <properties>
            <!-- This can be a single value, or a comma-separated list -->
            <spring.profiles.to.activate>uat</spring.profiles.to.activate>
        </properties>
    </profile>
    <profile>
        <id>prod</id>
        <properties>
            <!-- This can be a single value, or a comma-separated list -->
            <spring.profiles.to.activate>prod</spring.profiles.to.activate>
        </properties>
    </profile>
</profiles>

...

<build>
    <plugins>
        <plugin>
            <groupId>org.Apache.maven.plugins</groupId>
            <artifactId>maven-war-plugin</artifactId>
            <version>2.6</version>
            <configuration>
                <webResources>
                    <webResource>
                        <filtering>true</filtering>
                        <directory>src/main/webapp</directory>
                        <includes>
                            <include>**/web.xml</include>
                        </includes>
                    </webResource>
                </webResources>
                <failOnMissingWebXml>true</failOnMissingWebXml>
            </configuration>
        </plugin>
        ...
    </plugins>
</build>

modifications du fichier web.xml

<!-- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Setup for root Spring context
-->
<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>/WEB-INF/spring-core-config.xml</param-value>
</context-param>
<!--
Jim Tough - 2016-11-30
Per Spring Framework guide: http://docs.spring.io/spring/docs/current/spring-framework-reference/htmlsingle/#beans-environment

...profiles may also be activated declaratively through the spring.profiles.active 
property which may be specified through system environment variables, JVM system 
properties, servlet context parameters in web.xml, or even as an entry in JNDI.
-->
<context-param>
    <param-name>spring.profiles.active</param-name>
    <param-value>${spring.profiles.to.activate}</param-value>
</context-param>
<!-- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->

Maintenant, je peux créer des classes de configuration basées sur Java, comme celle ci-dessous, qui ne seront utilisées que lorsqu'un profil Spring particulier est actif.

@Configuration
@Profile({"dev","default"})
@ComponentScan
@EnableTransactionManagement
@EnableSpringDataWebSupport
public class PersistenceContext {
    // ...
}
1
Jim Tough

Ajouter un espace réservé ${activeProfile} dans web.xml:

<context-param>
  <param-name>spring.profiles.active</param-name>
  <param-value>${activeProfile}</param-value>
</context-param>

Définissez les propriétés dans pom.xml pour chaque profil:

<profiles>
  <profile>
    <id>profile1</id>
    <activation>
      <activeByDefault>true</activeByDefault>
    </activation>
    <properties>
      <activeProfile>profile1</activeProfile>
    </properties>
  </profile>
  <profile>
    <id>profile2</id>
    <properties>
      <activeProfile>profile2</activeProfile>
    </properties>
  </profile>
</profiles>

Ajouter maven-war-plugin Et mettre <filteringDeploymentDescriptors>true</filteringDeploymentDescriptors> pour remplacer l'espace réservé lors de l'exécution de mvn package -Pprofile1 ou mvn package -Pprofile2:

<build>
  <plugin>
    <artifactId>maven-war-plugin</artifactId>
    <version>3.2.2</version>
    <configuration>
      <filteringDeploymentDescriptors>true</filteringDeploymentDescriptors>
    </configuration>
  </plugin>
</build>
0
xxg

Pour une application Spring Boot, on peut ajouter une propriété dans le profil Maven dans pom.xml puis référence cette propriété dans application.properties.

Ajouter des profils Maven à pom.xml avec, par exemple, une propriété appelée spring.profile.from.maven:

<profiles>
    <profile>
        <id>postgres</id>
        <activation>
            <activeByDefault>true</activeByDefault>
        </activation>
        <properties>
            <spring.profile.from.maven>postgres</spring.profile.from.maven>
        </properties>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-jpa</artifactId>
            </dependency>
            <dependency>
                <groupId>org.postgresql</groupId>
                <artifactId>postgresql</artifactId>
                <scope>runtime</scope>
            </dependency>
        </dependencies>
    </profile>
    <profile>
        <id>noDb</id>
        <properties>
            <spring.profile.from.maven>noDb</spring.profile.from.maven>
        </properties>
    </profile>
</profiles>

Référencez la propriété Maven dans application.properties:

[email protected]@

Avec cette configuration, exécuter maven avec le profil postgres maven ou sans profil ajoute le profil postgres Spring à la liste des profils actifs de Spring, tout en exécutant maven avec le noDb Maven. profile ajoute le profil noDb Spring à la liste des profils actifs de Spring.

0
Sayadi