Spring的Bean的生命周期_面试系列之Spring

package com.example.demo.spring;


/**
 * 自定义一个Bean
 */
public class XiaoPBean {


    private String name = "xiaoP";


    public String getName() {
        return name;
    }


    public void setName(String name) {
        this.name = name;
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
                  http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
                 http://www.springframework.org/schema/context
                 http://www.springframework.org/schema/context/spring-context-3.1.xsd">


<bean id="xiaoPBean" class="com.example.demo.spring.XiaoPBean"/>
</beans>

package com.example.demo.spring;


import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;


public class BeanFactoryTest {


    @Test
    public void testSimpleLoad(){
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring/bean.xml");
        XiaoPBean xiaoPBean = (XiaoPBean) applicationContext.getBean("xiaoPBean");
        System.out.println(xiaoPBean.getName());
    }
}

@Override
  public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
      StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");


      // 1、刷新前的准备
      prepareRefresh();


      // 2、告诉子类刷新内部 bean 工厂
      ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();


      // 3、准备在此上下文中使用的 bean 工厂
      prepareBeanFactory(beanFactory);


      try {
        // 4、允许在上下文子类中对 bean 工厂进行后处理
        postProcessBeanFactory(beanFactory);


        StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
        // 5、调用在上下文中注册为 bean 的工厂处理器
        invokeBeanFactoryPostProcessors(beanFactory);


        // 6、注册拦截 bean 创建的 bean 处理器
        registerBeanPostProcessors(beanFactory);
        beanPostProcess.end();


        // 7、初始化此上下文的消息源
        initMessageSource();


        // 8、为此上下文初始化事件多播器
        initApplicationEventMulticaster();


        // 9、初始化特定上下文子类中的其他特殊 bean。
        onRefresh();


        // 10、检查监听器 bean 并注册它们
        registerListeners();


        // 11、实例化所有剩余的（非延迟初始化）单例
        finishBeanFactoryInitialization(beanFactory);


        // 12、最后一步：发布相应的事件
        finishRefresh();
      }


      catch (BeansException ex) {
        if (logger.isWarnEnabled()) {
          logger.warn("Exception encountered during context initialization - " +
              "cancelling refresh attempt: " + ex);
        }


        // 13、销毁已经创建的单例以避免悬空资源
        destroyBeans();


        // 14、重置“活动”标志
        cancelRefresh(ex);


        // 15、将异常传播给调用者
        throw ex;
      }


      finally {
        // 16、重置 Spring 核心中的常见内省缓存，因为我们可能不再需要单例 bean 的元数据......
        resetCommonCaches();
        contextRefresh.end();
      }
    }
  }

protected void prepareRefresh() {
    // 设置当前时间为容器的启动时间
    this.startupDate = System.currentTimeMillis();
    // 将关闭状态设置为false，因为要开始启动嘛
    this.closed.set(false);
    // 将激活状态设置为true
    this.active.set(true);


    //打印日志
    if (logger.isDebugEnabled()) {
      if (logger.isTraceEnabled()) {
        logger.trace("Refreshing " + this);
      }
      else {
        logger.debug("Refreshing " + getDisplayName());
      }
    }


    // 1.1、初始化Environment的propertySources属性
    initPropertySources();


    // 1.2、验证所有标记为必需的属性都是可解析的：请参阅 ConfigurablePropertyResolver#setRequiredProperties
    getEnvironment().validateRequiredProperties();


    // 1.3、存储预刷新应用程序监听器...
    if (this.earlyApplicationListeners == null) {
      this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);
    }
    else {
      // 1.4、将本地应用程序监听器重置为刷新前状态
      this.applicationListeners.clear();
      this.applicationListeners.addAll(this.earlyApplicationListeners);
    }


    // 1.5、允许收集早期的 ApplicationEvents，一旦多播器可用就发布......
    this.earlyApplicationEvents = new LinkedHashSet<>();
  }

/**
   * Tell the subclass to refresh the internal bean factory.
   * @return the fresh BeanFactory instance
   * @see #refreshBeanFactory()
   * @see #getBeanFactory()
   */
  protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
    // 1、刷新Bean工厂
    refreshBeanFactory();
    // 2、返回Bean工厂
    return getBeanFactory();
  }

