Spring源码分析一IOC源码

结构

Spring Bean的创建是典型的工厂模式，这一系列的Bean工厂，也即IOC容器为开发者管理对象间的依赖关系提供了很多便利和基础服务，在Spring中有许多的IOC容器的实现供用户选择和使用，其相互关系如下：
20200507220411
AnnotationConfigApplicationContext 是基于注解来使用的，它不需要配置文件，采用 java 配置类和各种注解来配置，是比较简单的方式，也是趋势，我倾向使用这种方式。

BeanFactory 简介

20200507223153
BeanFactory作为最顶层的一个接口类，它定义了IOC容器的基本功能规范，BeanFactory 有三个子类：ListableBeanFactory、HierarchicalBeanFactory 和AutowireCapableBeanFactory。最终的默认实现类是 DefaultListableBeanFactory。

为何要定义这么多层次的接口：他使用的场合，它主要是为了区分在 Spring 内部在操作过程中对象的传递和转化过程中，对对象的数据访问所做的限制。例如 ListableBeanFactory 接口表示这些 Bean 是可列表的，而 HierarchicalBeanFactory 表示的是这些 Bean 是有继承关系的，也就是每个Bean 有可能有父 Bean。AutowireCapableBeanFactory 接口定义 Bean 的自动装配规则。

public interface BeanFactory {    
     
     //对FactoryBean的转义定义，因为如果使用bean的名字检索FactoryBean得到的对象是工厂生成的对象， 如果需要得到工厂本身，需要转义。 
     String FACTORY_BEAN_PREFIX = "&"; 
        
     //根据bean的名字，获取在IOC容器中得到bean实例    
     Object getBean(String name) throws BeansException;    
   
    //根据bean的名字和Class类型来得到bean实例，增加了类型安全验证机制。    
     Object getBean(String name, Class requiredType) throws BeansException;    
    
    //提供对bean的检索，看看是否在IOC容器有这个名字的bean    
     boolean containsBean(String name);    
    
    //根据bean名字得到bean实例，并同时判断这个bean是不是单例    
    boolean isSingleton(String name) throws NoSuchBeanDefinitionException;    
    
    //得到bean实例的Class类型    
    Class getType(String name) throws NoSuchBeanDefinitionException;    
    
    //得到bean的别名，如果根据别名检索，那么其原名也会被检索出来    
   String[] getAliases(String name);    
    
 }

IOC构造初始化

Spring的Ioc的初始化过程，实际上就是把beanName和BeanDefinition注册到DefaultListableBeanFactory的map中。

使用注解的方式创建代码

AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);

Spring中出来注解Bean定义的类有两个： AnnotationConfigApplicationContext和AnnotationConfigWebApplicationContext。

AnotationConfigWebApplicationContext是AnnotationConfigApplicationContext的web版本，两者的用法以及对注解的处理方式几乎没有什么差别

AnnotationConfigApplicationContext构造方法如下：

public class AnnotationConfigApplicationContext extends GenericApplicationContext implements AnnotationConfigRegistry {

	/**
	 * 这个类顾名思义是一个reader，一个读取器
	 * 读取什么呢？还是顾名思义AnnotatedBeanDefinition意思是读取一个被加了注解的bean，此属性在构造方法中被实例化。
	 */
	private final AnnotatedBeanDefinitionReader reader;

	/**
	 * 这是一个扫描器，扫描所有加了注解的bean，此属性在构造方法中被实例化。
	 */
	private final ClassPathBeanDefinitionScanner scanner;
	/**
	 * 初始化一个bean的读取和扫描器
	 *
	 * 默认构造函数，如果直接调用这个默认构造方法，需要在稍后通过调用其register() 去注册配置类（javaconfig），并调用refresh()方法刷新容器，
	 * 触发容器对注解Bean的载入、解析和注册过程
	 */
	public AnnotationConfigApplicationContext() {
		/**
		 * 会先执行父类的构造方法
		 * public GenericApplicationContext() {
		 * 		this.beanFactory = new DefaultListableBeanFactory();
		 *        }
		 * 创建一个读取注解的Bean定义读取器 BeanDefinition
		 */
		this.reader = new AnnotatedBeanDefinitionReader(this);
		//可以用来扫描包或者类，继而转换成bd，但是实际上我们扫描包工作不是scanner这个对象来完成的,是spring 内部自己new的一个ClassPathBeanDefinitionScanner
		//这里的scanner仅仅是为了程序员能够在外部调用AnnotationConfigApplicationContext对象的scan方法
		this.scanner = new ClassPathBeanDefinitionScanner(this);
	}

	public AnnotationConfigApplicationContext(DefaultListableBeanFactory beanFactory) {
		super(beanFactory);
		this.reader = new AnnotatedBeanDefinitionReader(this);
		this.scanner = new ClassPathBeanDefinitionScanner(this);
	}

	/**
	 * 这个构造方法需要传入一个被javaconfig注解了的配置类，然后会把这个被注解了javaconfig的类通过注解读取器读取后继而解析
	 */
	public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
		//这里由于他有父类，故而会先调用父类的构造方法，然后才会调用自己的构造方法
		//在自己构造方法中初始一个读取器和扫描器
		this();
		register(annotatedClasses);
		refresh();
	}

	public AnnotationConfigApplicationContext(String... basePackages) {
		this();
		scan(basePackages);
		refresh();
	}
    //设置环境
	@Override
	public void setEnvironment(ConfigurableEnvironment environment) {
		super.setEnvironment(environment);
		this.reader.setEnvironment(environment);
		this.scanner.setEnvironment(environment);
	}

	/**
	 * 注册单个bean给容器
	 * 比如有新加的类可以用这个方法，但是注册注册之后需要手动调用refresh方法去触发容器解析注解
	 *
	 * 他可以注册一个配置类、还可以单独注册一个bean
	 */
	public void register(Class<?>... annotatedClasses) {
		Assert.notEmpty(annotatedClasses, "At least one annotated class must be specified");
		this.reader.register(annotatedClasses);
	}
	// 调用的是bean扫描器ClassPathBeanDefinitionScanner的scan方法
	public void scan(String... basePackages) {
		Assert.notEmpty(basePackages, "At least one base package must be specified");
		this.scanner.scan(basePackages);
	}
}

主要属性：

AnnotatedBeanDefinitionReader——BeanDefinition解析器用来解析带注解的bean
ClassPathBeanDefinitionScanner——bean的扫描器 用来扫描类
注册解析传入的配置类（使用类配置的方式进行解析）
调用容器的refresh方法初始化容器

1、注册BeanDefinition的注册器

/**
    *  这里的BeanDefinitionRegistry registry是通过在AnnotationConfigApplicationContext 的构造方法中传进来的this
    *  由此说明AnnotationConfigApplicationContext是一个BeanDefinitionRegistry类型的类
    *
    *  GenericApplicationContext extends AbstractApplicationContext implements BeanDefinitionRegistry
    *
    *  看到他实现了BeanDefinitionRegistry证明上面的说法，
    *  BeanDefinitionRegistry 顾名思义就是BeanDefinition的注册器  
    * @param registry
    */
public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry) {
    this(registry, getOrCreateEnvironment(registry));
}

2、注册扫描器

public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters,
		Environment environment, @Nullable ResourceLoader resourceLoader) {

	Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
       //为容器设置加载Bean定义的注册器
       this.registry = registry;
	//是否使用默认过滤规则
	if (useDefaultFilters) {
		registerDefaultFilters();
	}
	//设置环境
	setEnvironment(environment);
	//为容器设置资源加载器
	setResourceLoader(resourceLoader);
}

   //向容器注册过滤规则
@SuppressWarnings("unchecked")
protected void registerDefaultFilters() {
	//向要包含的过滤规则中添加@Component注解类
	//@Service和@Controller都是Component，因为这些注解都添加了@Component注解
	this.includeFilters.add(new AnnotationTypeFilter(Component.class));
	//获取当前类的类加载器
	ClassLoader cl = ClassPathScanningCandidateComponentProvider.class.getClassLoader();
	try {
		//向要包含的过滤规则添加JavaEE6的@ManagedBean注解
		this.includeFilters.add(new AnnotationTypeFilter(
				((Class<? extends Annotation>) ClassUtils.forName("javax.annotation.ManagedBean", cl)), false));
		logger.debug("JSR-250 'javax.annotation.ManagedBean' found and supported for component scanning");
	}
	catch (ClassNotFoundException ex) {
		// JSR-250 1.1 API (as included in Java EE 6) not available - simply skip.
	}
	try {
		//向要包含的过滤规则添加@Named注解
		this.includeFilters.add(new AnnotationTypeFilter(
				((Class<? extends Annotation>) ClassUtils.forName("javax.inject.Named", cl)), false));
		logger.debug("JSR-330 'javax.inject.Named' annotation found and supported for component scanning");
	}
	catch (ClassNotFoundException ex) {
		// JSR-330 API not available - simply skip.
	}
}

扫描注册

public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) { 
	//这里由于他有父类，故而会先调用父类的构造方法，然后才会调用自己的构造方法
	//在自己构造方法中初始一个读取器和扫描器
	this();
	register(annotatedClasses);
	refresh();
}

this()方法，会去初始化AnnotatedBeanDefinitionReader读取器和ClassPathBeanDefinitionScanner扫描器

如果传入类，最终会执行到：

