DefaultListableBeanFactory

该方法根据给定的beanName和annotationType，在对应的Bean实例上查找注解，并返回注解的实例。

该方法根据给定的beanName、annotationType和allowFactoryBeanInit，在对应的Bean实例上查找并合并注解，并返回注解的实例。

具体的实现步骤如下：

1. 调用 ​findMergedAnnotationOnBean(beanName, annotationType, allowFactoryBeanInit)​方法，传入beanName、annotationType和allowFactoryBeanInit参数。
2. 在 ​findMergedAnnotationOnBean()​方法中，根据beanName获取对应的Bean实例。
3. 在获取到的Bean实例上使用 ​annotationType​作为参数调用 ​findMergedAnnotation()​方法，该方法是Spring框架提供的方法，用于查找并合并指定注解。
4. 调用 ​synthesize()​方法，对合并后的注解进行处理，将其转化为一个具体的注解实例。
5. 使用 ​orElse(null)​方法，如果合并后的注解实例存在，则返回该实例；否则，返回null。

 这个方法用于在指定的Bean实例上查找并合并（merged）指定注解。

具体的实现步骤如下：

1. 首先，通过调用 ​getType(beanName, allowFactoryBeanInit)​方法获取Bean的类型。
2. 如果beanType不为null，则使用 ​MergedAnnotations.from(beanType, SearchStrategy.TYPE_HIERARCHY).get(annotationType)​查找并合并指定注解。如果找到注解且存在，则返回该注解。
3. 如果beanType为null，表示无法获取到Bean的类型，接下来继续处理。
4. 如果包含名为beanName的Bean定义（bean definition），则获取该Bean定义，并判断是否有Bean类信息（beanClass）。如果有，则获取该Bean类的类型（beanClass）。
5. 如果beanClass与之前获取的beanType不同，说明存在代理（proxy）或其他原因导致的类型不匹配，再次使用 ​MergedAnnotations.from(beanClass, SearchStrategy.TYPE_HIERARCHY).get(annotationType)​查找并合并指定注解。如果找到注解且存在，则返回该注解。
6. 如果存在名为factoryMethod的工厂方法，则使用 ​MergedAnnotations.from(factoryMethod, SearchStrategy.TYPE_HIERARCHY).get(annotationType)​查找并合并指定注解。如果找到注解且存在，则返回该注解。
7. 如果以上步骤都没有找到指定注解，则返回一个"missing"状态的MergedAnnotation。

• registerResolvableDependency(Class dependencyType, @Nullable Object autowiredValue) 

这个方法的作用是注册可解析的依赖关系。当系统需要解析自动注入时，会查找并使用已注册的依赖关系来提供对应的注入值。

具体的实现步骤如下：

1. 首先，使用断言 ​Assert.notNull(dependencyType, "Dependency type must not be null")​确保依赖类型不为null，如果依赖类型为null，则抛出异常。
2. 接着，判断注入值是否为null。
3. 如果注入值不为null，进一步判断注入值是否是ObjectFactory的实例，或者依赖类型是否是注入值的实例。
   • 如果注入值不是ObjectFactory的实例，且依赖类型不是注入值的实例，抛出IllegalArgumentException异常，说明该值无效。
   • 否则，将依赖类型和注入值存入resolvableDependencies，即注册可解析的依赖关系。
4. 注入值为null时，不做任何操作。

@Override
	public void registerResolvableDependency(Class dependencyType, @Nullable Object autowiredValue) {
		Assert.notNull(dependencyType, "Dependency type must not be null");
		if (autowiredValue != null) {
			if (!(autowiredValue instanceof ObjectFactory || dependencyType.isInstance(autowiredValue))) {
				throw new IllegalArgumentException("Value [" + autowiredValue +
						"] does not implement specified dependency type [" + dependencyType.getName() + "]");
			}
			this.resolvableDependencies.put(dependencyType, autowiredValue);
		}
	}

• isAutowireCandidate(String beanName, DependencyDescriptor descriptor) 

