La documentación de Spring Boot dice que para usar el @ConfigurationProperties
anotación
También debe enumerar las clases de propiedades para registrar en el
@EnableConfigurationProperties
anotación, como se muestra en el siguiente ejemplo:
y da este código:
@Configuration
@EnableConfigurationProperties(AcmeProperties.class)
public class MyConfiguration {
}
Pero en el siguiente párrafo dice:
Incluso si la configuración anterior crea un bean regular para AcmeProperties, recomendamos que @ConfigurationProperties
solo trata con el medio ambiente y, en particular, no inyecta otros frijoles del contexto. Habiendo dicho eso, el @EnableConfigurationProperties
La anotación también se aplica automáticamente a su proyecto para que cualquier
existente frijol anotado con @ConfigurationProperties
se configura desde el Environment
.
Sugiriendo que enumerar un @ConfigurationProperties
frijol bajo un @EnableConfigurationProperties
la anotación no es necesaria.
Entonces, ¿cuál es? Experimentalmente, he visto que si anoto un frijol con @ConfigurationProperties
se le inyectan propiedades como se esperaba sin necesidad de incluirlo en @EnableConfigurationProperties
pero si este es el caso, ¿por qué enumerar cualquier cosa que tenga un @ConfigurationProperties
anotación debajo @EnableConfigurationProperties
, como se muestra en la documentación? ¿Hace algún tipo de diferencia?
Como se refirió M. Deinum @EnableConfigurationProperties
Es para permitir el soporte de @ConfigurationProperties
. Si echas un vistazo a la anotación Java Doc puedes ver:
Habilite la compatibilidad con beans anotados de ConfigurationProperties. Los beans ConfigurationProperties se pueden registrar de forma estándar (por ejemplo, utilizando los métodos Bean @Bean) o, por comodidad, se pueden especificar directamente en esta anotación. […]
Por ejemplo, supongamos que tiene una clase cuya responsabilidad es leer y almacenar información de su application.yml
/ application.properties
que se requiere para hacer una conexión a diferentes bases de datos. Lo anotas con @ConfigurationProperties
.
Entonces, normalmente tienes un @Configuration
clase anotada que proporciona una DataSource
@Bean
a su aplicación. Puedes usar el @EnableConfigurationProperties
para vincularlo a la @ConfigurationProperties
class e inicie sus fuentes de datos en consecuencia.
Aquí hay un pequeño ejemplo:
aplicación.yml
data-sources:
db1:
url: "jdbc:postgresql://localhost:5432}/db1"
username: test
password: test
db2:
url: "jdbc:postgresql://localhost:5432}/db2"
username: test
password: test
Configuración de fuentes de datos
@ConfigurationProperties
public class DataSourcesConfiguration {
private Map<String, BasicDataSource> dataSources;
public void setDataSources(Map<String, BasicDataSource> dataSources) {
this.dataSources = dataSources;
}
Map<String, BasicDataSource > getDataSources() {
return dataSources;
}
}
Configuración de conexión de origen de datos
@Configuration
@EnableConfigurationProperties(DataSourcesConfiguration.class)
public class DatabaseConnectionConfiguration implements Provider<Connection> {
private DataSourcesConfiguration dataSourcesConfiguration;
public DatabaseConnectionConfiguration(DataSourcesConfiguration dataSourcesConfiguration) {
this.dataSourcesConfiguration = dataSourcesConfiguration;
}
@Bean
public DataSource dataSource() {
// Use dataSourcesConfiguration to create application data source. E.g., a AbstractRoutingDataSource..
}
}
Me tomó un tiempo llegar a esta publicación, pero me gustaría agregarla aquí para que otros puedan beneficiarse.
@ConfigurationProperties
– Se utiliza para enlazar una clase con un archivo de propiedades externalizado. Muy poderoso y debe usarse para separar las clases de bean con la clase de entidad de configuración.
@Configuration
– Crea un Spring bean de estereotipo de configuración.
@EnableConfigurationProperties
– Crea un enlace entre una clase de entidad de configuración y un estereotipo de configuración de Spring para que después de la inyección dentro de las propiedades de un servicio se puedan recuperar fácilmente.
Si nos fijamos en el siguiente código:
@Configuration @EnableConfigurationProperties @ConfigurationProperties(prefix="ar1")
public class ar1Settings { }
-
@Configuración le dice a Spring que trate esto como una clase de configuración y lo registre como un Bean
-
@EnableConfigurationProperties le dice a Spring que trate esta clase como un consumidor de los valores application.yml/properties
-
@Propiedades de configuración le dice a Spring qué sección representa esta clase.
Según tengo entendido, si no necesita especificar la sección del archivo de propiedades, se puede omitir @ConfigurationProperties.
mira mi respuesta aquí. stackoverflow.com/questions/48111941/… Este es un ejemplo en el que podría usar
@EnableConfigurationProperties
es obligatorio– pvpkiran
17 de abril de 2018 a las 14:23
Si entiendo correctamente, esto explica por qué necesita
@EnableConfigurationProperties
en una clase de configuración, pero no por qué necesita darle una lista de clases anotadas con@Configurationproperties
p.ej@EnableConfigurationProperties(AcmeProperties.class)
cuando AcmeProperties ya está anotado con@ConfigurationProperties
– Persona J
17 de abril de 2018 a las 14:33