在网上曾经有跟多Bean的生命周期的博客，然而很多都是基于比拟老的版本了，最近把整个流程画成了一个流程图。待会儿应用流程图，阐明以及代码的模式来阐明整个申明周期的流程。留神因为代码比拟多，这里的流程图只画出了大略的流程，具体的能够深刻代码
1.获取Bean
这里的流程图的入口在AbstractBeanFactory类的doGetBean办法，这里能够配合后面的getBean办法剖析文章进行浏览。次要流程就是
- 先解决Bean 的名称，因为如果以“&”结尾的Bean名称示意获取的是对应的FactoryBean对象；
- 从缓存中获取单例Bean，有则进一步判断这个Bean是不是在创立中，如果是的就期待创立结束，否则间接返回这个Bean对象
- 如果不存在单例Bean缓存，则先进行循环依赖的解析
- 解析结束之后先获取父类BeanFactory，获取到了则调用父类的getBean办法，不存在则先合并而后创立Bean
2.创立Bean
2.1 创立Bean之前
这个流程图对应的代码在AbstractAutowireCapableBeanFactory类的createBean办法中。
- 这里会先获取RootBeanDefinition对象中的Class对象并确保曾经关联了要创立的Bean的Class。
- 这里会查看3个条件
（1）Bean的属性中的beforeInstantiationResolved字段是否为true，默认是false。
（2）Bean是原生的Bean
（3）Bean的hasInstantiationAwareBeanPostProcessors属性为true，这个属性在Spring筹备刷新容器钱转杯BeanPostProcessors的时候会设置，如果以后Bean实现了InstantiationAwareBeanPostProcessor则这个就会是true。
当三个条件都存在的时候，就会调用实现的InstantiationAwareBeanPostProcessor接口的postProcessBeforeInstantiation办法，而后获取返回的Bean，如果返回的Bean不是null还会调用实现的BeanPostProcessor接口的postProcessAfterInitialization办法，这里用代码阐明
protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) { Object bean = null; //条件1 if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) { //条件2跟条件3 if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) { Class<?> targetType = determineTargetType(beanName, mbd); if (targetType != null) { //调用实现的postProcessBeforeInstantiation办法 bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName); if (bean != null) {//调用实现的postProcessAfterInitialization办法 bean = applyBeanPostProcessorsAfterInitialization(bean, beanName); } } } //不满足2或者3的时候就会设置为false mbd.beforeInstantiationResolved = (bean != null); } return bean; }- 如果下面3个条件其中一个不满足就不会调用实现的办法。默认这里都不会调用的这些BeanPostProcessors的实现办法。而后继续执行前面的doCreateBean办法。
2.1 真正的创立Bean，doCreateBean
这个代码的实现还是在AbstractAutowireCapableBeanFactory办法中。流程是
1.先查看instanceWrapper变量是不是null，这里个别是null，除非以后正在创立的Bean在factoryBeanInstanceCache中存在这个是保留还没创立实现的FactoryBean的汇合。
2.调用createBeanInstance办法实例化Bean，这个办法在前面会解说
3.如果以后RootBeanDefinition对象还没有调用过实现了的MergedBeanDefinitionPostProcessor接口的办法，则会进行调用
4.当满足以下三点
（1）是单例Bean
（2）尝试解析bean之间的循环援用
（3）bean目前正在创立中
则会进一步查看是否实现了SmartInstantiationAwareBeanPostProcessor接口如果实现了则调用是实现的getEarlyBeanReference办法
5.调用populateBean办法进行属性填充，这里前面会解说
6.调用initializeBean办法对Bean进行初始化，这里前面会解说
2.1.1 实例化Bean，createBeanInstance
这里的逻辑略微有一点简单，这个流程图曾经是简化过后的了。简要依据代码阐明一下流程
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) { //步骤1 Class<?> beanClass = resolveBeanClass(mbd, beanName); if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) { throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Bean class isn't public, and non-public access not allowed: " + beanClass.getName()); } //步骤2 Supplier<?> instanceSupplier = mbd.getInstanceSupplier(); if (instanceSupplier != null) { return obtainFromSupplier(instanceSupplier, beanName); } //步骤3 if (mbd.getFactoryMethodName() != null) { return instantiateUsingFactoryMethod(beanName, mbd, args); } boolean resolved = false; boolean autowireNecessary = false; if (args == null) { synchronized (mbd.constructorArgumentLock) { if (mbd.resolvedConstructorOrFactoryMethod != null) { resolved = true; autowireNecessary = mbd.constructorArgumentsResolved; } } } //步骤4.1 if (resolved) { if (autowireNecessary) { return autowireConstructor(beanName, mbd, null, null); } else { return instantiateBean(beanName, mbd); } } //步骤4.2 Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName); if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR || mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) { return autowireConstructor(beanName, mbd, ctors, args); } //步骤5 ctors = mbd.getPreferredConstructors(); if (ctors != null) { return autowireConstructor(beanName, mbd, ctors, null); } return instantiateBean(beanName, mbd); }- 先查看Class是否曾经关联了，并且对应的修饰符是否是public的
- 如果用户定义了Bean实例化的函数，则调用并返回
- 如果以后Bean实现了FactoryBean接口则调用对应的FactoryBean接口的getObject办法
- 依据getBean时候是否传入结构参数进行解决
4.1 如果没有传入结构参数，则查看是否存在曾经缓存的无参结构器，有则应用结构器间接创立，没有就会调用instantiateBean办法先获取实例化的策略默认是CglibSubclassingInstantiationStrategy，而后实例化Bean。最初返回
4.2 如果传入了结构参数，则会先查看是否实现了SmartInstantiationAwareBeanPostProcessor接口，如果实现了会调用determineCandidateConstructors获取返回的候选结构器。
4.3 查看4个条件是否满足一个
（1）结构器不为null
（2）从RootBeanDefinition中获取到的关联的注入形式是结构器注入（没有结构参数就是setter注入，有则是结构器注入）
（3）含有结构参数
（4）getBean办法传入结构参数不是空
满足其中一个则会调用返回的候选结构器实例化Bean并返回，如果都不满足，则会依据结构参数选则适合的有参结构器而后实例化Bean并返回
5.如果下面都没有适合的结构器，则间接应用无参结构器创立并返回Bean。
2.1.2 填充Bean，populateBean
这里还是依据代码来说一下流程
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) { if (bw == null) { if (mbd.hasPropertyValues()) { throw new BeanCreationException( mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance"); } else { // Skip property population phase for null instance. return; } } boolean continueWithPropertyPopulation = true; //步骤1 if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) { for (BeanPostProcessor bp : getBeanPostProcessors()) { if (bp instanceof InstantiationAwareBeanPostProcessor) { InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp; if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) { continueWithPropertyPopulation = false; break; } } } } if (!continueWithPropertyPopulation) { return; }//步骤2-------------------- PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null); int resolvedAutowireMode = mbd.getResolvedAutowireMode(); if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) { MutablePropertyValues newPvs = new MutablePropertyValues(pvs); // Add property values based on autowire by name if applicable. if (resolvedAutowireMode == AUTOWIRE_BY_NAME) { autowireByName(beanName, mbd, bw, newPvs); } // Add property values based on autowire by type if applicable. if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) { autowireByType(beanName, mbd, bw, newPvs); } pvs = newPvs; } boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors(); boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE); PropertyDescriptor[] filteredPds = null;//步骤3 if (hasInstAwareBpps) { if (pvs == null) { pvs = mbd.getPropertyValues(); } for (BeanPostProcessor bp : getBeanPostProcessors()) { if (bp instanceof InstantiationAwareBeanPostProcessor) { InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp; PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName); if (pvsToUse == null) { if (filteredPds == null) { filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching); } pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName); if (pvsToUse == null) { return; } } pvs = pvsToUse; } } } if (needsDepCheck) { if (filteredPds == null) { filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching); } checkDependencies(beanName, mbd, filteredPds, pvs); }//步骤4 if (pvs != null) { applyPropertyValues(beanName, mbd, bw, pvs); } }- 查看以后Bean是否实现了InstantiationAwareBeanPostProcessor的postProcessAfterInstantiation办法则调用，并完结Bean的填充。
- 将依照类型跟依照名称注入的Bean离开，如果注入的Bean还没有实例化的这里会实例化，而后放到PropertyValues对象中。
- 如果实现了InstantiationAwareBeanPostProcessor类的postProcessProperties则调用这个办法并获取返回值，如果返回值是null，则有可能是实现了过期的postProcessPropertyValues办法，这里须要进一步调用postProcessPropertyValues办法
- 进行参数填充
2.1.3 初始化Bean，initializeBean
同时这里依据代码跟流程图来阐明
- 如果Bean实现了BeanNameAware,BeanClassLoaderAware,BeanFactoryAware则调用对应实现的办法
- Bean不为null并且bean不是合成的，如果实现了BeanPostProcessor的postProcessBeforeInitialization则会调用实现的postProcessBeforeInitialization办法。在ApplicationContextAwareProcessor类中实现了postProcessBeforeInitialization办法。而这个类会在Spring刷新容器筹备beanFactory的时候会加进去，这里就会被调用，而调用外面会查看Bean是不是EnvironmentAware,EmbeddedValueResolverAware,ResourceLoaderAware,ApplicationEventPublisherAware,MessageSourceAware,ApplicationContextAware的实现类。这里就会调用对应的实现办法。代码如下
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) { ....... beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this)); ....... public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { if (!(bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware || bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware || bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware)){ return bean; } AccessControlContext acc = null; if (System.getSecurityManager() != null) { acc = this.applicationContext.getBeanFactory().getAccessControlContext(); } if (acc != null) { AccessController.doPrivileged((PrivilegedAction<Object>) () -> { invokeAwareInterfaces(bean); return null; }, acc); } else { invokeAwareInterfaces(bean); } return bean; }3.实例化Bean而后，查看是否实现了InitializingBean的afterPropertiesSet办法，如果实现了就会调用
4.Bean不为null并且bean不是合成的，如果实现了BeanPostProcessor的postProcessBeforeInitialization则会调用实现的postProcessAfterInitialization办法。到此创立Bean 的流程就没了，剩下的就是容器销毁的时候的了
3.destory办法跟销毁Bean
Bean在创立结束之后会检查用户是否指定了destroyMethodName以及是否实现了DestructionAwareBeanPostProcessor接口的requiresDestruction办法，如果指定了会记录下来保留在DisposableBeanAdapter对象中并保留在bean的disposableBeans属性中。代码在AbstractBeanFactory的registerDisposableBeanIfNecessary中
protected void registerDisposableBeanIfNecessary(String beanName, Object bean, RootBeanDefinition mbd) { ...... registerDisposableBean(beanName, new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc)); ...... }public DisposableBeanAdapter(Object bean, String beanName, RootBeanDefinition beanDefinition, List<BeanPostProcessor> postProcessors, @Nullable AccessControlContext acc) { ....... String destroyMethodName = inferDestroyMethodIfNecessary(bean, beanDefinition); if (destroyMethodName != null && !(this.invokeDisposableBean && "destroy".equals(destroyMethodName)) && !beanDefinition.isExternallyManagedDestroyMethod(destroyMethodName)) { ...... this.destroyMethod = destroyMethod; } this.beanPostProcessors = filterPostProcessors(postProcessors, bean); }在销毁Bean的时候最初都会调用AbstractAutowireCapableBeanFactory的destroyBean办法。
public void destroyBean(Object existingBean) { new DisposableBeanAdapter(existingBean, getBeanPostProcessors(), getAccessControlContext()).destroy(); }这里是创立一个DisposableBeanAdapter对象，这个对象实现了Runnable接口，在实现的run办法中会调用实现的DisposableBean接口的destroy办法。并且在创立DisposableBeanAdapter对象的时候会依据传入的bean是否实现了DisposableBean接口来设置invokeDisposableBean变量，这个变量表实有没有实现DisposableBean接口
public DisposableBeanAdapter(Object bean, List<BeanPostProcessor> postProcessors, AccessControlContext acc) { Assert.notNull(bean, "Disposable bean must not be null"); this.bean = bean; this.beanName = bean.getClass().getName(); //依据传入的bean是否实现了`DisposableBean`接口来设置`invokeDisposableBean`变量 this.invokeDisposableBean = (this.bean instanceof DisposableBean); this.nonPublicAccessAllowed = true; this.acc = acc; this.beanPostProcessors = filterPostProcessors(postProcessors, bean); } public void destroy() { ...... //依据invokeDisposableBean决定是否调用destroy办法 if (this.invokeDisposableBean) { if (logger.isTraceEnabled()) { logger.trace("Invoking destroy() on bean with name '" + this.beanName + "'"); } try { if (System.getSecurityManager() != null) { AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> { ((DisposableBean) this.bean).destroy(); return null; }, this.acc); } else { ((DisposableBean) this.bean).destroy(); } } catch (Throwable ex) { String msg = "Invocation of destroy method failed on bean with name '" + this.beanName + "'"; if (logger.isDebugEnabled()) { logger.warn(msg, ex); } else { logger.warn(msg + ": " + ex); } } }...... }4.总结
最初来一个大的流程
- 实例化前的筹备阶段
- 实例化前
- 实例化后
- 初始化前
- 初始化之后+销毁
写在最初
欢送大家关注我的公众号【惊涛骇浪如码】，海量Java相干文章，学习材料都会在外面更新，整顿的材料也会放在外面。
感觉写的还不错的就点个赞，加个关注呗！点关注，不迷路，继续更新！！！