Comment accéder à une valeur définie dans le fichier application.properties dans Spring Boot

312

Je souhaite accéder aux valeurs fournies application.properties, par exemple:

logging.level.org.springframework.web: DEBUG
logging.level.org.hibernate: ERROR
logging.file=${HOME}/application.log

userBucket.path=${HOME}/bucket

Je souhaite accéder userBucket.pathà mon programme principal dans une application Spring Boot.

Qasim
la source

Réponses:

467

Vous pouvez utiliser l' @Valueannotation et accéder à la propriété dans le bean Spring que vous utilisez

@Value("${userBucket.path}")
private String userBucketPath;

La section Configuration externalisée des documents Spring Boot explique tous les détails dont vous pourriez avoir besoin.

Maître d'esclave
la source
5
comme alternative on peut aussi les obtenir à partir du printemps Environmentou via@ConfigurationProperties
sodik
3
Pour ajouter en plus de la réponse de @ sodik, voici un exemple qui montre comment obtenir l' environnement stackoverflow.com/questions/28392231/…
cristi
Et si vous avez besoin d'accéder à plus de 10 valeurs, devrez-vous répéter votre exemple 10 fois?
Jesse
une approche serait de le faire, mais c'est lourd. Il existe des approches alternatives basées sur les @Configurationclasses, le problème est bien analysé dans le billet de blog
Master Slave
2
Remarque, cela ne fonctionne que sur un @Component(ou l'un de ses dérivés, c'est @Repository-à- dire , etc.)
Janac Meena
211

Une autre façon consiste à injecter org.springframework.core.env.Environmentdans votre haricot.

@Autowired
private Environment env;
....

public void method() {
    .....  
    String path = env.getProperty("userBucket.path");
    .....
}
Rodrigo Villalba Zayas
la source
6
également utile lorsque le nom de la propriété dont vous avez besoin pour accéder change dynamiquement
Paulo Merson
3
Et si vous souhaitez rechercher les propriétés? Et puis-je suggérer d'inclure la déclaration d'importation afin que tous puissent voir le nom du package d'environnement, probablement org.springframework.core.env.Environment
chrisinmtown
2
Faites attention de ne pas importer le mauvais environnement. J'ai intellij importé automatiquement l'environnement CORBA.
Janac Meena
3
Pourquoi mon env est-il nul?
Janac Meena
2
@JanacMeena a eu le même problème avec la classe CORBA de l'auto-importation IntelliJ au lieu deorg.springframework.core.env.Environment
Rasshu
31

@ConfigurationPropertiespeut être utilisé pour mapper des valeurs de .properties( .ymlégalement prises en charge) à un POJO.

Considérez l'exemple de fichier suivant.

.Propriétés

cust.data.employee.name=Sachin
cust.data.employee.dept=Cricket

Employee.java

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;

@ConfigurationProperties(prefix = "cust.data.employee")
@Configuration("employeeProperties")
public class Employee {

    private String name;
    private String dept;

    //Getters and Setters go here
}

Maintenant, la valeur des propriétés est accessible par câblage automatique employeePropertiescomme suit.

@Autowired
private Employee employeeProperties;

public void method() {

   String employeeName = employeeProperties.getName();
   String employeeDept = employeeProperties.getDept();

}
JoBⅈN
la source
1
J'ai utilisé cette méthode et obtenu un retour nul, j'ai mis mon fichier de propriétés dans src / test / resources et la classe java de propriétés (dans laquelle la valeur des propriétés est enregistrée) dans src / main / package / properties. ce qui me manquait? merci
Ahmad Leo Yudanto
vous devez enregistrer les fichiers src/main/resourcessi vous ne testez pas votre code à partir d'un test Spring.
JoBⅈN
Identique à @AhmadLeoYudanto et il n'y a rien que je puisse faire qui change cela
Dimitri Kopriwa
6

Actuellement, je connais les trois façons suivantes:

1. L' @Valueannotation

    @Value("${<property.name>}")
    private static final <datatype> PROPERTY_NAME;
  • D'après mon expérience, il y a des situations où vous ne pouvez pas obtenir la valeur ou où elle est définie null. Par exemple, lorsque vous essayez de le définir dans une preConstruct()méthode ou une init()méthode. Cela se produit car l'injection de valeur se produit après la construction complète de la classe. C'est pourquoi il vaut mieux utiliser la 3ème option.

