avant-propos
Devant l'expérience SpringBoot pour nous de faire des profils de configuration automatique, rapide et facile, compliqué par rapport à avant, mais pas trop bon, donc nous ne pouvons que nous demander, à la fin est de savoir comment faire, laissez-nous travailler ensemble pour explorer ce
texte
Nous avons mis au point une botte de printemps tout projet, sera utilisé comme classes de démarrage
@SpringBootApplication
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
Comme on peut le voir à partir du code ci-dessus, les définitions d'annotation (de @SpringBootApplication) et la plus éclatante, pour ainsi démystifier SpringBoot, nous voulons que ces deux pour commencer sur la définition de la classe (SpringApplication.run) il.
@ SpringBootApplication : le printemps a marqué les instructions d'application de démarrage sur une classe de cette classe est la configuration de la classe principale de SpringBoot, SpringBoot doit exécuter la principale méthode de cette classe pour démarrer l' application SpringBoot,
regardez sa source:
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = {
@Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {
SpringBootApplication est une combinaison de notes, bien que la définition a été utilisé plus Annotation informations d'étiquetage d'origine, il est important que trois Annotation:
- @SpringBootConfiguration
- @EnableAutoConfiguration
- @ComponentScan
Donc, si nous commençons à utiliser la classe SpringBoot comme suit, toute la classe a commencé l'application SpringBoot peut encore fonctionner comme avant et ainsi de suite:
@Configuration
@EnableAutoConfiguration
@ComponentScan
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
Chaque écriture trois plus fatigué, donc écrire un point pratique de @SpringBootApplication. Les sections suivantes décrivent ces trois Annotation.
@ 1. SpringBootConfiguration : le printemps de la classe de configuration de démarrage;
Marqué sur une classe, il a dit qu'il était une classe de configuration de démarrage Spring;
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration
public @interface SpringBootConfiguration {
}
Après @Configuration pas étranger à nous, que c'est la forme Spring IoC @ conteneur Configuration JavaConfig des classes de configuration utilisées, SpringBoot les configurations recommandées communautaires JavaConfig, afin de commencer ici des classes marquées @Configuration, lui-même classe de configuration est en fait un conteneur IoC. classe de configuration est un ensemble récipient; @component
Quelques exemples simples à l'étude, la configuration de configuration XML avec une différence:
Formes de niveaux d'expression
basés sur le chemin de configuration XML est le suivant:
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd"
default-lazy-init="true">
<!--bean定义-->
</beans>
La configuration à base JavaConfig est la suivante:
@Configuration
public class MockConfiguration{
//bean定义
}
Tout a marqué une définition de classe Java est une classe de configuration JavaConfig @Configuration.
niveau défini de haricot de signe en
fonction de la configuration sous forme de XML est la suivante:
<bean id="userService" class="..UserServiceImpl">
...
</bean>
La configuration basée sur un formulaire JavaConfig est la suivante:
@Configuration
public class SpringConfiguration{
@Bean
public UserService userService(){
return new UserServiceImpl();
}
}
Toute méthode @Bean marquée, la valeur de retour sera défini comme un haricot enregistré conteneur Spring IoC, un nom par défaut à la méthode définie bean id.
Le niveau d'expression injection de relation de dépendance
aux dépendances express entre fèves et, généralement sous forme XML est:
<bean id="mockService" class="..MockServiceImpl">
<propery name ="dependencyService" ref="dependencyService" />
</bean>
<bean id="dependencyService" class="DependencyServiceImpl"></bean>
La configuration basée sur un formulaire JavaConfig est la suivante:
@Configuration
public class SpringConfiguration{
@Bean
public UserService userService(){
return new UserServiceImpl(dependencyService());
}
@Bean
public DependencyService dependencyService(){
return new DependencyServiceImpl();
}
}
Si vous définissez une classe JavaConfig le haricot compter sur d'autres haricots, appelez directement la méthode de création de haricot dépendant correspondant à ce sujet.
@ 2. ComponentScan : tour à fonction de configuration automatique;
@ComponentScan ce commentaire est très important au printemps, qui correspondent à des éléments dans la configuration XML, @ fonction ComponentScan est en fait des composants qualifiés automatiquement numériser et de charger (tels que @component et @Repository etc.) ou des définitions de haricots, finalement ces définitions de haricots IoC chargé dans le récipient.
si non spécifié, nous pouvons à grains fins gamme d'attributs personnalisés tels que @ComponentScan par basePackages balayage automatique, la valeur par défaut sera le cadre de printemps pour obtenir un pack d'analyse des mensonges de déclaration de classe @ComponentScan.
Remarque : Alors SpringBoot commencer les classes est le mieux placé dans le paquet racine, car la valeur par défaut n'est pas spécifié basePackages.
@ 3. EnableAutoConfiguration : tour à fonction de configuration automatique;
raison SpringBoot peut être zéro configuration, son noyau est @EnableAutoConfiguration cette annotation, ce que nous avons utilisé pour configurer, Spring Boot pour nous aider à automatiquement configurer et @ EnableAutoConfiguration dire SpringBoot ouvrir les capacités de configuration automatique, la configuration automatique pour prendre effet,
si vous vous souvenez framework Spring offre une variété de noms commençant par @Enable les définitions d'annotation? Par exemple, @ EnableScheduling, @ EnableCaching, @ EnableMBeanExport etc., @ idées EnableAutoConfiguration et façons de faire est en fait la même souche
aperçu rapide qui, avec le soutien ** @ l' importation de la collecte et l' enregistrement des définitions de haricots ** liés à une scène particulière.
@EnableScheduling @import par le cadre de la planification des définitions de fèves de ressort sont chargés dans le conteneur IoC pertinent.
@EnableMBeanExport IoC est chargé dans le récipient à travers les définitions associées @import bean JMX.
Et aussi avec l'aide de @EnableAutoConfiguration @import chargera toutes les définitions de haricots qui répondent aux critères pour configurer automatiquement le conteneur IoC, et rien de plus!
@AutoConfigurationPackage
@Import(EnableAutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {
@ AutoConfigurationPackage : package de configuration automatique
@ Importation (AutoConfigurationPackages.Registrar.class):
l'annotation de ressort @import, introduit dans un récipient à l'assemblage, introduit par les composants AutoConfigurationPackages.Registrar.classLorsque tous les composants de toute classe de configuration primaire d'emballage (étiquette de classe @SpringBootApplication) et les sous-paquets inférieurs du conteneur Spring balayée à l'intérieur;
@ Importation (EnableAutoConfigurationImportSelector.class);
Importer des composants au conteneur?
EnableAutoConfigurationImportSelector : qui introduit l' assemblage du sélecteur;
Tous les composants nécessaires pour retourner la manière du nom complet de la classe introduite, ces composants seront ajoutés au récipient;
Donnera beaucoup de conteneur de classe de configuration automatique importés (de xxxAutoConfiguration), ce scénario est d'importer tous les composants nécessaires pour conteneur et configurer ces composants, la
classe de configuration automatique, ce qui élimine la nécessité d'écrire manuellement la configuration que nous injectons des composants fonctionnels et d' autres travaux,
au moyen d'un outil existant framework Spring: soutien SpringFactoriesLoader, SpringFactoriesLoader.loadFactoryNames (EnableAutoConfiguration.class, classLoader); chaussure printemps acquis à partir du chemin de classe META-INF / spring.factories au démarrage EnableAutoConfiguration spécifiée valeur, ces valeurs que les classes de configuration automatique dans le conteneur, la classe prendra effet automatiquement configuré pour la configuration automatique au travail pour nous, ce que nous avons besoin avant leur propre configuration, classe de configuration automatique pour nous aider;
des solutions d'intégration globale J2EE et configuration automatique sont le printemps-démarrage autoconfiguration dans