这个用于判断指定的Bean是否为候选的自动装配（autowire）目标。它会根据给定的beanName、DependencyDescriptor和AutowireCandidateResolver来进行判断。 

具体的实现步骤如下：

1. 调用 ​getAutowireCandidateResolver()​方法获取AutowireCandidateResolver的实例。
2. 调用重载方法 ​isAutowireCandidate(beanName, descriptor, getAutowireCandidateResolver())​，传入beanName、descriptor和AutowireCandidateResolver。
3. 在 ​isAutowireCandidate()​方法中，根据beanName和descriptor使用AutowireCandidateResolver的 ​isAutowireCandidate()​方法进行判断。
4. 返回判断的结果，即表示该Bean是否为自动装配的候选目标。

@Override
	public boolean isAutowireCandidate(String beanName, DependencyDescriptor descriptor)
			throws NoSuchBeanDefinitionException {
 
		return isAutowireCandidate(beanName, descriptor, getAutowireCandidateResolver());
	}

• isAutowireCandidate(
        String beanName, DependencyDescriptor descriptor, AutowireCandidateResolver resolver) 

这个方法用于确定指定的Bean定义是否符合自动装配（autowire）的候选条件，可以被注入到其他声明了匹配类型依赖的Bean中。

具体的实现步骤如下：

1. 首先，使用 ​BeanFactoryUtils.transformedBeanName(beanName)​将beanName转换为标准格式。
2. 判断容器中是否包含名为bdName的Bean定义。
   • 如果存在，调用 ​isAutowireCandidate(beanName, getMergedLocalBeanDefinition(bdName), descriptor, resolver)​进行判断。
   • 如果不存在，继续下面的处理。
3. 再次判断容器中是否包含名为beanName的单例Bean。
   • 如果存在，创建一个包含类型信息的RootBeanDefinition，并调用 ​isAutowireCandidate(beanName, rootBeanDefinition, descriptor, resolver)​进行判断。
   • 如果不存在，继续下面的处理。
4. 获得父级BeanFactory。
   • 如果父级BeanFactory是DefaultListableBeanFactory的实例，则将判断任务委托给父级BeanFactory的 ​isAutowireCandidate()​方法，并返回其结果。
   • 如果父级BeanFactory是ConfigurableListableBeanFactory的实例，则调用其 ​isAutowireCandidate(beanName, descriptor)​方法进行判断。
   • 如果父级BeanFactory不属于上述两种情况，则默认返回true，表示该Bean为自动装配候选对象。

protected boolean isAutowireCandidate(
			String beanName, DependencyDescriptor descriptor, AutowireCandidateResolver resolver)
			throws NoSuchBeanDefinitionException {
 
		String bdName = BeanFactoryUtils.transformedBeanName(beanName);
		if (containsBeanDefinition(bdName)) {
			return isAutowireCandidate(beanName, getMergedLocalBeanDefinition(bdName), descriptor, resolver);
		}
		else if (containsSingleton(beanName)) {
			return isAutowireCandidate(beanName, new RootBeanDefinition(getType(beanName)), descriptor, resolver);
		}
 
		BeanFactory parent = getParentBeanFactory();
		if (parent instanceof DefaultListableBeanFactory) {
			// No bean definition found in this factory -> delegate to parent.
			return ((DefaultListableBeanFactory) parent).isAutowireCandidate(beanName, descriptor, resolver);
		}
		else if (parent instanceof ConfigurableListableBeanFactory) {
			// If no DefaultListableBeanFactory, can't pass the resolver along.
			return ((ConfigurableListableBeanFactory) parent).isAutowireCandidate(beanName, descriptor);
		}
		else {
			return true;
		}
	}

• isAutowireCandidate(String beanName, RootBeanDefinition mbd,
        DependencyDescriptor descriptor, AutowireCandidateResolver resolver)

这个用于判断指定的Bean定义是否符合自动装配（autowire）的候选条件，可以被注入到其他声明了匹配类型依赖的Bean中。 

具体的实现步骤如下：

