Spring Bean生命周期(基于spring-beans-6.2.6分析)

Spring Bean生命周期(基于spring-beans-6.2.6分析)

SpringApplication.run()
 └─> createApplicationContext()
 └─> refreshContext()
     └─> AbstractApplicationContext.refresh()
         ├─> prepareRefresh()
         ├─> obtainFreshBeanFactory()        ← 加载 BeanDefinition
         ├─> prepareBeanFactory()            ← 设置基础属性
         ├─> invokeBeanFactoryPostProcessors()← 修改 BeanDefinition
         ├─> registerBeanPostProcessors()    ← 注册后置处理器
         ├─> initMessageSource()
         ├─> initApplicationEventMulticaster()
         ├─> onRefresh()                     ← 子类扩展点（如 Web 应用）
         ├─> registerListeners()
         ├─> finishBeanFactoryInitialization()
         |   └─> preInstantiateSingletons()  ← 实例化单例 Bean
         |       └─> getBean()               ← 获取 Bean 实例
         |           └─> doGetBean()
         |               └─> getSingleton()  ← 三级缓存机制
         |                   └─> singletonFactory.getObject()
         |                       └─> createBean()
         |                           ├─> doCreateBean()
         |                           |   ├─> createBeanInstance() ← 构造函数实例化
         |                           |   ├─> populateBean()       ← 属性填充
         |                           |   └─> initializeBean()     ← 初始化（@PostConstruct 等）
         └─> finishRefresh()

HawkeyeServer

@SpringBootApplication
public class HawkeyeServer {

    public static void main(String[] args) {
        SpringApplication.run(HawkeyeAiServer.class, args);
    }

}

SpringApplication

public ConfigurableApplicationContext run(String... args) {
        Startup startup = SpringApplication.Startup.create();
        if (this.properties.isRegisterShutdownHook()) {
            shutdownHook.enableShutdownHookAddition();
        }

        DefaultBootstrapContext bootstrapContext = this.createBootstrapContext();
        ConfigurableApplicationContext context = null;
        this.configureHeadlessProperty();
        SpringApplicationRunListeners listeners = this.getRunListeners(args);
        listeners.starting(bootstrapContext, this.mainApplicationClass);

        try {
            ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
            ConfigurableEnvironment environment = this.prepareEnvironment(listeners, bootstrapContext, applicationArguments);
            Banner printedBanner = this.printBanner(environment);
            context = this.createApplicationContext();
            context.setApplicationStartup(this.applicationStartup);
            this.prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
            // 初始刷新化容器
            this.refreshContext(context);
            this.afterRefresh(context, applicationArguments);
            startup.started();
            if (this.properties.isLogStartupInfo()) {
                (new StartupInfoLogger(this.mainApplicationClass, environment)).logStarted(this.getApplicationLog(), startup);
            }

            listeners.started(context, startup.timeTakenToStarted());
            this.callRunners(context, applicationArguments);
        } catch (Throwable ex) {
            throw this.handleRunFailure(context, ex, listeners);
        }

        try {
            if (context.isRunning()) {
                listeners.ready(context, startup.ready());
            }

            return context;
        } catch (Throwable ex) {
            throw this.handleRunFailure(context, ex, (SpringApplicationRunListeners)null);
        }
    }

 private void refreshContext(ConfigurableApplicationContext context) {
        if (this.properties.isRegisterShutdownHook()) {
            shutdownHook.registerApplicationContext(context);
        }

        this.refresh(context);
    }

 protected void refresh(ConfigurableApplicationContext applicationContext) {
        applicationContext.refresh();
    }

