web-dev-qa-db-fra.com

Spring Boot configuration externe du fichier de propriétés

J'ai une application de démarrage de printemps que je peux intégrer à une guerre que je souhaite déployer dans différents environnements. Pour automatiser ce déploiement, il serait plus facile d'externaliser le fichier de configuration.

Actuellement, tout fonctionne bien avec un fichier application.properties dans src/main/resources. Ensuite, j’utilise «mvn install» pour créer une guerre déployable sur Tomcat . Mais j’aimerais utiliser un fichier .yml qui n’a pas besoin d’être présent sur mvn install mais qui serait lu lors est dans le même ou un répertoire relatif à ma guerre.

24. configuration externalisée indique où Spring Boot recherchera les fichiers et 72.3 Modifier l'emplacement des propriétés externes d'une application donne plus de détails sur la configuration, mais je ne comprends tout simplement pas comment traduire cela en mon code.

Ma classe d'application ressemble à ceci: paquet be.ugent.lca;

Updated below

Dois-je ajouter un @PropertySource à ce fichier? Comment pourrais-je me référer à un certain chemin relatif?

Je pense que cela est probablement documenté dans la plupart des documents de démarrage, mais je ne comprends tout simplement pas comment ils veulent que je fasse cela.

MODIFIER

Je ne sais pas si cela devrait être une question distincte, mais je pense que c'est toujours lié.
Lors de la définition de la variable os, l’erreur du fichier yaml non trouvé a disparu. Pourtant, je reçois toujours la même erreur que lorsque je n'avais pas d'application .properties ou fichier .yml. L'application ressemble maintenant à ceci:

@Configuration
**@PropertySource("file:${application_home}/application.yml")**
@ComponentScan({"be.ugent.lca","be.ugent.sherpa.configuration"})
@EnableAutoConfiguration
@EnableSpringDataWebSupport
public class Application extends SpringBootServletInitializer{
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);

    }

La variable du système d'exploitation application_home

$ echo $application_home  
C:\Masterproef\clones\la15-lca-web\rest-service\target

Mon fichier application.yml (dont il se plaint):

sherpa:
  package:
    base: be.ugent.lca

Erreur sur Java -jar * .war Toutes les variations sur:

Caused by: Java.lang.IllegalArgumentException: Could not resolve placeholder 'sherpa.package.base' in string value "${sherpa.package.base}"
    at org.springframework.util.PropertyPlaceholderHelper.parseStringValue(PropertyPlaceholderHelper.Java:174)
    at org.springframework.util.PropertyPlaceholderHelper.replacePlaceholders(PropertyPlaceholderHelper.Java:126)
    at org.springframework.core.env.AbstractPropertyResolver.doResolvePlaceholders(AbstractPropertyResolver.Java:204)
    at org.springframework.core.env.AbstractPropertyResolver.resolveRequiredPlaceholders(AbstractPropertyResolver.Java:178)
    at org.springframework.context.support.PropertySourcesPlaceholderConfigurer$2.resolveStringValue(PropertySourcesPlaceholderConfigurer.Java:172)
    at org.springframework.beans.factory.support.AbstractBeanFactory.resolveEmbeddedValue(AbstractBeanFactory.Java:808)
    at org.springframework.beans.factory.support.DefaultListableBeanFactory.doResolveDependency(DefaultListableBeanFactory.Java:1027)
    at org.springframework.beans.factory.support.DefaultListableBeanFactory.resolveDependency(DefaultListableBeanFactory.Java:1014)
    at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor$AutowiredFieldElement.inject(AutowiredAnnotationBeanPostProcessor.Java:545)
    ... 142 more
javaspring-boot
13
turoni

Utilisation de fichiers de propriétés externes

La réponse se trouve dans les documents de démarrage du printemps, je vais essayer de vous en parler.

Tout d’abord, non, vous ne devriez pas utiliser @PropertySource lorsque vous travaillez avec la configuration de Yaml, comme mentionné ici dans la section Lacunes de Yaml :

Les fichiers YAML ne peuvent pas être chargés via l'annotation @PropertySource. Ainsi, dans le cas où vous devez charger des valeurs de cette manière, vous devez utiliser un fichier de propriétés.

Alors, comment charger des fichiers de propriétés? Ceci est expliqué ici Fichiers de propriétés d'application

L'un est chargé pour vous: application.yml, placez-le dans l'un des répertoires mentionnés dans le lien ci-dessus. C'est parfait pour votre configuration générale.

Maintenant, pour la configuration spécifique à votre environnement (et des choses comme les mots de passe) pour laquelle vous souhaitez utiliser des fichiers de propriétés externes, la procédure à suivre est également expliquée dans cette section:

Si vous n’aimez pas application.properties comme nom de fichier de configuration, vous pouvez en changer en spécifiant une propriété d’environnement spring.config.name. Vous pouvez également faire référence à un emplacement explicite à l'aide de la propriété d'environnement spring.config.location (liste d'emplacement de répertoires ou de chemins de fichiers séparés par des virgules).

Donc, vous utilisez la propriété d'environnement spring.config.location . Imaginez que vous avez un fichier de configuration externe: application-external.yml dans le répertoire conf/dir de votre répertoire personnel, ajoutez-le simplement comme ceci: -Dspring.config.location=file:${home}/conf/application-external.yml en tant que paramètre de démarrage de votre JVM ..__ Si vous avez plusieurs fichiers, séparez-les simplement par une virgule. Notez que vous pouvez facilement utiliser des propriétés externes telles que celle-ci pour écraser des propriétés, pas seulement pour les ajouter.

Je vous conseillerais de le tester en faisant en sorte que votre application fonctionne uniquement avec votre fichier interne application.yml, puis en écrasant une propriété (test) dans votre fichier de propriétés externe et en enregistrant la valeur quelque part.

Lier les propriétés de Yaml aux objets

Lorsque je travaille avec des propriétés Yaml, je les charge généralement avec @ConfigurationProperties, ce qui est bien pratique lorsque vous travaillez avec des listes, par exemple, ou avec une structure de propriété plus complexe. (C’est pourquoi vous devriez utiliser les propriétés Yaml. Pour les propriétés simples, il vaut peut-être mieux utiliser des fichiers de propriétés ordinaires). Lisez ceci pour plus d'informations: Propriétés de configuration de Type-Safe

Extra: chargement de ces propriétés dans les tests IntelliJ, Maven et JUnit

Parfois, vous souhaitez charger ces propriétés dans vos versions de maven ou lors de tests. Ou juste pour le développement local avec votre IDE 

Si vous utilisez IntelliJ pour le développement, vous pouvez facilement l'ajouter à votre configuration d'exécution Tomcat: "Exécuter" -> "Modifier les configurations", sélectionnez votre configuration d'exécution sous "Serveur Tomcat", vérifiez l'onglet Serveur et ajoutez sous "Options de la VM". 

Pour utiliser des fichiers de configuration externes dans votre Maven build: configurez le plug-in maven surefire comme ceci dans votre pom.xml:

<plugin>
  <groupId>org.Apache.maven.plugins</groupId>
  <artifactId>maven-surefire-plugin</artifactId>
  <configuration>
     <argLine>-Dspring.config.location=file:${home}/conf/application-external.yml
   </configuration>
</plugin>

Lorsque vous exécutez JUnit, testez dans IntelliJ:

  • Exécuter → Modifier les configurations
  • Valeurs par défaut → JUnit
  • ajouter VM Options -> -ea -Dspring.config.location=file:${home}/conf/application-external.yml
24
loïc

Oui, vous devez utiliser @PropertySource comme indiqué ci-dessous.

Le point important ici est que vous devez fournir la propriété application_home (ou choisir un autre nom) en tant que variable d’environnement de système d’exploitation ou propriété système, ou vous pouvez passer en argument de ligne de commande lors du lancement de Spring Boot. Cette propriété indique où se trouve exactement le fichier de configuration (.properties ou .yaml) (exemple: /usr/local/my_project/ etc.).

@Configuration
@PropertySource("file:${application_home}config.properties")//or specify yaml file
@ComponentScan({"be.ugent.lca","be.ugent.sherpa.configuration"})
@EnableAutoConfiguration
@EnableSpringDataWebSupport
public class Application extends SpringBootServletInitializer{
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}
5
developer

L'un des moyens les plus simples d'utiliser un fichier de propriété externalisé à l'aide d'une variable d'environnement système est d'utiliser le fichier application.properties dans la syntaxe suivante:

spring.datasource.url = ${OPENSHIFT_MYSQL_DB_Host}:${OPENSHIFT_MYSQL_DB_PORT}/"nameofDB"
spring.datasource.username = ${OPENSHIFT_MYSQL_DB_USERNAME}
spring.datasource.password = ${OPENSHIFT_MYSQL_DB_PORT}

Maintenant, déclarez les variables d'environnement utilisées ci-dessus,

export OPENSHIFT_MYSQL_DB_Host="jdbc:mysql://localhost"
export OPENSHIFT_MYSQL_DB_PORT="3306"
export OPENSHIFT_MYSQL_DB_USERNAME="root"
export OPENSHIFT_MYSQL_DB_PASSWORD="123asd"

De cette façon, vous pouvez utiliser différentes valeurs pour la même variable dans différents environnements.

0
vishal lakhyani