Bean生命周期（上）

流程

### scan（） 

​    记录当前spring有多少Bean  

​    doScan(basePackages)

​    AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);

​    记录扫描了多少Bean = 现在Bean -  初始Bean

#### doScan(basePackages)

​    for (String basePackage : basePackages) //可以传多个扫描路径

​        findCandidateComponents(basePackage); //（只得到BeanClass（BeanName）candidates）

​        for (BeanDefinition candidate : candidates)

​            解析Scope注解

​            生成BeanName

​            生成一些默认值 比如：单例

​            //解析@Lazy @Primary @DependOn @Role @Description(最后两个用的少)设置BeanDefination

​            checkCandidate(beanName, candidate)//检查是否有名字

​            注册到BeanDefinationMap中《Name，BD》

​            return set对象beanDefinitions《bdHolder《包含beanName》》

##### findCandidateComponents

​    indexSupportsIncludeFilters()//有没有索引走索引加快速度

​     scanCandidateComponents//没索引

###### scanCandidateComponents

​    确定扫描路径

​    MetadataReader

​    isCandidateComponent

​        //和排除过滤器匹配直接排除excludeFilters

​        //和includeFilters匹配那么加进来（@component已经注册到了include里面）再看是否符合@Conditional，不独立（内部类）、接口、抽象类（没有@Lookup注解方法）不能成为Bean，顶级类、静态内部类、抽象类（有@Lookup注解方法）是独立的

### finishBeanFactoryInitialization（初始化后的方法）

​    beanFactory.preInstantiateSingletons();//进入方法

#### beanFactory.preInstantiateSingletons()

for（）

​    判断是不是单例，是不是懒加载，BeanDefinition是不是抽象的

​    合并BeanDefinition mbd

​        单例非懒加载不抽象，生成Bean放入单例池    

上面的单例Bean是否实现了SmartInitializingSingleton,在for循环结束后执行的方法

是否实现了smartFactroyBean方法，实现了且isEagerInit=true执行，自动执行getBean（）；放入缓存（factoryBeanObjectCache）不是单例池中。

##### getBean

​    doGetBean（）

​        String beanName = this.transformedBeanName(name);
​        Object sharedInstance = this.getSingleton(beanName);  

​        sharedInstance 存在        

​            如果名字是&开头---》getObjectForBeanInstance（&xxx，xxx）----》（先缓存拿）执行自己的getObject（）

​            如果名字是&开头---》若从单例池拿到的对象不是FactoryBean的实例报错

​            如果名字不是&开头---》普通Bean单例池返回实例    

​            如果名字不是&开头---》普通BeanFactory（factoryBeanObjectCache）拿，执行自己的getObject（）

​        sharedInstance不存在创建

//扫描
public class ClassPathBeanDefinitionScanner extends ClassPathScanningCandidateComponentProvider {

    //单一职责的原则，不用DefaultListableBeanFactory（运行时是这个对象），
    //只需要注册BeanDefination
    private final BeanDefinitionRegistry registry;

    public int scan(String... basePackages) {
        //记录当前spring有多少Bean
        int beanCountAtScanStart = this.registry.getBeanDefinitionCount();

        doScan(basePackages);//重要方法

        // Register annotation config processors, if necessary.
        if (this.includeAnnotationConfig) {
            AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
        }

        //记录扫描了多少Bean = 现在Bean -  初始Bean
        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) {

            //进入 findCandidateComponents（只得到BeanClass（BeanName））
            Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
            
            //真正解析元数据
            for (BeanDefinition candidate : candidates) {
                ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
                candidate.setScope(scopeMetadata.getScopeName());//解析Scope注解
                
                String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);//生成BeanName
                if (candidate instanceof AbstractBeanDefinition) {
                    //生成一些默认值 比如：单例
                    postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
                }
                if (candidate instanceof AnnotatedBeanDefinition) {
                    //解析@Lazy @Primary @DependOn @Role @Description(最后两个用的少)设置BeanDefination
                    AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
                }
                
                //spring是否有beanName不包含返回True,有benaName返回异常（@Component（“name”）大部分），扫描两次可能会返回false（兼容），比如context.register(Appconfig1)、context.register(Appconfig2)会扫描两次
                if (checkCandidate(beanName, candidate)) {
                    
                    //BeanName和BeanDefination封装为BDHolder对象
                    
                    BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
                    definitionHolder =
                            AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
                    
                    
                    beanDefinitions.add(definitionHolder);
                    
                   //注册到BeanDefinationMap中《Name，BD》
                    registerBeanDefinition(definitionHolder, this.registry);
                }
            }
        }
        return beanDefinitions;
    }
}

 