AbstractApplicationContext

 public void refresh() throws BeansException, IllegalStateException {
        this.startupShutdownLock.lock();

        try {
            this.startupShutdownThread = Thread.currentThread();
            StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");
            this.prepareRefresh();
            ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
            this.prepareBeanFactory(beanFactory);

            try {
                this.postProcessBeanFactory(beanFactory);
                StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
                this.invokeBeanFactoryPostProcessors(beanFactory);
                this.registerBeanPostProcessors(beanFactory);
                beanPostProcess.end();
                this.initMessageSource();
                this.initApplicationEventMulticaster();
                this.onRefresh();
                this.registerListeners();
                // 完成 BeanFactory 的初始化，实例化所有非懒加载的单例 Bean。
                this.finishBeanFactoryInitialization(beanFactory);
                this.finishRefresh();
            } catch (Error | RuntimeException var12) {
                if (this.logger.isWarnEnabled()) {
                    this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt: " + String.valueOf(var12));
                }

                this.destroyBeans();
                this.cancelRefresh(var12);
                throw var12;
            } finally {
                contextRefresh.end();
            }
        } finally {
            this.startupShutdownThread = null;
            this.startupShutdownLock.unlock();
        }

    }

this.obtainFreshBeanFactory();

// 获取一个全新的 ConfigurableListableBeanFactory 实例，并加载所有的 BeanDefinition。
ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory(); 
public DefaultListableBeanFactory() {
        this.autowireCandidateResolver = SimpleAutowireCandidateResolver.INSTANCE;
        this.resolvableDependencies = new ConcurrentHashMap(16);
        this.beanDefinitionMap = new ConcurrentHashMap(256);
        this.mergedBeanDefinitionHolders = new ConcurrentHashMap(256);
        this.primaryBeanNames = ConcurrentHashMap.newKeySet(16);
        this.allBeanNamesByType = new ConcurrentHashMap(64);
        this.singletonBeanNamesByType = new ConcurrentHashMap(64);
        this.beanDefinitionNames = new ArrayList(256);
        this.manualSingletonNames = new LinkedHashSet(16);
        this.preInstantiationThread = new NamedThreadLocal("Pre-instantiation thread marker");
    }

this.invokeBeanFactoryPostProcessors(beanFactory);

// 执行所有的 BeanFactoryPostProcessor，这些处理器可以在 Bean 实例化前修改 BeanDefinition。
this.postProcessBeanFactory(beanFactory);

AbstractApplicationContext#PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, this.getBeanFactoryPostProcessors());

// 调用getBean
AbstractApplicationContext#currentRegistryProcessors.add((BeanDefinitionRegistryPostProcessor)beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
 
AbstractBeanFactory#doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly);
	 // 第一次初始化为空的
	 Object sharedInstance = this.getSingleton(beanName);
	 // 第一次初始化将bean的封装创建逻辑放入 
	 sharedInstance = this.getSingleton(beanName, () -> {
                        try {
                            return this.createBean(beanName, mbd, args);
                        } catch (BeansException ex) {
                            this.destroySingleton(beanName);
                            throw ex;
                        }
                    });

     

this.finishBeanFactoryInitialization(beanFactory);

// 完成 BeanFactory 的初始化，实例化所有非懒加载的单例 Bean。
this.finishBeanFactoryInitialization(beanFactory);

// 获取Bean
AbstractBeanFactory#doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)

// 使用三级缓存机制获取Bean，解决循环依赖
DefaultSingletonBeanRegistry#getSingleton(String beanName, boolean allowEarlyReference);
    protected Object getSingleton(String beanName, boolean allowEarlyReference) {
        Object singletonObject = this.singletonObjects.get(beanName);
        if (singletonObject == null && this.isSingletonCurrentlyInCreation(beanName)) {
            singletonObject = this.earlySingletonObjects.get(beanName);
            if (singletonObject == null && allowEarlyReference) {
                if (!this.singletonLock.tryLock()) {
                    return null;
                }

                try {
                    singletonObject = this.singletonObjects.get(beanName);
                    if (singletonObject == null) {
                        singletonObject = this.earlySingletonObjects.get(beanName);
                        if (singletonObject == null) {
                            ObjectFactory<?> singletonFactory = (ObjectFactory)this.singletonFactories.get(beanName);
                            if (singletonFactory != null) {
                                // 接口常用于延迟加载对象封装创建逻辑 
                                // 延迟加载 避免过早暴露原始对象，防止后续无法生成代理
                                // 代理对象
                                singletonObject = singletonFactory.getObject();
                                if (this.singletonFactories.remove(beanName) != null) {
                                    this.earlySingletonObjects.put(beanName, singletonObject);
                                } else {
                                    singletonObject = this.singletonObjects.get(beanName);
                                }
                            }
                        }
                    }
                } finally {
                    this.singletonLock.unlock();
                }
            }
        }

        return singletonObject;
    }