1. 使用 ​BeanFactoryUtils.transformedBeanName(beanName)​将beanName转换为标准格式。
2. 调用 ​resolveBeanClass(mbd, bdName)​方法，解析并设置Bean定义的类信息。
3. 如果Bean定义中的isFactoryMethodUnique为true且factoryMethodToIntrospect为null，则使用ConstructorResolver来尝试解析工厂方法（factory method）。
4. 创建一个BeanDefinitionHolder，根据beanName和mbd构造，如果beanName与bdName相等，则使用已存在的mergedBeanDefinitionHolders，否则创建一个新的BeanDefinitionHolder。
5. 调用resolver的 ​isAutowireCandidate(holder, descriptor)​方法进行判断。
6. 返回判断结果，表示该Bean是否应该被考虑作为自动装配候选。

protected boolean isAutowireCandidate(String beanName, RootBeanDefinition mbd,
			DependencyDescriptor descriptor, AutowireCandidateResolver resolver) {
 
		String bdName = BeanFactoryUtils.transformedBeanName(beanName);
		resolveBeanClass(mbd, bdName);
		if (mbd.isFactoryMethodUnique && mbd.factoryMethodToIntrospect == null) {
			new ConstructorResolver(this).resolveFactoryMethodIfPossible(mbd);
		}
		BeanDefinitionHolder holder = (beanName.equals(bdName) ?
				this.mergedBeanDefinitionHolders.computeIfAbsent(beanName,
						key -> new BeanDefinitionHolder(mbd, beanName, getAliases(bdName))) :
				new BeanDefinitionHolder(mbd, beanName, getAliases(bdName)));
		return resolver.isAutowireCandidate(holder, descriptor);
	}

• getBeanDefinition(String beanName) 

这个用于根据给定的beanName获取对应的Bean定义（BeanDefinition）对象 。

@Override
	public BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException {
		BeanDefinition bd = this.beanDefinitionMap.get(beanName);
		if (bd == null) {
			if (logger.isTraceEnabled()) {
				logger.trace("No bean named '" + beanName + "' found in " + this);
			}
			throw new NoSuchBeanDefinitionException(beanName);
		}
		return bd;
	}

• getBeanNamesIterator()

通过使用CompositeIterator，可以将多个迭代器组合成一个逻辑上的整体，方便遍历和访问各个迭代器的元素。这个方法的作用是将beanDefinitionNames和manualSingletonNames中的Bean定义名称合并为一个迭代器，以提供对所有Bean定义名称的统一访问。 

@Override
	public Iterator getBeanNamesIterator() {
		CompositeIterator iterator = new CompositeIterator<>();
		iterator.add(this.beanDefinitionNames.iterator());
		iterator.add(this.manualSingletonNames.iterator());
		return iterator;
	}

• clearMergedBeanDefinition(String beanName)

这个方法主要是用来清理与给定beanName相关的合并Bean定义信息和持有者。在Spring容器中，Bean定义信息可能存在于不同的地方，所以需要在清理时同时考虑清除相关的持有者。 

@Override
	protected void clearMergedBeanDefinition(String beanName) {
		super.clearMergedBeanDefinition(beanName);
		this.mergedBeanDefinitionHolders.remove(beanName);
	}

• clearMetadataCache() 

这个方法主要用来清除所有与Bean元数据相关的缓存信息，包括合并Bean定义持有者和类型缓存。通过清空这些缓存，可以刷新和更新容器中的Bean定义和类型信息，使得后续的操作能够重新获取最新的元数据。 

@Override
	public void clearMetadataCache() {
		super.clearMetadataCache();
		this.mergedBeanDefinitionHolders.clear();
		clearByTypeCache();
	}

• freezeConfiguration() 

这个方法主要用于冻结容器的配置，即禁止对容器的配置进行修改。通过设置configurationFrozen为true，可以防止后续的配置修改，以保护已经完成的配置不受更改。同时，通过将beanDefinitionNames转换为字符串数组并保存在frozenBeanDefinitionNames中，可以记录当前的Bean定义名称，方便后续的使用和比较。 

