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

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.

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.

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");
    .....
}

@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();

}

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 ();

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"); 

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;

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

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"));

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; 

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

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

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

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.

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