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


312

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.

Odpowiedzi:


467

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


5
alternatywnie można je również dostać od wiosny Environmentlub via@ConfigurationProperties
sodik

3
Aby dodać do odpowiedzi @ sodik, jest to przykład, który pokazuje, jak uzyskać środowisko stackoverflow.com/questions/28392231/...
cristi

Co jeśli potrzebujesz dostępu do ponad 10 wartości, czy musiałbyś powtarzać swój przykład 10 razy?
Jesse,

jednym podejściem byłoby to zrobić, ale jest to uciążliwe. Istnieją alternatywne podejścia oparte na @Configurationklasach, problem jest dobrze analizowany w następującym poście na blogu
Master Slave,

2
Uwaga, działa to tylko na @Component(lub jednym z jego pochodnych, tj. @RepositoryItp.)
Janac Meena,

210

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

@Autowired
private Environment env;
....

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

6
przydatne również, gdy nazwa nieruchomości, do której trzeba uzyskać dostęp, zmienia się dynamicznie
Paulo Merson

3
Co jeśli chcesz przeszukać nieruchomości? I czy mogę zasugerować dołączenie instrukcji importu, aby wszyscy mogli zobaczyć nazwę pakietu Środowisko, prawdopodobnie org.springframework.core.env.Environment
chrisinmtown

2
Uważaj, aby nie importować niewłaściwego środowiska. Intellij automatycznie zaimportowałem środowisko CORBA.
Janac Meena

3
Dlaczego moja env jest zerowa?
Janac Meena

2
@JanacMeena miał ten sam problem z automatycznym importowaniem klasy CORBA przez IntelliJ zamiastorg.springframework.core.env.Environment
Rasshu

31

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

}

1
skorzystałem w ten sposób i uzyskałem zerowy powrót, umieściłem mój plik właściwości w src / test / resources i właściwości Java klasy (w której zapisywana jest wartość właściwości) w src / main / package / properties. czego mi brakowało? dzięki
Ahmad Leo Yudanto

musisz zapisać pliki, src/main/resourcesjeśli nie testujesz kodu z testu wiosennego.
JoBⅈN

To samo co @AhmadLeoYudanto i nic nie mogę na to
poradzić

6

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

Co się stanie, jeśli domyślna lokalizacja zostanie zastąpiona spring.config.location? Czy # 2 nadal działa?
bmauter

W takim przypadku pierwszeństwo ma miejsce. Jak wiem, kiedy ustawiasz spring.config.location za pomocą wiersza polecenia, ma on wysoki priorytet, więc zastępuje istniejący.
Dhwanil Patel

5

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

1
Co to za paczka Environment?
e-info128

1
Znajdź tutaj: org.springframework.core.env.Environment
lucifer

Co się stanie, jeśli domyślna lokalizacja zostanie zastąpiona spring.config.location?
bmauter

3

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;

3

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

1

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; 

0

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


0

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

0

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

0

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


0

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;
}
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.