费曼乐园

DefaultListableBeanFactory

DefaultListableBeanFactory是Spring的默认实现，是ConfigurableListableBeanFactory和BeanDefinitionRegistry接口的实现，它是一个基于bean定义元数据的充分功能的bean工厂，并通过后置处理器进行可扩展。

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

getBean(Class requiredType, @Nullable Object... args)

这个方法的作用是提供了一种更便捷的方式来获取bean，而无需手动进行类型转换和判空等操作。通过使用泛型，可以确保返回的bean实例与指定的类型相匹配，避免了强制类型转换的风险和麻烦。

调用resolveBean方法解析指定类型的bean。resolveBean方法使用ResolvableType.forRawClass(requiredType)创建一个ResolvableType对象，表示所需类型。然后传入args和false参数，执行解析过程。解析bean的过程包括查找bean定义并创建bean实例。

@Override
	public  T getBean(Class requiredType, @Nullable Object... args) throws BeansException {
		Assert.notNull(requiredType, "Required type must not be null");
		Object resolved = resolveBean(ResolvableType.forRawClass(requiredType), args, false);
		if (resolved == null) {
			throw new NoSuchBeanDefinitionException(requiredType);
		}
		return (T) resolved;
	}

```
containsBeanDefinition(String beanName)
```

在一个大型的应用程序中，可能有很多不同的bean被定义在Spring的IoC容器中。而这些bean的定义信息被存储在DefaultListableBeanFactory类内部的一个称为beanDefinitionMap的数据结构中。

这个方法在DefaultListableBeanFactory中的设计目的是为了提供一种便捷的方式检查是否存在具有给定名称的bean定义。它增强了应用程序开发者对Spring框架的控制和灵活性，帮助开发者更有效地使用和管理bean对象。

@Override
	public boolean containsBeanDefinition(String beanName) {
		Assert.notNull(beanName, "Bean name must not be null");
		return this.beanDefinitionMap.containsKey(beanName);
	}

resolveBean(ResolvableType requiredType, @Nullable Object[] args, boolean nonUniqueAsNull)

resolveBean方法提供了一种灵活且递归的解析机制，使得用户在多层次的bean定义结构中能够方便地获取指定类型的bean实例。

该方法首先尝试调用resolveNamedBean方法，根据requiredType和args参数来查找匹配的bean定义。如果成功找到，则返回对应的bean实例。

如果在当前DefaultListableBeanFactory中未找到匹配的bean定义，它会检查父级BeanFactory的类型。如果父级BeanFactory是DefaultListableBeanFactory的实例，则递归调用其resolveBean方法来尝试从父级BeanFactory中获取指定类型的bean实例。

如果父级BeanFactory不是DefaultListableBeanFactory的实例，而是其他类型的BeanFactory，则使用父级BeanFactory提供的ObjectProvider来获取指定类型的bean实例。

@Nullable
	private  T resolveBean(ResolvableType requiredType, @Nullable Object[] args, boolean nonUniqueAsNull) {
		NamedBeanHolder namedBean = resolveNamedBean(requiredType, args, nonUniqueAsNull);
		if (namedBean != null) {
			return namedBean.getBeanInstance();
		}
		BeanFactory parent = getParentBeanFactory();
		if (parent instanceof DefaultListableBeanFactory) {
			return ((DefaultListableBeanFactory) parent).resolveBean(requiredType, args, nonUniqueAsNull);
		}
		else if (parent != null) {
			ObjectProvider parentProvider = parent.getBeanProvider(requiredType);
			if (args != null) {
				return parentProvider.getObject(args);
			}
			else {
				return (nonUniqueAsNull ? parentProvider.getIfUnique() : parentProvider.getIfAvailable());
			}
		}
		return null;
	}

getBeansOfType(

      @Nullable Class type, boolean includeNonSingletons, boolean allowEagerInit)

这个方法用于获取指定类型的所有bean实例，并将其封装成一个Map，其中key为bean名称，value为对应的bean实例。

getBeansOfType方法的主要功能是根据给定的类型，遍历所有的bean定义，获取满足条件的bean名称数组，然后通过调用getBean方法逐个获取相应的bean实例，并将其封装到结果Map中。

该方法还支持包含非单例bean和懒加载的bean，以及允许提前初始化bean的配置。这样可以灵活地满足不同场景下的需求。

首先，接收三个参数：type（要获取的bean类型）、includeNonSingletons（是否包含非单例bean）和allowEagerInit（是否允许提前初始化）。

然后，调用getBeanNamesForType方法获取指定类型的bean名称数组。

接着，创建一个空的LinkedHashMap来存储结果，确保结果的顺序与遍历的顺序一致。

对于每个beanName，通过调用getBean(beanName)方法获取对应的bean实例，并进行如下处理：