public class ClassPathScanningCandidateComponentProvider implements EnvironmentCapable, ResourceLoaderAware {
    public Set<BeanDefinition> findCandidateComponents(String basePackage) {
        //举例
        if (this.componentsIndex != null && indexSupportsIncludeFilters()) {
            //如果需要扫描类太多，可以通过一些配置加快速度
            return addCandidateComponentsFromIndex(this.componentsIndex, basePackage);
            
        }


        //大部分走下面逻辑

        else {
            
            //只有一个BeanClass（BeanName）
            return scanCandidateComponents(basePackage);
        }
    }

    private Set<BeanDefinition> scanCandidateComponents(String basePackage) {
        Set<BeanDefinition> candidates = new LinkedHashSet<>();
        try {

            // String CLASSPATH_ALL_URL_PREFIX = "classpath*:";
            
            /*
            protected String resolveBasePackage(String basePackage) {
		return    ClassUtils.convertClassNameToResourcePath(getEnvironment().resolveRequiredPlaceholders(basePackage));
	}
	
	//拼凑之后classpath*:com/zhouyu/**/*.class
            //只找class在寻找dao时会有区别
            */


            //private String resourcePattern = DEFAULT_RESOURCE_PATTERN;
            //static final String DEFAULT_RESOURCE_PATTERN = 	"**/*.class";


            //class拼凑路径
            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);
                }
                if (resource.isReadable()) {
                    try {

                        //源数据读取器（ASM）

                        MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource);

                        //判断这个类是不是一个Bean(进入方法)

                        if (isCandidateComponent(metadataReader)) {

                            //注解、类名（Object类型，最开始是名字之后可能是Class）设置到sbd里面去

                            ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
                            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;
    }


    protected boolean isCandidateComponent(MetadataReader metadataReader) throws IOException {

        //和排除过滤器匹配直接排除

        for (TypeFilter tf : this.excludeFilters) {
            if (tf.match(metadataReader, getMetadataReaderFactory())) {
                return false;
            }
        }

        //和includeFilters匹配那么加进来（@component已经注册到了include里面）再看是否符合@Conditional

        for (TypeFilter tf : this.includeFilters) {
            if (tf.match(metadataReader, getMetadataReaderFactory())) {
                //再看是否符合@Conditional没有这个注解直接符合（举例如下）
                return isConditionMatch(metadataReader);
            }
        }
        return false;
    }

    //重载方法
    protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {
        AnnotationMetadata metadata = beanDefinition.getMetadata();

        //不独立（内部类）、接口、抽象类（没有@Lookup注解方法）不能成为Bean，顶级类、静态内部类、抽象类（有@Lookup注解方法）是独立的
        return (metadata.isIndependent() && (metadata.isConcrete() ||
                (metadata.isAbstract() && metadata.hasAnnotatedMethods(Lookup.class.getName()))));
    }


}

//名字设置的一些类方法（@Component（“value”）取出value）

public class AnnotationBeanNameGenerator implements BeanNameGenerator {