// 创建createBean逻辑
// singletonObject = singletonFactory.getObject();等价于singletonObject = createBean(beanName, mbd, args);
AbstractAutowireCapableBeanFactory#doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)；

AbstractAutowireCapableBeanFactory

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
        BeanWrapper instanceWrapper = null;
        if (mbd.isSingleton()) {
            instanceWrapper = (BeanWrapper)this.factoryBeanInstanceCache.remove(beanName);
        }

        if (instanceWrapper == null) {
            // 实例化
            instanceWrapper = this.createBeanInstance(beanName, mbd, args);
        }

        Object bean = instanceWrapper.getWrappedInstance();
        Class<?> beanType = instanceWrapper.getWrappedClass();
        if (beanType != NullBean.class) {
            mbd.resolvedTargetType = beanType;
        }

        synchronized(mbd.postProcessingLock) {
            if (!mbd.postProcessed) {
                try {
                    this.applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
                } catch (Throwable ex) {
                    throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Post-processing of merged bean definition failed", ex);
                }

                mbd.markAsPostProcessed();
            }
        }

        boolean earlySingletonExposure = mbd.isSingleton() && this.allowCircularReferences && this.isSingletonCurrentlyInCreation(beanName);
        if (earlySingletonExposure) {
            if (this.logger.isTraceEnabled()) {
                this.logger.trace("Eagerly caching bean '" + beanName + "' to allow for resolving potential circular references");
            }

            this.addSingletonFactory(beanName, () -> this.getEarlyBeanReference(beanName, mbd, bean));
        }

        Object exposedObject = bean;

        try {
            // 填充属性
            this.populateBean(beanName, mbd, instanceWrapper);
            // 初始化
            exposedObject = this.initializeBean(beanName, exposedObject, mbd);
        } catch (Throwable var18) {
            if (var18 instanceof BeanCreationException bce) {
                if (beanName.equals(bce.getBeanName())) {
                    throw bce;
                }
            }

            throw new BeanCreationException(mbd.getResourceDescription(), beanName, var18.getMessage(), var18);
        }

        if (earlySingletonExposure) {
            Object earlySingletonReference = this.getSingleton(beanName, false);
            if (earlySingletonReference != null) {
                if (exposedObject == bean) {
                    exposedObject = earlySingletonReference;
                } else if (!this.allowRawInjectionDespiteWrapping && this.hasDependentBean(beanName)) {
                    String[] dependentBeans = this.getDependentBeans(beanName);
                    Set<String> actualDependentBeans = CollectionUtils.newLinkedHashSet(dependentBeans.length);

                    for(String dependentBean : dependentBeans) {
                        if (!this.removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
                            actualDependentBeans.add(dependentBean);
                        }
                    }

                    if (!actualDependentBeans.isEmpty()) {
                        throw new BeanCurrentlyInCreationException(beanName, "Bean with name '" + beanName + "' has been injected into other beans [" + StringUtils.collectionToCommaDelimitedString(actualDependentBeans) + "] in its raw version as part of a circular reference, but has eventually been wrapped. This means that said other beans do not use the final version of the bean. This is often the result of over-eager type matching - consider using 'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.");
                    }
                }
            }
        }

        try {
            this.registerDisposableBeanIfNecessary(beanName, bean, mbd);
            return exposedObject;
        } catch (BeanDefinitionValidationException ex) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
        }
    }