<T> void doRegisterBean(Class<T> annotatedClass, @Nullable Supplier<T> instanceSupplier, @Nullable String name,
        @Nullable Class<? extends Annotation>[] qualifiers, BeanDefinitionCustomizer... definitionCustomizers) {
    /**
        * 根据指定的bean创建一个AnnotatedGenericBeanDefinition
        * 这个AnnotatedGenericBeanDefinition可以理解为一个数据结，包含了类的其他信息，比如一些元信息scope，lazy等等
        */
    AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass);
    /**
        * 判断这个类是否需要跳过解析
        * 通过代码可以知道spring判断是否跳过解析，主要判断类有没有加注解
        */
    if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
        return;
    }
    //？
    abd.setInstanceSupplier(instanceSupplier);
    /**
        * 得到类的作用域,默认singleton
        */
    ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
    /**
        * 把类的作用域添加到数据结构结构中
        */
    abd.setScope(scopeMetadata.getScopeName());
    /**
        * 生成类的名字通过beanNameGenerator，可以自己扩展
        */
    String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));
    /**
        * 处理类当中的通用注解：Lazy DependsOn Primary Role等等注解
        * 处理完成之后processCommonDefinitionAnnotations中依然是把他添加到数据结构当中
        *
        */
    AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);

    /**
        * 如果在向容器注册注解Bean定义时，使用了额外的限定符注解则解析
        * 关于Qualifier和Primary前面的课当中讲过，主要涉及到spring的自动装配
        *
        * 这里需要注意的
        * byName和qualifiers这个变量是Annotation类型的数组，里面存不仅仅是Qualifier注解
        * 理论上里面里面存的是一切注解，所以可以看到下面的代码spring去循环了这个数组
        * 然后依次判断了注解当中是否包含了Primary，是否包含了Lazyd
        */
    if (qualifiers != null) {
        for (Class<? extends Annotation> qualifier : qualifiers) {
            // 如果配置了@Primary注解，如果加了则作为首选
            if (Primary.class == qualifier) {
                abd.setPrimary(true);
            }
            //懒加载，前面加过
            else if (Lazy.class == qualifier) {
                abd.setLazyInit(true);
            }
            else {
                //如果使用了除@Primary和@Lazy以外的其他注解，则为该Bean添加一个根据名字自动装配的限定符
                abd.addQualifier(new AutowireCandidateQualifier(qualifier));
            }
        }
    }
    for (BeanDefinitionCustomizer customizer : definitionCustomizers) {
        customizer.customize(abd);
    }

    /**
        * 这个BeanDefinitionHolder也是一个数据结构
        */
    BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);

    /**
        * ScopedProxyMode 这个知识点比较复杂，需要结合web去理解
        */
    definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);

    /**
        * 把上述的这个数据结构注册给registry registy就是AnnotatonConfigApplicationContext
        * AnnotatonConfigApplicationContext在初始化的時候通过调用父类构造方法实例化了一个DefaultListableBeanFactory
        *
        * registerBeanDefinition里面就是把definitionHolder这个数据结构包含的信息注册到 DefaultListableBeanFactory这个工厂
        */
    BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
}

如果是个包名

public int scan(String... basePackages) {
	// 获取当前注册bean的数量
	int beanCountAtScanStart = this.registry.getBeanDefinitionCount();

	doScan(basePackages);

	// 注册配置处理器
	if (this.includeAnnotationConfig) {
		//往BeanDefinitionMap注册
		AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
	}
	// 返回此次注册的数量
	return (this.registry.getBeanDefinitionCount() - beanCountAtScanStart);
}

具体扫描操作

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路径下的java文件， 符合条件的并把它转成BeanDefinition类型
		Set<BeanDefinition> candidates = findCandidateComponents(basePackage);

		for (BeanDefinition candidate : candidates) {
			// 解析scope属性 并绑定
			ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
			candidate.setScope(scopeMetadata.getScopeName());
			// 查看是否配置类是否指定bean的名称，如没指定则使用类名首字母小写
			String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
			// 这两个if处理lazy、Autowire、DependencyOn、initMethod、enforceInitMethod、destroyMethod、enforceDestroyMethod、Primary、Role、Description这些逻辑的
			if (candidate instanceof AbstractBeanDefinition) {
				//如果这个类是AbstractBeanDefinition的子类，则为他设置默认值，比如lazy，init destory
				postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
			}
			if (candidate instanceof AnnotatedBeanDefinition) {
				// 检查并且处理常用的注解 把常用注解的值设置到AnnotatedBeanDefinition当中
				// 当前前提是这个类必须是AnnotatedBeanDefinition类型的，说白了就是加了注解的类
				AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
			}
			//检查bean是否存在
			if (checkCandidate(beanName, candidate)) {
				//又包装了一层
				BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
				//检查scope是否创建，如未创建则进行创建
				definitionHolder =
						AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
				beanDefinitions.add(definitionHolder);
				//加入到map当中 注册BeanDefinition
				registerBeanDefinition(definitionHolder, this.registry);
			}
		}
	}
	return beanDefinitions;
}

findCandidateComponents(basePackage)方法，这个方法里就是具体的扫描逻辑。

public Set<BeanDefinition> findCandidateComponents(String basePackage) {
	//判断是否使用Filter指定忽略包不扫描
	if (this.componentsIndex != null && indexSupportsIncludeFilters()) {
		return addCandidateComponentsFromIndex(this.componentsIndex, basePackage);
	}
	else {//扫描包
		return scanCandidateComponents(basePackage);
	}
}

这里是扫描逻辑，主要过程：

根据包路径，扫描所有.class文件
根据包路径，生成.class对应的Resource对象
通过ASM获取class元数据，并封装在MetadataReader元数据读取器中
判断该类是否符合过滤规则
判断该类是否为独立的类、具体的类
加入到集合中

private Set<BeanDefinition> scanCandidateComponents(String basePackage) {
    Set<BeanDefinition> candidates = new LinkedHashSet<>();
    try {
        //组装扫描路径（组装完成后是这种格式：classpath*:com/../config/**/*.class）
        String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
                resolveBasePackage(basePackage) + '/' + this.resourcePattern;
        //asm 读取class文件
        Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath);
        boolean traceEnabled = logger.isTraceEnabled();
        boolean debugEnabled = logger.isDebugEnabled();
        for (Resource resource : resources) {
            if (traceEnabled) {
                logger.trace("Scanning " + resource);
            }
            if (resource.isReadable()) {
                try {
                    //根据资源对象通过反射获取资源对象的MetadataReader
                    MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource);
                    //查看配置类是否有@Conditional一系列的注解，然后是否满足注册Bean的条件
                    if (isCandidateComponent(metadataReader)) {
                        ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
                        sbd.setResource(resource);
                        sbd.setSource(resource);
                        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 (Throwable ex) {
                    throw new BeanDefinitionStoreException(
                            "Failed to read candidate component class: " + resource, ex);
                }
            }
            else {
                if (traceEnabled) {
                    logger.trace("Ignored because not readable: " + resource);
                }
            }
        }
    }
    catch (IOException ex) {
        throw new BeanDefinitionStoreException("I/O failure during classpath scanning", ex);
    }
    return candidates;
}

这里最主要的是isCandidateComponent判断规则

//判断元信息读取器读取的类是否符合容器定义的注解过滤规则@CompoentScan的过滤规则支持5种 （注解、类、正则、aop、自定义）
protected boolean isCandidateComponent(MetadataReader metadataReader) throws IOException {
    //如果读取的类的注解在排除注解过滤规则中，返回false
    for (TypeFilter tf : this.excludeFilters) {
        if (tf.match(metadataReader, getMetadataReaderFactory())) {
            return false;
        }
    }
    //如果读取的类的注解在包含的注解的过滤规则中，则返回ture
    for (TypeFilter tf : this.includeFilters) {
        //判断当前类的注解是否match规则
        if (tf.match(metadataReader, getMetadataReaderFactory())) {
            //是否有@Conditional注解，进行相关处理
            return isConditionMatch(metadataReader);
        }
    }
    //如果读取的类的注解既不在排除规则，也不在包含规则中，则返回false
    return false;
}

通过 isCandidateComponent(metadataReader)，在这个方法中有 tf.match(metadataReader, getMetadataReaderFactory())

Spring就是这样发现@Configuration、@Controller、@Service这些注解修饰的类的。过滤方法：

//是否是独立的类、具体的类
protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {
    AnnotationMetadata metadata = beanDefinition.getMetadata();
    return (metadata.isIndependent() && (metadata.isConcrete() ||
            (metadata.isAbstract() && metadata.hasAnnotatedMethods(Lookup.class.getName()))));
}

这个方法的作用是，判断该类是否为：顶层的类（没有父类或静态内部类）、具体的类（不是抽象类或接口）
类型封装

protected void processConfigurationClass(ConfigurationClass configClass) throws IOException {
	if (this.conditionEvaluator.shouldSkip(configClass.getMetadata(), ConfigurationPhase.PARSE_CONFIGURATION)) {
		return;
	}

	// 处理Imported 的情况
	//就是当前这个注解类有没有被别的类import
	ConfigurationClass existingClass = this.configurationClasses.get(configClass);
	//如果同一个配置类被处理两次，两次都属于被import的则合并导入类，返回。如果配置类不是被导入的，则移除旧使用新的配置类。
	if (existingClass != null) {
		if (configClass.isImported()) {
			if (existingClass.isImported()) {
				existingClass.mergeImportedBy(configClass);
			}
			// Otherwise ignore new imported config class; existing non-imported class overrides it.
			return;
		}
		else {
			// Explicit bean definition found, probably replacing an imports.
			// Let's remove the old one and go with the new one.
			this.configurationClasses.remove(configClass);
			this.knownSuperclasses.values().removeIf(configClass::equals);
		}
	}

	// Recursively process the configuration class and its superclass hierarchy.
	SourceClass sourceClass = asSourceClass(configClass);
	do {
		sourceClass = doProcessConfigurationClass(configClass, sourceClass);
	}
	while (sourceClass != null);
	//一个map，用来存放扫描出来的bean（注意这里的bean不是对象，仅仅bean的信息，因为还没到实例化这一步）
	this.configurationClasses.put(configClass, configClass);
}