	private static final String COMPONENT_ANNOTATION_CLASSNAME = "org.springframework.stereotype.Component";


@Override
	public String generateBeanName(BeanDefinition definition, BeanDefinitionRegistry registry) {
		if (definition instanceof AnnotatedBeanDefinition) {
			String beanName = determineBeanNameFromAnnotation((AnnotatedBeanDefinition) definition);
			if (StringUtils.hasText(beanName)) {
				// Explicit bean name found.
				return beanName;
			}
		}
		
		// Fallback: generate a unique default bean name.有名字直接返回
		
		//没有名字创建名字（user（User） ABcd（ABcd））
		return buildDefaultBeanName(definition, registry);
	}
	
	@Nullable
	protected String determineBeanNameFromAnnotation(AnnotatedBeanDefinition annotatedDef) {
		AnnotationMetadata amd = annotatedDef.getMetadata();
		Set<String> types = amd.getAnnotationTypes();
		String beanName = null;
		for (String type : types) {
			AnnotationAttributes attributes = AnnotationConfigUtils.attributesFor(amd, type);
			if (attributes != null) {
				Set<String> metaTypes = this.metaAnnotationTypesCache.computeIfAbsent(type, key -> {
					Set<String> result = amd.getMetaAnnotationTypes(key);
					return (result.isEmpty() ? Collections.emptySet() : result);
				});
				if (isStereotypeWithNameValue(type, metaTypes, attributes)) {
					Object value = attributes.get("value");
					if (value instanceof String) {
						String strVal = (String) value;
						if (StringUtils.hasLength(strVal)) {
							if (beanName != null && !strVal.equals(beanName)) {
								throw new IllegalStateException("Stereotype annotations suggest inconsistent " +
										"component names: '" + beanName + "' versus '" + strVal + "'");
							}
							beanName = strVal;
						}
					}
				}
			}
		}
		return beanName;
	}
	
	protected boolean isStereotypeWithNameValue(String annotationType,
			Set<String> metaAnnotationTypes, @Nullable Map<String, Object> attributes) {

		boolean isStereotype = annotationType.equals(COMPONENT_ANNOTATION_CLASSNAME) ||
				metaAnnotationTypes.contains(COMPONENT_ANNOTATION_CLASSNAME) ||
				annotationType.equals("javax.annotation.ManagedBean") ||
				annotationType.equals("javax.inject.Named");

		return (isStereotype && attributes != null && attributes.containsKey("value"));
	}
}

//this.componentsIndex（配置加快速度）(只找这个类判断是不是Bean，要加@Component)
-resource
    -META-INF
    	-spring.components
    com.zhouyu.service.UserService=org.springframework.stereotype.Component

//@Conditional注解作用
@Component
@Conditional(ZhouyuCondition.class)
public class UserService {


    public void test(){
        System.out.println("test");
    }

}

public class ZhouyuCondition implements Condition {
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {

        //com.zhouyu.service.User类存在返回true不存在返回false
        try {
            context.getClassLoader().loadClass("com.zhouyu.service.User");
            return true;
        } catch (ClassNotFoundException e) {
            return false;
        }

    }
}

//@Lookup注解作用
@Component
//单例Bean
public class UserService {
    @Autowired
    private User user;

    public void test() {
        System.out.println(a());
    }

