怕什么真理无穷
进一步有近一步的欢喜
说明
本文是Spring Boot核心编程思想记录的笔记，书籍地址：Spring Boot编程思想（核心篇）：
这篇文档会记录这本我的一些读书的思考，内容可能比较多，我也会根据理解去扩展一些自己的东西，加强自己对技术理解以及应用。
在开头在叨叨一下，技术书籍的评论或评分有时候也就是简单参考下，因为不同的人对书籍内容的理解是不同的。莎士比亚也说过："一千个观众眼中有一千个哈姆雷特"。我是觉得一本书如果你能从中有些许的收获和思考，那都是有价值的，有时候可以忽略网上的评论或者评价。
PS：本文有大部分内容摘抄自书籍内容，如果内容前后不是很通顺，请阅读书籍原文，谢谢。
第一部分读书笔记：Spring Boot 核心编程思想-第一部分-读书笔记
二、走向自动装配
Spring Boot的自动装配,很大程度上是基于Spring Framework 的努力，Spring Framework的注解驱动开发使得Spring Boot 能够兼容并包，继往开来。
第7 章 走向注解驱动编程（Annotation-Driver）
技术发展是不断演进的，什么都不是一蹴而就的。所以回顾技术的发展路线和轨迹也是和有必要的。就如 ：以史为镜，可以知兴替。
Spring的两个核心特性：IOC ?DI。看技术大神对Spring IOC是怎么理解的
推崇：应用不应该以Java代码的方式直接控制依赖关系，而是通过容器去管理。（容器的原理就是Map，依赖关系在配置文件，如xml中管理），早期Spring 因为Java5没发布，不支持Annotation，Bean之间的依赖关系还是通过XML管理。
随着技术的不段发展，xml方式显得繁琐和笨重，则慢慢发展为注解驱动的方式。
注解驱动的发展历史和注解的使用场景
主要的发展轨迹：
SF：Spring Framework
SF1.x ?: 启蒙 时期，随着Java5的发布，支持Annotation特性，Spring也不甘落后，框架层面支持了一些注解：如@Transaction 等
SF2.x ：过渡阶段，出现了相对较多的注解，依赖注入（@AutoWired），依赖查询（@Qualifer)、组件申明（@Component），Spring MVC 的注解@Controller等；在此之还支持了可拓展的xml编写（Dubbo xml配置）；支持了JSR-250（@Resource 、@PostConstruct、@PerDestroy）
此时注解的激活和扫描还是需要使用xml配置
SF3.x ：黄金时代，出现 @Configuration 对应 @Bean 相关注解 @ComponentScan ，这些基本上以及可以取代xml配置 了，也引入了 AnnotationConfigApplicationContext（**@since **3.0），以及 @Import ?@ImportResource。还有其他的如：抽象全新属性API Environment 、 PropertySource ;缓存 @Cache ?；异步 @Ansys 等
SF4.x ：完善阶段，如@Conditional ，@EventListener ，@ RestController 等
SF5.x ：当下阶段， @Indexed，提升加载速度，也有需要的注意点，可以看：SpringFramework5.0 @Indexed注解 简单解析
核心注解的使用场景：
Spring 模式注解：
装配注解：
依赖注入：
Bean定义注解：
属性配置注解：
生命周期回调：
PostConstruct
PreDestroy
注解属性的注解：
注解编程模式和原理分析
元注解：注解注解的注解。也就是指一个能声明在其他注解上的注解。
组合注解：多个注解 注解的注解。也就是一个注解上声明了一个或者多个注解。
Spring 模式注解 ：说白了就是 @Component “派生性”注解。
@Component “派生性”：被@Component注解后，能够被Spring 加入到容器中。
主要注意的是不同版本的层次性：
Spring2.x :单层次
Spring3.x ：两层次
Spring4.x :多层次
@Component “派生性" 原理
1、 @Component 需要通过扫描的方式将其加入Spring容器。Spring的方式，xml的时候配置；注解使用 @ComponentScan 。
2、那么 xml方式或者注解的方式，Component-Scan 是如何被Spring处理的呢？
在Spring 中有两个类：分别是 用来处理 xml 和注解。
以xml方式进行分析（注解同理）。
ComponentScanBeanDefinitionParser 的分析过程
（1）、首先是通过ContextNamespaceHandler ?注册。
@Override
public?void?init()?{
????//?...
????registerBeanDefinitionParser("component-scan",?new?ComponentScanBeanDefinitionParser());
????//?...
}
（2）、ComponentScanBeanDefinitionParser implements BeanDefinitionParser ，则在运行的时候会执行 org.springframework.beans.factory.xml.BeanDefinitionParser#parse ?接口方法
（3）、通过源码可以看到 ComponentScanBeanDefinitionParser ?中定义了属性常量。如
private?static?final?String?BASE_PACKAGE_ATTRIBUTE?=?"base-package";
我们 核心还是看 ?parse_(Element element, ParserContext parserContext) ?方法。_
@Override
@Nullable
public?BeanDefinition?parse(Element?element,?ParserContext?parserContext)?{
????//?获取?base-package?的值
????String?basePackage?=?element.getAttribute(BASE_PACKAGE_ATTRIBUTE);
????//?解决占位符的问题
????basePackage?=?parserContext.getReaderContext().getEnvironment().resolvePlaceholders(basePackage);
????String[]?basePackages?=?StringUtils.tokenizeToStringArray(basePackage,
??????????????????????????????????????????????????????????????ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
????//?Actually?scan?for?bean?definitions?and?register?them.
????//?这里开始才真正的扫描?Bean?，首先创建扫描器，然后执行扫描
????ClassPathBeanDefinitionScanner?scanner?=?configureScanner(parserContext,?element);
????Set<BeanDefinitionHolder>?beanDefinitions?=?scanner.doScan(basePackages);
????//?注册组件
????registerComponents(parserContext.getReaderContext(),?beanDefinitions,?element);
????return?null;
}
（4）在看 scanner.doScan(basePackages) 执行扫描，核心是 findCandidateComponents ，查找候选组件。
protected?Set<BeanDefinitionHolder>?doScan(String...?basePackages)?{
????????Assert.notEmpty(basePackages,?"At?least?one?base?package?must?be?specified");
????????Set<BeanDefinitionHolder>?beanDefinitions?=?new?LinkedHashSet<>();
????????for?(String?basePackage?:?basePackages)?{
????????????Set<BeanDefinition>?candidates?=?findCandidateComponents(basePackage);
????????????//?....
????????}
????????return?beanDefinitions;
????}
5、、org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider#scanCandidateComponents 方法
String?packageSearchPath?=?ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX?+
????????????????????resolveBasePackage(basePackage)?+?'/'?+?this.resourcePattern;
????????????Resource[]?resources?=?getResourcePatternResolver().getResources(packageSearchPath);
将 backagePage 转换为 ClassLoader 类资源 搜索路径。得到类的资源集合。
MetadataReader?metadataReader?=?getMetadataReaderFactory().getMetadataReader(resource);
获取该资源的 MetadataReader对象(包含了类和注解的元信息)
**
?*?Simple?facade?for?accessing?class?metadata,
?*?as?read?by?an?ASM?{@link?org.springframework.asm.ClassReader}.
?*
?*?@author?Juergen?Hoeller
?*?@since?2.5
?*/
public?interface?MetadataReader?{
????/**
?????*?Return?the?resource?reference?for?the?class?file.
?????????org.springframework.core.io.Resource
?????*/
????Resource?getResource();
????/**
?????*?Read?basic?class?metadata?for?the?underlying?class.
?????*/
????ClassMetadata?getClassMetadata();
????/**
?????*?Read?full?annotation?metadata?for?the?underlying?class,
?????*?including?metadata?for?annotated?methods.
?????*/
????AnnotationMetadata?getAnnotationMetadata();
}
（6）根据 MetadataReader 进行判断 isCandidateComponent_(MetadataReader metadataReader)_
protected?boolean?isCandidateComponent(MetadataReader?metadataReader)?throws?IOException?{
????for?(TypeFilter?tf?:?this.excludeFilters)?{
????????if?(tf.match(metadataReader,?getMetadataReaderFactory()))?{
????????????return?false;
????????}
????}
????for?(TypeFilter?tf?:?this.includeFilters)?{
????????if?(tf.match(metadataReQader,?getMetadataReaderFactory()))?{
????????????return?isConditionMatch(metadataReader);
????????}
????}
????return?false;
}
注：match 是含义
注：includeFilters 在 createScanner创建 ClassPathBeanDefinitionScanner对象的时候，构建函数中有一个 registerDefaultFilters 方法。
//?注册为默认过滤器@Component 。
这将隐式寄存器，有所有注释@Component元注解包括@Repository?，?@Service和@Controller典型化注解。
还支持Java?EE?6的javax.annotation.ManagedBean和JSR-330的javax.inject.Named注释，如果有的话.
protected?void?registerDefaultFilters()?{
????????this.includeFilters.add(new?AnnotationTypeFilter(Component.class));
}
（7）match返回true ，则封装为 ScannedGenericBeanDefinition 对象，并加入到 candidates ?中。
Set<BeanDefinition>?candidates?=?new?LinkedHashSet<>();
tips:??
ClassPathBeanDefinitionScanner 运行自定义类型过滤规则，通过 ?scanner.addIncludeFilter_(typeFilter)_
Spring 5.x 之后，多层次 派生 的原理和 Sping 4.x 实现不同了。
org.springframework.core.type.classreading.AnnotationAttributesReadingVisitor#visitEndorg.springframework.core.type.classreading.SimpleAnnotationMetadataReadingVisitor#visitEnd
总结：通过扫描 @Component 以及其派生注解，然后加入 候选组件集合中，在Sping 启动的时候将后续组件 加入Spring 容器。其中 加入到候选组件集合中的时候，不同的Spring 版本可能存在实现上的差异。
附：org.springframework.context.annotation.ComponentScanAnnotationParser#parse ?Spring Boot启动执行时序图
然后 scanner.doScan扫描，获取候选的注解。
Spring 注解属性覆盖和别名
较低层次注解属性覆盖较高层次。
属性之间相互 @AliasFor ，他们的默认值就必须相等。多层次注解属性之间的 @AliasFor 关系 只能由 较低层次向较高层次建立。
Spring Framework 为Spring 元注解和@AliasFor 提供了属性覆盖和别名的特性，最终 由 AnnotationAttributes 对象来表达语义。
第8章 Spring 注解驱动设计模式
Spring @Enable 模块驱动
@Import ?: 提供的功能和 Spring XML中 标签元素一样。它能允许 引入[ ]() @Configuration classes, [ ]() ImportSelector 和 [ ]() ImportBeanDefinitionRegistrar的 实现类或者普通的 组件类。
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public?@interface?Import?{
????/**
?????*?{@link?Configuration?@Configuration},?{@link?ImportSelector},
?????*?{@link?ImportBeanDefinitionRegistrar},?or?regular?component?classes?to?import.
?????*/
????Class<?>[]?value();
}
理解@Enable 模块驱动（SF3.1 发行）
模块：具备相同领域的功能组件集合，形成一个独立的单元。
Enable : 激活、启动
在Spring 中，如 Web MVC 模块、 AspectJ模块、Cachinig模块、Async模块等
使用了@Enablexx ，就能激活xxx领域相应的组件。
@Enable 在 SF 、 SB 、SC 中 一以贯之，命令模块化 的注解 均以 @Enable 作为前缀。
优点： 简化装配步骤，实现“ 按需装配”，屏蔽组件集合装配的细节。
缺点：该模块必须手动触发，即需要标注在某个配置Bean中；实现该模块成本相对较高，尤其是 理解其中的原理和加载机制及单元测试方面。
自定义@Enable模块驱动（三种方式）
自定义分为（本质）两种：
注解驱动 ：使用@Import 导入 @Configuration 标注的 类(直接导入配置类)
接口编程 ：使用@Import 导入 ImportSelector（依据条件选择配置类） 或 [ ]() ImportBeanDefinitionRegistrar（动态注册Bean） 实现类
两种方式的演练代码：
注解驱动 ：
1、写配置类
@Configuration
public?class?HelloWorldConfiguration?{
????@Bean
????public?List?helloWorld(){
????????return?new?LinkedList();
????}
}
2、Enable的注解, 使用 @Import(HelloWorldConfiguration.class)
@Documented
@Retention(value?=?RetentionPolicy.RUNTIME)
@Import(HelloWorldConfiguration.class)
public?@interface?EnableHelloWorld?{
????String?value()?default?"";
}
3、在组件bean上使用 @ EnableHelloWorld 注解
@Configuration
@EnableHelloWorld
public?class?EnableXxxBootStrap?{
????public?static?void?main(String[]?args)?{
????????AnnotationConfigApplicationContext?applicationContext?=
????????????????new?AnnotationConfigApplicationContext(EnableXxxBootStrap.class);
????????String[]?beanDefinitionNames?=?applicationContext.getBeanDefinitionNames();
????????Arrays.stream(beanDefinitionNames).forEach(System.out::println);
????}
}
//?打印的?beab?中有?helloWorld?
接口编程：实现接口，具体就不演示了。如果不会写，看一下 Spring框架 内部实现的类，可参考。
@Enable模块驱动原理
核心还是理解 @Import 注解，因为不管是Spring内建的Enable还是 自定义的Enable，均使用@Import实现。
@Import 的职责 在于装载导入类 ，将其定义为 Spring Bean。
这里肯定还是需要理解 Spring中的 BeanPostProcesser
@Import 注解是如何解析的，这个解析就包括了相关的原理。
第一步：注册 ConfigurationClassPostProcessor
三种情况注册
_
--> _org.springframework.context.annotation.AnnotationConfigBeanDefinitionParser
@Override
????@Nullable
????public?BeanDefinition?parse(Element?element,?ParserContext?parserContext)?{
????????Object?source?=?parserContext.extractSource(element);
????????//?Obtain?bean?definitions?for?all?relevant?BeanPostProcessors.
????????Set<BeanDefinitionHolder>?processorDefinitions?=
????????????????AnnotationConfigUtils.registerAnnotationConfigProcessors(parserContext.getRegistry(),?source);
????????//?....
????????return?null;
????}
_
--> _org.springframework.context.annotation.ComponentScanBeanDefinitionParser#registerComponents
protected?void?registerComponents(
????????????XmlReaderContext?readerContext,?Set<BeanDefinitionHolder>?beanDefinitions,?Element?element)?{
????????//?....
????????//?Register?annotation?config?processors,?if?necessary.
????????boolean?annotationConfig?=?true;
????????if?(element.hasAttribute(ANNOTATION_CONFIG_ATTRIBUTE))?{
????????????annotationConfig?=?Boolean.parseBoolean(element.getAttribute(ANNOTATION_CONFIG_ATTRIBUTE));
????????}
????????if?(annotationConfig)?{
????????????Set<BeanDefinitionHolder>?processorDefinitions?=
????????????????????AnnotationConfigUtils.registerAnnotationConfigProcessors(readerContext.getRegistry(),?source);
????????????for?(BeanDefinitionHolder?processorDefinition?:?processorDefinitions)?{
????????????????compositeDef.addNestedComponent(new?BeanComponentDefinition(processorDefinition));
????????????}
????????}
????????readerContext.fireComponentRegistered(compositeDef);
????}
org.springframework.context.annotation.AnnotationConfigUtils#registerAnnotationConfigProcessors(org.springframework.beans.factory.support.BeanDefinitionRegistry)
这个方法 找到ClassPathBeanDefinitionScanner相关的调用 ：
AnnotatedBeanDefinitionReader ? 注册方法，在构建 AnnotationConfigApplicationContext 的时候。
so , ComponentScanAnnotationParser 解析 ComponentScan 这个就不需要在执行的时候在注册一次了
org.springframework.context.annotation.AnnotationConfigUtils#registerAnnotationConfigProcessor
public?static?Set<BeanDefinitionHolder>?registerAnnotationConfigProcessors(
????????????BeanDefinitionRegistry?registry,?@Nullable?Object?source)?{
????????DefaultListableBeanFactory?beanFactory?=?unwrapDefaultListableBeanFactory(registry);
????????//?省略?....
????????Set<BeanDefinitionHolder>?beanDefs?=?new?LinkedHashSet<>(8);
????????if?(!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME))?{
????????????RootBeanDefinition?def?=?new?RootBeanDefinition(ConfigurationClassPostProcessor.class);
????????????def.setSource(source);
????????????//?CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME?=?org.springframework.context.annotation.internalConfigurationAnnotationProcessor
????????????beanDefs.add(registerPostProcessor(registry,?def,?CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
????????}
????????//?省略?....??
????????return?beanDefs;
????}
在 beanFactory 注册一个 名称为 org.springframework.context.annotation.internalConfigurationAnnotationProcessor 的 ConfigurationClassPostProcessor，并且 这个Processor 在第一位，因为使用的是 LinkedHashSet 有序的（底层实现是LinkHashMap）。
总结：千方百计 要先将 ? ConfigurationClassPostProcessor ?进行注册。
第二步：回调 BeanPostProcessor#postProcessBeanFactory 方法
ConfigurationClassPostProcessor 的优先级是最低的 。
_
执行回调顺序分析调用链路，执行main方法后：
//?1.0
org.springframework.boot.SpringApplication#run(java.lang.String...)
????org.springframework.boot.SpringApplication#refreshContext
????org.springframework.boot.SpringApplication#refresh
????org.springframework.context.support.AbstractApplicationContext#refresh
????org.springframework.context.support.AbstractApplicationContext#invokeBeanFactoryPostProcessors?
???????org.springframework.context.support.PostProcessorRegistrationDelegate#invokeBeanDefinitionRegistryPostProcessors
????????private?static?void?invokeBeanDefinitionRegistryPostProcessors(
????????????????Collection<??extends?BeanDefinitionRegistryPostProcessor>?postProcessors,?BeanDefinitionRegistry?registry)?{
????????????for?(BeanDefinitionRegistryPostProcessor?postProcessor?:?postProcessors)?{
????????????????postProcessor.postProcessBeanDefinitionRegistry(registry);
????????????}
????????}
?????????//?1.1???先执行?postProcessBeanDefinitionRegistry?
????????org.springframework.context.annotation.ConfigurationClassPostProcessor#postProcessBeanDefinitionRegistry
????org.springframework.context.support.PostProcessorRegistrationDelegate#invokeBeanFactoryPostProcessors
????????private?static?void?invokeBeanFactoryPostProcessors(
????????????Collection<??extends?BeanFactoryPostProcessor>?postProcessors,?ConfigurableListableBeanFactory?beanFactory)?{
????????????for?(BeanFactoryPostProcessor?postProcessor?:?postProcessors)?{
????????????????postProcessor.postProcessBeanFactory(beanFactory);
????????????}
????????}
????????//?1.2??然后执行?
????????org.springframework.context.annotation.ConfigurationClassPostProcessor#postProcessBeanFactory
第三步：处理 processConfigBeanDefinitions
Spring 之前的版本处理的处理是在 ?postProcessBeanFactory 方法中（具体哪个版本后进行修改了，没有去追踪）。在本次分析的5.2.1 版本中，首先执行 ?postProcessBeanDefinitionRegistry --> postProcessBeanFactory
方法。
在 postProcessBeanDefinitionRegistry ?中会先处理 进行 processConfigBeanDefinitions_(registry) 的处理。_
_并且保存一个注册的处理ID。在执行 _postProcessBeanFactory ?进行判断，已处理则不在处理。
入参都是 DefaultListableBeanFactory ?对象，则获取 hashcode 值是一样的。即 registryId == factoryId 。
/**
?????*?Build?and?validate?a?configuration?model?based?on?the?registry?of
?????*?{@link?Configuration}?classes.
?????*/
????public?void?processConfigBeanDefinitions(BeanDefinitionRegistry?registry)?{
????????List<BeanDefinitionHolder>?configCandidates?=?new?ArrayList<>();
????????//?从?DefaultListableBeanFactory?中获取?所有?BeanDefinitionName
????????String[]?candidateNames?=?registry.getBeanDefinitionNames();
????????//?循环?
????????for?(String?beanName?:?candidateNames)?{
????????????//?通过Bean的名字获取?BeanDefinition
????????????BeanDefinition?beanDef?=?registry.getBeanDefinition(beanName);
????????????//?判断beanDef是否有被处理过，处理过则不进行?BeanDefinitionHolder?封装
????????????if?(beanDef.getAttribute(ConfigurationClassUtils.CONFIGURATION_CLASS_ATTRIBUTE)?!=?null)?{
????????????????if?(logger.isDebugEnabled())?{
????????????????????logger.debug("Bean?definition?has?already?been?processed?as?a?configuration?class:?"?+?beanDef);
????????????????}
????????????}
????????????//?checkConfigurationClassCandidate?检查和筛选
????????????//（检查给定bean定义是否为配置类的候选（或配置/部件类中声明的一个嵌套组件类，以自动注册为好），并相应地标记它）
????????????else?if?(ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef,?this.metadataReaderFactory))?{
????????????????configCandidates.add(new?BeanDefinitionHolder(beanDef,?beanName));
????????????}
????????}
????????//?Return?immediately?if?no?@Configuration?classes?were?found
????????if?(configCandidates.isEmpty())?{
????????????return;
????????}
????????//?Sort?by?previously?determined?@Order?value,?if?applicable
????????//?根据order?对候选的Config类进行排序
????????configCandidates.sort((bd1,?bd2)?->?{
????????????int?i1?=?ConfigurationClassUtils.getOrder(bd1.getBeanDefinition());
????????????int?i2?=?ConfigurationClassUtils.getOrder(bd2.getBeanDefinition());
????????????return?Integer.compare(i1,?i2);
????????});
????????//?Detect?any?custom?bean?name?generation?strategy?supplied?through?the?enclosing?application?context
????????SingletonBeanRegistry?sbr?=?null;
????????if?(registry?instanceof?SingletonBeanRegistry)?{
????????????sbr?=?(SingletonBeanRegistry)?registry;
????????????if?(!this.localBeanNameGeneratorSet)?{
????????????????BeanNameGenerator?generator?=?(BeanNameGenerator)?sbr.getSingleton(
????????????????????????AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR);
????????????????if?(generator?!=?null)?{
????????????????????this.componentScanBeanNameGenerator?=?generator;
????????????????????this.importBeanNameGenerator?=?generator;
????????????????}
????????????}
????????}
????????if?(this.environment?==?null)?{
????????????this.environment?=?new?StandardEnvironment();
????????}
????????//?Parse?each?@Configuration?class
????????//?解析?Configuration?类
????????ConfigurationClassParser?parser?=?new?ConfigurationClassParser(
????????????????this.metadataReaderFactory,?this.problemReporter,?this.environment,
????????????????this.resourceLoader,?this.componentScanBeanNameGenerator,?registry);
????????Set<BeanDefinitionHolder>?candidates?=?new?LinkedHashSet<>(configCandidates);
????????Set<ConfigurationClass>?alreadyParsed?=?new?HashSet<>(configCandidates.size());
????????do?{
????????????//??解析?candidates?
????????????parser.parse(candidates);
????????????parser.validate();
????????????//?解析?后?通过?getConfigurationClasses?获取?ConfigurationClass?集合
????????????Set<ConfigurationClass>?configClasses?=?new?LinkedHashSet<>(parser.getConfigurationClasses());
????????????configClasses.removeAll(alreadyParsed);
????????????//?Read?the?model?and?create?bean?definitions?based?on?its?content
????????????if?(this.reader?==?null)?{
????????????????this.reader?=?new?ConfigurationClassBeanDefinitionReader(
????????????????????????registry,?this.sourceExtractor,?this.resourceLoader,?this.environment,
????????????????????????this.importBeanNameGenerator,?parser.getImportRegistry());
????????????}
????????????this.reader.loadBeanDefinitions(configClasses);
????????????alreadyParsed.addAll(configClasses);
????????????candidates.clear();
????????????if?(registry.getBeanDefinitionCount()?>?candidateNames.length)?{
????????????????String[]?newCandidateNames?=?registry.getBeanDefinitionNames();
????????????????Set<String>?oldCandidateNames?=?new?HashSet<>(Arrays.asList(candidateNames));
????????????????Set<String>?alreadyParsedClasses?=?new?HashSet<>();
????????????????for?(ConfigurationClass?configurationClass?:?alreadyParsed)?{
????????????????????alreadyParsedClasses.add(configurationClass.getMetadata().getClassName());
????????????????}
????????????????for?(String?candidateName?:?newCandidateNames)?{
????????????????????if?(!oldCandidateNames.contains(candidateName))?{
????????????????????????BeanDefinition?bd?=?registry.getBeanDefinition(candidateName);
????????????????????????if?(ConfigurationClassUtils.checkConfigurationClassCandidate(bd,?this.metadataReaderFactory)?&&
????????????????????????????????!alreadyParsedClasses.contains(bd.getBeanClassName()))?{
????????????????????????????candidates.add(new?BeanDefinitionHolder(bd,?candidateName));
????????????????????????}
????????????????????}
????????????????}
????????????????candidateNames?=?newCandidateNames;
????????????}
????????}
????????while?(!candidates.isEmpty());
????????//?Register?the?ImportRegistry?as?a?bean?in?order?to?support?ImportAware?@Configuration?classes
????????if?(sbr?!=?null?&&?!sbr.containsSingleton(IMPORT_REGISTRY_BEAN_NAME))?{
????????????sbr.registerSingleton(IMPORT_REGISTRY_BEAN_NAME,?parser.getImportRegistry());
????????}
????????if?(this.metadataReaderFactory?instanceof?CachingMetadataReaderFactory)?{
????????????//?Clear?cache?in?externally?provided?MetadataReaderFactory;?this?is?a?no-op
????????????//?for?a?shared?cache?since?it'll?be?cleared?by?the?ApplicationContext.
????????????((CachingMetadataReaderFactory)?this.metadataReaderFactory).clearCache();
????????}
????}
重点看下 parser.parse_(candidates)_; -> processConfigurationClass ->doProcessConfigurationClass
protected?final?SourceClass?doProcessConfigurationClass(ConfigurationClass?configClass,?SourceClass?sourceClass)
????????????throws?IOException?{
????????if?(configClass.getMetadata().isAnnotated(Component.class.getName()))?{
????????????//?Recursively?process?any?member?(nested)?classes?first
????????????processMemberClasses(configClass,?sourceClass);
????????}
????????//?Process?any?@PropertySource?annotations
????????for?(AnnotationAttributes?propertySource?:?AnnotationConfigUtils.attributesForRepeatable(
????????????????sourceClass.getMetadata(),?PropertySources.class,
????????????????org.springframework.context.annotation.PropertySource.class))?{
????????????if?(this.environment?instanceof?ConfigurableEnvironment)?{
????????????????processPropertySource(propertySource);
????????????}
????????????else?{
????????????????logger.info("Ignoring?@PropertySource?annotation?on?["?+?sourceClass.getMetadata().getClassName()?+
????????????????????????"].?Reason:?Environment?must?implement?ConfigurableEnvironment");
????????????}
????????}
????????//?Process?any?@ComponentScan?annotations
????????Set<AnnotationAttributes>?componentScans?=?AnnotationConfigUtils.attributesForRepeatable(
????????????????sourceClass.getMetadata(),?ComponentScans.class,?ComponentScan.class);
????????if?(!componentScans.isEmpty()?&&
????????????????!this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(),?ConfigurationPhase.REGISTER_BEAN))?{
????????????for?(AnnotationAttributes?componentScan?:?componentScans)?{
????????????????//?The?config?class?is?annotated?with?@ComponentScan?->?perform?the?scan?immediately
????????????????Set<BeanDefinitionHolder>?scannedBeanDefinitions?=
????????????????????????this.componentScanParser.parse(componentScan,?sourceClass.getMetadata().getClassName());
????????????????//?Check?the?set?of?scanned?definitions?for?any?further?config?classes?and?parse?recursively?if?needed
????????????????for?(BeanDefinitionHolder?holder?:?scannedBeanDefinitions)?{
????????????????????BeanDefinition?bdCand?=?holder.getBeanDefinition().getOriginatingBeanDefinition();
????????????????????if?(bdCand?==?null)?{
????????????????????????bdCand?=?holder.getBeanDefinition();
????????????????????}
????????????????????if?(ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand,?this.metadataReaderFactory))?{
????????????????????????parse(bdCand.getBeanClassName(),?holder.getBeanName());
????????????????????}
????????????????}
????????????}
????????}
????????//?Process?any?@Import?annotations
????????processImports(configClass,?sourceClass,?getImports(sourceClass),?true);
????????//?Process?any?@ImportResource?annotations
????????AnnotationAttributes?importResource?=
????????????????AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(),?ImportResource.class);
????????if?(importResource?!=?null)?{
????????????String[]?resources?=?importResource.getStringArray("locations");
????????????Class<??extends?BeanDefinitionReader>?readerClass?=?importResource.getClass("reader");
????????????for?(String?resource?:?resources)?{
????????????????String?resolvedResource?=?this.environment.resolveRequiredPlaceholders(resource);
????????????????configClass.addImportedResource(resolvedResource,?readerClass);
????????????}
????????}
????????//?Process?individual?@Bean?methods
????????Set<MethodMetadata>?beanMethods?=?retrieveBeanMethodMetadata(sourceClass);
????????for?(MethodMetadata?methodMetadata?:?beanMethods)?{
????????????configClass.addBeanMethod(new?BeanMethod(methodMetadata,?configClass));
????????}
????????//?Process?default?methods?on?interfaces
????????processInterfaces(configClass,?sourceClass);
????????//?Process?superclass,?if?any
????????if?(sourceClass.getMetadata().hasSuperClass())?{
????????????String?superclass?=?sourceClass.getMetadata().getSuperClassName();
????????????if?(superclass?!=?null?&&?!superclass.startsWith("java")?&&
????????????????????!this.knownSuperclasses.containsKey(superclass))?{
????????????????this.knownSuperclasses.put(superclass,?configClass);
????????????????//?Superclass?found,?return?its?annotation?metadata?and?recurse
????????????????return?sourceClass.getSuperClass();
????????????}
????????}
????????//?No?superclass?->?processing?is?complete
????????return?null;
????}
终于找打了Import ?处理
//?Process?any?@Import?annotations
processImports(configClass,?sourceClass,?getImports(sourceClass),?true);
//?getImports(sourceClass)?递归获取??imports
private?Set<SourceClass>?getImports(SourceClass?sourceClass)?throws?IOException?{
????Set<SourceClass>?imports?=?new?LinkedHashSet<>();
????Set<SourceClass>?visited?=?new?LinkedHashSet<>();
????collectImports(sourceClass,?imports,?visited);
????return?imports;
}
private?void?collectImports(SourceClass?sourceClass,?Set<SourceClass>?imports,?Set<SourceClass>?visited)
????throws?IOException?{
????if?(visited.add(sourceClass))?{
????????for?(SourceClass?annotation?:?sourceClass.getAnnotations())?{
????????????String?annName?=?annotation.getMetadata().getClassName();
????????????if?(!annName.equals(Import.class.getName()))?{
????????????????collectImports(annotation,?imports,?visited);
????????????}
????????}
????????imports.addAll(sourceClass.getAnnotationAttributes(Import.class.getName(),?"value"));
????}
}
//?然后是处理 processImports，递归调用，实现多层次的@Import 元标注ConfigurationClass 的解析。
//?ImportSelector.class?和?ImportBeanDefinitionRegistrar.class?处理也在此逻辑中
很多细节没有去写。可以看源码的时候，通过debug 方式 跟踪。解析最后，注册成 BeanDefiniton。
第四步：增强 enhanceConfigurationClasses
先判断是ConfigurationClassPostProcessor.getName + "configurationClass"
Object configClassAttr = beanDef.getAttribute_(ConfigurationClassUtils._CONFIGURATION_CLASS_ATTRIBUTE);
然后判断是 ConfigurationClassUtils.CONFIGURATION_CLASS_FULL ?完全模式。可进行增强、
_
org.springframework.context.annotation.ConfigurationClassUtils#checkConfigurationClassCandidate
Map<String,?Object>?config?=?metadata.getAnnotationAttributes(Configuration.class.getName());
// Configuration proxyBeanMethods 默认是 true，默认就是完全模式。
if?(config?!=?null?&&?!Boolean.FALSE.equals(config.get("proxyBeanMethods")))?{
????beanDef.setAttribute(CONFIGURATION_CLASS_ATTRIBUTE,?CONFIGURATION_CLASS_FULL);
}
else?if?(config?!=?null?||?isConfigurationCandidate(metadata))?{
????//?轻量模式，
????beanDef.setAttribute(CONFIGURATION_CLASS_ATTRIBUTE,?CONFIGURATION_CLASS_LITE);
}
else?{
????return?false;
}
Spring web 自动装配
前面 掌握了 @Enable 模块驱动， 这种方式 是需要手动触发的， Spring Boot 提供的是自动 装配的能力， 首先看一下 Spring web的自动装配，对后续SB的自动装配会更得心应手。
SB自动装配：
Web应用
非Web应用
Spring Framework 3.1+ 自动装配：
仅支持 web应用，并且依赖的容器 必须是Servlet 3.0 +
理解 WebApplicationInitializer
Spring web自动装配依托于 Servlet3.0+ ，Spring自己也做了一些工作来适应Servlet3.0+的改变。在SpringFramework 3.1.0中 新增了一个类：WebApplicationInitializer ?。构建在Servlet3.0 的 ServletContainerIniitializer 之上，WebApplicationInitializer ? ? 的自定义实现，能够被任何Servlet3.0容器侦测并自动初始化。初始化调用的是 onStartup 方法。
public?interface?WebApplicationInitializer?{
????/**
?????*?Configure?the?given?{@link?ServletContext}?with?any?servlets,?filters,?listeners
?????*?context-params?and?attributes?necessary?for?initializing?this?web?application.?See
?????*?examples?{@linkplain?WebApplicationInitializer?above}.
?????*?@param?servletContext?the?{@code?ServletContext}?to?initialize
?????*?@throws?ServletException?if?any?call?against?the?given?{@code?ServletContext}
?????*?throws?a?{@code?ServletException}
?????*/
????void?onStartup(ServletContext?servletContext)?throws?ServletException;
}
用编程的方式支持替换传统的 web.xml
相关代码可 Spring WebMVC 官网介绍：https://docs.spring.io/spring/docs/current/spring-framework-reference/web.html#spring-web
AbstractAnnotationConfigDispatcherServletInitializer ：SpringJava代码配置驱动
public?class?MyWebAppInitializer?extends?AbstractAnnotationConfigDispatcherServletInitializer?{
????@Override
????protected?Class<?>[]?getRootConfigClasses()?{
????????return?new?Class<?>[]?{?RootConfig.class?};
????}
????@Override
????protected?Class<?>[]?getServletConfigClasses()?{
????????return?new?Class<?>[]?{?App1Config.class?};
????}
????@Override
????protected?String[]?getServletMappings()?{
????????return?new?String[]?{?"/app1/*"?};
????}
}
上面的代码等同于下面的xml配置。
<web-app>
????<listener>
????????<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
????</listener>
????<context-param>
????????<param-name>contextConfigLocation</param-name>
????????<param-value>/WEB-INF/root-context.xml</param-value>
????</context-param>
????<servlet>
????????<servlet-name>app1</servlet-name>
????????<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
????????<init-param>
????????????<param-name>contextConfigLocation</param-name>
????????????<param-value>/WEB-INF/app1-context.xml</param-value>
????????</init-param>
????????<load-on-startup>1</load-on-startup>
????</servlet>
????<servlet-mapping>
????????<servlet-name>app1</servlet-name>
????????<url-pattern>/app1/*</url-pattern>
????</servlet-mapping>
</web-app>
AbstractDispatcherServletInitializer ：Spring XML配置驱动
public?class?MyWebAppInitializer?extends?AbstractDispatcherServletInitializer?{
????@Override
????protected?WebApplicationContext?createRootApplicationContext()?{
????????return?null;
????}
????@Override
????protected?WebApplicationContext?createServletApplicationContext()?{
????????XmlWebApplicationContext?cxt?=?new?XmlWebApplicationContext();
????????cxt.setConfigLocation("/WEB-INF/spring/dispatcher-config.xml");
????????return?cxt;
????}
????@Override
????protected?String[]?getServletMappings()?{
????????return?new?String[]?{?"/"?};
????}
}
自定义Web自动装配
1、 实现 AbstractAnnotationConfigDispatcherServletInitializer?
2、写配置 类- ConfigClasses
3、将配置类加入 getServletConfigClasses
?@Override
????protected?Class<?>[]?getServletConfigClasses()?{
????????return?new?Class<?>[]?{?App1Config.class?};
????}
4、打包，启动
5、测试
具体示例可自行实现下。
理解 Servlet 3.0 ?- ServletContainerInitializer
1、首先 Servlet3.0开始提供 ServletContext 可以 通过编程的方式动态的装配Servlet、Filter和各种Listener 。（SpringBoot中使用较多）
2、ServletContext ?仅能在 如下两个方法被调用。
javax.servlet.ServletContainerInitializer#onStartup：当容器启动的时候，onStartup 方法执行，ServletContext当作参数传入
javax.servlet.ServletContextListener#contextInitialized （监听 ServletContext 的生命周期事件- 初始化 - 销毁）
关于ServletContainerInitializer 可以参考 Servlet 3.0规范。需要关注的两个点：
第一：当容器或应用启动的时候，onStartup 方法回调，onStartup 有两个参数
Set
<class@HandlersTypes 来进行过滤。（Spring web mvc 自动装配就是利用了这一特性。）</class
ServletContext ctx：
/**
?????*?应用启动的时候，会运行onStartup方法；
?????*?
?????* Set<Class<?>> arg0：感兴趣的类型的所有子类型；
?????* ServletContext arg1:代表当前Web应用的ServletContext；一个Web应用一个ServletContext；
?????*?
?????*?1）、使用ServletContext注册Web组件（Servlet、Filter、Listener）
?????* 2）、使用编码的方式，在项目启动的时候给ServletContext里面添加组件；
?????*??????必须在项目启动的时候来添加；
?????*????? 1）、ServletContainerInitializer得到的ServletContext；
?????*????? 2）、ServletContextListener得到的ServletContext；
?????*/
public?void?onStartup(Set<Class<?>>?c,?ServletContext?ctx)
????????throws?ServletException;?
第二：ServletContainerInitializer 的实现类必须放到 ?javax.servlet.ServletContainerInitializer 文本文件中，该文件存在在独立JAR包中的 METE-INF/services 目录。
META-INF/services
Spring web自动装配原理-SpringServletContainerInitializer
@HandlesTypes(WebApplicationInitializer.class)
public?class?SpringServletContainerInitializer?implements?ServletContainerInitializer?{
}
侦测 WebApplicationInitializer 以及其所有的子类，调用 onStartup ，它的子类在上文已经贴出。具体源码实现可以参考SpringFramework 框架实现。
总结:
推荐阅读：
Java SPI (Service Provider Interface) and ServiceLoader：
https://www.journaldev.com/31602/java-spi-service-provider-interface-and-serviceloader
可以看看，讲解的比较清晰，还有对应的示例。
Spring 条件装配
条件装配 @Profile ?和 @Conditional ?
Profile：侧面，通过某个角度去观察。Maven 中类似语义。静态激活和配置，Spring中存在两种类型：Active 、 Default，当 Active 不存在，采用默认 Profile。
在Spring中的原理： 解析@Profile 注解，然后根据当前的环境配置 进行验证是否匹配。
@Conditional ：相较于 @Profile 更关注 运行时 动态选择。Spring Boot中内建了不少条件注解：
ConditionalOnClass
ConditionalOnBean
ConditionalOnProperty
….
自定义@Conditional 条件装配
1、写一个类实现 Condition 接口，实现 ?matches 方法
public?class?SystemCondition?implements?Condition?{
????@Override
????public?boolean?matches(ConditionContext?context,?AnnotatedTypeMetadata?metadata)?{
????????Map<String,?Object>?annotationAttributes?=?metadata.getAnnotationAttributes(SystemOnCondition.class.getName());
????????String?name?=?(String)annotationAttributes.get("name");
????????if("aflyun".equals(name)){
????????????return?true;
????????}
????????return?false;
????}
}
2、写一个条件注解，使用 @Conditional 注解，@Conditional 的 value 加入自定义的实现
@Target({ElementType.TYPE,?ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Conditional(SystemCondition.class)
public?@interface?SystemOnCondition?{
????String?name()?default?"";
}
3、在需要进行条件判断的地方使用此注解
???@Bean
????@SystemOnCondition(name?=?"aflyun")
????public?String?dufy(){
????????return?"hello?Java编程技术乐园";
????}
第9 章 ?Spring Boot 自动装配
掌握@SpringBootApplication#@EnableAutoConfiguration
@EnableAutoConfiguration ?适合用 Import导入 Selector。
@Import_(AutoConfigurationImportSelector.class)_
_
protected?AutoConfigurationEntry?getAutoConfigurationEntry(AutoConfigurationMetadata?autoConfigurationMetadata,
???????????????????????????????????????????????????????????AnnotationMetadata?annotationMetadata)?{
????if?(!isEnabled(annotationMetadata))?{
????????return?EMPTY_ENTRY;
????}
????AnnotationAttributes?attributes?=?getAttributes(annotationMetadata);
????List<String>?configurations?=?getCandidateConfigurations(annotationMetadata,?attributes);
????configurations?=?removeDuplicates(configurations);
????Set<String>?exclusions?=?getExclusions(annotationMetadata,?attributes);
????checkExcludedClasses(configurations,?exclusions);
????configurations.removeAll(exclusions);
????configurations?=?filter(configurations,?autoConfigurationMetadata);
????fireAutoConfigurationImportEvents(configurations,?exclusions);
????return?new?AutoConfigurationEntry(configurations,?exclusions);
}
_
调用流程简单分析：
org.springframework.context.annotation.ConfigurationClassParser#processImports
????-->org.springframework.context.annotation.ConfigurationClassParser.DeferredImportSelectorHandler#handle
????????-->?org.springframework.context.annotation.ConfigurationClassParser.DeferredImportSelectorGroupingHandler#processGroupImports
????????????-->org.springframework.context.annotation.ConfigurationClassParser.DeferredImportSelectorGrouping#getImports
????????????????-->org.springframework.context.annotation.DeferredImportSelector.Group#process
????????????????-->org.springframework.boot.autoconfigure.AutoConfigurationImportSelector.AutoConfigurationGroup#process
????????????????????-->org.springframework.boot.autoconfigure.AutoConfigurationImportSelector#getAutoConfigurationEntry
记录Spring Boot启动SPI 加载机制
1、如果是内嵌的tomcat容器，则 不走 SPI机制（注：SPI机制可以往上翻看推荐阅读。），直接 EnableAutoXX 进行配置。如DispatcherServlet bean 配置。
2、如果使用外部Tomcat 启动的时候，则 需要 配置 SpringBootServletInitializer 。如下：
1.必须创建war项目，需要创建好web项目的目录。
2.嵌入式Tomcat依赖scope指定provided。
3.编写SpringBootServletInitializer类子类,并重写configure方法。
public?class?MySpringBootServletInitializer?extends?SpringBootServletInitializer?{
????private?static?Logger?logger?=?LoggerFactory.getLogger(MySpringBootServletInitializer.class);
????@Override
????protected?SpringApplicationBuilder?configure(SpringApplicationBuilder?builder)?{
????????logger.info("MySpringBootServletInitializer--->Springboot2CoreCh02Application引导");
????????return?createSpringApplicationBuilder().sources(Springboot2CoreCh02Application.class);
????}
}
这的一套流程，原理是Spring Framework web的自动装配的原理。使用了Servlet3.0+ ，具体可以看上面 ：Spring web 自动装配
Tomcat 加载 ServletContainerInitializer 文件。
import?java.util.Set;
import?javax.servlet.ServletContainerInitializer;
//?**************?ServletContainerInitializer接口?的使用?**************?
//?1、在jar包中创建META-INF/services/javax.servlet.ServletContainerInitializer文件
// 2、在文件中写入实现的类路径，如：org.apache.jasper.servlet.JasperInitializer
//?**************?Tomcat中对ServletContainerInitializer接口的实现类的检测和自动调用?**************
//?检测实现ServletContainerInitializer接口的类---------------------------1
class?org.apache.catalina.core.StandardContext{
????protected?synchronized?void?startInternal()?throws?LifecycleException?{
????????//?读取并解析“d:/a/c/d/tomcat/conf/web.xml”，读取并解析"d:/a/b/tomcat/conf/Catalina/localhost/web.xml.default"
????????//?取得输入流?"d:/a/b/c/tomcat/webapps/dir1/WEB-INF/web.xml"
????????//?合并配置文件内容
????????//?合并全局配置
????????//?使用?org.apache.jasper.servlet.JspServlet?包装??<jsp-file>/a/b/c/file.jsp</jsp-file>的文件
????????//?把解析处理的内容设置到 context 中?，如：context.addFilterMap(filterMap);
????????//?在org.apache.catalina.core.NamingContextListener事件处理器中，内部调用了createNamingContext()创建?envCtx
????????//?Notify?our?interested?LifecycleListeners??触发事件监听器??org.apache.catalina.startup.ContextConfig
????????fireLifecycleEvent(Lifecycle.CONFIGURE_START_EVENT,?null);?//?配置启动事件?"configure_start"----------------------
????}
????//?添加初始化器
????public?void?addServletContainerInitializer(
????????ServletContainerInitializer?sci,?Set<Class<?>>?classes)?{
????????initializers.put(sci,?classes);
????}
}
class?org.apache.catalina.startup.ContextConfig{
????public?void?lifecycleEvent(LifecycleEvent?event)?{
????????context?=?(Context)?event.getLifecycle();?//?取得触发者?org.apache.catalina.core.StandardContext
????????configureStart();
????}
????protected?synchronized?void?configureStart()?{
????????//?读取并解析“d:/a/c/d/tomcat/conf/web.xml”，读取并解析"d:/a/b/tomcat/conf/Catalina/localhost/web.xml.default"
????????//?取得输入流?"d:/a/b/c/tomcat/webapps/dir1/WEB-INF/web.xml"
????????//?合并配置文件内容
????????//?合并全局配置
????????//?使用?org.apache.jasper.servlet.JspServlet?包装??<jsp-file>/a/b/c/file.jsp</jsp-file>的文件
????????//?把解析处理的内容设置到 context 中?，如：context.addFilterMap(filterMap);
????????webConfig();//!!!!??核心
????}
????protected?void?webConfig()?{
????????//?org.apache.jasper.servlet.JasperInitializer??jasper.jar
????????//?org.apache.tomcat.websocket.server.WsSci????tomcat-websocket.jar
????????//?解析类路径中"META-INF/services/javax.servlet.ServletContainerInitializer"文件内容
????????//?创建文件中声明的类型对象，并把创建对象转成ServletContainerInitializer类型的引用
????????//????????????????????initializerClassMap{
????????//????????????????????????'MyServletContainerInitializer1_Obj'=>[],
????????//????????????????????????'MyServletContainerInitializer2_Obj'=>[],
????????//????????????????????}
????????//????????????????????typeInitializerMap{
????????//????????????????????????'MyAnnotation1.class'=>[MyServletContainerInitializer1_Obj?],
????????//????????????????????????'MyAnnotation2.class'=>[MyServletContainerInitializer2_Obj?]
????????//????????????????????}
????????processServletContainerInitializers();?//?查看实现ServletContainerInitializer的初始化器
????????if?(ok)?{
????????????//?org.apache.jasper.servlet.JasperInitializer??jasper.jar
????????????//?org.apache.tomcat.websocket.server.WsSci????tomcat-websocket.jar
????????????//?解析类路径中"META-INF/services/javax.servlet.ServletContainerInitializer"文件内容
????????????//?创建文件中声明的类型对象，并把创建对象转成ServletContainerInitializer类型的引用
????????????//????????????????????????initializerClassMap{
????????????//????????????????????????????'MyServletContainerInitializer1_Obj'=>[],
????????????//????????????????????????????'MyServletContainerInitializer2_Obj'=>[],
????????????//????????????????????????}
????????????//????????????????????????typeInitializerMap{
????????????//????????????????????????????'MyAnnotation1.class'=>[MyServletContainerInitializer1_Obj?],
????????????//????????????????????????????'MyAnnotation2.class'=>[MyServletContainerInitializer2_Obj?]
????????????//????????????????????????}
????????????for?(Map.Entry<ServletContainerInitializer,Set<Class<?>>>?entry?:?initializerClassMap.entrySet())?{
????????????????if?(entry.getValue().isEmpty())?{?//?添加Servlet容器初始化器到StandardContext
????????????????????//?添加初始化器
????????????????????//?context?===?org.apache.catalina.core.StandardContext
????????????????????//?StandardContext.initializers.put(entry.getKey(),?null);
????????????????????context.addServletContainerInitializer(
????????????????????????entry.getKey(),?null);?
????????????????}?else?{
????????????????????context.addServletContainerInitializer(
????????????????????????entry.getKey(),?entry.getValue());
????????????????}
????????????}
????????}
????????protected?void?processServletContainerInitializers()?{
????????????//?容器初始化器
????????????WebappServiceLoader<ServletContainerInitializer>?loader?=?new?WebappServiceLoader<>(context);
????????????//?org.apache.jasper.servlet.JasperInitializer??jasper.jar
????????????//?org.apache.tomcat.websocket.server.WsSci????tomcat-websocket.jar
????????????//?解析类路径中"META-INF/services/javax.servlet.ServletContainerInitializer"文件内容
????????????//?创建文件中声明的类型对象，并把创建对象转成ServletContainerInitializer类型的引用
????????????detectedScis?=?loader.load(ServletContainerInitializer.class);?//?检测到的?ServletContainerInitializer
????????????for?(ServletContainerInitializer?sci?:?detectedScis)?{
????????????????initializerClassMap.put(sci,?new?HashSet<Class<?>>());?//?要调用的初始化器
????????????}
????????}
????}
????public?List<T>?load(Class<T>?serviceType)?throws?IOException?{
????????String?configFile?=?"META-INF/services/"?+?serviceType.getName();
????????LinkedHashSet<String>?applicationServicesFound?=?new?LinkedHashSet();
????????LinkedHashSet<String>?containerServicesFound?=?new?LinkedHashSet();
????????ClassLoader?loader?=?this.servletContext.getClassLoader();
????????List<String>?orderedLibs?=?(List)this.servletContext.getAttribute("javax.servlet.context.orderedLibs");
????????return?containerServicesFound.isEmpty()???Collections.emptyList()?:?this.loadServices(serviceType,?containerServicesFound);
????}
????//?调用实现ServletContainerInitializer接口的类的方法，进行初始化---------------------------2
????class?org.apache.catalina.core.StandardContext{
????????protected?synchronized?void?startInternal()?throws?LifecycleException?{
????????????//?fireLifecycleEvent(Lifecycle.CONFIGURE_START_EVENT,?null);
????????????//?....
????????????//?org.apache.jasper.servlet.JasperInitializer??jasper.jar
????????????//?org.apache.tomcat.websocket.server.WsSci????tomcat-websocket.jar
????????????//?Call?ServletContainerInitializers
????????????for?(Map.Entry<ServletContainerInitializer,?Set<Class<?>>>?entry?:
?????????????????initializers.entrySet())?{?//?调用容器初始化器?，
????????????????//?如：org.apache.jasper.servlet.JasperInitializer.onStartup();?
????????????????try?{
????????????????????//?执行初始化器
????????????????????entry.getKey().onStartup(entry.getValue(),getServletContext());
????????????????}?catch?(ServletException?e)?{
????????????????????log.error(sm.getString("standardContext.sciFail"),?e);
????????????????????ok?=?false;
????????????????????break;
????????????????}
????????????}
????????}
????}
}
@EnableAutoConfiguration扫描BasePackage
本质是理解：@AutoConfigurationPackage 注解。
/**
?*?Indicates?that?the?package?containing?the?annotated?class?should?be?registered?with
?*?{@link?AutoConfigurationPackages}.
?*
?*?@author?Phillip?Webb
?*?@since?1.3.0
?*?@see?AutoConfigurationPackages
?*/
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Import(AutoConfigurationPackages.Registrar.class)
public?@interface?AutoConfigurationPackage?{
}
static?class?Registrar?implements?ImportBeanDefinitionRegistrar,?DeterminableImports?{
???????//?new?PackageImport(metadata).getPackageName()?获取?当前?metadata?对应的包名????
????????@Override
????????public?void?registerBeanDefinitions(AnnotationMetadata?metadata,?BeanDefinitionRegistry?registry)?{
????????????register(registry,?new?PackageImport(metadata).getPackageName());
????????}
????????@Override
????????public?Set<Object>?determineImports(AnnotationMetadata?metadata)?{
????????????return?Collections.singleton(new?PackageImport(metadata));
????????}
????}
ConstructorArgumentValues 应该如何理解？
第9 章 ?Spring Boot 自动装配
9.3 自定义 Spring Boot 自动装配
1、如何命名自动装配Class和package
官网并没有给出命名规则。
从官方目前实现的源码中窥探一二。
Class 命名：xxxAutoConfiguration
package命名：
{module-package}
|- AutoConfiguration ?
|- ${sub-module-package}
|- …
例子 ：org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration
2、如何命名自动装配 Starter
Spring boot starter 包含的组件
autofigure 模块
starter 模块
官方建议 ：将自动装配的代码存放在 autoconfigure 模块， starter模块依赖该模块。
上述建议并非强制，也可以将两个模块合在一起，当Starter部署结构确定后，取一个佳名即可。
Spring boot starter 命名规则
官方推荐 ${module-name}-spring-boot-starter .
Spring 官方 Starter 通常命名为 spring-boot-starter-{module-name}如：spring-boot-starter-web，
比如：spring-cloud-starter-openfeign
Spring 官方建议非官方的 Starter 命名应遵守 {module-name}-spring-boot-starter 的格式。
比如：mybatis-spring-boot-starte
注意：starter 的配置文件 命名空间不要 使用 server 、management、Spring 等作为配置key 命名空间。
3、实现一个 Spring boot ?starter
①：新建Maven工程，在pom中添加依赖配置
<!--?添加?Spring?boot?starter?基础依赖?-->
<dependency>
??<groupId>org.springframework.boot</groupId>
??<artifactId>spring-boot-starter</artifactId>
??<!--?注意：设置为true ,不传递这个依赖-->
??<optional>true</optional>
</dependency>
②：写功能代码
③：自动装配类 xxxAutoConfiguration
④：在 META-INF/spring.factories 资源申明 xxxAutoConfiguration
org.springframework.boot.autoconfigure.EnableAutoConfiguration=
com.test.configure.xxxAutoConfiguration
⑤：在其他的工程中依赖 此 Starter
实现的套路比较简单，真正要思考的是实际场景下如何更好的使用。
9.4 ?Spring Boot 条件化自动装配-@Conditional
所有 Spring 条件注解 @Conditional 均采用 元标注 @Conditional(OnClassCondition.class) 的方式实现。
Spring boot 条件注解学习成本不高，但是合理的运用需要较高的专业化程度。
1、Class 条件注解
2、Bean 条件注解
3、Property 条件注解
4、Resource 条件注解
5、Web Application 条件注解
6、SpEL 表达式 ?条件注解
总结
Spring boot 自动装配 所依赖的
注解驱动
@Enable模块驱动
条件装配
Spring 工厂加载机制等（从spring.factories中加载）
这些特性 均来自 Spring Framework。
Sprng Framework 时代，Spring应用上下文通常 由容器启动，如 ContextLoaderListener 或 WebApplicationInitializer 的实现类由Servlet 容器装载并驱动。
Spring boot 时代，只用一个SpringApplication#run 结合 @SpringBootApplication 或 @EnableAutoConfiguration注解方式完成，启动方式发生了逆转？（和之前WAR启动对比，不需要发布到容器就能启动）
需知后续，请看下回分解，或者你自己直接去看书吧。
tips：最近很多伙伴后台留言说准备换新地方体验【拧螺丝】的工作了，
但是没有好的【造火箭】的资料，这不，特意整理了一份，内容非常丰富，包括大厂Java面试资料和经验总结！
See you next good day~
?