2. L' @PropertySourceannotation

<pre>@PropertySource("classpath:application.properties")

//env is an Environment variable
env.getProperty(configKey);</pre>
  • PropertySoucedéfinit les valeurs du fichier source de propriété dans une Environmentvariable (dans votre classe) lorsque la classe est chargée. Vous pouvez donc récupérer facilement la postface.
    • Accessible via la variable d'environnement système.

3. L' @ConfigurationPropertiesannotation.

  • Ceci est principalement utilisé dans les projets Spring pour charger les propriétés de configuration.
  • Il initialise une entité basée sur des données de propriété.

    • @ConfigurationProperties identifie le fichier de propriétés à charger.
    • @Configuration crée un bean basé sur les variables du fichier de configuration.
    @ConfigurationProperties (prefix = "user")
    @Configuration ("UserData")
    utilisateur de classe {
      // Propriété et son getter / setter
    }
    
    @Autowired
    Private UserData userData;
    
    userData.getPropertyName ();
Dhwanil Patel
la source
Que faire si l'emplacement par défaut est remplacé par spring.config.location? Est-ce que # 2 fonctionne toujours?
bmauter
Dans ce cas, la priorité entre en jeu. Comme je le sais lorsque vous définissez spring.config.location à l'aide de la ligne de commande, il a une priorité élevée, il remplace donc celui existant.
Dhwanil Patel
5

Vous pouvez aussi le faire de cette façon ....

@Component
@PropertySource("classpath:application.properties")
public class ConfigProperties {

    @Autowired
    private Environment env;

    public String getConfigValue(String configKey){
        return env.getProperty(configKey);
    }
}

Ensuite, où que vous souhaitiez lire dans application.properties, passez simplement la clé de la méthode getConfigValue.

@Autowired
ConfigProperties configProp;

// Read server.port from app.prop
String portNumber = configProp.getConfigValue("server.port"); 
Lucifer
la source
1
Quel est le package Environment?
e-info128
1
Trouvez-le ici: org.springframework.core.env.Environment
lucifer
Que faire si l'emplacement par défaut est remplacé par spring.config.location?
bmauter
3

Vous pouvez utiliser le @Valuepour charger des variables à partir de application.propertiessi vous allez utiliser cette valeur à un seul endroit, mais si vous avez besoin d'un moyen plus centralisé pour charger ces variables, @ConfigurationPropertiesc'est une meilleure approche.

De plus, vous pouvez charger des variables et les diffuser automatiquement si vous avez besoin de différents types de données pour effectuer vos validations et votre logique métier.

application.properties
custom-app.enable-mocks = false

@Value("${custom-app.enable-mocks}")
private boolean enableMocks;
JorgeTovar
la source
3

Suivez ces étapes. 1: - créez votre classe de configuration comme ci-dessous vous pouvez voir

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.beans.factory.annotation.Value;

@Configuration
public class YourConfiguration{

    // passing the key which you set in application.properties
    @Value("${userBucket.path}")
    private String userBucket;

   // getting the value from that key which you set in application.properties
    @Bean
    public String getUserBucketPath() {
        return userBucket;
    }
}

2: - lorsque vous avez une classe de configuration, injectez la variable à partir d'une configuration où vous en avez besoin.

@Component
public class YourService {

    @Autowired
    private String getUserBucketPath;

    // now you have a value in getUserBucketPath varibale automatically.
}
Fazle Subhan
la source
1
1.Injecting a property with the @Value annotation is straightforward:
@Value( "${jdbc.url}" )
private String jdbcUrl;

2. we can obtain the value of a property using the Environment API

@Autowired
private Environment env;
...
dataSource.setUrl(env.getProperty("jdbc.url"));
sai
la source
1

Une application peut lire 3 types de valeur dans le fichier application.properties.

application.properties


     my.name=kelly

my.dbConnection ={connection_srting:'http://localhost:...',username:'benz',password:'pwd'}

fichier de classe

@Value("${my.name}")
private String name;

@Value("#{${my.dbConnection}}")
private Map<String,String> dbValues;

Si vous n'avez pas de propriété dans application.properties, vous pouvez utiliser la valeur par défaut

        @Value("${your_name : default value}")
         private String msg; 
