Jak uzyskać dostęp do wartości zdefiniowanej w pliku application.properties w Spring Boot

Chcę uzyskać dostęp do wartości podanych application.propertiesnp .:

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

userBucket.path=${HOME}/bucket

Chcę uzyskać dostęp userBucket.pathdo mojego programu głównego w aplikacji Spring Boot.

Możesz użyć @Valueadnotacji i uzyskać dostęp do właściwości w dowolnej fasoli wiosennej, której używasz

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

Sekcja Zewnętrzna konfiguracja dokumentów Spring Boot wyjaśnia wszystkie szczegóły, których możesz potrzebować.

Innym sposobem jest wstrzyknięcie org.springframework.core.env.Environmentdo fasoli.

@Autowired
private Environment env;
....

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

@ConfigurationPropertiesmoże być używany do mapowania wartości z .properties( .ymlrównież obsługiwanych) na POJO.

Rozważ następujący przykładowy plik.

.nieruchomości

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
}

Teraz do wartości właściwości można uzyskać dostęp przez automatyczne okablowanie employeePropertiesw następujący sposób.

@Autowired
private Employee employeeProperties;

public void method() {

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

}

Obecnie znam trzy następujące sposoby:

1. @ValueAdnotacja

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

• Z mojego doświadczenia wynika, że ​​są sytuacje, w których nie można uzyskać wartości lub jest ona ustawiona na null. Na przykład, gdy próbujesz ustawić go w preConstruct()metodzie lub init()metodzie. Dzieje się tak, ponieważ wstrzykiwanie wartości następuje po pełnym zbudowaniu klasy. Dlatego lepiej jest użyć opcji 3.

2. @PropertySourceAdnotacja

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

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

• PropertySouceustawia wartości z pliku źródłowego właściwości w Environmentzmiennej (w twojej klasie), gdy klasa jest ładowana. Więc możesz łatwo pobrać posłowie.
  • Dostępne poprzez zmienną środowiskową systemu.

3. @ConfigurationPropertiesAdnotacja.

• Jest to najczęściej używane w projektach Spring do ładowania właściwości konfiguracji.

• Inicjuje jednostkę na podstawie danych właściwości.

  • @ConfigurationProperties określa plik właściwości do załadowania.
  • @Configuration tworzy komponent bean na podstawie zmiennych pliku konfiguracyjnego.

  @ConfigurationProperties (prefix = „user”)
  @ Konfiguracja („UserData”)
  użytkownik klasy {
    // Właściwość i ich getter / setter
  }
  
  @Autowired
  prywatny UserData userData;
  
  userData.getPropertyName ();

Możesz to zrobić również w ten sposób ....

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

    @Autowired
    private Environment env;

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

Następnie, gdziekolwiek chcesz czytać z application.properties, po prostu przekaż klucz do metody getConfigValue.

@Autowired
ConfigProperties configProp;

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

Możesz użyć @Valuedo załadowania zmiennych z tego, application.propertiesczy użyjesz tej wartości w jednym miejscu, ale jeśli potrzebujesz bardziej scentralizowanego sposobu ładowania tych zmiennych, @ConfigurationPropertiesjest to lepsze podejście.

Dodatkowo możesz ładować zmienne i rzutować je automatycznie, jeśli potrzebujesz różnych typów danych do przeprowadzenia weryfikacji i logiki biznesowej.

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

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

wykonaj następujące kroki. 1: - stwórz swoją klasę konfiguracji jak poniżej

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: - gdy masz klasę konfiguracji, wstaw zmienną z konfiguracji, w której potrzebujesz.

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

Aplikacja może odczytać 3 typy wartości z pliku application.properties.

application.properties

     my.name=kelly

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

plik klasy

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

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

Jeśli nie masz właściwości w application.properties, możesz użyć wartości domyślnej

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

Spring-boot pozwala nam na kilka metod zapewniania konfiguracji zewnętrznych, możesz spróbować użyć pliku application.yml lub yaml zamiast pliku właściwości i zapewnić różne ustawienia plików właściwości w zależności od różnych środowisk.

Możemy rozdzielić właściwości każdego środowiska na osobne pliki yml w osobnych profilach sprężynowych. Następnie podczas wdrażania możesz użyć:

java -jar -Drun.profiles=SpringProfileName

aby określić, który profil sprężyny ma zostać użyty. Pamiętaj, że pliki yml powinny mieć nazwy takie jak

application-{environmentName}.yml

aby były automatycznie podejmowane przez springboot.

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

Aby odczytać z pliku application.yml lub pliku właściwości:

Najprostszym sposobem, aby odczytać wartość z pliku właściwości lub yml jest użycie annotation.Spring wiosna @value automatycznie ładuje wszystkie wartości z yml do środowiska sprężyny, dzięki czemu możemy bezpośrednio korzystać z tych wartości ze środowiska, takich jak:

@Component
public class MySampleBean {

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

// ...

}

Lub inna metoda, którą zapewnia wiosna, aby odczytać silnie typowane fasole, jest następująca:

YML

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

Odpowiadający POJO do odczytania 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) { ... }
    }
}

Powyższa metoda działa dobrze z plikami yml.

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

Dla mnie żadne z powyższych nie działało bezpośrednio dla mnie. To, co zrobiłem, to:

Dodatkowo do odpowiedzi @Rodrigo Villalba Zayas tam dodałem
implements InitializingBeando klasy
i zaimplementowałem metodę

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

Tak to będzie wyglądać

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

Korzystają z najlepszych sposobów uzyskania wartości nieruchomości.

1. Korzystanie z adnotacji o wartości

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

2. Korzystanie z fasoli środowiskowej

@Autowired
private Environment env;

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

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

Najlepiej jest użyć @Valueadnotacji, która automatycznie przypisze wartość do obiektu private Environment en. Spowoduje to zmniejszenie kodu i łatwe filtrowanie plików.

Istnieją dwa sposoby

1. możesz bezpośrednio używać @Valuew swojej klasie

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

LUB

1. Aby to wyczyścić, możesz wyczyścić @Configurationklasę, w której możesz dodać wszystkie swoje@value

@Configuration
public class AppConfig {

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