@Override
	public void freezeConfiguration() {
		this.configurationFrozen = true;
		this.frozenBeanDefinitionNames = StringUtils.toStringArray(this.beanDefinitionNames);
	}

• isBeanEligibleForMetadataCaching 

这个方法用于确定指定的Bean是否符合元数据缓存的条件。如果容器的配置已被冻结，表示不会再有修改操作，此时所有的Bean都被认为是符合元数据缓存的条件的。如果容器的配置未被冻结，则会使用父类的默认判断逻辑来确定指定的Bean是否符合元数据缓存的条件。 

/**
	 * Considers all beans as eligible for metadata caching
	 * if the factory's configuration has been marked as frozen.
	 * @see #freezeConfiguration()
	 */
	@Override
	protected boolean isBeanEligibleForMetadataCaching(String beanName) {
		return (this.configurationFrozen || super.isBeanEligibleForMetadataCaching(beanName));
	}

• preInstantiateSingletons() 

 这个方法的主要目的是提前实例化所有非懒加载的单例Bean，并在初始化完成后触发SmartInitializingSingleton的回调方法。通过预实例化单例Bean，在容器启动时可以避免在第一次使用时才进行实例化，为后续的Bean使用提供了便利性和性能优化。同时，也会触发SmartInitializingSingleton的回调，用于在所有单例Bean实例化完成后进行一些定制的初始化操作。

具体实现步骤如下：

1. 如果日志级别为trace，记录关于预初始化单例Bean的日志信息。
2. 创建一个副本的beanDefinitionNames列表，用于迭代预初始化单例Bean。这样做是为了防止在迭代过程中存在可能会注册新的bean定义的初始化方法。
3. 遍历beanNames列表，获取每个bean定义，并判断是否为非抽象、单例且非懒加载的Bean。
4. 如果是FactoryBean类型的Bean，先获取对应的FactoryBean实例，然后判断是否为SmartFactoryBean并判断是否需要立即初始化。如果需要立即初始化，则调用getBean(beanName)方法。
5. 如果是普通的Bean，则直接调用getBean(beanName)方法进行初始化。
6. 再次遍历beanNames列表，获取每个已实例化的单例Bean实例。
7. 如果该Bean实例属于SmartInitializingSingleton类型，执行afterSingletonsInstantiated()方法来触发smart初始化回调。

@Override
	public void preInstantiateSingletons() throws BeansException {
		if (logger.isTraceEnabled()) {
			logger.trace("Pre-instantiating singletons in " + this);
		}
 
		// Iterate over a copy to allow for init methods which in turn register new bean definitions.
		// While this may not be part of the regular factory bootstrap, it does otherwise work fine.
		List beanNames = new ArrayList<>(this.beanDefinitionNames);
 
		// Trigger initialization of all non-lazy singleton beans...
		for (String beanName : beanNames) {
			RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
			if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
				if (isFactoryBean(beanName)) {
					Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
					if (bean instanceof FactoryBean) {
						FactoryBean factory = (FactoryBean) bean;
						boolean isEagerInit;
						if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
							isEagerInit = AccessController.doPrivileged(
									(PrivilegedAction) ((SmartFactoryBean) factory)::isEagerInit,
									getAccessControlContext());
						}
						else {
							isEagerInit = (factory instanceof SmartFactoryBean &&
									((SmartFactoryBean) factory).isEagerInit());
						}
						if (isEagerInit) {
							getBean(beanName);
						}
					}
				}
				else {
					getBean(beanName);
				}
			}
		}
 
		// Trigger post-initialization callback for all applicable beans...
		for (String beanName : beanNames) {
			Object singletonInstance = getSingleton(beanName);
			if (singletonInstance instanceof SmartInitializingSingleton) {
				StartupStep smartInitialize = this.getApplicationStartup().start("spring.beans.smart-initialize")
						.tag("beanName", beanName);
				SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
				if (System.getSecurityManager() != null) {
					AccessController.doPrivileged((PrivilegedAction