@Override
  protected final void refreshBeanFactory() throws BeansException {
    // 1、当前Bean工厂是否存在
    if (hasBeanFactory()) {
      // 如果存在，就销毁工厂里的单例bean
      destroyBeans();
      // 关闭Bean工厂
      closeBeanFactory();
    }
    try {
      // 2、新创建一个Bean工厂
      DefaultListableBeanFactory beanFactory = createBeanFactory();
      // 3、给Bean工厂设置序列化id
      beanFactory.setSerializationId(getId());
      // 4、给Bean工厂做定制
      customizeBeanFactory(beanFactory);
      // 5、加载Bean定义信息
      loadBeanDefinitions(beanFactory);
      // 6、将新创建的Bean工厂设置为当前Bean工厂
      this.beanFactory = beanFactory;
    }
    catch (IOException ex) {
      throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
    }
  }

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
    // 告诉内部bean工厂使用容器的类加载器
    beanFactory.setBeanClassLoader(getClassLoader());
    if (!shouldIgnoreSpel) {
      // 设置beanFactory的表达式语言处理器,Spring3开始增加了对语言表达式的支持,默认可以使用#{bean.xxx}的形式来调用相关属性值
      beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
    }
    // 为beanFactory增加一个默认的propertyEditor
    beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));


    // 添加该处理器的作用：当应用程序定义的Bean实现ApplicationContextAware接口时注入ApplicationContext对象
    beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));


    // 如果某个 bean 依赖于以下几个接口的实现类，在自动装配的时候忽略它们，Spring 会通过其他方式来处理这些依赖
    beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
    beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
    beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
    beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
    beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
    beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
    beanFactory.ignoreDependencyInterface(ApplicationStartupAware.class);


    // 修正依赖，这里是注册一些自动装配的特殊规则，比如是BeanFactory class接口的实现类，则在运行时修指定为当前BeanFactory
    beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
    beanFactory.registerResolvableDependency(ResourceLoader.class, this);
    beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
    beanFactory.registerResolvableDependency(ApplicationContext.class, this);


    // 如果是，加入到事件监听者队列
    beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));


    // 如果找到一个LoadTimeWeaver，那么就准备将后置处理器“织入”bean工厂
    if (!NativeDetector.inNativeImage() && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
      beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
      // 为类型匹配设置临时类加载器.
      beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
    }


    // 注册默认environment环境bean
    if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
      // 环境信息ConfigurableEnvironment
      beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
    }
    if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
      //系统属性，systemProperties
      beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
    }
    if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
      // 系统环境变量systemEnvironment
      beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
    }
    if (!beanFactory.containsLocalBean(APPLICATION_STARTUP_BEAN_NAME)) {
      // 应用启动变量，5.3版本时增加
      beanFactory.registerSingleton(APPLICATION_STARTUP_BEAN_NAME, getApplicationStartup());
    }
  }

protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        // 添加ServletContextAwareProcessor处理器
        beanFactory.addBeanPostProcessor(new ServletContextAwareProcessor(this.servletContext, this.servletConfig));
        // 在自动注入时忽略指定的依赖接口,通常被应用上下文用来注册以其他方式解析的依赖项
        beanFactory.ignoreDependencyInterface(ServletContextAware.class);
        beanFactory.ignoreDependencyInterface(ServletConfigAware.class);
        // 注册web应用的scopes
        WebApplicationContextUtils.registerWebApplicationScopes(beanFactory, this.servletContext);
        // 注册和环境有关的beans
        WebApplicationContextUtils.registerEnvironmentBeans(beanFactory, this.servletContext, this.servletConfig);
    }

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
    // 初始化此容器的转换器，转换器的职责是处理通过配置给Bean实例成员变量赋值的时候的类型转换工作
    if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
        beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
      beanFactory.setConversionService(
          beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
    }


    // 如果没有注册过bean后置处理器post-processor，则注册默认的解析器，(例如主要用于解析properties文件的PropertyPlaceholderConfigurer
    // )，@value注解或在xml中使用${}的方式进行环境相关的配置
    if (!beanFactory.hasEmbeddedValueResolver()) {
      beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
    }


    // AOP分为三种方式：编译期织入、类加载期织入和运行期织入，LoadTimeWeaving属于第二种，主要通过JVM进行织入，先初始化LoadTimeWeaverAware 
    // bean，以便尽早注册它们的transformers
    String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
    for (String weaverAwareName : weaverAwareNames) {
      getBean(weaverAwareName);
    }


    // 停止使用临时类加载器进行类型匹配
    beanFactory.setTempClassLoader(null);


    // 允许缓存所有bean定义元数据，不希望有进一步的更改
    beanFactory.freezeConfiguration();


    // 实例化所有剩余的(non-lazy-init非延时加载的)单例
    beanFactory.preInstantiateSingletons();
  }

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
      throws BeanCreationException {


     1、实例化bean
    BeanWrapper instanceWrapper = null;
    if (mbd.isSingleton()) {
      instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
    }
    if (instanceWrapper == null) {
      instanceWrapper = 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 {
          applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
        }
        catch (Throwable ex) {
          throw new BeanCreationException(mbd.getResourceDescription(), beanName,
              "Post-processing of merged bean definition failed", ex);
        }
        mbd.postProcessed = true;
      }
    }
 
    boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
        isSingletonCurrentlyInCreation(beanName));
    if (earlySingletonExposure) {
      if (logger.isTraceEnabled()) {
        logger.trace("Eagerly caching bean '" + beanName +
            "' to allow for resolving potential circular references");
      }
      addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
    }


    Object exposedObject = bean;
    try {
      // 2、对bean的属性进行填充，属性注入
      populateBean(beanName, mbd, instanceWrapper);
      ///3、初始化bean
      exposedObject = initializeBean(beanName, exposedObject, mbd);
    }
    catch (Throwable ex) {
      if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
        throw (BeanCreationException) ex;
      }
      else {
        throw new BeanCreationException(
            mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
      }
    }


    if (earlySingletonExposure) {
      Object earlySingletonReference = getSingleton(beanName, false);
      if (earlySingletonReference != null) {
        if (exposedObject == bean) {
          exposedObject = earlySingletonReference;
        }
        else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
          String[] dependentBeans = getDependentBeans(beanName);
          Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
          for (String dependentBean : dependentBeans) {
            if (!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 {
      registerDisposableBeanIfNecessary(beanName, bean, mbd);
    }
    catch (BeanDefinitionValidationException ex) {
      throw new BeanCreationException(
          mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
    }


    return exposedObject;
  }

protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
    if (System.getSecurityManager() != null) {
      AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
        invokeAwareMethods(beanName, bean);
        return null;
      }, getAccessControlContext());
    }
    else {
      // 1、执行实现了Aware接口中的方法
      invokeAwareMethods(beanName, bean);
    }


    Object wrappedBean = bean;
    if (mbd == null || !mbd.isSynthetic()) {
      // 2、调用BeanPostProcessor的postProcessorsBeforeInitialization方法
      wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
    }


    try {
      // 3、调用初始化方法(自定义的初始化方法或者实现InitialzingBean接口)
      invokeInitMethods(beanName, wrappedBean, mbd);
    }
    catch (Throwable ex) {
      throw new BeanCreationException(
          (mbd != null ? mbd.getResourceDescription() : null),
          beanName, "Invocation of init method failed", ex);
    }
    if (mbd == null || !mbd.isSynthetic()) {
      // 4、调用BeanPostProcessor的postProcessorsAfterInitialization方法
      wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
    }


    return wrappedBean;
  }

private void invokeAwareMethods(String beanName, Object bean) {
    // 如果Bean是Aware类型的
    if (bean instanceof Aware) {
      // 如果Bean是BeanNameAware类型的
      if (bean instanceof BeanNameAware) {
        // BeanNameAware设置beanName
        ((BeanNameAware) bean).setBeanName(beanName);
      }
      // 如果Bean是BeanClassLoaderAware类型的
      if (bean instanceof BeanClassLoaderAware) {
        ClassLoader bcl = getBeanClassLoader();
        if (bcl != null) {
          // BeanClassLoaderAware设置beanClassloader
          ((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
        }
      }
      // 如果Bean是BeanFactoryAware类型的
      if (bean instanceof BeanFactoryAware) {
        // BeanFactoryAware设置beanFactory
        ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
      }
    }
  }

protected void invokeInitMethods(String beanName, Object bean, @Nullable RootBeanDefinition mbd)
      throws Throwable {
     当前bean是否实现了InitializingBean接口
    boolean isInitializingBean = (bean instanceof InitializingBean);
     如果实现了 InitializingBean 接口，则只调用bean的 afterPropertiesSet()
    if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
      if (logger.isTraceEnabled()) {
        logger.trace("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
      }
      if (System.getSecurityManager() != null) {
        try {
          AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
            ((InitializingBean) bean).afterPropertiesSet();
            return null;
          }, getAccessControlContext());
        }
        catch (PrivilegedActionException pae) {
          throw pae.getException();
        }
      }
      else {
         直接调用 afterPropertiesSet()
        ((InitializingBean) bean).afterPropertiesSet();
      }
    }


    if (mbd != null && bean.getClass() != NullBean.class) {
       判断是否自定义了 init-method()，是的话再调用自定义的的init-method
      String initMethodName = mbd.getInitMethodName();
      if (StringUtils.hasLength(initMethodName) &&
          !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
          !mbd.isExternallyManagedInitMethod(initMethodName)) {
         利用反射执行
        invokeCustomInitMethod(beanName, bean, mbd);
      }
    }
  }

package com.example.demo.spring;




import org.springframework.beans.BeansException;
import org.springframework.beans.factory.*;


/**
 * 自定义一个Bean
 */
public class XiaoPBean implements BeanNameAware, BeanClassLoaderAware, BeanFactoryAware, InitializingBean, DisposableBean {


    private String name = "xiaoP";


    public String getName() {
        return name;
    }


    public void setName(String name) {
        this.name = name;
    }


    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("执行了afterPropertiesSet方法......");
    }


    public void init(){
        System.out.println("执行自定义的init-method......");
    }


    @Override
    public void destroy() throws Exception {
        System.out.println("执行destroy方法销毁......");
    }


    @Override
    public void setBeanClassLoader(ClassLoader classLoader) {
        System.out.println("设置classLoader");
    }


    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("设置beanFactory");
    }


    @Override
    public void setBeanName(String name) {
        System.out.println("设置bean的name");
    }
}

