SpringBean的生命周期
1.什么是springBean？
? 一个springBean是具有走完整个springbean的生命周期创建流程才称为springbean。
? 否则一切都是javabean。
2.AnnotationConfigApplicationContext(MyConfig.class);
这里以AnnotationConfigApplicationContext形式讲解spring bean的生命周期
// 这里只有三行代码，我分为三个部分分别讲解分别干了什么。
public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
this(); // 调用了无参构造器this.register(componentClasses); // 注册配置类this.refresh(); // 完成更新(完成bean的创建)
}
3. this();
3.1AnnotationConfigApplicationContext无参构造器
这个时候先看一下AnnotationConfigApplicationContext的继承图：
AnnotationConfigApplicationContext的无参构造器。在调用一个类的无参构造器的时候编译器会去找这个类是否有父类，如果有则会先执行父类的构造器(上面继承图中的父类无参构造器都会被执行，不过重要的 只有GenericApplicationContext)。父类：GenericApplicationContext
public AnnotationConfigApplicationContext() {
this.reader = new AnnotatedBeanDefinitionReader(this); // 读取带注解的描述beanthis.scanner = new ClassPathBeanDefinitionScanner(this); // 扫描类路径下面的描述bean
}
GenericApplicationContext父类的无参构造器，这个
public GenericApplicationContext() {
this.customClassLoader = false; // 赋值this.refreshed = new AtomicBoolean(); // 赋值 this.beanFactory = new DefaultListableBeanFactory();// 创建一个 DefaultListableBeanFactory 对象。记住，后面还会出来}
3.2DefaultListableBeanFactory
DefaultListableBeanFactory这个对象很重要，看一下它的继承图
DefaultListableBeanFactory: 这是一个放着bean的一个工厂，简单来说就是bean工厂。
这里抽取俩个重要的属性来讲：
/** Map of bean definition objects, keyed by bean name. */
private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);/** List of bean definition names, in registration order. */
private volatile List<String> beanDefinitionNames = new ArrayList<>(256);
beanDefinitionMap存放bean的地方。key为：bean的名字，value为bean的描述信息。
beanDefinitionNames存放bean名字的地方。
3.3 new AnnotatedBeanDefinitionReader(this);
这个时候回到AnnotationConfigApplicationContext的无参构造器中的AnnotatedBeanDefinitionReader
AnnotatedBeanDefinition: 读取带注解的描述bean,
让我们点进去看看这行代码里面的代码长什么样
// 首先进入的是这个有参构造器
public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry) {
// 执行有参构造器，这个有参构造器是下面的有参构造器。this(registry, getOrCreateEnvironment(registry));
}public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) {
this.beanNameGenerator = AnnotationBeanNameGenerator.INSTANCE;this.scopeMetadataResolver = new AnnotationScopeMetadataResolver();Assert.notNull(registry, "BeanDefinitionRegistry must not be null");Assert.notNull(environment, "Environment must not be null");this.registry = registry;this.conditionEvaluator = new ConditionEvaluator(registry, environment, (ResourceLoader)null);// 这里是关键，意思是注册带注解的配置处理器,点进去看看里面// 这里不得不提，spring源码的命名规范写的真的好，一眼就能看懂这个方法是什么意思。AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
}
AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry); 这个方法的代码
public static void registerAnnotationConfigProcessors(BeanDefinitionRegistry registry) {
// 调用了registerAnnotationConfigProcessors这个静态方法。点进去看看这个方法。registerAnnotationConfigProcessors(registry, (Object)null);}
// 这里的返回值是一个Set，但是上游却没有进行接收，说明这个方法有玄机。
public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(BeanDefinitionRegistry registry, @Nullable Object source) {
DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);if (beanFactory != null) {
if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);}if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());}}Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet(8);RootBeanDefinition def;if (!registry.containsBeanDefinition("org.springframework.context.annotation.internalConfigurationAnnotationProcessor")) {
def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);def.setSource(source);beanDefs.add(registerPostProcessor(registry, def, "org.springframework.context.annotation.internalConfigurationAnnotationProcessor"));}if (!registry.containsBeanDefinition("org.springframework.context.annotation.internalAutowiredAnnotationProcessor")) {
def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);def.setSource(source);beanDefs.add(registerPostProcessor(registry, def, "org.springframework.context.annotation.internalAutowiredAnnotationProcessor"));}if (jsr250Present && !registry.containsBeanDefinition("org.springframework.context.annotation.internalCommonAnnotationProcessor")) {
def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);def.setSource(source);beanDefs.add(registerPostProcessor(registry, def, "org.springframework.context.annotation.internalCommonAnnotationProcessor"));}if (jpaPresent && !registry.containsBeanDefinition("org.springframework.context.annotation.internalPersistenceAnnotationProcessor")) {
def = new RootBeanDefinition();try {
def.setBeanClass(ClassUtils.forName("org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor", AnnotationConfigUtils.class.getClassLoader()));} catch (ClassNotFoundException var6) {
throw new IllegalStateException("Cannot load optional framework class: org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor", var6);}def.setSource(source);beanDefs.add(registerPostProcessor(registry, def, "org.springframework.context.annotation.internalPersistenceAnnotationProcessor"));}if (!registry.containsBeanDefinition("org.springframework.context.event.internalEventListenerProcessor")) {
def = new RootBeanDefinition(EventListenerMethodProcessor.class);def.setSource(source);beanDefs.add(registerPostProcessor(registry, def, "org.springframework.context.event.internalEventListenerProcessor"));}if (!registry.containsBeanDefinition("org.springframework.context.event.internalEventListenerFactory")) {
def = new RootBeanDefinition(DefaultEventListenerFactory.class);def.setSource(source);beanDefs.add(registerPostProcessor(registry, def, "org.springframework.context.event.internalEventListenerFactory"));}return beanDefs;}
这个方法重点：
创建了spring开天辟地所需要的bean，把这些bean放到DefaultListableBeanFactory中的beanDefinitionMap当中。以及beanDefinitionNames当中。按照上面的方式进行存储。
所以这个时候容器里面会有这5个bean。
1)、ConfigurationClassPostProcessor : 配置类后置处理器
2)、DefaultEventListenerFactory : 默认的事件监听器工厂
3)、EventListenerMethodProcessor : 默认方法的处理器
4)、AutowiredAnnotationBeanPostProcessor : 自动装配注解Bean后置处理器
5)、CommonAnnotationBeanPostProcessor : 普通注解bean后置处理器
有图有真相，直接上图:
这个方法执行完毕后， this.reader = new AnnotatedBeanDefinitionReader(this); 这个方法也就执行完毕了，因为没有往上游传返回值。回到上面代码中的new ClassPathBeanDefinitionScanner(this)中。
3.4new ClassPathBeanDefinitionScanner(this)
这里不做解析了，没啥用。
4.this.register(componentClasses)
这个从代码中就可以看出来是注册参数，这个参数是传进来的配置类。
点进这个方法中可以看出配置类可以传多个。但是几乎不会这样做。
public void register(Class<?>... componentClasses) {
// 判断这个集合为空的话就抛异常Assert.notEmpty(componentClasses, "At least one component class must be specified");// 读取注册器配置类。this.reader.register(componentClasses);}
点进这个方法 this.reader.register(componentClasses);
// 循环这个配置类集合，然后注册这个配置类。
public void register(Class<?>... componentClasses) {
Class[] var2 = componentClasses;int var3 = componentClasses.length;for(int var4 = 0; var4 < var3; ++var4) {
Class<?> componentClass = var2[var4];// 点进这个方法this.registerBean(componentClass);}}
this.registerBean(componentClass);
// 这个方法还要再点进去.
public void registerBean(Class<?> beanClass) {
this.doRegisterBean(beanClass, (String)null, (Class[])null, (Supplier)null, (BeanDefinitionCustomizer[])null);}
this.doRegisterBean(beanClass, (String)null, (Class[])null, (Supplier)null, (BeanDefinitionCustomizer[])null);
// 只看重点。
private <T> void doRegisterBean(Class<T> beanClass, @Nullable String name, @Nullable Class<? extends Annotation>[] qualifiers, @Nullable Supplier<T> supplier, @Nullable BeanDefinitionCustomizer[] customizers) {
AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(beanClass);if (!this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
abd.setInstanceSupplier(supplier);ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);abd.setScope(scopeMetadata.getScopeName());String beanName = name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry);AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);int var10;int var11;if (qualifiers != null) {
Class[] var9 = qualifiers;var10 = qualifiers.length;for(var11 = 0; var11 < var10; ++var11) {
Class<? extends Annotation> qualifier = var9[var11];if (Primary.class == qualifier) {
abd.setPrimary(true);} else if (Lazy.class == qualifier) {
abd.setLazyInit(true);} else {
abd.addQualifier(new AutowireCandidateQualifier(qualifier));}}}if (customizers != null) {
BeanDefinitionCustomizer[] var13 = customizers;var10 = customizers.length;for(var11 = 0; var11 < var10; ++var11) {
BeanDefinitionCustomizer customizer = var13[var11];customizer.customize(abd);}}BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);// 整段代码的重点。注册bean。点进去BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);}}
BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
public static void registerBeanDefinition(BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)throws BeanDefinitionStoreException {
// Register bean definition under primary name.// 获取配置类。String beanName = definitionHolder.getBeanName();//把配置类注册到spring容器当中，这个代码单独讲registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());// Register aliases for bean name, if any.String[] aliases = definitionHolder.getAliases();if (aliases != null) {
for (String alias : aliases) {
registry.registerAlias(beanName, alias);}}}
registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
这个方法点进去是BeanDefinitionRegistry接口调用的。这个时候debug下找到这个registry发现其实是一个
AnnotationConfigApplicationContext，但是AnnotationConfigApplicationContext中并没有registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());这个方法，但是在它的父类GenericApplicationContext找到了这个方法。
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) throws BeanDefinitionStoreException {
// 这个beanFactory其实就是上面所初始化的 DefaultListableBeanFactory。// 调用 DefaultListableBeanFactory 中的 registerBeanDefinition 看看this.beanFactory.registerBeanDefinition(beanName, beanDefinition);}
this.beanFactory.registerBeanDefinition(beanName, beanDefinition);
因为这个方法上面标注了@Override注解，发现这个方法是实现了接口方法。
在BeanDefinitionRegistry接口中可以找到这个方法。
@Overridepublic void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)throws BeanDefinitionStoreException {
Assert.hasText(beanName, "Bean name must not be empty");Assert.notNull(beanDefinition, "BeanDefinition must not be null");if (beanDefinition instanceof AbstractBeanDefinition) {
try {
((AbstractBeanDefinition) beanDefinition).validate();}catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,"Validation of bean definition failed", ex);}}BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);if (existingDefinition != null) {
if (!isAllowBeanDefinitionOverriding()) {
throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);}else if (existingDefinition.getRole() < beanDefinition.getRole()) {
// e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTUREif (logger.isInfoEnabled()) {
logger.info("Overriding user-defined bean definition for bean '" + beanName +"' with a framework-generated bean definition: replacing [" +existingDefinition + "] with [" + beanDefinition + "]");}}else if (!beanDefinition.equals(existingDefinition)) {
if (logger.isDebugEnabled()) {
logger.debug("Overriding bean definition for bean '" + beanName +"' with a different definition: replacing [" + existingDefinition +"] with [" + beanDefinition + "]");}}else {
if (logger.isTraceEnabled()) {
logger.trace("Overriding bean definition for bean '" + beanName +"' with an equivalent definition: replacing [" + existingDefinition +"] with [" + beanDefinition + "]");}}this.beanDefinitionMap.put(beanName, beanDefinition);}else {
if (hasBeanCreationStarted()) {
// Cannot modify startup-time collection elements anymore (for stable iteration)synchronized (this.beanDefinitionMap) {
this.beanDefinitionMap.put(beanName, beanDefinition);List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);updatedDefinitions.addAll(this.beanDefinitionNames);updatedDefinitions.add(beanName);this.beanDefinitionNames = updatedDefinitions;removeManualSingletonName(beanName);}}else {
// Still in startup registration phase// 在这一步完成了注册配置类到bean工厂，这个put是往beanDefinitionMap里面存放this.beanDefinitionMap.put(beanName, beanDefinition);// 往beanDefinitionNames中存放配置类的名字。this.beanDefinitionNames.add(beanName);removeManualSingletonName(beanName);}this.frozenBeanDefinitionNames = null;}if (existingDefinition != null || containsSingleton(beanName)) {
resetBeanDefinition(beanName);}}
这段代码走完后就已经完成了对配置类的注册。
5.this.refresh();
回到AnnotationConfigApplicationContext无参构造器中的第三行代码。
public void refresh() throws BeansException, IllegalStateException {
synchronized(this.startupShutdownMonitor) {
this.prepareRefresh();ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();this.prepareBeanFactory(beanFactory);try {
this.postProcessBeanFactory(beanFactory);// 完成了把所有bean放到definitionBeanMap当中。this.invokeBeanFactoryPostProcessors(beanFactory);// 注册了bean工厂的后置处理器，把这些后置处理器放到单例池中this.registerBeanPostProcessors(beanFactory);// 初始化数据源this.initMessageSource();this.initApplicationEventMulticaster();this.onRefresh();this.registerListeners();// 完成了对扫描到的bean的实例化// 最重要的这是行代码，点进去看this.finishBeanFactoryInitialization(beanFactory);this.finishRefresh();} catch (BeansException var9) {
if (this.logger.isWarnEnabled()) {
this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt: " + var9);}this.destroyBeans();this.cancelRefresh(var9);throw var9;} finally {
this.resetCommonCaches();}}}
this.finishBeanFactoryInitialization(beanFactory);
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
if (beanFactory.containsBean("conversionService") && beanFactory.isTypeMatch("conversionService", ConversionService.class)) {
beanFactory.setConversionService((ConversionService)beanFactory.getBean("conversionService", ConversionService.class));}if (!beanFactory.hasEmbeddedValueResolver()) {
beanFactory.addEmbeddedValueResolver((strVal) -> {
return this.getEnvironment().resolvePlaceholders(strVal);});}String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);String[] var3 = weaverAwareNames;int var4 = weaverAwareNames.length;for(int var5 = 0; var5 < var4; ++var5) {
String weaverAwareName = var3[var5];this.getBean(weaverAwareName);}beanFactory.setTempClassLoader((ClassLoader)null);beanFactory.freezeConfiguration();// 这里一行代码最为重要，顾名思义：实例化单实例beanFactory.preInstantiateSingletons();}
beanFactory.preInstantiateSingletons();
这里调用的是DefaultLIstableBeanFactory中的beanFactory.preInstantiateSingletons();
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. // 从bean工厂当中获取当前所有bean的名字。List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);// Trigger initialization of all non-lazy singleton beans...// 循环遍历bean。for (String beanName : beanNames) {
// 获取合并描述beanRootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);// 判断是否抽象，是否单实例，是否懒加载。if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
// 判断是否是一个工厂bean，相当于可以理解是否是一个特殊bean。if (isFactoryBean(beanName)) {
Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);if (bean instanceof FactoryBean) {
final FactoryBean<?> factory = (FactoryBean<?>) bean;boolean isEagerInit;if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)((SmartFactoryBean<?>) factory)::isEagerInit,getAccessControlContext());}else {
isEagerInit = (factory instanceof SmartFactoryBean &&((SmartFactoryBean<?>) factory).isEagerInit());}if (isEagerInit) {
getBean(beanName);}}}else {
// 这里的代码最为关键，点进去看，这里是获取bean的地方。getBean(beanName);}}}// Trigger post-initialization callback for all applicable beans...for (String beanName : beanNames) {
Object singletonInstance = getSingleton(beanName);if (singletonInstance instanceof SmartInitializingSingleton) {
final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
smartSingleton.afterSingletonsInstantiated();return null;}, getAccessControlContext());}else {
smartSingleton.afterSingletonsInstantiated();}}}}
getBean(beanName);
顾名思义就是获取bean。
public Object getBean(String name) throws BeansException {
return doGetBean(name, null, null, false);}
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 {
final String beanName = transformedBeanName(name);Object bean;// Eagerly check singleton cache for manually registered singletons.// 从单例缓存池中获取bean，这个时候肯定是为null，因为这个时候单例池里面还没有这个bean// 后面往容器当中拿bean的时候就不会为null。Object sharedInstance = getSingleton(beanName);if (sharedInstance != null && args == null) {
if (logger.isTraceEnabled()) {
if (isSingletonCurrentlyInCreation(beanName)) {
logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +"' that is not fully initialized yet - a consequence of a circular reference");}else {
logger.trace("Returning cached instance of singleton bean '" + beanName + "'");}}bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);}else {
// Fail if we're already creating this bean instance:// We're assumably within a circular reference.if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);}// Check if bean definition exists in this factory.// 获取父bean工厂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 if (requiredType != null) {
// No args -> delegate to standard getBean method.return parentBeanFactory.getBean(nameToLookup, requiredType);}else {
return (T) parentBeanFactory.getBean(nameToLookup);}}if (!typeCheckOnly) {
// 标记bean正在被创建，是一个标识。markBeanAsCreated(beanName);}try {
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);checkMergedBeanDefinition(mbd, beanName, args);// Guarantee initialization of beans that the current 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);}}}// Create bean instance.if (mbd.isSingleton()) {
// 获取单实例，这个方法要点进去sharedInstance = getSingleton(beanName, () -> {
try {
// 创建beanreturn 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);}else if (mbd.isPrototype()) {
// It's a prototype -> create a new instance.Object prototypeInstance = null;try {
beforePrototypeCreation(beanName);prototypeInstance = createBean(beanName, mbd, args);}finally {
afterPrototypeCreation(beanName);}bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);}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.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.isTraceEnabled()) {
logger.trace("Failed to convert bean '" + name + "' to required type '" +ClassUtils.getQualifiedName(requiredType) + "'", ex);}throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());}}return (T) bean;}
这个方法中有俩个getSingleton，第一个getSingleton(beanName); 是为了从单例缓存池当中获取这个bean，在创建bean这个的时候，单例池(singletonObjects)当中没有这个bean，则会创建这个bean。后续从容器当中拿bean的时候一样会走这个getSingleton(beanName);方法，而这个时候单例池当中有这个bean则会拿到返回这个bean。
第二个getSingleton，则是创建bean。
sharedInstance = getSingleton(beanName, () ->
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(beanName, "Bean name must not be null");synchronized (this.singletonObjects) {
// 第一次获取，肯定是为null，这个时候单例池里面还没有这个bean。Object singletonObject = this.singletonObjects.get(beanName);if (singletonObject == null) {
if (this.singletonsCurrentlyInDestruction) {
throw new BeanCreationNotAllowedException(beanName,"Singleton bean creation not allowed while singletons of this factory are in destruction " +"(Do not request a bean from a BeanFactory in a destroy method implementation!)");}if (logger.isDebugEnabled()) {
logger.debug("Creating shared instance of singleton bean '" + beanName + "'");}beforeSingletonCreation(beanName);boolean newSingleton = false;boolean recordSuppressedExceptions = (this.suppressedExceptions == null);if (recordSuppressedExceptions) {
this.suppressedExceptions = new LinkedHashSet<>();}try {
// 创建bean，如果能拿到这个单实例，说明是第一次创建。singletonObject = singletonFactory.getObject();// 则会把这个新单实例改为true，下面添加的单实例的时候则会判断是否是true，是则添 加。newSingleton = true;}catch (IllegalStateException ex) {
// Has the singleton object implicitly appeared in the meantime ->// if yes, proceed with it since the exception indicates that state.singletonObject = this.singletonObjects.get(beanName);if (singletonObject == null) {
throw ex;}}catch (BeanCreationException ex) {
if (recordSuppressedExceptions) {
for (Exception suppressedException : this.suppressedExceptions) {
ex.addRelatedCause(suppressedException);}}throw ex;}finally {
if (recordSuppressedExceptions) {
this.suppressedExceptions = null;}afterSingletonCreation(beanName);}if (newSingleton) {
// 添加单实例addSingleton(beanName, singletonObject);}}return singletonObject;}}
addSingleton(beanName, singletonObject);
protected void addSingleton(String beanName, Object singletonObject) {
synchronized (this.singletonObjects) {
// 把bean添加到单实例池当中。// 单实例池：singletonObjects,是一个Mapthis.singletonObjects.put(beanName, singletonObject);this.singletonFactories.remove(beanName);this.earlySingletonObjects.remove(beanName);// 把bean的名字添加到一个set当中，这个set是一组已注册的单例对象，按注册顺序包含bean名称。this.registeredSingletons.add(beanName);}}
总结：
? this():
? 创建了DefaultListabBeanFacory（bean工厂），把spring开天辟地所需要的5个组件注册到了DefinitionBean当中。
? this.register(componentClasses);
? 把配置类注册到了DefinitionBean当中。
? this.refresh();
? 扫描bean，把bean注册到单例池里面。