处理内部类

protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass)
		throws IOException {

	// Recursively process any member (nested) classes first
	//处理内部类
	processMemberClasses(configClass, sourceClass);

	// 处理@PropertySource注解
	for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(
			sourceClass.getMetadata(), PropertySources.class,
			org.springframework.context.annotation.PropertySource.class)) {
		if (this.environment instanceof ConfigurableEnvironment) {
			processPropertySource(propertySource);
		}
		else {
			logger.warn("Ignoring @PropertySource annotation on [" + sourceClass.getMetadata().getClassName() +
					"]. Reason: Environment must implement ConfigurableEnvironment");
		}
	}

	// 处理 @ComponentScan 注解
	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
			//扫描普通类：componentScan=com.hu：：：扫描出来所有@@Component  并且把扫描的出来的普通bean放到map当中
			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
			//检查扫描出来的类当中是否还有configuration
			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());
				}
			}
		}
	}

	/**
		* 上面的代码就是扫描普通类----@Component
		* 并且放到了map当中
		*/
	// Process any @Import annotations
	//处理Import注解  imports 3种情况
	//ImportSelector
	//普通类
	//ImportBeanDefinitionRegistrar

	//递归     这里和内部递归调用时候的情况不同
	/**
		* 这里处理的import是需要判断我们的类当中时候有@Import注解
		* 如果有这把@Import当中的值拿出来，是一个类
		* 比如@Import(xxxxx.class)，那么这里便把xxxxx传进去进行解析，在解析的过程中如果发觉是一个importSelector那么就回调selector的方法
		* 返回一个字符串（类名），通过这个字符串得到一个类，继而在递归调用本方法来处理这个类。
		*
		* 判断一组类是不是imports（3种import）
		*/
	processImports(configClass, sourceClass, getImports(sourceClass), true);

	// 处理@ImportResource 注解
	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);
		}
	}

	//处理包含@Bean注解的方法
	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;
}

至此包扫描也结束了，已经把扫描到的类存入到了集合中，结下来就是解析注册Bean的过程了。

bean实例化

注册的主要方法：

public void refresh() throws BeansException, IllegalStateException {
    //为了避免refresh还没结束，再次发起启动或者销毁容器引起的冲突
    synchronized (this.startupShutdownMonitor) {
        ////准备工作包括设置启动时间，是否激活标识位，
        // 初始化属性源(property source)配置
        prepareRefresh();
        //BeanFactory的初始化、Bean的加载和注册等事件
        //返回一个factory 为什么需要返回一个工厂
        //因为要对工厂进行初始化
        //这里同时会限制容器只能调用一个该refresh方法，在obtainFreshBeanFactory()中的refreshBeanFactory()方法中限制了
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
        /**
            * 准备工厂，设置BeanFactory的类加载器、bean表达式解释器等一些初始化操作，添加几个 BeanPostProcessor、手动注册几个特殊的bean。			 *
            *
            * 这里会把EnvironmentAware,EmbeddedValueResolverAware,ResourceLoaderAware,ApplicationEventPublisherAware,MessageSourceAware,ApplicationContextAware
            *
            * 这几个接口忽略掉，Spring不会自动注入这些接口的实例，同时注册两个后置处理器：ApplicationContextAwareProcessor、ApplicationListenerDetector，
            * 第一个主要是 给实现了上面六个接口的对象注入相应的资源
            */
        prepareBeanFactory(beanFactory);

        try {
            // TODO: Spring的一个扩展点
            // 这个方法在这里是一个空方法，但是在后面的Web的上下文是XmlWebApplicationContext有用的
            // 如果有Bean实现了BeanFactoryPostProcessor接口，那么在容器初始化以后，Spring 会负责调用里面的 postProcessBeanFactory 方法。
            // 具体的子类可以在这步的时候添加一些特殊的 BeanFactoryPostProcessor 的实现类或做一些操作。
            postProcessBeanFactory(beanFactory);
            //在spring的环境中去执行已经被注册的 后置工厂处理器
            //自定义的BeanFactoryPostProcessor 和spring内部自己定义
            invokeBeanFactoryPostProcessors(beanFactory);
            //注册beanPostProcessor，注意不是BeanFactoryPostProcessor
            //此接口有两个方法: postProcessBeforeInitialization 和 postProcessAfterInitialization分别会在Bean初始化之前和初始化之后得到执行
            registerBeanPostProcessors(beanFactory);
            // 初始化当前 ApplicationContext 的 MessageSource，国际化的相关
            initMessageSource();
            //初始化应用事件广播器
            initApplicationEventMulticaster();
            // TODO:扩展点  比如初始化其他特殊的bean
            onRefresh();
            // 注册事件监听器
            registerListeners();
            // bean还没有初始化。这个方法就是负责初始化所有的没有设置懒加载的singleton bean
            finishBeanFactoryInitialization(beanFactory);
            finishRefresh();
        }

        catch (BeansException ex) {
            if (logger.isWarnEnabled()) {
                logger.warn("Exception encountered during context initialization - " +
                        "cancelling refresh attempt: " + ex);
            }

            // Destroy already created singletons to avoid dangling resources.
            destroyBeans();

            // Reset 'active' flag.
            cancelRefresh(ex);

            // Propagate exception to caller.
            throw ex;
        }

        finally {
            // Reset common introspection caches in Spring's core, since we
            // might not ever need metadata for singleton beans anymore...
            resetCommonCaches();
        }
    }
}

准备工作

//做一些准备工作，记录容器的启动时间、标记“已启动”状态、检查环境变量等
protected void prepareRefresh() {
	this.startupDate = System.currentTimeMillis();
	this.closed.set(false);
	this.active.set(true);

	if (logger.isInfoEnabled()) {
		logger.info("Refreshing " + this);
	}

	// Initialize any placeholder property sources in the context environment
	//初始化加载配置文件方法，并没有具体实现，一个留给用户的扩展点
	//例如WebContext初始化参数用的，把xml中的${key}替换成实际值，这个后面用web上下文证实一下
	initPropertySources();

	// Validate that all properties marked as required are resolvable
	// see ConfigurablePropertyResolver#setRequiredProperties
	//// 检查环境变量
	//其中检查环境变量的核心方法为，简单来说就是如果存在环境变量的value 为空的时候就抛异常，然后停止启动Spring
	getEnvironment().validateRequiredProperties();

	// Allow for the collection of early ApplicationEvents,
	// to be published once the multicaster is available...
	this.earlyApplicationEvents = new LinkedHashSet<>();
}

BeanFactory的初始化、Bean的加载和注册等事件

ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
	// 核心
	refreshBeanFactory();
	// 返回刚刚创建的 BeanFactory
	ConfigurableListableBeanFactory beanFactory = getBeanFactory();
	if (logger.isDebugEnabled()) {
		logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
	}
	return beanFactory;
}

protected final void refreshBeanFactory() throws BeansException {
	// 判断当前ApplicationContext是否存在BeanFactory，如果存在的话就销毁所有 Bean，关闭 BeanFactory
	// 注意，一个应用可以存在多个BeanFactory，这里判断的是当前ApplicationContext是否存在BeanFactory
	if (hasBeanFactory()) {
		destroyBeans();
		closeBeanFactory();
	}
	try {
		// 初始化DefaultListableBeanFactory
		DefaultListableBeanFactory beanFactory = createBeanFactory();
		beanFactory.setSerializationId(getId());
		// 设置 BeanFactory 的两个配置属性：是否允许 Bean 覆盖、是否允许循环引用
		customizeBeanFactory(beanFactory);
		// 这个方法会根据配置，加载各个 Bean的BeanDefinitions，然后放到 BeanFactory 中
		loadBeanDefinitions(beanFactory);
		synchronized (this.beanFactoryMonitor) {
			this.beanFactory = beanFactory;
		}
	}
	catch (IOException ex) {
		throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
	}
}

准备工厂，设置BeanFactory的类加载器、bean表达式解释器等一些初始化操作，添加几个 BeanPostProcessor、手动注册几个特殊的bean。

/**
* 设置BeanFactory的类加载器、配置其标准的特征，添加几个 BeanPostProcessor、手动注册几个特殊的bean 、上下文的加载器ClassLoader和post-processors回调
* 此处的beanFactory参数等于DefaultListableFactory
*/
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
	// 设置为加载当前ApplicationContext类的类加载器
	beanFactory.setBeanClassLoader(getClassLoader());
	//BeanExpressionResolver bean表达式解释器，能够获取bean当中的属性在前台页面
	beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
	//对象与string类型的转换   <property red="dao">
	beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
 
	// 添加一个后置管理器  ApplicationContextAwareProcessor
	// 能够在bean中获得到各种*Aware（*Aware都有其作用）：在所有实现了Aware接口的bean在初始化的时候，这个 processor负责回调
	// TODO: 这里是Spring的又一个扩展点：这个我们很常用，如我们会为了获取 ApplicationContext 而 实现接口 ApplicationContextAware
	// 注意：它不仅仅回调 ApplicationContextAware，还会负责回调 EnvironmentAware、ResourceLoaderAware 等
	beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
	//
	//如果某个 bean 依赖于以下几个接口的实现类，spring容器就不会帮你注入这几个接口的实例，在自动装配的时候忽略它们，Spring 会通过其他方式来处理这些依赖。
	beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
	beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
	beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
	beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
	beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
	beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);

	// BeanFactory interface not registered as resolvable type in a plain factory.
	// MessageSource registered (and found for autowiring) as a bean.
	// 特殊的几个 bean 赋值，如果有 bean 依赖了以下几个，会注入这边相应的值
	beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
	beanFactory.registerResolvableDependency(ResourceLoader.class, this);
	beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
	beanFactory.registerResolvableDependency(ApplicationContext.class, this);
 
	//注册一个后置处理器，主要检查是否实现了ApplicationListener接口，如果实现了就加入当前的applicationContext的applicationListeners列表
	beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
   
	// 如果存在bean名称为loadTimeWeaver的bean则注册一个BeanPostProcessor
	if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
		beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
		// Set a temporary ClassLoader for type matching.
		beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
	}

	// 意思是如果自定义的Bean中没有名为"systemProperties"、"environment"和"systemEnvironment"的Bean，那么 Spring 会 "手动" 注册一个
	// Key为"systemProperties"和"systemEnvironment"，Value为Map，
	// 这两个Bean就是一些系统配置和系统环境信息
	// Register default environment beans.
	if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
		beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
	}
	if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
		beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
	}
	if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
		beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
	}
}

