Maintenant, mis au point dans un développement de la pile Android complète, mis en place les informations suivantes sur le printemps Boot:
Boot avantage d'un cadre de printemps
① bons gènes
Parce que SpringBoot est accompagné par Spring 4.0 né, démarrage de la chaussure est le sens, qui est, en fait, son rôle est d'aider les développeurs à créer rapidement framework Spring, Spring SpringBoot a hérité de bons gènes, de développer plus pratique au printemps rapide.
② simplifier le codage
, Tel que nous voulons créer un projet Web en utilisant les amis de printemps savons tous que lorsque vous utilisez Spring, vous devez ajouter plus dépendants du fichier pom, et Spring Boot aidera à développer un démarrage rapide d'un conteneur Web, au printemps Boot nous avons juste besoin d'ajouter une personne à charge de démarrage Web au fichier pom.
③ configuration simplifiée
Bien que le cadre de printemps pour le poids léger Java EE, mais en raison de sa configuration lourde, était autrefois considéré comme un « enfer de configuration. » Une variété de XML, la configuration d'annotation sera éblouissante et multiple de configuration, et si une erreur est difficile de savoir pourquoi. Spring Boot plus est l'utilisation de Java Config manière pour la configuration Spring.
④ Simplifiez le déploiement
Lors de l'utilisation du printemps, quand nous avons besoin de déployer tomcat déploiement de projet sur le serveur, l'élément étiqueté comme paquet de guerre jeté dans la tomcat, après avoir utilisé Spring Boot, on n'a pas besoin d'aller le déploiement dans le serveur tomcat car Spring Boot intégré tomcat nous avons seulement besoin de paquet de pot étiqueté de projet, en utilisant java jar xxx.jar un bouton pour démarrer le projet.
De plus, pour réduire les exigences de base de l'environnement d'exploitation, la variable d'environnement dans le JDK.
⑤ simplifier la surveillance
Nous pouvons introduire dépendent directement à l'aide du printemps-démarrage démarrage actionneur façon REST pour obtenir les paramètres de performance d'exécution du processus, de manière à atteindre l'objectif de la surveillance, plus pratique. Mais le printemps Boot est juste un cadre micro ne fournit pas une découverte de service et l'enregistrement des fonctions de soutien, il n'y a aucun programme de surveillance périphérique intégré, il n'y a pas de solutions de gestion de sécurité de périmètre, de sorte que l'architecture micro-services, utilisé en conjonction Nuage de printemps a également besoin de match.
Le flux principal d'exécution de deux Spring Boot
Tout d' abord, un nouvel objet est SpringApplication
effectuée au cours du procédé de l'objet SpingApplication
1. 新建一个SpringApplication对象
Get webApplicationType type de paquet lorsque la guerre springboot comme une application d'emballage, ce type de SERVLET
injection ApplicationContextInitializer initialiseur
auditeur disposé ApplicationListener
2. 执行对象的run方法，
Créer une nouvelle StopWatch, et commencer à surveiller le temps d'exécution du programme
pour obtenir des objets SpringApplicationRunListeners, et commencer à l'auditeur
passé conformément aux paramètres de démarrage args, objet Nouveau ApplicationArguments
Nouvel objet ConfigurableEnvironment type spécifique StandardServletEnvironment, se chargera dans son processus de création Profil de springboot application.properties, tandis que le programme SpringApplication dans sa tenue
de créer ConfigurableApplicationContext le contexte d'objet, et les propriétés de l' environnement de l' ensemble d'objets, traversant ApplicationContextInitializer l'objet est initialisé,
obtenir BeanFactory inscrit applicationArguments unique à travers l'objet de contexte
contexte d'exécution de rafraîchissement de d' exploitation
Principe des trois printemps autoconfiguration Boot
@SpringBootApplication
public class MyApplication {
public static void main(String[] args) {SpringApplication.run(MyApplication .class, args);}
}
Nous voyons, classe MyApplication comme l'entrée, la classe d'entrée a une méthode principale, qui est en fait une méthode d'entrée standard pour les applications Java, généralement utilisés dans la principale méthode SpringApplication.run () pour lancer l'application. Il est intéressant de noter que la classe d'entrée d'annotation de l'utilisation @SpringBootApplication déclare qu'il est au cœur de commentaire SpringBoot.
@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 {
// 略
}
Cet intérieur d'annotation, le plus important est @EnableAutoConfiguration, le nom si simple, pour voir qu'il est d'ouvrir la configuration automatique, SpringBoot commencent à se manifester, en silence dans la source de @EnableAutoConfiguration.
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(EnableAutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {
// 略
}
On peut voir dans les notes à @EnableAutoConfiguration @import configuration annotation terminée à l'importation, et est utilisé dans les analyses de paquet jar méthode EnableAutoConfigurationImportSelector SpringFactoriesLoader.loadFactoryNames avec fichier META-INF / spring.factories. Voici la source réalisation 1.5.8.RELEASE:
@Override
public String[] selectImports(AnnotationMetadata annotationMetadata) {
if (!isEnabled(annotationMetadata)) {
return NO_IMPORTS;
}
try {
AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader
.loadMetadata(this.beanClassLoader);
AnnotationAttributes attributes = getAttributes(annotationMetadata);
//扫描具有META-INF/spring.factories文件的jar包
List<String> configurations = getCandidateConfigurations(annotationMetadata,
attributes);
//去重
configurations = removeDuplicates(configurations);
//排序
configurations = sort(configurations, autoConfigurationMetadata);
//删除需要排除的类
Set<String> exclusions = getExclusions(annotationMetadata, attributes);
checkExcludedClasses(configurations, exclusions);
configurations.removeAll(exclusions);
configurations = filter(configurations, autoConfigurationMetadata);
fireAutoConfigurationImportEvents(configurations, exclusions);
return configurations.toArray(new String[configurations.size()]);
}
catch (IOException ex) {
throw new IllegalStateException(ex);
}
}
//加载spring.factories实现
protected List<String> getCandidateConfigurations(AnnotationMetadata metadata,
AnnotationAttributes attributes) {
List<String> configurations = SpringFactoriesLoader.loadFactoryNames(
getSpringFactoriesLoaderFactoryClass(), getBeanClassLoader());
Assert.notEmpty(configurations,
"No auto configuration classes found in META-INF/spring.factories. If you "
+ "are using a custom packaging, make sure that file is correct.");
return configurations;
}
Springboot toute application qui introduisent springboot-autoconfiguration et fichier spring.factories dans le package ci-dessous. spring.factories document est sous la forme clé = valeur, valeur lorsqu'une pluralité de distance, définie dans ces informations de fichiers lors de l'initialisation, un moniteur ou similaire, de sorte que la vraie clé est en effet automatiquement configuré org.springframework.boot.autoconfigure.EnableAutoConfiguration comme suit:
# Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\
org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration,\
//省略
Il y a beaucoup de code de configuration automatisée , nous ne auparavant pas utiliser la configuration des commentaires:
@Configuration: Cette configuration ne serait pas faire plus pour expliquer, nous avons utilisé
@EnableConfigurationProperties: Ceci est un commentaire ouvert en utilisant les paramètres de configuration, la valeur est la valeur de notre entité de configuration mappage des paramètres ClassType, entité de configuration en tant que source de configuration.
La condition suivante est construite annotation SpringBoot:
@ConditionalOnBean: récipient SpringIoc lorsque la condition spécifiée existe dans le Bean
@ConditionalOnClass: récipient SpringIoc lorsque la condition spécifiée existe dans la classe
@ConditionalOnExpression: expression Spel telle que déterminée en fonction de la condition
@ConditionalOnJava: une condition de détermination en fonction de la version de la machine virtuelle Java
@ConditionalOnJndi: Trouver l'emplacement indiqué en présence JNDI
@ConditionalOnMissingBean: lorsqu'il n'y a pas désigné récipient à grains dans des conditions SpringIoc
@ConditionalOnMissingClass: lorsqu'il n'y a pas de classe désignée dans des conditions de conteneurs SpringIoc
@ConditionalOnNotWebApplication: élément de l' état actuel est pas un projet Web
@ConditionalOnProperty: Indique si les attributs sont spécifiés valeur
@ConditionalOnResource: si la valeur spécifiée classpath
@ConditionalOnSingleCandidate: Lorsque vous spécifiez un seul dans le conteneur SpringIoc Bean, ou plus, mais bien qu'il y sont désignés préféré Bean
@ConditionalOnWebApplication: projet Le courant est une des conditions de projet Web
ci - dessus sont des notes méta-annotation @Conditional a évolué, non conforme aux conditions conditions spécifiques créées au- dessus des notes correspondantes.