package com.example.demo.spring;


import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.context.support.ClassPathXmlApplicationContext;


public class MyClassPathXmlApplicationContext extends ClassPathXmlApplicationContext {




    public MyClassPathXmlApplicationContext(String configLocations) {
        super(configLocations);
    }


    @Override
    protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory) {
        beanFactory.addBeanPostProcessor(new XiaoPBeanPostProcessor());
        super.addBeanFactoryPostProcessor(new XiaoPBeanFactoryPostProcessor());
    }
}

package com.example.demo.spring;


import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;


public class XiaoPBeanFactoryPostProcessor implements BeanFactoryPostProcessor {


    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        System.out.println("XiaoPBeanFactoryPostProcessor调用了...");
        BeanDefinition xiaoPBean = beanFactory.getBeanDefinition("xiaoPBean");
        xiaoPBean.getPropertyValues().add("name", "daP");
    }
}

package com.example.demo.spring;


import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.lang.Nullable;


public class XiaoPBeanPostProcessor implements BeanPostProcessor {


    @Nullable
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("XiaoPBeanPostProcessor的postProcessBeforeInitialization方法执行了");
        return bean;
    }


    @Nullable
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("XiaoPBeanPostProcessor的postProcessAfterInitialization方法执行了");
        return bean;
    }
}

package com.example.demo.spring;


import org.junit.Test;


public class BeanFactoryTest {


    @Test
    public void testSimpleLoad(){
        MyClassPathXmlApplicationContext applicationContext = new MyClassPathXmlApplicationContext("spring/bean.xml");
        XiaoPBean xiaoPBean = (XiaoPBean) applicationContext.getBean("xiaoPBean");
        System.out.println("使用xiaoPBean：" + xiaoPBean.getName());
        applicationContext.close();
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
               xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
               xmlns:context="http://www.springframework.org/schema/context"
               xsi:schemaLocation="http://www.springframework.org/schema/beans
                  http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
                 http://www.springframework.org/schema/context
                 http://www.springframework.org/schema/context/spring-context-3.1.xsd">




    <bean id="xiaoPBean" class="com.example.demo.spring.XiaoPBean" init-method="init"/>


</beans>