NafazBenzema
la source
0

Spring-boot nous permet plusieurs méthodes pour fournir des configurations externalisées, vous pouvez essayer d'utiliser des fichiers application.yml ou yaml au lieu du fichier de propriétés et fournir différentes configurations de fichiers de propriétés selon différents environnements.

Nous pouvons séparer les propriétés de chaque environnement dans des fichiers yml distincts sous des profils de ressort distincts. Ensuite, pendant le déploiement, vous pouvez utiliser:

java -jar -Drun.profiles=SpringProfileName

pour spécifier le profil de ressort à utiliser. Notez que les fichiers yml doivent être nommés comme

application-{environmentName}.yml

pour qu'ils soient automatiquement repris par springboot.

Référence: https://docs.spring.io/spring-boot/docs/current/reference/html/boot-features-external-config.html#boot-features-external-config-profile-specific-properties

Pour lire à partir du fichier application.yml ou de la propriété:

La façon la plus simple de lire une valeur à partir du fichier de propriétés ou du yml est d'utiliser l'annotation spring @value. Spring charge automatiquement toutes les valeurs du yml dans l'environnement spring, afin que nous puissions directement utiliser ces valeurs de l'environnement comme:

@Component
public class MySampleBean {

@Value("${name}")
private String sampleName;

// ...

}

Ou une autre méthode que le printemps propose pour lire les beans fortement typés est la suivante:

YML

ymca:
    remote-address: 192.168.1.1
    security:
        username: admin

POJO correspondant pour lire le yml:

@ConfigurationProperties("ymca")
public class YmcaProperties {
    private InetAddress remoteAddress;
    private final Security security = new Security();
    public boolean isEnabled() { ... }
    public void setEnabled(boolean enabled) { ... }
    public InetAddress getRemoteAddress() { ... }
    public void setRemoteAddress(InetAddress remoteAddress) { ... }
    public Security getSecurity() { ... }
    public static class Security {
        private String username;
        private String password;
        public String getUsername() { ... }
        public void setUsername(String username) { ... }
        public String getPassword() { ... }
        public void setPassword(String password) { ... }
    }
}

La méthode ci-dessus fonctionne bien avec les fichiers yml.

Référence: https://docs.spring.io/spring-boot/docs/current/reference/html/boot-features-external-config.html

Ananthapadmanabhan
la source
0

Pour moi, rien de ce qui précède n'a fonctionné directement pour moi. Ce que j'ai fait est le suivant:

En plus de la réponse de @Rodrigo Villalba Zayas là-haut, j'ai ajouté
implements InitializingBeanà la classe
et mis en œuvre la méthode

@Override
public void afterPropertiesSet() {
    String path = env.getProperty("userBucket.path");
}

Cela ressemblera donc

import org.springframework.core.env.Environment;
public class xyz implements InitializingBean {

    @Autowired
    private Environment env;
    private String path;

    ....

    @Override
    public void afterPropertiesSet() {
        path = env.getProperty("userBucket.path");
    }

    public void method() {
        System.out.println("Path: " + path);
    }
}
Rapalagui
la source
0

Les meilleures façons d'obtenir des valeurs de propriété sont d'utiliser.

1. Utilisation de l'annotation de valeur

@Value("${property.key}")
private String propertyKeyVariable;

2. Utilisation du bean Enviornment

@Autowired
private Environment env;

public String getValue() {
    return env.getProperty("property.key");
}

public void display(){
  System.out.println("# Value : "+getValue);
}
Naresh Bhadke
la source
0

La meilleure chose à faire est d'utiliser l' @Valueannotation, elle attribuera automatiquement une valeur à votre objet private Environment en. Cela réduira votre code et il sera facile de filtrer vos fichiers.

MindFlayerA
la source
0

Il y a deux façons,

  1. vous pouvez utiliser directement @Valuedans votre classe
    @Value("#{'${application yml field name}'}")
    public String ymlField;

OU

  1. Pour le rendre propre, vous pouvez nettoyer la @Configurationclasse où vous pouvez ajouter tous vos@value
@Configuration
public class AppConfig {

    @Value("#{'${application yml field name}'}")
    public String ymlField;
}
Rishabh Agarwal
la source