So greifen Sie auf einen Wert zu, der in der Datei application.properties in Spring Boot definiert ist

Ich möchte auf Werte zugreifen, die in bereitgestellt werden application.properties, z.

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

userBucket.path=${HOME}/bucket

Ich möchte userBucket.pathin meinem Hauptprogramm in einer Spring Boot-Anwendung zugreifen .

Sie können die @ValueAnmerkung verwenden und auf die Eigenschaft in der von Ihnen verwendeten Spring Bean zugreifen

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

Im Abschnitt Externalisierte Konfiguration der Spring Boot-Dokumente werden alle Details erläutert, die Sie möglicherweise benötigen.

Ein anderer Weg ist das Injizieren org.springframework.core.env.Environmentin Ihre Bohne.

@Autowired
private Environment env;
....

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

@ConfigurationPropertieskann verwendet werden, um Werte von .properties( .ymlauch unterstützt) einem POJO zuzuordnen .

Betrachten Sie die folgende Beispieldatei.

.Eigenschaften

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
}

Jetzt kann auf den Eigenschaftswert employeePropertieswie folgt automatisch zugegriffen werden .

@Autowired
private Employee employeeProperties;

public void method() {

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

}

Derzeit kenne ich die folgenden drei Möglichkeiten:

1. Die @ValueAnmerkung

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

• Nach meiner Erfahrung gibt es einige Situationen, in denen Sie den Wert nicht erhalten können oder auf den er eingestellt ist null. Zum Beispiel, wenn Sie versuchen, es in einer preConstruct()Methode oder einer init()Methode festzulegen. Dies geschieht, weil die Wertinjektion erfolgt, nachdem die Klasse vollständig erstellt wurde. Aus diesem Grund ist es besser, die 3. Option zu verwenden.

2. Die @PropertySourceAnmerkung

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

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

• PropertySouceLegt Werte aus der Eigenschaftsquelldatei in einer EnvironmentVariablen (in Ihrer Klasse) fest, wenn die Klasse geladen wird. So können Sie leicht Nachworte abrufen.
  • Zugriff über die Systemumgebungsvariable.

3. Die @ConfigurationPropertiesAnmerkung.

• Dies wird hauptsächlich in Spring-Projekten zum Laden von Konfigurationseigenschaften verwendet.

• Es initialisiert eine Entität basierend auf Eigenschaftsdaten.

  • @ConfigurationProperties Identifiziert die zu ladende Eigenschaftendatei.
  • @Configuration Erstellt eine Bean basierend auf Variablen der Konfigurationsdatei.

  @ConfigurationProperties (Präfix = "Benutzer")
  @Configuration ("UserData")
  Klassenbenutzer {
    // Eigenschaft & ihr Getter / Setter
  }}
  
  @Autowired
  private UserData userData;
  
  userData.getPropertyName ();

Sie können es auch so machen ...

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

    @Autowired
    private Environment env;

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

Übergeben Sie dann, wo immer Sie aus application.properties lesen möchten, einfach den Schlüssel an die Methode getConfigValue.

@Autowired
ConfigProperties configProp;

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

Sie können das verwenden @Value, um Variablen aus dem zu laden, application.propertieswenn Sie diesen Wert an einer Stelle verwenden. Wenn Sie jedoch eine zentralere Methode zum Laden dieser Variablen benötigen, @ConfigurationPropertiesist dies ein besserer Ansatz.

Darüber hinaus können Sie Variablen laden und automatisch umwandeln, wenn Sie unterschiedliche Datentypen benötigen, um Ihre Validierungen und Geschäftslogik durchzuführen.

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

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

folge diesen Schritten. 1: - Erstellen Sie Ihre Konfigurationsklasse wie unten gezeigt

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: - Wenn Sie eine Konfigurationsklasse haben, fügen Sie die Variable aus einer Konfiguration ein, die Sie benötigen.

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

Eine Anwendung kann drei Werttypen aus der Datei application.properties lesen.

application.properties

     my.name=kelly

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

Klassendatei

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

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

Wenn Sie in application.properties keine Eigenschaft haben, können Sie den Standardwert verwenden

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

Mit Spring-Boot können wir auf verschiedene Weise externe Konfigurationen bereitstellen. Sie können versuchen, anstelle der Eigenschaftendatei application.yml- oder yaml-Dateien zu verwenden und je nach Umgebung unterschiedliche Eigenschaftendateien einzurichten.

Wir können die Eigenschaften für jede Umgebung in separate yml-Dateien unter separaten Federprofilen aufteilen. Während der Bereitstellung können Sie Folgendes verwenden:

java -jar -Drun.profiles=SpringProfileName

Geben Sie an, dass die yml-Dateien den Namen haben sollen

application-{environmentName}.yml

damit sie automatisch von springboot aufgenommen werden.

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

So lesen Sie aus der Datei application.yml oder der Eigenschaft:

Der einfachste Weg , einen Wert aus der Eigenschaftendatei oder der yml zu lesen, ist die Verwendung der Annotation spring @value. Spring lädt automatisch alle Werte aus der yml in die spring-Umgebung, sodass wir diese Werte direkt aus der Umgebung verwenden können, wie:

@Component
public class MySampleBean {

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

// ...

}

Oder eine andere Methode, die der Frühling zum Lesen stark typisierter Bohnen bietet, ist folgende:

YML

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

Entsprechender POJO zum Lesen des 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) { ... }
    }
}

Die obige Methode funktioniert gut mit yml-Dateien.

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

Für mich hat keines der oben genannten Dinge direkt für mich funktioniert. Was ich getan habe, ist Folgendes:

Zusätzlich zu @Rodrigo Villalba Zayas Antwort dort oben habe ich
implements InitializingBeandie Klasse hinzugefügt
und die Methode implementiert

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

Das wird also so aussehen

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

Die besten Methoden zum Abrufen von Eigenschaftswerten sind.

1. Verwenden der Wertanmerkung

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

2. Verwenden von Enviornment Bean

@Autowired
private Environment env;

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

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

Am besten verwenden Sie eine @ValueAnmerkung, die Ihrem Objekt automatisch einen Wert zuweist private Environment en. Dies reduziert Ihren Code und es ist einfach, Ihre Dateien zu filtern.

Es gibt zwei Wege,

1. Sie können direkt @Valuein Ihrer Klasse verwenden

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

ODER

1. Um es sauber zu machen, können Sie die @ConfigurationKlasse reinigen , in der Sie alle Ihre hinzufügen können@value

@Configuration
public class AppConfig {

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