在spring的环境中去执行已经被注册的后置工厂处理器

1、getBeanFactoryPostProcessors()得到自己定义的（就是没有交给spring管理，没有加上@Component）

2、得到spring内部自己维护的BeanDefinitionRegistryPostProcessor

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
	// 注意：getBeanFactoryPostProcessors()是获取手动给spring的BeanFactoryPostProcessor
	// 所谓的自定义的就是你手动调用AnnotationConfigApplicationContext.addBeanFactoryPostProcesor()添加到list的
	// 并不仅仅是程序员写的，可以加@companent也可以不加，如果加了getBeanFactoryPostProcessors()这个地方得不到，是spring自己扫描得到。
	// 为什么得不到？getBeanFactoryPostProcessors（）这个方法是直接获取一个list，
	// 这个list是在AnnotationConfigApplicationContext被定义
	/*
	自己定义的BeanFactoryProcessor可以有两种方式
	1、实现BeanFactoryProcessor接口
	2、实现BeanDefinitionRegistryPostProcessor  因为BeanDefinitionRegistryPostProcessor实现了BeanFactoryProcessor于是可以猜想实现bdrp和实现bfp是能够完成不同的功能。
		其实也可以理解，因为bdrp是子类，他肯定扩展了bfp的功能
		*/
	PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());

	// Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime 
	if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
		beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
		beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
	}
}

循环所有的BeanDefinitionRegistryPostProcessor，该方法内部postProcessor.postProcessBeanDefinitionRegistry

org.springframework.context.support.PostProcessorRegistrationDelegate#invokeBeanDefinitionRegistryPostProcessors

public static void invokeBeanFactoryPostProcessors(
		ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) { 
	Set<String> processedBeans = new HashSet<>();

	if (beanFactory instanceof BeanDefinitionRegistry) {
		BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;

		List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
		List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();

		//自定义的beanFactoryPostProcessors
		for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
			if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
				BeanDefinitionRegistryPostProcessor registryProcessor =
						(BeanDefinitionRegistryPostProcessor) postProcessor;
				registryProcessor.postProcessBeanDefinitionRegistry(registry);
				registryProcessors.add(registryProcessor);
			}
			else {//BeanDefinitionRegistryPostProcessor  BeanfactoryPostProcessor
				regularPostProcessors.add(postProcessor);
			}
		}
 
		//这个currentRegistryProcessors 放的是spring内部自己实现了BeanDefinitionRegistryPostProcessor接口的对象
		List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();

		// First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
		//BeanDefinitionRegistryPostProcessor 等于 BeanFactoryPostProcessor
		//getBeanNamesForType  根据bean的类型获取bean的名字ConfigurationClassPostProcessor
		String[] postProcessorNames =
				beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
		//这个地方可以得到一个BeanFactoryPostProcessor，因为是spring默认在最开始自己注册的
		//为什么要在最开始注册这个呢？
		//因为spring的工厂需要许解析去扫描等等功能
		//而这些功能都是需要在spring工厂初始化完成之前执行
		//要么在工厂最开始的时候、要么在工厂初始化之中，反正不能再之后
		//因为如果在之后就没有意义，因为那个时候已经需要使用工厂了
		//所以这里spring'在一开始就注册了一个BeanFactoryPostProcessor，用来插手springfactory的实例化过程
		//在这个地方断点可以知道这个类叫做ConfigurationClassPostProcessor
		//ConfigurationClassPostProcessor那么这个类能干嘛呢？可以参考源码
		//下面我们对这个牛逼哄哄的类（他能插手spring工厂的实例化过程还不牛逼吗？）重点解释
		for (String ppName : postProcessorNames) {
			if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
				currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
				processedBeans.add(ppName);
			}
		}
		//排序不重要，况且currentRegistryProcessors这里也只有一个数据
		sortPostProcessors(currentRegistryProcessors, beanFactory);
		//合并list，不重要(为什么要合并，因为还有自己的)
		registryProcessors.addAll(currentRegistryProcessors);
		//最重要。注意这里是方法调用
		//执行所有BeanDefinitionRegistryPostProcessor

		invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
		//执行完成了所有BeanDefinitionRegistryPostProcessor
		//这个list只是一个临时变量，故而要清除
		currentRegistryProcessors.clear();

		// Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
		postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
		for (String ppName : postProcessorNames) {
			if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
				currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
				processedBeans.add(ppName);
			}
		}
		sortPostProcessors(currentRegistryProcessors, beanFactory);
		registryProcessors.addAll(currentRegistryProcessors);
		invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
		currentRegistryProcessors.clear();

		// Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
		boolean reiterate = true;
		while (reiterate) {
			reiterate = false;
			postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
			for (String ppName : postProcessorNames) {
				if (!processedBeans.contains(ppName)) {
					currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
					processedBeans.add(ppName);
					reiterate = true;
				}
			}
			sortPostProcessors(currentRegistryProcessors, beanFactory);
			registryProcessors.addAll(currentRegistryProcessors);
			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
			currentRegistryProcessors.clear();
		}

		// Now, invoke the postProcessBeanFactory callback of all processors handled so far.
		//执行BeanFactoryPostProcessor的回调，前面不是吗？
		//前面执行的BeanFactoryPostProcessor的子类BeanDefinitionRegistryPostProcessor的回调
		//这是执行的是BeanFactoryPostProcessor    postProcessBeanFactory
		//ConfuguratuonClassPpostProcssor
		invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
		//自定义BeanFactoryPostProcessor
		invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
	}

	else {
		// Invoke factory processors registered with the context instance.
		invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
	}

	// Do not initialize FactoryBeans here: We need to leave all regular beans
	// uninitialized to let the bean factory post-processors apply to them!
	//ConfigurationClassPostProcessor
	String[] postProcessorNames =
			beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

	// Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
	// Ordered, and the rest.
	List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
	List<String> orderedPostProcessorNames = new ArrayList<>();
	List<String> nonOrderedPostProcessorNames = new ArrayList<>();
	for (String ppName : postProcessorNames) {
		if (processedBeans.contains(ppName)) {
			// skip - already processed in first phase above
		}
		else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
			priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
		}
		else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
			orderedPostProcessorNames.add(ppName);
		}
		else {
			nonOrderedPostProcessorNames.add(ppName);
		}
	}

	// First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
	sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
	invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

	// Next, invoke the BeanFactoryPostProcessors that implement Ordered.
	List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>();
	for (String postProcessorName : orderedPostProcessorNames) {
		orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
	}
	sortPostProcessors(orderedPostProcessors, beanFactory);
	invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

	// Finally, invoke all other BeanFactoryPostProcessors.
	List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
	for (String postProcessorName : nonOrderedPostProcessorNames) {
		nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
	}
	invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

	// Clear cached merged bean definitions since the post-processors might have
	// modified the original metadata, e.g. replacing placeholders in values...
	beanFactory.clearMetadataCache();
}

调用扩展方法postProcessBeanDefinitionRegistry

public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
	int registryId = System.identityHashCode(registry);
	if (this.registriesPostProcessed.contains(registryId)) {
		throw new IllegalStateException(
				"postProcessBeanDefinitionRegistry already called on this post-processor against " + registry);
	}
	if (this.factoriesPostProcessed.contains(registryId)) {
		throw new IllegalStateException(
				"postProcessBeanFactory already called on this post-processor against " + registry);
	}
	this.registriesPostProcessed.add(registryId);

	processConfigBeanDefinitions(registry);
}

拿出的所有bd，然后判断bd时候包含了@Configuration、@Import，@Compent。。。注解

