Come accedere a un valore definito nel file application.properties in Spring Boot

Voglio accedere ai valori forniti in application.properties, ad esempio:

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

userBucket.path=${HOME}/bucket

Voglio accedere userBucket.pathal mio programma principale in un'applicazione Spring Boot.

È possibile utilizzare l' @Valueannotazione e accedere alla proprietà in qualunque bean Spring che si sta utilizzando

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

La sezione Configurazione esterna dei documenti di Spring Boot, spiega tutti i dettagli di cui potresti aver bisogno.

Un altro modo è l'iniezione org.springframework.core.env.Environmental tuo bean.

@Autowired
private Environment env;
....

public void method() {
    .....  
    String path = env.getProperty("userBucket.path");
    .....
}

@ConfigurationPropertiespuò essere utilizzato per mappare i valori da .properties( .ymlanche supportato) a un POJO.

Considera il seguente file di esempio.

.proprietà

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
}

Ora è possibile accedere al valore delle proprietà autowiring employeePropertiescome segue.

@Autowired
private Employee employeeProperties;

public void method() {

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

}

Attualmente, conosco i seguenti tre modi:

1. L' @Valueannotazione

    @Value("${<property.name>}")
    private static final <datatype> PROPERTY_NAME;

• Nella mia esperienza ci sono alcune situazioni in cui non si è in grado di ottenere il valore o è impostato su null. Ad esempio, quando si tenta di impostarlo in un preConstruct()metodo o in un init()metodo. Ciò accade perché l'iniezione di valore avviene dopo che la classe è stata completamente costruita. Ecco perché è meglio usare la 3a opzione.

2. L' @PropertySourceannotazione

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

//env is an Environment variable
env.getProperty(configKey);</pre>

• PropertySouceimposta i valori dal file sorgente della proprietà in una Environmentvariabile (nella tua classe) quando la classe viene caricata. Quindi sei in grado di recuperare facilmente postfazione.
  • Accessibile tramite la variabile di ambiente di sistema.

3. L' @ConfigurationPropertiesannotazione.

• Viene utilizzato principalmente nei progetti Spring per caricare le proprietà di configurazione.

• Inizializza un'entità in base ai dati di proprietà.

  • @ConfigurationProperties identifica il file delle proprietà da caricare.
  • @Configuration crea un bean in base alle variabili del file di configurazione.

  @ConfigurationProperties (prefix = "user")
  @Configuration ( "UserData")
  utente di classe {
    // Proprietà e loro getter / setter
  }
  
  @Autowired
  UserData privato UserData;
  
  userData.getPropertyName ();

Puoi farlo anche in questo modo ....

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

    @Autowired
    private Environment env;

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

Quindi, ovunque tu voglia leggere da application.properties, passa la chiave al metodo getConfigValue.

@Autowired
ConfigProperties configProp;

// Read server.port from app.prop
String portNumber = configProp.getConfigValue("server.port"); 

È possibile utilizzare il @Valueper caricare variabili dal application.propertiesse si utilizzerà questo valore in un unico posto, ma se è necessario un modo più centralizzato per caricare queste variabili @ConfigurationPropertiesè un approccio migliore.

Inoltre, è possibile caricare variabili e trasmetterle automaticamente se sono necessari diversi tipi di dati per eseguire le convalide e la logica aziendale.

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

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

Segui questi passi. 1: - crea la tua classe di configurazione come sotto puoi vedere

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: - quando si dispone di una classe di configurazione, iniettare nella variabile da una configurazione in cui è necessario.

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

Un'applicazione può leggere 3 tipi di valore dal file application.properties.

application.properties

     my.name=kelly

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

file di classe

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

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

Se non si possiede una proprietà in application.properties, è possibile utilizzare il valore predefinito

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

Spring-boot ci consente diversi metodi per fornire configurazioni esternalizzate, puoi provare a utilizzare i file application.yml o yaml invece del file delle proprietà e fornire una diversa configurazione dei file delle proprietà in base a diversi ambienti.

È possibile separare le proprietà di ciascun ambiente in file yml separati in profili di primavera separati, quindi durante la distribuzione è possibile utilizzare:

java -jar -Drun.profiles=SpringProfileName

per specificare quale profilo di primavera utilizzare. Notare che i file yml devono essere simili al nome

application-{environmentName}.yml

per essere automaticamente ripresi da Springboot.

Riferimento: https://docs.spring.io/spring-boot/docs/current/reference/html/boot-features-external-config.html#boot-features-external-config-profile-specific-properties

Per leggere dal file application.yml o dalle proprietà:

Il modo più semplice per leggere un valore dal file di proprietà o yml è utilizzare l'annotazione spring @value. Pring carica automaticamente tutti i valori dall'YML all'ambiente Spring, in modo da poter utilizzare direttamente quei valori dall'ambiente come:

@Component
public class MySampleBean {

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

// ...

}

O un altro metodo fornito da Spring per leggere i bean fortemente tipizzati è il seguente:

YML

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

POJO corrispondente per leggere il codice 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) { ... }
    }
}

Il metodo sopra funziona bene con i file yml.

Riferimento: https://docs.spring.io/spring-boot/docs/current/reference/html/boot-features-external-config.html

Per me, nessuna delle precedenti ha funzionato direttamente per me. Quello che ho fatto è il seguente:

Inoltre, alla risposta di @Rodrigo Villalba Zayas, ho aggiunto
implements InitializingBeanalla classe
e implementato il metodo

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

Così sembrerà

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

I modi migliori per ottenere i valori delle proprietà stanno usando.

1. Utilizzo dell'annotazione valore

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

2. Utilizzo del bean Enviornment

@Autowired
private Environment env;

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

public void display(){
  System.out.println("# Value : "+getValue);
}

La cosa migliore è usare l' @Valueannotazione che assegnerà automaticamente valore al tuo oggetto private Environment en. Ciò ridurrà il tuo codice e sarà facile filtrare i tuoi file.

Ci sono due modi,

1. puoi usarlo direttamente @Valuenella tua classe

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

O

1. Per renderlo pulito puoi pulire la @Configurationclasse dove puoi aggiungere tutto il tuo@value

@Configuration
public class AppConfig {

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