java - propertysourcesplaceholderconfigurer - Cómo acceder a un valor definido en el archivo application.properties en Spring Boot

leer properties java spring

Question

Quiero acceder a los valores proporcionados en application.properties , por ejemplo:

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

Quiero acceder a userBucket.path en mi programa principal en una aplicación Spring Boot.

Answer 1

Actualmente, conozco las siguientes tres formas:

1. La anotación @Value

   java -jar -Drun.profiles=SpringProfileName

   • En mi experiencia, hay algunas situaciones en las que no puede obtener el valor o se establece en null . Por ejemplo, cuando intenta establecerlo en un método preConstruct() o un método init() . Esto sucede porque la inyección de valor ocurre después de que la clase está completamente construida. Es por eso que es mejor usar la tercera opción.

2. La anotación @PropertySource

   application-{environmentName}.yml

   • PropertySouce establece valores del archivo fuente de propiedades en una variable de Environment (en su clase) cuando se carga la clase. Por lo tanto, puede buscar fácilmente el epílogo.
   • Accesible a través de la variable de entorno del sistema.

3. La anotación @ConfigurationProperties .

   • Esto se usa principalmente en proyectos Spring para cargar propiedades de configuración.
   • Inicializa una entidad basada en datos de propiedad.
   • @ConfigurationProperties identifica el archivo de propiedad para cargar.
   • @Configuration crea un bean basado en las variables del archivo de configuración.

   @Component
   public class MySampleBean {
   @Value("${name}")
   private String sampleName;
   // ...
   }

Answer 2

Lo mejor es usar la anotación @Value, automáticamente asignará valor a su objeto "Entorno privado en". Esto reducirá su código y será fácil filtrar sus archivos.

Answer 3

Otra forma es inyectando el entorno a su bean.

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

Answer 4

Para mí, ninguno de los anteriores me funcionó directamente. Lo que hice es lo siguiente:

Además de @Rodrigo Villalba Zayas respondo allí agregué
implements InitializingBean a la clase
e implementó el método

@Autowired
private Environment env;
public String getValue() {
return env.getProperty("property.key");
}
public void display(){
System.out.println("# Value : "+getValue);
}

Entonces eso se verá como

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

Answer 5

Puede usar @Value para cargar variables desde application.properties si va a usar este valor en un lugar, pero si necesita una forma más centralizada de cargar estas variables @ConfigurationProperties es un mejor enfoque.

Además, puede cargar variables y emitirlas automáticamente si necesita diferentes tipos de datos para realizar sus validaciones y lógica de negocios.

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

Answer 6

Puede usar la anotación @Value y acceder a la propiedad en cualquier Spring bean que esté usando

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

La sección Configuración externalizada de los documentos de Spring Boot explica todos los detalles que pueda necesitar.

Answer 7

Puedes hacerlo de esta manera también ...

@Component
@PropertySource("classpath:application.properties")
public class ConfigProperties {
@Autowired
private Environment env;
public String getConfigValue(String configKey){
return env.getProperty(configKey);
}
}

Luego, donde quiera leer desde application.properties, simplemente pase la clave al método getConfigValue.

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

Answer 8

Se están utilizando las mejores formas de obtener valores de propiedad.

1. Usando la anotación de valor

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

2. Usando frijol ambiental

@Autowired private Environment env; public String getValue() { return env.getProperty("property.key"); } public void display(){ System.out.println("# Value : "+getValue); }

Answer 9

Spring-boot nos permite varios métodos para proporcionar configuraciones externalizadas, puede intentar usar los archivos application.yml o yaml en lugar del archivo de propiedades y proporcionar diferentes archivos de propiedades configurados de acuerdo a diferentes entornos.

Podemos separar las propiedades de cada entorno en archivos yml separados en perfiles de resorte separados. Luego, durante la implementación, puede usar:

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

para especificar qué perfil de primavera usar. Tenga en cuenta que los archivos yml deben tener un nombre como

@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) { ... }
}
}

para que sean automáticamente recogidos por springboot.

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

Para leer desde el archivo application.yml o de propiedad:

La forma más fácil de leer un valor del archivo de propiedades o yml es usar la anotación spring @value. Spring carga automáticamente todos los valores desde el yml al entorno spring, por lo que podemos usar directamente esos valores del entorno como:

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

U otro método que proporciona spring para leer frijoles fuertemente tipados es el siguiente:

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

POJO correspondiente para leer el yml:

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

El método anterior funciona bien con archivos yml.

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

Answer 10

@ConfigurationProperties se puede usar para asignar valores de .properties (también se admite .yml ) a un POJO.

Considere el siguiente archivo de ejemplo.

.propiedades

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
}

Ahora se puede acceder al valor de las propiedades mediante la propiedad automática de propiedades de los employeeProperties siguiente manera.

@Autowired
private Employee employeeProperties;
public void method() {
String employeeName = employeeProperties.getName();
String employeeDept = employeeProperties.getDept();
}