public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
	//定义一个list存放app 提供的bd（项目当中提供了@Compent）
	List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
	//获取容器中注册的所有bd名字
	//7个
	String[] candidateNames = registry.getBeanDefinitionNames();

	/**
		* Full
		* Lite
		*/
	for (String beanName : candidateNames) {
		BeanDefinition beanDef = registry.getBeanDefinition(beanName);
		if (ConfigurationClassUtils.isFullConfigurationClass(beanDef) ||
				ConfigurationClassUtils.isLiteConfigurationClass(beanDef)) {
			//果BeanDefinition中的configurationClass属性为full或者lite,则意味着已经处理过了,直接跳过
			//这里需要结合下面的代码才能理解
			if (logger.isDebugEnabled()) {
				logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
			}
		}
		//判断是否是Configuration类，如果加了Configuration下面的这几个注解就不再判断了
		//                          add(Component.class.getName());
		//		candidateIndicators.add(ComponentScan.class.getName());
		//		candidateIndicators.add(Import.class.getName());
		//		candidateIndicators.add(ImportResource.class.getName());
		// beanDef == appconfig
		else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
			//BeanDefinitionHolder 也可以看成一个数据结构
			configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
		}
	}

	// Return immediately if no @Configuration classes were found
	//如果没有配置类就直接返回
	if (configCandidates.isEmpty()) {
		return;
	}

	// 排序，根据order,不重要
	// Sort by previously determined @Order value, if applicable
	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;
	// 如果BeanDefinitionRegistry是SingletonBeanRegistry子类的话, 由于我们当前传入的是DefaultListableBeanFactory,是SingletonBeanRegistry 的子类
	// 因此会将registry强转为SingletonBeanRegistry
	if (registry instanceof SingletonBeanRegistry) {
		sbr = (SingletonBeanRegistry) registry;
		if (!this.localBeanNameGeneratorSet) {
			//是否有自定义的
			BeanNameGenerator generator = (BeanNameGenerator) sbr.getSingleton(CONFIGURATION_BEAN_NAME_GENERATOR);
			//SingletonBeanRegistry中有id为 org.springframework.context.annotation.internalConfigurationBeanNameGenerator
			//如果有则利用他的，否则则是spring默认的
			if (generator != null) {
				this.componentScanBeanNameGenerator = generator;
				this.importBeanNameGenerator = generator;
			}
		}
	}

	if (this.environment == null) {
		this.environment = new StandardEnvironment();
	}

	// Parse each @Configuration class
	//实例化ConfigurationClassParser 为了解析各个配置类
	ConfigurationClassParser parser = new ConfigurationClassParser(
			this.metadataReaderFactory, this.problemReporter, this.environment,
			this.resourceLoader, this.componentScanBeanNameGenerator, registry);

	//实例化2个set,candidates用于将之前加入的configCandidates进行去重
	//因为可能有多个配置类重复了
	Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
	//alreadyParsed用于判断是否处理过
	Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
	do {
		parser.parse(candidates);
		parser.validate();
		//map.keyset
		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());
		}

		/**
			* 这里值得注意的是扫描出来的bean当中可能包含了特殊类 比如ImportBeanDefinitionRegistrar那么也在这个方法里面处理
			* 但是并不是包含在configClasses当中  configClasses当中主要包含的是importSelector
			* 因为ImportBeanDefinitionRegistrar在扫描出来的时候已经被添加到一个list当中去了
			*/

		//bd 到 map 除却普通
		this.reader.loadBeanDefinitions(configClasses);
		alreadyParsed.addAll(configClasses);

		candidates.clear();
		//由于我们这里进行了扫描，把扫描出来的BeanDefinition注册给了factory
		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();
	}
}

1、的到bd当中描述的类的元数据（类的信息）
2、判断是不是加了@Configuration   metadata.isAnnotated(Configuration.class.getName())
3、如果加了@Configuration，添加到一个set当中,把这个set传给下面的方法去解析

public static boolean checkConfigurationClassCandidate(BeanDefinition beanDef, MetadataReaderFactory metadataReaderFactory) {
	String className = beanDef.getBeanClassName();
	if (className == null || beanDef.getFactoryMethodName() != null) {
		return false;
	}

	AnnotationMetadata metadata;
	if (beanDef instanceof AnnotatedBeanDefinition &&
			className.equals(((AnnotatedBeanDefinition) beanDef).getMetadata().getClassName())) { 
		//如果BeanDefinition 是 AnnotatedBeanDefinition的实例,并且className 和 BeanDefinition中 的元数据 的类名相同
		// 则直接从BeanDefinition 获得Metadata
		metadata = ((AnnotatedBeanDefinition) beanDef).getMetadata();
	}
	else if (beanDef instanceof AbstractBeanDefinition && ((AbstractBeanDefinition) beanDef).hasBeanClass()) { 
		//如果BeanDefinition 是 AbstractBeanDefinition的实例,并且beanDef 有 beanClass 属性存在
		//则实例化StandardAnnotationMetadata
		Class<?> beanClass = ((AbstractBeanDefinition) beanDef).getBeanClass();
		metadata = new StandardAnnotationMetadata(beanClass, true);
	}
	else {
		try {
			MetadataReader metadataReader = metadataReaderFactory.getMetadataReader(className);
			metadata = metadataReader.getAnnotationMetadata();
		}
		catch (IOException ex) {
			if (logger.isDebugEnabled()) {
				logger.debug("Could not find class file for introspecting configuration annotations: " + className, ex);
			}
			return false;
		}
	}

	//判断当前这个bd中存在的类是不是加了@Configruation注解
	//如果存在则spring认为他是一个全注解的类
	if (isFullConfigurationCandidate(metadata)) {
		//如果存在Configuration 注解,则为BeanDefinition 设置configurationClass属性为full
		beanDef.setAttribute(CONFIGURATION_CLASS_ATTRIBUTE, CONFIGURATION_CLASS_FULL);
	}
	//判断是否加了以下注解，摘录isLiteConfigurationCandidate的源码
	//     candidateIndicators.add(Component.class.getName());
	//		candidateIndicators.add(ComponentScan.class.getName());
	//		candidateIndicators.add(Import.class.getName());
	//		candidateIndicators.add(ImportResource.class.getName());
	//如果不存在Configuration注解，spring则认为是一个部分注解类
	else if (isLiteConfigurationCandidate(metadata)) {
		beanDef.setAttribute(CONFIGURATION_CLASS_ATTRIBUTE, CONFIGURATION_CLASS_LITE);
	}
	else {
		return false;
	}

	// It's a full or lite configuration candidate... Let's determine the order value, if any.
	Integer order = getOrder(metadata);
	if (order != null) {
		beanDef.setAttribute(ORDER_ATTRIBUTE, order);
	}

	return true;
}

org.springframework.context.annotation.ConfigurationClassParser#parse(java.util.Set<org.springframework.beans.factory.config.BeanDefinitionHolder>)

public void parse(Set<BeanDefinitionHolder> configCandidates) {
	this.deferredImportSelectors = new LinkedList<>();
	//根据BeanDefinition 的类型 做不同的处理,一般都会调用ConfigurationClassParser#parse 进行解析
	for (BeanDefinitionHolder holder : configCandidates) {
		BeanDefinition bd = holder.getBeanDefinition();
		//
		try {
			if (bd instanceof AnnotatedBeanDefinition) {
				//解析注解对象，并且把解析出来的bd放到map，但是这里的bd指的是普通的
				//何谓不普通的呢？比如@Bean 和各种beanFactoryPostProcessor得到的bean不在这里put
				//但是是这里解析，只是不put而已
				parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());
			}
			else if (bd instanceof AbstractBeanDefinition && ((AbstractBeanDefinition) bd).hasBeanClass()) {
				parse(((AbstractBeanDefinition) bd).getBeanClass(), holder.getBeanName());
			}
			else {
				parse(bd.getBeanClassName(), holder.getBeanName());
			}
		}
		catch (BeanDefinitionStoreException ex) {
			throw ex;
		}
		catch (Throwable ex) {
			throw new BeanDefinitionStoreException(
					"Failed to parse configuration class [" + bd.getBeanClassName() + "]", ex);
		}
	}

	//处理延迟加载的importSelect？为什么要延迟加载，估计就是为了延迟吧
	processDeferredImportSelectors();
}

注册beanPostProcessor（registerBeanPostProcessors(beanFactory);）

注意不是BeanFactoryPostProcessor，此接口有两个方法: postProcessBeforeInitialization 和 postProcessAfterInitialization分别会在Bean初始化之前和初始化之后得到执行。

public static void registerBeanPostProcessors(
		ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {

	//从beanDefinitionMap中得到所有的BeanPostProcessor
	String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

	// Register BeanPostProcessorChecker that logs an info message when
	// a bean is created during BeanPostProcessor instantiation, i.e. when
	// a bean is not eligible for getting processed by all BeanPostProcessors.
	int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
	beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

	// Separate between BeanPostProcessors that implement PriorityOrdered,
	// Ordered, and the rest.
	List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
	List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
	List<String> orderedPostProcessorNames = new ArrayList<>();
	List<String> nonOrderedPostProcessorNames = new ArrayList<>();
	for (String ppName : postProcessorNames) {
		if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
			BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
			priorityOrderedPostProcessors.add(pp);
			if (pp instanceof MergedBeanDefinitionPostProcessor) {
				internalPostProcessors.add(pp);
			}
		}
		else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
			orderedPostProcessorNames.add(ppName);
		}
		else {
			nonOrderedPostProcessorNames.add(ppName);
		}
	}
//		priorityOrderedPostProcessors.remove(1);
	// First, register the BeanPostProcessors that implement PriorityOrdered.
	sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
	registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

	// Next, register the BeanPostProcessors that implement Ordered.
	List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>();
	for (String ppName : orderedPostProcessorNames) {
		BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
		orderedPostProcessors.add(pp);
		if (pp instanceof MergedBeanDefinitionPostProcessor) {
			internalPostProcessors.add(pp);
		}
	}
	sortPostProcessors(orderedPostProcessors, beanFactory);
	registerBeanPostProcessors(beanFactory, orderedPostProcessors);

	// Now, register all regular BeanPostProcessors.
	List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
	for (String ppName : nonOrderedPostProcessorNames) {
		BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
		nonOrderedPostProcessors.add(pp);
		if (pp instanceof MergedBeanDefinitionPostProcessor) {
			internalPostProcessors.add(pp);
		}
	}
	registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

	// Finally, re-register all internal BeanPostProcessors.
//		internalPostProcessors.remove(1);
	sortPostProcessors(internalPostProcessors, beanFactory);

	registerBeanPostProcessors(beanFactory, internalPostProcessors);

	// Re-register post-processor for detecting inner beans as ApplicationListeners,
	// moving it to the end of the processor chain (for picking up proxies etc).
	beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}

初始化当前 ApplicationContext 的 MessageSource

