Spring Framework
1.Spring 5下载
1.进入Spring官网
2.进入Spring Framework
3.进入Spring5的github 按照下面步骤
然后根据地址下载需要的版本
Spring的在线文档；
离线文档：
2.Spring学习的核心内容：
1.Spring核心学习内容IOC,AOP,jdbcTemplate，声明式事务
2.IOC：控制反转，可以管理java对象
3.AOP：切面编程
4.JDBCTemplate：是spring提供一套访问数据库的技术，应用性强，相对好理解
5.声明式事务：基于IOC/AOP实现事务管理，理解需要花时间
6.IOC.AOP是重点同时也是难点
Spring几个重要概念：
1.Spring可以整合其他的框架（Spring是管理框架的框架）
2.Spring有两个核心的概念：IOC和AOP
3.传统的开发模式：
程序------>环境//程序读取环境配置，然后自己创建对象
IOC的开发模式：容器--------->程序//容器创建好对象，程序直接使用
1.Spring根据配置文件xml/注解，创建对象，并放入到容器（ConcurrentHashMap）中，并且可以完成对象之间的依赖。
2.当需要使用某个对象实例的时候，就直接从容器中获取即可。
3.程序员可以更加关注如何使用对象完成相应的业务。
4.DI依赖注入，可以理解成事IOC的另外叫法。
5.Spring最大的价值，通过配置，给程序提供需要使用的web层对象，这个是核心价值所在，也是IOC的具体体现，实现解耦。
3.手写简易SpringFrame框架：
实现一下内容：
1.手写模拟Spring容器启动过程底层实现
2.手写模拟Spring解析配置类底层实现
3.手写模拟Spring扫描Bean过程底层实现
4.手写模拟Bean生命周期创建过程底层实现
5.手写模拟Bean生命周期依赖注入过程底层实现
6.手写模拟Bean生命周期Aware回调过程底层实现
7.手写模拟Bean生命周期初始化过程底层实现
8.手写模拟BeanDefinition生成过程底层实现
9.手写模拟@Component，@ComponentScan
10.手写模拟@Autowired，@PostConstruct
11.手写模拟BeanPostProcessor后置处理底层实现
12.手写模拟Spring AOP过程底层实现
13.手写模拟Pointcut，Advisor，Advice底层实现
代码仓库：https://gitee.com/CHEN--YUQIAO/spring-frame 参考学习
4.Spring源码中核心组件的使用与解析
4.1BeanDefinition
BeanDefinition是非常非常核心的一个概念，一个BeanDefinition表示一个Bean定义，Spring会根据BeanDefinition来创建具体的Bean对象。
BeanDefinition中常用的属性：
- beanClass，表示Bean的类型
- scope，表示Bean的作用域，比如单例或多例
- LazyInit：表示Bean是不是懒加载的
- initMethodName：表示Bean初始化时要执行的方法
- destoryMethodName：表示Bean销毁时要执行的方法
当使用@Bean，@Component等方式定义Bean时，Spring底层就会解析这些标签和注解生成对应的BeanDefinition对象。（声明式创建）
也可以通过编程式定义和注册BeanDefinition：
AnnotationConfigApplicationContext applicationContext=new AnnotationConfigApplicationContext(DeviceService.class);BeanDefinition definition=new AnnotatedGenericBeanDefinition(DeviceService.class);definition.setScope("prototype");definition.setLazyInit(false);definition.setInitMethodName("a");applicationContext.registerBeanDefinition("deviceService",definition);5.BeanDefinition扫描过程源码解析
package org.springframework.context.annotation;import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Repeatable;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;import org.springframework.beans.factory.support.BeanNameGenerator;
import org.springframework.core.annotation.AliasFor;
import org.springframework.core.type.filter.TypeFilter;@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Repeatable(ComponentScans.class)
public @interface ComponentScan {@AliasFor("value")String[] basePackages() default {};@AliasFor("value")String[] basePackages() default {};Class<? extends BeanNameGenerator> nameGenerator() default BeanNameGenerator.class;Class<?>[] basePackageClasses() default {};Class<? extends ScopeMetadataResolver> scopeResolver() default AnnotationScopeMetadataResolver.class;ScopedProxyMode scopedProxy() default ScopedProxyMode.DEFAULT;String resourcePattern() default ClassPathScanningCandidateComponentProvider.DEFAULT_RESOURCE_PATTERN;boolean useDefaultFilters() default true;Filter[] includeFilters() default {};Filter[] excludeFilters() default {};boolean lazyInit() default false;@Retention(RetentionPolicy.RUNTIME)@Target({})@interface Filter {FilterType type() default FilterType.ANNOTATION;@AliasFor("classes")Class<?>[] value() default {};@AliasFor("value")Class<?>[] classes() default {};String[] pattern() default {};}}
/** Copyright 2002-2021 the original author or authors.** Licensed under the Apache License, Version 2.0 (the "License");* you may not use this file except in compliance with the License.* You may obtain a copy of the License at** https://www.apache.org/licenses/LICENSE-2.0** Unless required by applicable law or agreed to in writing, software* distributed under the License is distributed on an "AS IS" BASIS,* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.* See the License for the specific language governing permissions and* limitations under the License.*/package org.springframework.context.annotation;import java.util.Collections; import java.util.LinkedHashSet; import java.util.List; import java.util.Set;import org.springframework.beans.BeanUtils; import org.springframework.beans.factory.config.BeanDefinitionHolder; import org.springframework.beans.factory.support.BeanDefinitionRegistry; import org.springframework.beans.factory.support.BeanNameGenerator; import org.springframework.context.ConfigurableApplicationContext; import org.springframework.core.annotation.AnnotationAttributes; import org.springframework.core.env.Environment; import org.springframework.core.io.ResourceLoader; import org.springframework.core.type.filter.AbstractTypeHierarchyTraversingFilter; import org.springframework.core.type.filter.TypeFilter; import org.springframework.util.ClassUtils; import org.springframework.util.StringUtils;/*** Parser for the @{@link ComponentScan} annotation.** @author Chris Beams* @author Juergen Hoeller* @author Sam Brannen* @since 3.1* @see ClassPathBeanDefinitionScanner#scan(String...)* @see ComponentScanBeanDefinitionParser*/ class ComponentScanAnnotationParser {private final Environment environment;private final ResourceLoader resourceLoader;private final BeanNameGenerator beanNameGenerator;private final BeanDefinitionRegistry registry;public ComponentScanAnnotationParser(Environment environment, ResourceLoader resourceLoader,BeanNameGenerator beanNameGenerator, BeanDefinitionRegistry registry) {this.environment = environment;this.resourceLoader = resourceLoader;this.beanNameGenerator = beanNameGenerator;this.registry = registry;}public Set<BeanDefinitionHolder> parse(AnnotationAttributes componentScan, String declaringClass) {ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(this.registry,componentScan.getBoolean("useDefaultFilters"), this.environment, this.resourceLoader);Class<? extends BeanNameGenerator> generatorClass = componentScan.getClass("nameGenerator");boolean useInheritedGenerator = (BeanNameGenerator.class == generatorClass);scanner.setBeanNameGenerator(useInheritedGenerator ? this.beanNameGenerator :BeanUtils.instantiateClass(generatorClass));ScopedProxyMode scopedProxyMode = componentScan.getEnum("scopedProxy");if (scopedProxyMode != ScopedProxyMode.DEFAULT) {scanner.setScopedProxyMode(scopedProxyMode);}else {Class<? extends ScopeMetadataResolver> resolverClass = componentScan.getClass("scopeResolver");scanner.setScopeMetadataResolver(BeanUtils.instantiateClass(resolverClass));}scanner.setResourcePattern(componentScan.getString("resourcePattern"));for (AnnotationAttributes includeFilterAttributes : componentScan.getAnnotationArray("includeFilters")) {List<TypeFilter> typeFilters = TypeFilterUtils.createTypeFiltersFor(includeFilterAttributes, this.environment,this.resourceLoader, this.registry);for (TypeFilter typeFilter : typeFilters) {scanner.addIncludeFilter(typeFilter);}}for (AnnotationAttributes excludeFilterAttributes : componentScan.getAnnotationArray("excludeFilters")) {List<TypeFilter> typeFilters = TypeFilterUtils.createTypeFiltersFor(excludeFilterAttributes, this.environment,this.resourceLoader, this.registry);for (TypeFilter typeFilter : typeFilters) {scanner.addExcludeFilter(typeFilter);}}boolean lazyInit = componentScan.getBoolean("lazyInit");if (lazyInit) {scanner.getBeanDefinitionDefaults().setLazyInit(true);}Set<String> basePackages = new LinkedHashSet<>();String[] basePackagesArray = componentScan.getStringArray("basePackages");for (String pkg : basePackagesArray) {String[] tokenized = StringUtils.tokenizeToStringArray(this.environment.resolvePlaceholders(pkg),ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);Collections.addAll(basePackages, tokenized);}for (Class<?> clazz : componentScan.getClassArray("basePackageClasses")) {basePackages.add(ClassUtils.getPackageName(clazz));}if (basePackages.isEmpty()) {basePackages.add(ClassUtils.getPackageName(declaringClass));}scanner.addExcludeFilter(new AbstractTypeHierarchyTraversingFilter(false, false) {@Overrideprotected boolean matchClassName(String className) {return declaringClass.equals(className);}});return scanner.doScan(StringUtils.toStringArray(basePackages));}}ComponentScanAnnotationParser这个类是CompanentScan注解的解析器，用来构建并给scan扫描对象赋值，做扫描前的准备！！
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) { //扫描basePackage中的所有类，并注册到BeanDefinitionRegistry中Set<BeanDefinition> candidates = findCandidateComponents(basePackage);for (BeanDefinition candidate : candidates) { //获取bean的scopeScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);candidate.setScope(scopeMetadata.getScopeName()); //生成beanNameString beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry); //给BeanDefinition对象中的属性赋默认值if (candidate instanceof AbstractBeanDefinition) {postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);} //解析@Lazy，@Primary，@Fallback，@DependsOn，@Role，@Description等注解并赋值给BeanDefinition对应的属性if (candidate instanceof AnnotatedBeanDefinition) {AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);} //检查beanName是否已存在if (checkCandidate(beanName, candidate)) { //BeanDefinitionHolder的作用实在BeanDefinition的基础上 添加了beanNameBeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName); //如果设置了ScopedProxyMode，则会生成一个新的BeanDefinition，类型为ScopedProxyFactoryBeandefinitionHolder =AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);beanDefinitions.add(definitionHolder); //注册beanDefinitionregisterBeanDefinition(definitionHolder, this.registry);}}}return beanDefinitions;}
接下来进入第一个方法，看看是如何实现扫描，获得候选BeanDefinition的：
public Set<BeanDefinition> findCandidateComponents(String basePackage) {if (this.componentsIndex != null && indexSupportsIncludeFilters()) {return addCandidateComponentsFromIndex(this.componentsIndex, basePackage);}else {return scanCandidateComponents(basePackage);}}构建扫描路径 → 查找所有类资源 → 读取类元数据 → 双重过滤（规则匹配 + 类合法性） → 生成 Bean 定义。
private Set<BeanDefinition> scanCandidateComponents(String basePackage) {Set<BeanDefinition> candidates = new LinkedHashSet<>();try {String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +resolveBasePackage(basePackage) + '/' + this.resourcePattern;Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath);boolean traceEnabled = logger.isTraceEnabled();boolean debugEnabled = logger.isDebugEnabled();for (Resource resource : resources) {if (traceEnabled) {logger.trace("Scanning " + resource);}try { //利用ASM技术解析每个.class文件得到类的各种信息（类的元数据信息）MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource); //利用exludeFileters和includeFilters判断当前class是否为beanif (isCandidateComponent(metadataReader)) {ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);sbd.setSource(resource); //不能是接口或抽象类，如果是抽象类，但是有@Lookup注解的方法则通过if (isCandidateComponent(sbd)) {if (debugEnabled) {logger.debug("Identified candidate component class: " + resource);}candidates.add(sbd);}else {if (debugEnabled) {logger.debug("Ignored because not a concrete top-level class: " + resource);}}}else {if (traceEnabled) {logger.trace("Ignored because not matching any filter: " + resource);}}}catch (FileNotFoundException ex) {if (traceEnabled) {logger.trace("Ignored non-readable " + resource + ": " + ex.getMessage());}}catch (Throwable ex) {throw new BeanDefinitionStoreException("Failed to read candidate component class: " + resource, ex);}}}catch (IOException ex) {throw new BeanDefinitionStoreException("I/O failure during classpath scanning", ex);}return candidates;}
进入第一重过滤的方法如下：
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(metadataReader, getMetadataReaderFactory())) {return isConditionMatch(metadataReader);}}return false;}
第二重过滤方法如下：
此时，对 findCandidateComponents（）方法的剖析就已经完成！！
接下来继续看扫描中的
checkCandidate（）方法 即检查beanName是否已经存在
到这里doscan（）方法的逻辑就理清楚了！
接下来，总结一下：扫描的入口------> 容器调用refresh（）方法
接着会调用到
ConfigurationClassParser类中的doProcessConfigurationClass（）方法
调用parse（）回到上面分析过得，创建一个scanner对象，然后再调用doscan（）实现扫描！！
