yml propertysourcesplaceholderconfigurer property leer example context application java spring-boot properties-file

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



leer properties java spring (10)

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.


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; // ... }


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.


Otra forma es inyectando el entorno a su bean.

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


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


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;


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.


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


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


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


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