Quelle différence cela fait-@EnableConfigurationproperties si un harit est déjà annoté avec @ConfigurationProperties?

Question

Le Printemps de Démarrage de la documentation dit que pour utiliser l' @ConfigurationProperties d'annotation

Vous avez également besoin d'énumérer les propriétés des classes de s'inscrire dans l' @EnableConfigurationProperties d'annotation, comme illustré ci-dessous exemple:

et donne ce code:

@Configuration
@EnableConfigurationProperties(AcmeProperties.class)
public class MyConfiguration {
}

Mais dans le très à côté de l'alinéa dit:

Même si la configuration précédente, crée régulièrement bean pour AcmeProperties, nous vous recommandons @ConfigurationProperties seulement affaire avec l'environnement et, en particulier, ne pas injecter d'autres haricots à partir du contexte. Cela dit, l' @EnableConfigurationProperties l'annotation est automatiquement appliqué à votre projet afin que tous existant bean annotée avec @ConfigurationProperties est configuré de l'Environnement

Ce qui suggère que l'inscription d'un @ConfigurationProperties haricot en vertu d'un @EnableConfigurationProperties d'annotation n'est pas nécessaire.

Alors, qui est-il? Expérimentalement, j'ai vu que si je annoter un haricot avec @ConfigurationProperties il obtient des propriétés injecté à elle comme prévu sans avoir besoin de liste dans @EnableConfigurationProperties, mais si c'est le cas, alors pourquoi la liste de tout ce qui a un @ConfigurationProperties d'annotation en vertu de l' @EnableConfigurationProperties, comme c'est indiqué dans la documentation? Faut-il faire une différence?

Answer 1

Comme M. Deinum visée @EnableConfigurationProperties Est pour activer la prise en charge de l' @ConfigurationProperties. Si vous jetez un oeil à l'annotation Java Doc vous pouvez le voir:

Activer la prise en charge ConfigurationProperties annoté des haricots. ConfigurationProperties les haricots peuvent être enregistrés dans le mode standard (par exemple à l'aide de Fèves @Bean méthodes) ou, pour des raisons de commodité, peut être spécifié directement sur cette annotation. [...]

Par exemple, disons que vous avez une classe qui a la responsabilité de lire et de stocker des informations à partir de votre application.yml / application.properties qui est requis pour établir une connexion à des bases de données différentes. Vous de les annoter avec @ConfigurationProperties.

Ensuite, vous avez généralement un @Configuration annoté de la classe qui fournit un DataSource @Bean de votre application. Vous pouvez utiliser l' @EnableConfigurationProperties pour la relier à l' @ConfigurationProperties de la classe et de l'init de vos sources de données en conséquence.

Voici un petit exemple:

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

DataSourcesConfiguration

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

DataSourceConnectionConfiguration

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

}

Answer 2

Il m'a fallu un certain temps pour atteindre à ce poste, mais voudrais ajouter ici afin que d'autres puissent obtenir bénéficié.

@ConfigurationProperties - Utilisé pour lier une classe avec un externalisés fichier de propriétés. Très puissants et doivent être utilisés pour séparer les classes de haricots avec la configuration de la classe d'entité.

@Configuration - Crée un Printemps haricot de configuration stéréotype.

@EnableConfigurationProperties - Crée une liaison entre une configuration de classe d'entité et de configuration Spring stéréotype de sorte qu'après l'injection au sein d'un service de propriétés peuvent être facilement récupérés.

Answer 3

Si l'on regarde le code ci-dessous:

@Configuration @EnableConfigurationProperties @ConfigurationProperties(prefix="ar1") public class ar1Settings { }

• @Configuration indique Printemps pour traiter cela comme une classe de configuration et l'enregistrer comme un Haricot

• @EnableConfigurationProperties dit Printemps pour traiter cette classe en tant que consommateur de l'application.yml/valeurs des propriétés

• @ConfigurationProperties dit de Printemps de la section dans cette classe représente.

Ma compréhension est que si vous n'avez pas besoin de spécifier la section de la propriété du fichier, puis @ConfigurationProperties peut être omis.