    @Lookup("user")
    public User a(){

        //随便返回
        return null;
    }

}


@Component
//原型Bean
@Scope("prototype")
public class User {

}


@ComponentScan(value = "com.zhouyu")
@Configuration
public class AppConfig {
    public static void main( String[] args )
    {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        UserService userService = (UserService) context.getBean("userService");
        userService.test();
        userService.test();
        userService.test();//不加@lookup那么会是一个对象

    }
}

//一个启动类
public abstract class AbstractApplicationContext extends DefaultResourceLoader
      implements ConfigurableApplicationContext {
      			public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			// Prepare this context for refreshing.
			prepareRefresh();

			// Tell the subclass to refresh the internal bean factory.
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

			// Prepare the bean factory for use in this context.
			prepareBeanFactory(beanFactory);

			try {
				// Allows post-processing of the bean factory in context subclasses.
				postProcessBeanFactory(beanFactory);

				// Invoke factory processors registered as beans in the context.
				invokeBeanFactoryPostProcessors(beanFactory);

				// Register bean processors that intercept bean creation.
				registerBeanPostProcessors(beanFactory);

				// Initialize message source for this context.
				initMessageSource();

				// Initialize event multicaster for this context.
				initApplicationEventMulticaster();

				// Initialize other special beans in specific context subclasses.
				onRefresh();

				// Check for listener beans and register them.
				registerListeners();

				// Instantiate all remaining (non-lazy-init) singletons.
				finishBeanFactoryInitialization(beanFactory);//先进入方法

				// Last step: publish corresponding event.
				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 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));
		}

		// Register a default embedded value resolver if no bean post-processor
		// (such as a PropertyPlaceholderConfigurer bean) registered any before:
		// at this point, primarily for resolution in annotation attribute values.
		if (!beanFactory.hasEmbeddedValueResolver()) {
			beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
		}

		// Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
		String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
		for (String weaverAwareName : weaverAwareNames) {
			getBean(weaverAwareName);
		}

		// Stop using the temporary ClassLoader for type matching.
		beanFactory.setTempClassLoader(null);

		// Allow for caching all bean definition metadata, not expecting further changes.
		beanFactory.freezeConfiguration();

		// Instantiate all remaining (non-lazy-init) singletons.
		beanFactory.preInstantiateSingletons();//进入方法
	}
}
	