protected void initMessageSource() {
	ConfigurableListableBeanFactory beanFactory = getBeanFactory();
	//查找是否包含了名为messageSource的bean，如果没有，创建一个默认的
	if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
		this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
		// Make MessageSource aware of parent MessageSource.
		//判断是否有父类且是一个分层级的messageSource，如果是将父容器的的messageSource设置到里边
		if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
			HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;
			if (hms.getParentMessageSource() == null) {
				// Only set parent context as parent MessageSource if no parent MessageSource
				// registered already.
				hms.setParentMessageSource(getInternalParentMessageSource());
			}
		}
		if (logger.isDebugEnabled()) {
			logger.debug("Using MessageSource [" + this.messageSource + "]");
		}
	}
	else {
		// Use empty MessageSource to be able to accept getMessage calls.
		DelegatingMessageSource dms = new DelegatingMessageSource();
		dms.setParentMessageSource(getInternalParentMessageSource());
		this.messageSource = dms;
		beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
		if (logger.isDebugEnabled()) {
			logger.debug("Unable to locate MessageSource with name '" + MESSAGE_SOURCE_BEAN_NAME +
					"': using default [" + this.messageSource + "]");
		}
	}
}

初始化应用事件广播器

protected void initApplicationEventMulticaster() {
	ConfigurableListableBeanFactory beanFactory = getBeanFactory();
	// 如果用户配置了自定义事件广播器，就使用用户的
	if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
		this.applicationEventMulticaster =
				beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
		if (logger.isDebugEnabled()) {
			logger.debug("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
		}
	}
	else {
		// 使用默认的时间广播器
		this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
		beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
		if (logger.isDebugEnabled()) {
			logger.debug("Unable to locate ApplicationEventMulticaster with name '" +
					APPLICATION_EVENT_MULTICASTER_BEAN_NAME +
					"': using default [" + this.applicationEventMulticaster + "]");
		}
	}
}

初始化其他

1 2	// TODO:扩展点比如初始化其他特殊的bean onRefresh();

完成此上下文的bean工厂的初始化，初始化所有剩余的单例bean。

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
	// Initialize conversion service for this context.
	if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
			beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
		beanFactory.setConversionService(
				beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
	}
	if (!beanFactory.hasEmbeddedValueResolver()) {
		beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
	}

	// 先初始化 LoadTimeWeaverAware 类型的 Bean
	String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
	for (String weaverAwareName : weaverAwareNames) {
		getBean(weaverAwareName);
	}
	// 停止使用用于类型匹配的临时类加载器
	beanFactory.setTempClassLoader(null);
	// 冻结所有的bean定义，即已注册的bean定义将不会被修改或后处理
	beanFactory.freezeConfiguration();
	//实例化所有的单例对象
	beanFactory.preInstantiateSingletons();
}

发布事件

protected void finishRefresh() {
	//清除上下文级别的资源缓存（例如来自扫描的ASM元数据）
	clearResourceCaches();
	// 初始化LifecycleProcessor
	initLifecycleProcessor();
	// 这个方法的内部实现是启动所有实现了Lifecycle接口的bean
	getLifecycleProcessor().onRefresh();
	// 发布ContextRefreshedEvent事件
	publishEvent(new ContextRefreshedEvent(this));
	// 检查spring.liveBeansView.mbeanDomain是否存在，有就会创建一个MBeanServer
	LiveBeansView.registerApplicationContext(this);
}

spring初始化bean工厂的过程

Bean的加载

refresh()还调用了很多后处理器的方法，其中有一个方法 finishBeanFactoryInitialization()，意味着非延迟加载的类，将在这一步实例化，完成类的加载。

当我们显示或者隐式地调用 BeanFactory#getBean(String name) 方法时，则会触发加载 Bean 阶段。

@Override
public Object getBean(String name) throws BeansException {
	return doGetBean(name, null, null, false);
}

protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
			@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
	/**
		* 通过 name 获取 beanName。这里不使用 name 直接作为 beanName 有两个原因
		* 1、name 可能会以 & 字符开头，表明调用者想获取 FactoryBean 本身，而非 FactoryBean 实现类所创建的 bean。
		* 	在 BeanFactory 中，FactoryBean 的实现类和其他的 bean 存储方式是一致的，即 <beanName, bean>，beanName 中是没有 & 这个字符的。
		*  所以我们需要 将 name 的首字符 & 移除，这样才能从缓存里取到 FactoryBean 实例。
		* 2、还是别名的问题，转换需要 &beanName
		*/
	final String beanName = transformedBeanName(name);
	Object bean;
 
	/**
		* 这个方法在初始化的时候会调用，在getBean的时候也会调用 为什么需要这么做呢？
		* 也就是说spring在初始化的时候先获取这个对象 判断这个对象是否被实例化好了(普通情况下绝对为空====有一种情况可能不为空)
		*
		* 从spring的bean容器中获取一个bean，由于spring中bean容器是一个map（singletonObjects）
		* 所以你可以理解getSingleton(beanName)等于beanMap.get(beanName)
		* 由于方法会在spring环境初始化的时候（就是对象被创建的时候调用一次）调用一次 还会在getBean的时候调用一次
		*
		* 所以再调试的时候需要特别注意，不能直接断点在这里， 需要先进入到annotationConfigApplicationContext.getBean(IndexDao.class)
		* 之后再来断点，这样就确保了我们是在获取这个bean的时候调用的
		*
		* 需要说明的是在初始化时候调用一般都是返回null
		*
		* lazy
		*/
	Object sharedInstance = getSingleton(beanName);
	//如果已经初始化过了，且没有传args参数就代表是get，直接取出返回
	if (sharedInstance != null && args == null) {
		//这里的代码是对于日志的记录，方便我们以后阅读应该注释，不影响spring功能
		if (logger.isDebugEnabled()) {
			if (isSingletonCurrentlyInCreation(beanName)) {
				logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
						"' that is not fully initialized yet - a consequence of a circular reference");
			}
			else {
				logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
			}
		}

		/**
			* 如果 sharedInstance 是普通的单例 bean，下面的方法会直接返回。但如果sharedInstance 是 FactoryBean 类型的，
			* 则需调用 getObject 工厂方法获取真正的bean 实例。
			*
			* 如果用户想获取 FactoryBean 本身，这里也不会做特别的处理，直接返回即可。毕竟 FactoryBean 的实现类本身也是一种 bean，只不过具有一点特殊的功能而已。
			*/
		bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
	}

	else {
		/**
			* 原型
			* 如果是原型不应该在初始化的时候创建
			*/
		if (isPrototypeCurrentlyInCreation(beanName)) {
			throw new BeanCurrentlyInCreationException(beanName);
		}

		// Check if bean definition exists in this factory.
		// 如果当前BeanDefinition不存在这个bean且具有父BeanFactory
		BeanFactory parentBeanFactory = getParentBeanFactory();
		if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
			// Not found -> check parent.
			String nameToLookup = originalBeanName(name);
			// 返回父容器的查询结果
			if (parentBeanFactory instanceof AbstractBeanFactory) {
				return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
						nameToLookup, requiredType, args, typeCheckOnly);
			}
			else if (args != null) {
				// Delegation to parent with explicit args.
				return (T) parentBeanFactory.getBean(nameToLookup, args);
			}
			else {
				// No args -> delegate to standard getBean method.
				return parentBeanFactory.getBean(nameToLookup, requiredType);
			}
		}
		if (!typeCheckOnly) {
			//添加到alreadyCreated set集合当中，表示他已经创建过
			markBeanAsCreated(beanName);
		}
		// 创建bean
		try {
			final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
			checkMergedBeanDefinition(mbd, beanName, args);

			// Guarantee initialization of beans that the current bean depends on.
			// 先初始化依赖的所有 Bean， depends-on 中定义的依赖
			String[] dependsOn = mbd.getDependsOn();
			if (dependsOn != null) {
				for (String dep : dependsOn) {
					// 检查是不是有循环依赖
					if (isDependent(beanName, dep)) {
						throw new BeanCreationException(mbd.getResourceDescription(), beanName,
								"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
					}
					// 注册一下依赖关系
					registerDependentBean(dep, beanName);
					try {
						// 先初始化被依赖项
						getBean(dep);
					}
					catch (NoSuchBeanDefinitionException ex) {
						throw new BeanCreationException(mbd.getResourceDescription(), beanName,
								"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
					}
				}
			}
			// 如果是单例的 
			if (mbd.isSingleton()) {
				sharedInstance = getSingleton(beanName, () -> {
					try {
						// create bean
						return createBean(beanName, mbd, args);
					}
					catch (BeansException ex) {
						// Explicitly remove instance from singleton cache: It might have been put there
						// eagerly by the creation process, to allow for circular reference resolution.
						// Also remove any beans that received a temporary reference to the bean.
						destroySingleton(beanName);
						throw ex;
					}
				});
				bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
			}
			// 如果是prototype
			else if (mbd.isPrototype()) {
				// It's a prototype -> create a new instance.
				Object prototypeInstance = null;
				try {
					beforePrototypeCreation(beanName);
					// 执行创建 Bean
					prototypeInstance = createBean(beanName, mbd, args);
				}
				finally {
					afterPrototypeCreation(beanName);
				}
				bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
			}
			// 如果不是 singleton 和 prototype 那么就是自定义的scope、例如Web项目中的session等类型，这里就交给自定义scope的应用方去实现
			else {
				String scopeName = mbd.getScope();
				final Scope scope = this.scopes.get(scopeName);
				if (scope == null) {
					throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
				}
				try {
					Object scopedInstance = scope.get(beanName, () -> {
						beforePrototypeCreation(beanName);
						try {
							return createBean(beanName, mbd, args);
						}
						finally {
							afterPrototypeCreation(beanName);
						}
					});
					bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
				}
				catch (IllegalStateException ex) {
					throw new BeanCreationException(beanName,
							"Scope '" + scopeName + "' is not active for the current thread; consider " +
							"defining a scoped proxy for this bean if you intend to refer to it from a singleton",
							ex);
				}
			}
		}
		catch (BeansException ex) {
			cleanupAfterBeanCreationFailure(beanName);
			throw ex;
		}
	}

	// Check if required type matches the type of the actual bean instance.
	//检查bean的类型
	if (requiredType != null && !requiredType.isInstance(bean)) {
		try {
			T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
			if (convertedBean == null) {
				throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
			}
			return convertedBean;
		}
		catch (TypeMismatchException ex) {
			if (logger.isDebugEnabled()) {
				logger.debug("Failed to convert bean '" + name + "' to required type '" +
						ClassUtils.getQualifiedName(requiredType) + "'", ex);
			}
			throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
		}
	}
	return (T) bean;
}