如果beanInstance不是NullBean的实例，则将beanName和beanInstance添加到结果中。
如果在获取bean实例时抛出了BeanCreationException异常，则检查异常的最具体原因。如果原因是BeanCurrentlyInCreationException，表示存在循环引用的情况。
- 如果被循环引用的bean正在创建中，则忽略这个匹配，并记录异常。这样可以避免循环引用导致的死循环。
- 如果被循环引用的bean已经创建完成，则抛出异常，以避免无限递归。

最后，返回封装了指定类型的所有bean实例的Map。

@Override
	@SuppressWarnings("unchecked")
	public  Map getBeansOfType(
			@Nullable Class type, boolean includeNonSingletons, boolean allowEagerInit) throws BeansException {

		String[] beanNames = getBeanNamesForType(type, includeNonSingletons, allowEagerInit);
		Map result = CollectionUtils.newLinkedHashMap(beanNames.length);
		for (String beanName : beanNames) {
			try {
				Object beanInstance = getBean(beanName);
				if (!(beanInstance instanceof NullBean)) {
					result.put(beanName, (T) beanInstance);
				}
			}
			catch (BeanCreationException ex) {
				Throwable rootCause = ex.getMostSpecificCause();
				if (rootCause instanceof BeanCurrentlyInCreationException) {
					BeanCreationException bce = (BeanCreationException) rootCause;
					String exBeanName = bce.getBeanName();
					if (exBeanName != null && isCurrentlyInCreation(exBeanName)) {
						if (logger.isTraceEnabled()) {
							logger.trace("Ignoring match to currently created bean '" + exBeanName + "': " +
									ex.getMessage());
						}
						onSuppressedException(ex);
						// Ignore: indicates a circular reference when autowiring constructors.
						// We want to find matches other than the currently created bean itself.
						continue;
					}
				}
				throw ex;
			}
		}
		return result;
	}

getBeanNamesForAnnotation(Class annotationType)

这个方法用于根据给定的注解类型获取所有被标注该注解的bean名称数组。

首先，接收一个参数annotationType（要查找的注解类型）。

然后，创建一个空的List来存储满足条件的bean名称。

接着，对所有的beanDefinitionNames进行遍历。对于每个beanName，会进行如下判断和处理：

通过beanName获取对应的BeanDefinition对象bd。
如果bd不为null，并且当前bean不是抽象的（!bd.isAbstract()），并且通过findAnnotationOnBean(beanName, annotationType)方法能够找到该bean上的注解，则将这个bean的名称添加到结果集result中。
对于通过手动注册的单例bean（manualSingletonNames），也进行相同的判断和处理。

最后，将结果集result转换成字符串数组，并返回。

当我们需要获取所有被特定注解标注的bean名称时，可以使用该方法快速获取结果，并进行相应的处理，如进一步获取或操作这些bean实例。

@Override
	public String[] getBeanNamesForAnnotation(Class annotationType) {
		List result = new ArrayList<>();
		for (String beanName : this.beanDefinitionNames) {
			BeanDefinition bd = this.beanDefinitionMap.get(beanName);
			if (bd != null && !bd.isAbstract() && findAnnotationOnBean(beanName, annotationType) != null) {
				result.add(beanName);
			}
		}
		for (String beanName : this.manualSingletonNames) {
			if (!result.contains(beanName) && findAnnotationOnBean(beanName, annotationType) != null) {
				result.add(beanName);
			}
		}
		return StringUtils.toStringArray(result);
	}

getBeansWithAnnotation(Class annotationType)

这是获取带有指定注解的Bean实例的方法。

具体的实现步骤如下：

调用 getBeanNamesForAnnotation(annotationType)方法，该方法是Spring框架提供的，用于获取在容器中带有指定注解的Bean名称。
将获取的Bean名称存入 beanNames数组中。
创建一个空的LinkedHashMap，用于存储最终的结果。
遍历 beanNames数组，对于每个Bean名称，调用 getBean(beanName)方法获取对应的Bean实例。
判断获取的Bean实例是否为 NullBean的实例，如果不是，则将Bean名称和实例存入结果Map中。
遍历结束后，返回存有Bean名称和实例的结果Map。

@Override
	public Map getBeansWithAnnotation(Class annotationType) {
		String[] beanNames = getBeanNamesForAnnotation(annotationType);
		Map result = CollectionUtils.newLinkedHashMap(beanNames.length);
		for (String beanName : beanNames) {
			Object beanInstance = getBean(beanName);
			if (!(beanInstance instanceof NullBean)) {
				result.put(beanName, beanInstance);
			}
		}
		return result;
	}

findAnnotationOnBean(String beanName, Class annotationType)

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

@Override
	@Nullable
	public  A findAnnotationOnBean(String beanName, Class annotationType)
			throws NoSuchBeanDefinitionException {

		return findAnnotationOnBean(beanName, annotationType, true);
	}