public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {

		private volatile List<String> beanDefinitionNames = new ArrayList(256);
		
		
		public void preInstantiateSingletons() throws BeansException {
        if (this.logger.isTraceEnabled()) {
            this.logger.trace("Pre-instantiating singletons in " + this);
        }

        List<String> beanNames = new ArrayList(this.beanDefinitionNames);
        Iterator var2 = beanNames.iterator();

        while(true) {
            String beanName;
            Object bean;
            do {
                while(true) {
                    RootBeanDefinition bd;
                    do {
                        do {
                            do {
                                if (!var2.hasNext()) {
                                    var2 = beanNames.iterator();

                                    while(var2.hasNext()) {
                                        beanName = (String)var2.next();
                                        Object singletonInstance = this.getSingleton(beanName);
                                        
                                        
                                         //判断上面的单例Bean是否实现了SmartInitializingSingleton也就是在所有非懒加载单例bean结束之后执行
                                        if (singletonInstance instanceof SmartInitializingSingleton) {
                                            SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton)singletonInstance;
                                            if (System.getSecurityManager() != null) {
                                                AccessController.doPrivileged(() -> {
                                                    smartSingleton.afterSingletonsInstantiated();
                                                    return null;
                                                }, this.getAccessControlContext());
                                            } else {
                                                smartSingleton.afterSingletonsInstantiated();
                                            }
                                        }
                                    }

                                    return;
                                }

                                beanName = (String)var2.next();i
                                
                                //为什么要合并是因为下面的原因（合并BeanDefinition）进入方法
                                bd = this.getMergedLocalBeanDefinition(beanName);
                            } while(bd.isAbstract()); //不能是抽象的BeanDefination(不是类)（xml（bean id="user" class = "com.zhouyu.service.User" abstract = "true" 【parent = “userservice”】/））（用法就是自己不能生成Bean但是可以子类继承父类的一些属性）
                        } while(!bd.isSingleton());
                    } while(bd.isLazyInit());

                 
                    
                    //如果是FactoryBean
                    /*isFactoryBean(beanName)方法是AbstractBeanFactory.calss
                    public boolean isFactoryBean(String name) throws NoSuchBeanDefinitionException {
        String beanName = this.transformedBeanName(name);
        Object beanInstance = this.getSingleton(beanName, false);
        
        //拿到名字可以根据Bean类型判断(第一次拿不到没创建Bean)
        if (beanInstance != null) {
            return beanInstance instanceof FactoryBean;
        } else {
        //拿不到名字根据BDefinition判断
            return !this.containsBeanDefinition(beanName) && this.getParentBeanFactory() instanceof ConfigurableBeanFactory ? ((ConfigurableBeanFactory)this.getParentBeanFactory()).isFactoryBean(name) : this.isFactoryBean(beanName, this.getMergedLocalBeanDefinition(beanName));//本容器有没有没有的话去父容器取（启动类设置（context.setParent(contextParent)）），isFactoryBean(beanName, this.getMergedLocalBeanDefinition(beanName))是从缓存中拿（mbd是否实现了FactoryBean或者没实现放在缓存中）
        }
    }
                    
                    */
                    if (this.isFactoryBean(beanName)) {
                        bean = this.getBean("&" + beanName);
                        break;
                    }
					//如果不是FactoryBean得到单例bean
                    this.getBean(beanName);
                }
            } while(!(bean instanceof FactoryBean));//当前bean名字是不是FactoryBean

               //非单例懒加载完成后
            FactoryBean<?> factory = (FactoryBean)bean;
            
            
            boolean isEagerInit;
            
            //SmartFactoryBean extends FactoryBean （isEagerInit为true spring启动的时候就会调用getObject）
            if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                SmartFactoryBean var10000 = (SmartFactoryBean)factory;
                ((SmartFactoryBean)factory).getClass();
                
                //判断安全管理器
                isEagerInit = (Boolean)AccessController.doPrivileged(var10000::isEagerInit, this.getAccessControlContext());
            } else {
                isEagerInit = factory instanceof SmartFactoryBean && ((SmartFactoryBean)factory).isEagerInit();
            }

            if (isEagerInit) {
            
            
            
                this.getBean(beanName);
                
                /*  AbstractBeanFactory的方法getBean（）最终会调用doGetBean（）
                protected <T> T doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly) throws BeansException {
                
                
                //传入&xxx会解析成xxx然后取单例池的值
                
        String beanName = this.transformedBeanName(name);
        Object sharedInstance = this.getSingleton(beanName);  
        Object bean;
        if (sharedInstance != null && args == null) {
            if (this.logger.isTraceEnabled()) {
                if (this.isSingletonCurrentlyInCreation(beanName)) {
                    this.logger.trace("Returning eagerly cached instance of singleton bean '" + beanName + "' that is not fully initialized yet - a consequence of a circular reference");
                } else {
                    this.logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
                }
            }

            bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, (RootBeanDefinition)null);//进入方法name=&xxx, beanName=xxx, 
        } else {
            if (this.isPrototypeCurrentlyInCreation(beanName)) {
                throw new BeanCurrentlyInCreationException(beanName);
            }

            BeanFactory parentBeanFactory = this.getParentBeanFactory();
            if (parentBeanFactory != null && !this.containsBeanDefinition(beanName)) {
                String nameToLookup = this.originalBeanName(name);
                if (parentBeanFactory instanceof AbstractBeanFactory) {
                    return ((AbstractBeanFactory)parentBeanFactory).doGetBean(nameToLookup, requiredType, args, typeCheckOnly);
                }

                if (args != null) {
                    return parentBeanFactory.getBean(nameToLookup, args);
                }

                if (requiredType != null) {
                    return parentBeanFactory.getBean(nameToLookup, requiredType);
                }

                return parentBeanFactory.getBean(nameToLookup);
            }

            if (!typeCheckOnly) {
                this.markBeanAsCreated(beanName);
            }

            try {
                RootBeanDefinition mbd = this.getMergedLocalBeanDefinition(beanName);
                this.checkMergedBeanDefinition(mbd, beanName, args);
                String[] dependsOn = mbd.getDependsOn();
                String[] var11;
                if (dependsOn != null) {
                    var11 = dependsOn;
                    int var12 = dependsOn.length;

                    for(int var13 = 0; var13 < var12; ++var13) {
                        String dep = var11[var13];
                        if (this.isDependent(beanName, dep)) {
                            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
                        }

                        this.registerDependentBean(dep, beanName);

                        try {
                            this.getBean(dep);
                        } catch (NoSuchBeanDefinitionException var24) {
                            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "'" + beanName + "' depends on missing bean '" + dep + "'", var24);
                        }
                    }
                }

                if (mbd.isSingleton()) {
                    sharedInstance = this.getSingleton(beanName, () -> {
                        try {
                            return this.createBean(beanName, mbd, args);
                        } catch (BeansException var5) {
                            this.destroySingleton(beanName);
                            throw var5;
                        }
                    });
                    bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
                } else if (mbd.isPrototype()) {
                    var11 = null;

                    Object prototypeInstance;
                    try {
                        this.beforePrototypeCreation(beanName);
                        prototypeInstance = this.createBean(beanName, mbd, args);
                    } finally {
                        this.afterPrototypeCreation(beanName);
                    }

                    bean = this.getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
                } else {
                    String scopeName = mbd.getScope();
                    Scope 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, () -> {
                            this.beforePrototypeCreation(beanName);

                            Object var4;
                            try {
                                var4 = this.createBean(beanName, mbd, args);
                            } finally {
                                this.afterPrototypeCreation(beanName);
                            }

                            return var4;
                        });
                        bean = this.getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
                    } catch (IllegalStateException var23) {
                        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", var23);
                    }
                }
            } catch (BeansException var26) {
                this.cleanupAfterBeanCreationFailure(beanName);
                throw var26;
            }
        }

        if (requiredType != null && !requiredType.isInstance(bean)) {
            try {
                T convertedBean = this.getTypeConverter().convertIfNecessary(bean, requiredType);
                if (convertedBean == null) {
                    throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
                } else {
                    return convertedBean;
                }
            } catch (TypeMismatchException var25) {
                if (this.logger.isTraceEnabled()) {
                    this.logger.trace("Failed to convert bean '" + name + "' to required type '" + ClassUtils.getQualifiedName(requiredType) + "'", var25);
                }

                throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
            }
        } else {
            return bean;
        }
    }
    
    
    
    
    
    protected Object getObjectForBeanInstance(Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {
        if (BeanFactoryUtils.isFactoryDereference(name)) {//以&开头
            if (beanInstance instanceof NullBean) {
                return beanInstance;
            } else if (!(beanInstance instanceof FactoryBean)) {
            
            //此时若从单例池拿到的对象不是FactoryBean的实例报错（getBean（“&xxx'”）报错）
            
                throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass());
            } else {
                if (mbd != null) {
                    mbd.isFactoryBean = true;
                }

                return beanInstance;
            }
        } else if (!(beanInstance instanceof FactoryBean)) {//不&开头普通Bean不是FactoryBean的实例返回
            return beanInstance;
        } else {                                   //不&开头是FactoryBean的实例返回
            Object object = null;
            if (mbd != null) {
                mbd.isFactoryBean = true;
            } else {
                object = this.getCachedObjectForFactoryBean(beanName);  
                
                /*
                 synchronized(this.getSingletonMutex()) {
                Object object = this.factoryBeanObjectCache.get(beanName);//先去FactoryBean缓存中拿
                if (object == null) {
                    object = this.doGetObjectFromFactoryBean(factory, beanName);//没拿到执行方法
                    Object alreadyThere = this.factoryBeanObjectCache.get(beanName);//
                    if (alreadyThere != null) {
                        object = alreadyThere;
                        }
                 }
                  if (this.containsSingleton(beanName)) {
                            this.factoryBeanObjectCache.put(beanName, object);//放入缓存
                        }
                 }         
            }

            if (object == null) {
                FactoryBean<?> factory = (FactoryBean)beanInstance;
                if (mbd == null && this.containsBeanDefinition(beanName)) {
                    mbd = this.getMergedLocalBeanDefinition(beanName);
                }

                boolean synthetic = mbd != null && mbd.isSynthetic();
                object = this.getObjectFromFactoryBean(factory, beanName, !synthetic);//执行getObject（）
            }

            return object;
        }
    }
                
                */
            }
        }
    }
}