#doGetBean(…) 方法的代码量比较多，可以看出 bean 的加载过程是一个非常复杂的过程，会涉及到各种各样的情况处理。

可以分为以下几个过程：

转换 beanName，方法传入的 name 并不一定就是 beanName，可以传入 aliasName，FactoryBean，所以这里需要进行简单的转换过程。
尝试从缓存中加载单例 bean。
bean的实例化。
原型模式的依赖检查。Spring只会解决单例模式的循环依赖，对于原型模式的循环依赖都是直接抛出 BeanCurrentlyInCreationException 异常。
尝试从 parentBeanFactory 获取 bean 实例。如果 parentBeanFactory != null && !containsBeanDefinition(beanName) 则尝试从 parentBeanFactory 中获取 bean 实例对象，因为 !containsBeanDefinition(beanName) 就意味着定义的 xml 文件中没有 beanName 相应的配置，这个时候就只能从 parentBeanFactory 中获取。
获取 RootBeanDefinition，并对其进行合并检查。从缓存中获取已经解析的 RootBeanDefinition 。同时，如果父类不为 null 的话，则会合并父类的属性。
依赖检查。某个 bean 依赖其他 bean ，则需要先加载依赖的 bean。
对不同的 scope 进行处理。
类型转换处理。如果传递的 requiredType 不为 null，则需要检测所得到 bean 的类型是否与该 requiredType 一致。如果不一致则尝试转换，当然也要能够转换成功，否则抛出 BeanNotOfRequiredTypeException 异常。

获取原始beanName

protected String transformedBeanName(String name) {
		return canonicalName(BeanFactoryUtils.transformedBeanName(name));
	}
BeanFactoryUtils.transformedBeanName(name)方法主要是去除 FactoryBean 的修饰符

//对FactoryBean的转义定义，因为如果使用bean的名字检索FactoryBean得到的对象是工厂生成的对象，
	//如果需要得到工厂本身，需要转义
	String FACTORY_BEAN_PREFIX = "&";

public static String transformedBeanName(String name) {
	Assert.notNull(name, "'name' must not be null");
	String beanName = name;
	while (beanName.startsWith(BeanFactory.FACTORY_BEAN_PREFIX)) {
		beanName = beanName.substring(BeanFactory.FACTORY_BEAN_PREFIX.length());
	}
	return beanName;
}

//循环处理，从aliasMap中根据aliasName获取真实beanName，直到获取到的真实beanName为null
public String canonicalName(String name) {
	String canonicalName = name;
	// Handle aliasing...
	String resolvedName;
	do {
		resolvedName = this.aliasMap.get(canonicalName);
		if (resolvedName != null) {
			canonicalName = resolvedName;
		}
	}
	while (resolvedName != null);
	return canonicalName;
}

从缓存中获取单例bean

//单例bean的缓存
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
 
//单例对象工厂缓存
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
 
//预加载单例bean缓存
//存放的 bean 不一定是完整的
private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);

//对于单例模式的Bean整个IOC容器中只创建一次，不需要重复创建
@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
	//从单例缓存中获取单例bean
	Object singletonObject = this.singletonObjects.get(beanName);
	//如果缓存中没有 并且 该bean正在创建
	if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
		synchronized (this.singletonObjects) {
			singletonObject = this.earlySingletonObjects.get(beanName);
			// earlySingletonObjects 中没有，且允许提前创建
			if (singletonObject == null && allowEarlyReference) {
				//从缓存中获取 ObjectFactory
				ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
				if (singletonFactory != null) {
					//从单例工厂中获取bean
					singletonObject = singletonFactory.getObject();
					//存入early
					this.earlySingletonObjects.put(beanName, singletonObject);
					this.singletonFactories.remove(beanName);
				}
			}
		}
	}
	return singletonObject;
}

该方法就是从 singletonObjects、earlySingletonObjects、 singletonFactories 三个缓存中获取，这里也是 Spring 解决 bean 循环依赖的关键之处。

第一步，从singletonObjects中获取Bean对象

第二步，如果获取不到且Bean正在创建中，从earlySingletonObjects获取Bean对象

第三步，如果获取不到且允许提前创建,从singletonFactories获取FactoryBean

第四步，如果不为null，则通过FactoryBean.getObject()获取Bean，然后将其加入到 earlySingletonObjects ，并且从 singletonFactories 删除，两者是互斥的，主要用来解决循环依赖的问题

创建 bean 实例对象

如果缓存中没有，也没有 parentBeanFactory ，则会调用 #createBean(String beanName, RootBeanDefinition mbd, Object[] args) 方法，创建 bean 实例。

1
2
3

// AbstractBeanFactory.java
protected abstract Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
            throws BeanCreationException;

抽象方法的默认实现是在类 AbstractAutowireCapableBeanFactory 中实现，该方法其实只是做一些检查和验证工作，真正的初始化工作是由 #doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) 方法来实现。

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
		throws BeanCreationException {
	BeanWrapper instanceWrapper = null;
	if (mbd.isSingleton()) {
		//如果是.factoryBean则从缓存删除
		instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
	}
	if (instanceWrapper == null) {
		/**
			* 创建 bean 实例，并将实例包裹在 BeanWrapper 实现类对象中返回。
			* createBeanInstance中包含三种创建 bean 实例的方式：
			*   1. 通过工厂方法创建 bean 实例
			*   2. 通过构造方法自动注入（autowire by constructor）的方式创建 bean 实例
			*   3. 通过无参构造方法方法创建 bean 实例
			*
			* 若 bean 的配置信息中配置了 lookup-method 和 replace-method，则会使用 CGLIB
			* 增强 bean 实例。关于lookup-method和replace-method
			*/
		instanceWrapper = createBeanInstance(beanName, mbd, args);
	}
	final Object bean = instanceWrapper.getWrappedInstance();
	Class<?> beanType = instanceWrapper.getWrappedClass();
	if (beanType != NullBean.class) {
		mbd.resolvedTargetType = beanType;
	}

	// Allow post-processors to modify the merged bean definition.
	synchronized (mbd.postProcessingLock) {
		if (!mbd.postProcessed) {
			try {
				// 循环调用实现了MergedBeanDefinitionPostProcessor接口的postProcessMergedBeanDefinition方法
				// Spring对这个接口有几个默认的实现，其中大家最熟悉的一个是操作@Autowired注解的
				applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
			}
			catch (Throwable ex) {
				throw new BeanCreationException(mbd.getResourceDescription(), beanName,
						"Post-processing of merged bean definition failed", ex);
			}
			mbd.postProcessed = true;
		}
	}

	// Eagerly cache singletons to be able to resolve circular references
	// even when triggered by lifecycle interfaces like BeanFactoryAware.
	// 解决循环依赖问题
	boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
			isSingletonCurrentlyInCreation(beanName));
	if (earlySingletonExposure) {
		if (logger.isDebugEnabled()) {
			logger.debug("Eagerly caching bean '" + beanName +
					"' to allow for resolving potential circular references");
		}
		//当正在创建A时，A依赖B，此时通过（B将A作为ObjectFactory放入单例工厂中进行early expose，此处B需要引用A，但A正在创建，从单例工厂拿到ObjectFactory，从而允许循环依赖)
		addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
	}

	// Initialize the bean instance.
	Object exposedObject = bean;
	try {
		//设置属性，非常重要
		populateBean(beanName, mbd, instanceWrapper);
		// 这里是处理bean初始化完成后的各种回调，例如init-method、InitializingBean 接口、BeanPostProcessor 接口
		// aop就是在这里完成的处理
		exposedObject = initializeBean(beanName, exposedObject, mbd);
	}
	catch (Throwable ex) {
		if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
			throw (BeanCreationException) ex;
		}
		else {
			throw new BeanCreationException(
					mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
		}
	}

	// 同样的，如果存在循环依赖
	if (earlySingletonExposure) {
		Object earlySingletonReference = getSingleton(beanName, false);
		if (earlySingletonReference != null) {
			if (exposedObject == bean) {
				exposedObject = earlySingletonReference;
			}
			else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
				String[] dependentBeans = getDependentBeans(beanName);
				Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
				for (String dependentBean : dependentBeans) {
					if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
						actualDependentBeans.add(dependentBean);
					}
				}
				if (!actualDependentBeans.isEmpty()) {
					throw new BeanCurrentlyInCreationException(beanName,
							"Bean with name '" + beanName + "' has been injected into other beans [" +
							StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
							"] in its raw version as part of a circular reference, but has eventually been " +
							"wrapped. This means that said other beans do not use the final version of the " +
							"bean. This is often the result of over-eager type matching - consider using " +
							"'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
				}
			}
		}
	}

	// Register bean as disposable.
	// 把bean注册到相应的Scope中
	try {
		registerDisposableBeanIfNecessary(beanName, bean, mbd);
	}
	catch (BeanDefinitionValidationException ex) {
		throw new BeanCreationException(
				mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
	}

	return exposedObject;
}

实例化 bean