findAnnotationOnBean(
      String beanName, Class annotationType, boolean allowFactoryBeanInit)

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

具体的实现步骤如下：

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

@Override
	@Nullable
	public  A findAnnotationOnBean(
			String beanName, Class annotationType, boolean allowFactoryBeanInit)
			throws NoSuchBeanDefinitionException {

		return findMergedAnnotationOnBean(beanName, annotationType, allowFactoryBeanInit)
				.synthesize(MergedAnnotation::isPresent).orElse(null);
	}

findMergedAnnotationOnBean(
      String beanName, Class annotationType, boolean allowFactoryBeanInit)

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

具体的实现步骤如下：

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

private  MergedAnnotation findMergedAnnotationOnBean(
			String beanName, Class annotationType, boolean allowFactoryBeanInit) {

		Class beanType = getType(beanName, allowFactoryBeanInit);
		if (beanType != null) {
			MergedAnnotation annotation =
					MergedAnnotations.from(beanType, SearchStrategy.TYPE_HIERARCHY).get(annotationType);
			if (annotation.isPresent()) {
				return annotation;
			}
		}
		if (containsBeanDefinition(beanName)) {
			RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
			// Check raw bean class, e.g. in case of a proxy.
			if (bd.hasBeanClass()) {
				Class beanClass = bd.getBeanClass();
				if (beanClass != beanType) {
					MergedAnnotation annotation =
							MergedAnnotations.from(beanClass, SearchStrategy.TYPE_HIERARCHY).get(annotationType);
					if (annotation.isPresent()) {
						return annotation;
					}
				}
			}
			// Check annotations declared on factory method, if any.
			Method factoryMethod = bd.getResolvedFactoryMethod();
			if (factoryMethod != null) {
				MergedAnnotation annotation =
						MergedAnnotations.from(factoryMethod, SearchStrategy.TYPE_HIERARCHY).get(annotationType);
				if (annotation.isPresent()) {
					return annotation;
				}
			}
		}
		return MergedAnnotation.missing();
	}

registerResolvableDependency(Class dependencyType, @Nullable Object autowiredValue)

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

具体的实现步骤如下：

首先，使用断言 Assert.notNull(dependencyType, "Dependency type must not be null")确保依赖类型不为null，如果依赖类型为null，则抛出异常。
接着，判断注入值是否为null。
如果注入值不为null，进一步判断注入值是否是ObjectFactory的实例，或者依赖类型是否是注入值的实例。
- 如果注入值不是ObjectFactory的实例，且依赖类型不是注入值的实例，抛出IllegalArgumentException异常，说明该值无效。
- 否则，将依赖类型和注入值存入resolvableDependencies，即注册可解析的依赖关系。
注入值为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来进行判断。

具体的实现步骤如下：

调用 getAutowireCandidateResolver()方法获取AutowireCandidateResolver的实例。
调用重载方法 isAutowireCandidate(beanName, descriptor, getAutowireCandidateResolver())，传入beanName、descriptor和AutowireCandidateResolver。
在 isAutowireCandidate()方法中，根据beanName和descriptor使用AutowireCandidateResolver的 isAutowireCandidate()方法进行判断。
返回判断的结果，即表示该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中。

具体的实现步骤如下：

首先，使用 BeanFactoryUtils.transformedBeanName(beanName)将beanName转换为标准格式。
判断容器中是否包含名为bdName的Bean定义。
- 如果存在，调用 isAutowireCandidate(beanName, getMergedLocalBeanDefinition(bdName), descriptor, resolver)进行判断。
- 如果不存在，继续下面的处理。
再次判断容器中是否包含名为beanName的单例Bean。
- 如果存在，创建一个包含类型信息的RootBeanDefinition，并调用 isAutowireCandidate(beanName, rootBeanDefinition, descriptor, resolver)进行判断。
- 如果不存在，继续下面的处理。
获得父级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中。

具体的实现步骤如下：

使用 BeanFactoryUtils.transformedBeanName(beanName)将beanName转换为标准格式。
调用 resolveBeanClass(mbd, bdName)方法，解析并设置Bean定义的类信息。
如果Bean定义中的isFactoryMethodUnique为true且factoryMethodToIntrospect为null，则使用ConstructorResolver来尝试解析工厂方法（factory method）。
创建一个BeanDefinitionHolder，根据beanName和mbd构造，如果beanName与bdName相等，则使用已存在的mergedBeanDefinitionHolders，否则创建一个新的BeanDefinitionHolder。
调用resolver的 isAutowireCandidate(holder, descriptor)方法进行判断。
返回判断结果，表示该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实例化完成后进行一些定制的初始化操作。

具体实现步骤如下：

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

DefaultListableBeanFactory

你可能感兴趣的:(Spring,spring,java)