public abstract class AbstractBeanFactoiry extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory {

//RootBeanDefinition是合并之后的BeanDefinition（合并之后放在map中）
private final Map<String, RootBeanDefinition> mergedBeanDefinitions = new ConcurrentHashMap(256);


protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws BeansException {
    RootBeanDefinition mbd = (RootBeanDefinition)this.mergedBeanDefinitions.get(beanName);
    return mbd != null && !mbd.stale ? mbd : this.getMergedBeanDefinition(beanName, this.getBeanDefinition(beanName));
    //如果mbd合并过那么直接返回
    //没有合并过执行this.getBeanDefinition(beanName)
    //执行getMergedBeanDefinition（）
}

protected abstract BeanDefinition getBeanDefinition(String var1) throws BeansException;
    
    /*DefaultListableBeanFactroy的实现类
    public BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException {
    //拿出beanDefinition
        BeanDefinition bd = (BeanDefinition)this.beanDefinitionMap.get(beanName);
        if (bd == null) {
            if (this.logger.isTraceEnabled()) {
                this.logger.trace("No bean named '" + beanName + "' found in " + this);
            }

            throw new NoSuchBeanDefinitionException(beanName);
        } else {
            return bd;
        }
    }
    */
      protected RootBeanDefinition getMergedBeanDefinition(String beanName, BeanDefinition bd) throws BeanDefinitionStoreException {
        return this.getMergedBeanDefinition(beanName, bd, (BeanDefinition)null);
    }
    