如果缓存中没有 BeanWrapper 实例对象或者该 bean 不是 singleton，则调用 createBeanInstance方法创建 bean 实例。

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
	// Make sure bean class is actually resolved at this point.
	// 确保已经加载了此 class
	Class<?> beanClass = resolveBeanClass(mbd, beanName);

	// 检测一个类的访问权限spring默认情况下对于非public的类是允许访问的。
	if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
		throw new BeanCreationException(mbd.getResourceDescription(), beanName,
				"Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
	}

	Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
	if (instanceSupplier != null) {
		return obtainFromSupplier(instanceSupplier, beanName);
	}

	/**
	 * 采用工厂方法实例化
	 * 如果工厂方法不为空，则通过工厂方法构建 bean 对象
	 */
	if (mbd.getFactoryMethodName() != null)  {
		return instantiateUsingFactoryMethod(beanName, mbd, args);
	}

	// Shortcut when re-creating the same bean...
	/**
	 * 从spring的原始注释可以知道这个是一个Shortcut，什么意思呢？
	 * 当多次构建同一个 bean 时，可以使用这个Shortcut， 也就是说不在需要次推断应该使用哪种方式构造bean
	 *  比如在多次构建同一个prototype类型的 bean 时，就可以走此处的shortcut
	 * 这里的 resolved 和 mbd.constructorArgumentsResolved 将会在 bean 第一次实例化的过程中被设置
	 */
	// 是否第一次
	boolean resolved = false;
	// 是否采用构造函数注入
	boolean autowireNecessary = false;
	if (args == null) {
		synchronized (mbd.constructorArgumentLock) {
			if (mbd.resolvedConstructorOrFactoryMethod != null) {
				resolved = true;
				//如果已经解析了构造方法的参数，则必须要通过一个带参构造方法来实例
				autowireNecessary = mbd.constructorArgumentsResolved;
			}
		}
	}
	if (resolved) {
		if (autowireNecessary) {
			// 通过构造方法自动装配的方式构造 bean 对象
			return autowireConstructor(beanName, mbd, null, null);
		}
		else {
			//通过默认的无参构造方法进行
			return instantiateBean(beanName, mbd);
		}
	}

	// Candidate constructors for autowiring?
	//由后置处理器决定返回哪些构造方法
	Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
	if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
			mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args))  {
		return autowireConstructor(beanName, mbd, ctors, args);
	}

	// No special handling: simply use no-arg constructor.
	//使用默认的无参构造方法进行初始化
	return instantiateBean(beanName, mbd);
}

属性填充

属性填充其实就是将 BeanDefinition 的属性值赋值给 BeanWrapper 实例对象的过程。

protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
	if (bw == null) {
		if (mbd.hasPropertyValues()) {
			throw new BeanCreationException(
					mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
		}
		else {
			// Skip property population phase for null instance.
			return;
		}
	}

	// Give any InstantiationAwareBeanPostProcessors the opportunity to modify the
	// state of the bean before properties are set. This can be used, for example,
	// to support styles of field injection.
	boolean continueWithPropertyPopulation = true;

	if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
		for (BeanPostProcessor bp : getBeanPostProcessors()) {
			if (bp instanceof InstantiationAwareBeanPostProcessor) {
				InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
				// 如果返回 false，代表不需要进行后续的属性设值，也不需要再经过其他的 BeanPostProcessor 的处理
				if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
					continueWithPropertyPopulation = false;
					break;
				}
			}
		}
	}

	if (!continueWithPropertyPopulation) {
		return;
	}

	// bean的所有属性
	PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);

	if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME || mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {
		MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
		// Add property values based on autowire by name if applicable.
		// 通过名字找到所有属性值，如果是 bean 依赖，先初始化依赖的 bean。记录依赖关系
		if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME) {
			autowireByName(beanName, mbd, bw, newPvs);
		}
		// Add property values based on autowire by type if applicable.
		// 通过类型装配。复杂一些
		if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {
			autowireByType(beanName, mbd, bw, newPvs);
		}
		pvs = newPvs;
	}

	boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
	boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);

	if (hasInstAwareBpps || needsDepCheck) {
		if (pvs == null) {
			pvs = mbd.getPropertyValues();
		}
		PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
		if (hasInstAwareBpps) {
			for (BeanPostProcessor bp : getBeanPostProcessors()) {
				if (bp instanceof InstantiationAwareBeanPostProcessor) {
					InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
					// 这里就是上方曾经提到过得对@Autowired处理的一个BeanPostProcessor了
					// 它会对所有标记@Autowired、@Value 注解的属性进行设值
					pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
					if (pvs == null) {
						return;
					}
				}
			}
		}
		if (needsDepCheck) {
			checkDependencies(beanName, mbd, filteredPds, pvs);
		}
	}

	if (pvs != null) {
		applyPropertyValues(beanName, mbd, bw, pvs);
	}
}

初始化 bean

protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
	if (System.getSecurityManager() != null) {
		AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
			invokeAwareMethods(beanName, bean);
			return null;
		}, getAccessControlContext());
	}
	else {
		invokeAwareMethods(beanName, bean);
	}

	Object wrappedBean = bean;
	if (mbd == null || !mbd.isSynthetic()) {
		//执行后置处理的befor
		wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
	}

	try {
		//执行bean的声明周期回调中的init方法
		invokeInitMethods(beanName, wrappedBean, mbd);
	}
	catch (Throwable ex) {
		throw new BeanCreationException(
				(mbd != null ? mbd.getResourceDescription() : null),
				beanName, "Invocation of init method failed", ex);
	}
	if (mbd == null || !mbd.isSynthetic()) {
		//执行后置处理器的after方法
		wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
	}

	return wrappedBean;
}

从 bean 实例中获取对象

无论是从单例缓存中获取的 bean 实例还是通过 createBean() 方法来创建的 bean 实例，最终调用getObjectForBeanInstance()方法，来获取最终的Bean实例。

//获取给定Bean的实例对象，主要是完成FactoryBean的相关处理
protected Object getObjectForBeanInstance(
		Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {
 
	//容器已经得到了Bean实例对象，这个实例对象可能是一个普通的Bean，
	//也可能是一个工厂Bean，如果是一个工厂Bean，则使用它创建一个Bean实例对象，
	//如果调用本身就想获得一个容器的引用，则指定返回这个工厂Bean实例对象

	//若为工厂类引用（name 以 & 开头） 且 Bean实例也不是 FactoryBean
	if (BeanFactoryUtils.isFactoryDereference(name) && !(beanInstance instanceof FactoryBean)) { 
		throw new BeanIsNotAFactoryException(transformedBeanName(name), beanInstance.getClass());
	}

	// Now we have the bean instance, which may be a normal bean or a FactoryBean.
	
	//如果类型不是FactoryBean，直接返回
	if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
		return beanInstance;
	}

	Object object = null;
	//若 BeanDefinition 为 null，则从缓存中加载 Bean 对象
	if (mbd == null) {
		//从Bean工厂缓存中获取给定名称的Bean实例对象
		object = getCachedObjectForFactoryBean(beanName);
	}

	// 若 object 依然为空，则可以确认，beanInstance 一定是 FactoryBean 。从而，使用 FactoryBean 获得 Bean 对象
	if (object == null) { 
		FactoryBean<?> factory = (FactoryBean<?>) beanInstance; 
		// 检测是否定义 beanName
		if (mbd == null && containsBeanDefinition(beanName)) {
			//从容器中获取指定名称的Bean定义，如果继承基类，则合并基类相关属性
			mbd = getMergedLocalBeanDefinition(beanName);
		}
		//如果从容器得到Bean定义信息，并且Bean定义信息不是虚构的，
		//则让工厂Bean生产Bean实例对象
		boolean synthetic = (mbd != null && mbd.isSynthetic());
		//调用FactoryBeanRegistrySupport类的getObjectFromFactoryBean方法，
		//实现工厂Bean生产Bean对象实例的过程
		object = getObjectFromFactoryBean(factory, beanName, !synthetic);
	}
	return object;
}

当该实例对象为非 FactoryBean 类型，直接返回给定的 Bean 实例对象 beanInstance 。当该实例对象为FactoryBean 类型，从 FactoryBean ( beanInstance ) 中，获取 Bean 实例对象。

getObjectFromFactoryBean

//Bean工厂生产Bean实例对象
protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
	//为单例模式且缓存中存在
	if (factory.isSingleton() && containsSingleton(beanName)) {
		//多线程同步，以防止数据不一致
		synchronized (getSingletonMutex()) {
			//从缓存中获取指定的 factoryBean
			Object object = this.factoryBeanObjectCache.get(beanName);
			if (object == null) {
				// 为空，则从 FactoryBean 中获取对象
				object = doGetObjectFromFactoryBean(factory, beanName); 
				Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
				if (alreadyThere != null) {
					object = alreadyThere;
				}
				else {
					if (shouldPostProcess) {
						try {
							// 对从 FactoryBean 获取的对象进行后处理 生成的对象将暴露给 bean 引用
							object = postProcessObjectFromFactoryBean(object, beanName);
						}
						catch (Throwable ex) {
							throw new BeanCreationException(beanName, "Post-processing of FactoryBean's singleton object failed", ex);
						}
					}
					//将生产的实例对象添加到Bean工厂缓存中
					this.factoryBeanObjectCache.put(beanName, object);
				}
			}
			return object;
		}
	}
	// 为空，则从 FactoryBean 中获取对象
	else {
		Object object = doGetObjectFromFactoryBean(factory, beanName);
		// 需要后续处理
		if (shouldPostProcess) {
			try {
				object = postProcessObjectFromFactoryBean(object, beanName);
			}
			catch (Throwable ex) {
				throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex);
			}
		}
		return object;
	}
}

Bean生命周期

20200516174812

结构