Springboot @ activer * Annotation Utilisation

1. Pourquoi puis-je réaliser une configuration automatique à l'aide de l'annotation @springbootapplication?

Réponse: @springbootapplication, il y a en fait 3 annotations internes. @EnableAutoConfiguration, @ComponentsCan, @configuration. Cet article explique principalement @enablexx annotation

2. Pourquoi @EnableAutoConfiguration est-elle utilisée? Lorsque @configurationproperties est utilisée, les éléments de configuration dans .yml ou .properties peuvent être automatiquement importés?

Réponse: Inside @enableAutoConfiguration, l'annotation @Import est utilisée. Importation AutoConfigurationImportSelector aide à charger la configuration qualifiée dans le conteneur IOC. Mais l'utilisation interne de Springfactoriesloader est utilisée pour la terminer. Semblable à Java SPI, c'est-à-dire le chargement de la configuration de /Meta-inf/spring.factories

 @Target ({elementType.Type}) @ retention (retentionPolicy.runtime) @ documenté @ hérité @ autoconfigurationpackage @ import ({autoconfigurationImportSelect

Vous pouvez voir que dans @Import, une classe AutoConfigurationImportSelector est réellement importée. La chose la plus importante est que cette classe implémente l'interface importselector

 Interface publique ImportSelector {/ ** * Sélectionnez et renvoyez les noms des classes (es) doit être importée en fonction de la classe {@Link AnnotationMetAdata} de la classe Importation @ {@ lien}. * / String [] selectImports (annotationMetadata importationclassmetadata);}

Il s'agit de la description d'importSelector, qui signifie à peu près que le haricot renvoyé par cette méthode sera automatiquement injecté et géré par le printemps.

Ensuite, examinons la mise en œuvre de SelectImports dans AutoConfigurationImportSelector

 String public [] selectImports (annotationMetadata annotationMetAdata) {if (! this.iseNabled (annotationMetadata)) {return no_imports; } else {autoconfigurationMetAdata autoconfigurationMetAdata = autoconfigurationMetAdatalOader.LoadMetAdata (this.BeANClassloader); ANNOTATATATTRIBUTES Attributs = this.getAttributes (annotationMetAdata); List <string> configurations = this.getCanDateConfigurations (annotationMetadata, attributs); configurations = this.reMovedUplications (configurations); Set <string> exclusions = this.getExclusions (annotationMetadata, attributs); this.checKexCludClasses (configurations, exclus); configurations.removeall (exclusions); configurations = this.filter (configurations, autoconfigurationMetAdata); this.fireAutoConfigurationImportEvents (configurations, excclusions); return stringUtils.toStringArray (configurations); }}

Le code est écrit très clairement. Je ne l'expliquerai pas.

Dans @Impport, vous pouvez voir qu'un lien pointe vers ImportBeanDefinitionRegistrar. Il s'agit également d'une interface, et sa fonction est la même que l'importonlector.

 Interface publique ImportBeAnDefinitionRegistrar {public void RegisterBeAndefinitions (AnnotationMetadata ImporttingClassMetadata, BeanDefinitionRegistry Registry);}

Dans la méthode RegisterBeanDefinitions, vous pouvez utiliser BeanDefinitionRegistry pour injecter le haricot que nous voulons injecter.

Exemple de code:

Écrivez votre propre @enable en utilisant @Import

1. Créez 2 haricots de test

 Rôle de classe publique {} Utilisateur de classe publique {}

2. Personnaliser Activer les annotations

 @Target ({elementType.Type}) @ Rétention (RetenderPolicy.Runtime) @ documenté @ import (MyenableAutoConfig.class) public @Interface ActiveBean {}

3. Implémentez votre propre classe d'activité

 classe publique MyEnableAutoConfig implémente ImportSelector {@Override public String [] selectImports (AnnotationMetAdata importationclassMetadata) {return new String [] {"com.xhn2.role", "com.xhn2.user"}; }}

4. Écrivez une classe de démarrage

 @ EnableBean @ ComponentsCan ("com.xhn2") classe publique main {public static void main (String [] args) {configurableApplicationContext context = springApplication.run (main.class, args); System.out.println (context.getBean (user.class)); System.out.println (context.getBean (role.class)); }}

5. Résultats de l'opération

com.xhn2.user@496bc455
com.xhn2.role@59402b8f

La console imprime avec succès.

Exemple de code 2, assemblage automatique du package de pot tiers

Nouveau projet Maven

1. Pom.xml

 <ModelVersion> 4.0.0 </ ModelVersion> <GroupId> org.csp </rom grouped> <ArtifActid> Bonjour </ artifactid> <version> 1.0.0 </ version> <properties> <maven.compiller.source> 1.8 </maven.comPiler.source> <acaven.comPiler.target> 1.8 </maven.Tegret.Teler.Target> 1.8 </maven.Terget....target> 1.8 </maven.Terget....target> 1.8 </maven.Tegret.Teler.Target> 1.8 </maven.Telert. <project.build.sourceencoding> utf-8 </project.build.sourceencoding> </properties> <dépendances> <dependency> <proupId> org.springframework </proupId> <Artefactive> Spring-Context </tatifactid> </ version> 4.3.17.release </DERNÉRAL

2. Écrivez la configuration

 @Configurationpublic class mytest {@bean public runnable runnable () {return () -> {}; }}

Créez un nouveau fichier Meta-Inf / Spring.factories sous Ressources et ajoutez la configuration suivante

 org.springframework.boot.autoconfigure.enableAutoConfiguration = com.edu.mytest

3. Installez le projet sur le référentiel Maven local: MVN Installer

4. Le projet principal présente le pot qui vient d'être installé dans la région.

 <dependency> <proupId> org.csp </proupId> <ArtifActid> Bonjour </ artifactId> <DERVIÈRE> 1.0.0 </DERNIERS> </ Dependency>

5. Obtenez la configuration de Runnable tout à l'heure

 @SpringBootApplicationPublic class main {public static void main (String [] args) {SpringApplication Application = new SpringApplication (main.class); ConfigurableApplicationContext context = application.run (args); System.out.println (context.getBean (runnable.class)); }}

6. Impression de console

com.edu.mytest$$lambda$153/284686302@2c07545f

Ce qui précède est tout le contenu de cet article. J'espère que cela sera utile à l'apprentissage de tous et j'espère que tout le monde soutiendra davantage Wulin.com.