    protected RootBeanDefinition getMergedBeanDefinition(String beanName, BeanDefinition bd, @Nullable BeanDefinition containingBd) throws BeanDefinitionStoreException {
        synchronized(this.mergedBeanDefinitions) {
            RootBeanDefinition mbd = null;
            RootBeanDefinition previous = null;
            if (containingBd == null) {
                mbd = (RootBeanDefinition)this.mergedBeanDefinitions.get(beanName);
            }

            if (mbd == null || mbd.stale) {
                previous = mbd;
                 //当前bean是否指定Parent
                if (bd.getParentName() == null) {
                    if (bd instanceof RootBeanDefinition) {
                        mbd = ((RootBeanDefinition)bd).cloneBeanDefinition();//没有的话基于BD克隆生成新的mbd
                    } else {
                        mbd = new RootBeanDefinition(bd);//没有的话生成新的mbd
                    }
                } else {
                    BeanDefinition pbd;
                    try {
                       
                        String parentBeanName = this.transformedBeanName(bd.getParentName());
                        if (!beanName.equals(parentBeanName)) {
                            pbd = this.getMergedBeanDefinition(parentBeanName);//父子孙，孙不断向上找到父（自己合并前父类先合并）
                        } else {
                            BeanFactory parent = this.getParentBeanFactory();
                            if (!(parent instanceof ConfigurableBeanFactory)) {
                                throw new NoSuchBeanDefinitionException(parentBeanName, "Parent name '" + parentBeanName + "' is equal to bean name '" + beanName + "': cannot be resolved without a ConfigurableBeanFactory parent");
                            }

                            pbd = ((ConfigurableBeanFactory)parent).getMergedBeanDefinition(parentBeanName);
                        }
                    } catch (NoSuchBeanDefinitionException var11) {
                        throw new BeanDefinitionStoreException(bd.getResourceDescription(), beanName, "Could not resolve parent bean definition '" + bd.getParentName() + "'", var11);
                    }

                    mbd = new RootBeanDefinition(pbd);//递归执行之后父类先合并（基于父类属性赋值给子类）
                    mbd.overrideFrom(bd);//执行方法
                }

                if (!StringUtils.hasLength(mbd.getScope())) {
                    mbd.setScope("singleton");
                }

                if (containingBd != null && !containingBd.isSingleton() && mbd.isSingleton()) {
                    mbd.setScope(containingBd.getScope());
                }

                if (containingBd == null && this.isCacheBeanMetadata()) {
                    this.mergedBeanDefinitions.put(beanName, mbd);
                }
            }

            if (previous != null) {
                this.copyRelevantMergedBeanDefinitionCaches(previous, mbd);
            }

            return mbd;
        }
    }
    
    
    public void overrideFrom(BeanDefinition other) {
        //如果子类有属性的话，那么直接填充属性，没有沿用父类的
        if (StringUtils.hasLength(other.getBeanClassName())) {
            this.setBeanClassName(other.getBeanClassName());
        }

        if (StringUtils.hasLength(other.getScope())) {
            this.setScope(other.getScope());
        }

        this.setAbstract(other.isAbstract());
        if (StringUtils.hasLength(other.getFactoryBeanName())) {
            this.setFactoryBeanName(other.getFactoryBeanName());
        }

        if (StringUtils.hasLength(other.getFactoryMethodName())) {
            this.setFactoryMethodName(other.getFactoryMethodName());
        }

        this.setRole(other.getRole());
        this.setSource(other.getSource());
        this.copyAttributesFrom(other);
        if (other instanceof AbstractBeanDefinition) {
            AbstractBeanDefinition otherAbd = (AbstractBeanDefinition)other;
            if (otherAbd.hasBeanClass()) {
                this.setBeanClass(otherAbd.getBeanClass());
            }

            if (otherAbd.hasConstructorArgumentValues()) {
                this.getConstructorArgumentValues().addArgumentValues(other.getConstructorArgumentValues());
            }

            if (otherAbd.hasPropertyValues()) {
                this.getPropertyValues().addPropertyValues(other.getPropertyValues());
            }

            if (otherAbd.hasMethodOverrides()) {
                this.getMethodOverrides().addOverrides(otherAbd.getMethodOverrides());
            }

            Boolean lazyInit = otherAbd.getLazyInit();
            if (lazyInit != null) {
                this.setLazyInit(lazyInit);
            }

            this.setAutowireMode(otherAbd.getAutowireMode());
            this.setDependencyCheck(otherAbd.getDependencyCheck());
            this.setDependsOn(otherAbd.getDependsOn());
            this.setAutowireCandidate(otherAbd.isAutowireCandidate());
            this.setPrimary(otherAbd.isPrimary());
            this.copyQualifiersFrom(otherAbd);
            this.setInstanceSupplier(otherAbd.getInstanceSupplier());
            this.setNonPublicAccessAllowed(otherAbd.isNonPublicAccessAllowed());
            this.setLenientConstructorResolution(otherAbd.isLenientConstructorResolution());
            if (otherAbd.getInitMethodName() != null) {
                this.setInitMethodName(otherAbd.getInitMethodName());
                this.setEnforceInitMethod(otherAbd.isEnforceInitMethod());
            }

            if (otherAbd.getDestroyMethodName() != null) {
                this.setDestroyMethodName(otherAbd.getDestroyMethodName());
                this.setEnforceDestroyMethod(otherAbd.isEnforceDestroyMethod());
            }

            this.setSynthetic(otherAbd.isSynthetic());
            this.setResource(otherAbd.getResource());
        } else {
            this.getConstructorArgumentValues().addArgumentValues(other.getConstructorArgumentValues());
            this.getPropertyValues().addPropertyValues(other.getPropertyValues());
            this.setLazyInit(other.isLazyInit());
            this.setResourceDescription(other.getResourceDescription());
        }

    }

}