第八章 Bean 的生命周期

public class JavaBeanTest {

    @Test
    void javaBeanLifeCycle(){
        PeopleBean peopleBean = new PeopleBean();
        peopleBean.setName("zhangsan");

        System.out.println(peopleBean.getName());
    }
}

package com.source.hot.ioc.book.live;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanClassLoaderAware;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.context.ApplicationEventPublisherAware;
import org.springframework.context.EmbeddedValueResolverAware;
import org.springframework.context.EnvironmentAware;
import org.springframework.context.MessageSource;
import org.springframework.context.MessageSourceAware;
import org.springframework.context.ResourceLoaderAware;
import org.springframework.core.env.Environment;
import org.springframework.core.io.ResourceLoader;
import org.springframework.util.StringValueResolver;

public class LiveBean implements BeanNameAware, BeanFactoryAware,
      ApplicationContextAware, InitializingBean, DisposableBean, BeanClassLoaderAware,
      EnvironmentAware, EmbeddedValueResolverAware, ResourceLoaderAware,
      ApplicationEventPublisherAware, MessageSourceAware {

  private String address;

  public LiveBean() {
      System.out.println("init LiveBean");
  }

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

  @Override
  public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
      System.out.println("run setApplicationEventPublisher method.");

  }

  @Override
  public void setEmbeddedValueResolver(StringValueResolver resolver) {
      System.out.println("run setEmbeddedValueResolver method.");

  }

  @Override
  public void setEnvironment(Environment environment) {
      System.out.println("run Environment method.");

  }

  @Override
  public void setMessageSource(MessageSource messageSource) {
      System.out.println("run setMessageSource method.");

  }

  @Override
  public void setResourceLoader(ResourceLoader resourceLoader) {
      System.out.println("run setResourceLoader method.");

  }

  @Override
  public void setBeanName(String name) {
      System.out.println("run setBeanName method.");
  }

  @Override
  public void destroy() throws Exception {
      System.out.println("run destroy method.");
  }

  @Override
  public void afterPropertiesSet() throws Exception {
      System.out.println("run afterPropertiesSet method.");
  }

  @Override
  public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
  }

  @PostConstruct
  public void springPostConstruct() {
      System.out.println("@PostConstruct");
  }

  @PreDestroy
  public void springPreDestroy() {
      System.out.println("@PreDestroy");
  }


  public void myPostConstruct() {
      System.out.println("run myPostConstruct method.");
  }

  public void myPreDestroy() {
      System.out.println("run myPreDestroy method.");
  }


  public String getAddress() {
      return address;
  }

  public void setAddress(String address) {
     System.out.println("run setAddress method.");
     this.address = address;
  }


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

package com.source.hot.ioc.book.live;

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

public class MyBeanPostProcessor implements BeanPostProcessor {

  public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
      if (bean instanceof LiveBean) {
          System.out.println("run MyBeanPostProcessor postProcessBeforeInitialization method.");
      }
      return bean;
  }

  public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
      if (bean instanceof LiveBean) {
          System.out.println("run MyBeanPostProcessor postProcessAfterInitialization method.");
      }
      return bean;
  }
}

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

  <bean class="com.source.hot.ioc.book.live.MyBeanPostProcessor"/>
  <bean id="liveBean" class="com.source.hot.ioc.book.live.LiveBean" init-method="myPostConstruct" destroy-method="myPreDestroy">
      <property name="address" value="shangHai"/>
  </bean>
</beans>

public class JavaBeanTest {


    @Test
    void testSpringBeanLive() {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("META-INF/live-bean.xml");
        LiveBean liveBean = context.getBean("liveBean", LiveBean.class);
        context.close();
    }
}

init LiveBean
run setAddress method.
run setBeanName method.
run setBeanClassLoader method.
run setBeanFactory method.
run Environment method.
run setEmbeddedValueResolver method.
run setResourceLoader method.
run setApplicationEventPublisher method.
run setMessageSource method.
run MyBeanPostProcessor postProcessBeforeInitialization method.
run afterPropertiesSet method.
run myPostConstruct method.
run MyBeanPostProcessor postProcessAfterInitialization method.
run destroy method.
run myPreDestroy method.

<bean id="liveBean" class="com.source.hot.ioc.book.live.LiveBean" init-method="myPostConstruct" destroy-method="myPreDestroy">
    <property name="address" value="shangHai"/>
</bean>

String className = "com.source.hot.ioc.book.live.LiveBean";
ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();

Class<?> aClass = contextClassLoader.loadClass(className);

Object o2 = aClass.newInstance();

Constructor<?> constructor = aClass.getConstructor();
Object o = constructor.newInstance();

@Test
void testClass() throws Exception {
    String className = "com.source.hot.ioc.book.live.LiveBean";
    ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
    Class<?> aClass = contextClassLoader.loadClass(className);

    Object o2 = aClass.newInstance();

    Constructor<?> constructor = aClass.getConstructor();
    Object o = constructor.newInstance();
    if (o instanceof LiveBean) {
        LiveBean o1 = (LiveBean) o;
        o1.setAddress("shangHai");
        System.out.println(o1.getAddress());
    }
}

// 删除注释、异常处理和部分验证
public static <T> T instantiateClass(Constructor<T> ctor, Object... args) throws BeanInstantiationException {
    
  ReflectionUtils.makeAccessible(ctor);
  if (KotlinDetector.isKotlinReflectPresent() && KotlinDetector.isKotlinType(ctor.getDeclaringClass())) {
      return KotlinDelegate.instantiateClass(ctor, args);
  }
  else {
      Class<?>[] parameterTypes = ctor.getParameterTypes();
      Assert.isTrue(args.length <= parameterTypes.length, "Can't specify more arguments than constructor parameters");
      Object[] argsWithDefaultValues = new Object[args.length];
      for (int i = 0; i < args.length; i++) {
          if (args[i] == null) {
              Class<?> parameterType = parameterTypes[i];
              argsWithDefaultValues[i] = (parameterType.isPrimitive() ? DEFAULT_TYPE_VALUES.get(parameterType) : null);
          }
          else {
              argsWithDefaultValues[i] = args[i];
          }
      }
      return ctor.newInstance(argsWithDefaultValues);
  }

}

public class PeopleBean {
    private String name;
	public PeopleBean(String name) {
    	this.name = name;
    }
}

<bean id="people" class="com.source.hot.ioc.book.pojo.PeopleBean">
    <constructor-arg index="0" type="java.lang.String" value="zhangsan">

    </constructor-arg>

</bean>

/**
 * 构造函数信息
 * key: 索引
 * value: 标签数据
 */
private final Map<Integer, ValueHolder> indexedArgumentValues = new LinkedHashMap<>();

/**
 * name 模式的存储信息
 */
private final List<ValueHolder> genericArgumentValues = new ArrayList<>();

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

  <bean id="people" class="com.source.hot.ioc.book.pojo.PeopleBean">
      <constructor-arg index="0" type="java.lang.String" value="zhangsan">

      </constructor-arg>

  </bean>
  <bean id="people2" class="com.source.hot.ioc.book.pojo.PeopleBean">
      <constructor-arg name="name" type="java.lang.String" value="zhangsan">

      </constructor-arg>
      <constructor-arg name="pb" ref="people"/>

  </bean>

</beans>

minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues)

public boolean hasMethodOverrides() {
   return !this.methodOverrides.isEmpty();
}

void setField() throws Exception {
    LiveBean liveBean = new LiveBean();
    Field address = liveBean.getClass().getDeclaredField("address");
    address.setAccessible(true);
    address.set(liveBean, "shangHai");
    System.out.println(liveBean.getAddress());
}

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

    <bean class="com.source.hot.ioc.book.live.MyBeanPostProcessor"/>
    <bean id="liveBean" class="com.source.hot.ioc.book.live.LiveBean" init-method="myPostConstruct" destroy-method="myPreDestroy">
        <property name="address" value="shangHai"/>
    </bean>
</beans>

protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
   try {
      Object beanInstance;
      final BeanFactory parent = this;
      if (System.getSecurityManager() != null) {
         // 获取实例化策略来进行实例化
         beanInstance = AccessController.doPrivileged(
               (PrivilegedAction<Object>) () ->
                     getInstantiationStrategy().instantiate(mbd, beanName, parent),
               getAccessControlContext()
         );
      }
      else {
         // 获取实例化策略来进行实例化
         beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
      }

      // beanWrapper 创建
      BeanWrapper bw = new BeanWrapperImpl(beanInstance);
      initBeanWrapper(bw);
      return bw;
   }
   catch (Throwable ex) {
      throw new BeanCreationException(
            mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
   }
}

@Override
public void setPropertyValue(PropertyValue pv) throws BeansException {
   // 需要设置的字段名称
   PropertyTokenHolder tokens = (PropertyTokenHolder) pv.resolvedTokens;
   if (tokens == null) {
      // 属性名称
      // 获取属性名称
      String propertyName = pv.getName();
      AbstractNestablePropertyAccessor nestedPa;
      try {
         // 属性访问器
         nestedPa = getPropertyAccessorForPropertyPath(propertyName);
      }
      catch (NotReadablePropertyException ex) {
         throw new NotWritablePropertyException(getRootClass(), this.nestedPath + propertyName,
               "Nested property in path '" + propertyName + "' does not exist", ex);
      }
      tokens = getPropertyNameTokens(getFinalPath(nestedPa, propertyName));
      if (nestedPa == this) {
         pv.getOriginalPropertyValue().resolvedTokens = tokens;
      }
      // 设置属性
      nestedPa.setPropertyValue(tokens, pv);
   }
   else {
      setPropertyValue(tokens, pv);
   }
}

// 删除日志，异常处理等代码
private void processLocalProperty(PropertyTokenHolder tokens, PropertyValue pv) {
    // ph 里面有对象
    PropertyHandler ph = getLocalPropertyHandler(tokens.actualName);
    Object oldValue = null;
    // 获取 PV 的属性值
    Object originalValue = pv.getValue();
    Object valueToApply = originalValue;
    // 是否需要
    if (!Boolean.FALSE.equals(pv.conversionNecessary)) {
        // 是否能够转换
        if (pv.isConverted()) {
            valueToApply = pv.getConvertedValue();
        }
        // 不能转换换
        else {
            if (isExtractOldValueForEditor() && ph.isReadable()) {
                oldValue = ph.getValue();
            }
            valueToApply = convertForProperty(tokens.canonicalName, oldValue, originalValue, ph.toTypeDescriptor());
        }
        pv.getOriginalPropertyValue().conversionNecessary = (valueToApply != originalValue);
    }
    ph.setValue(valueToApply);
}

@Override
@Nullable
protected BeanPropertyHandler getLocalPropertyHandler(String propertyName) {
 PropertyDescriptor pd = getCachedIntrospectionResults().getPropertyDescriptor(propertyName);
 return (pd != null ? new BeanPropertyHandler(pd) : null);
}

private CachedIntrospectionResults getCachedIntrospectionResults() {
   if (this.cachedIntrospectionResults == null) {
      this.cachedIntrospectionResults = CachedIntrospectionResults.forClass(getWrappedClass());
   }
   return this.cachedIntrospectionResults;
}

@Test
void testCachedIntrospectionResults(){
  CachedIntrospectionResults results = CachedIntrospectionResults.forClass(LiveBean.class);
  System.out.println();
}

@Override
public void setValue(final @Nullable Object value) throws Exception {
 final Method writeMethod = (this.pd instanceof GenericTypeAwarePropertyDescriptor ?
       ((GenericTypeAwarePropertyDescriptor) this.pd).getWriteMethodForActualAccess() :
       this.pd.getWriteMethod());
 if (System.getSecurityManager() != null) {
    AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
       ReflectionUtils.makeAccessible(writeMethod);
       return null;
    });
    try {
       AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () ->
             writeMethod.invoke(getWrappedInstance(), value), acc);
    }
    catch (PrivilegedActionException ex) {
       throw ex.getException();
    }
 }
 else {
    ReflectionUtils.makeAccessible(writeMethod);
    writeMethod.invoke(getWrappedInstance(), value);
 }
}

protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
   // 第一部分
   if (System.getSecurityManager() != null) {
      AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
         invokeAwareMethods(beanName, bean);
         return null;
      }, getAccessControlContext());
   }
   else {
      // aware 接口执行
      invokeAwareMethods(beanName, bean);
   }

   // 第二部分
   Object wrappedBean = bean;
   if (mbd == null || !mbd.isSynthetic()) {
      // BeanPostProcessor 前置方法执行
      wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
   }

   // 第三部分
   try {
      // 执行实例化函数
      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()) {
      // BeanPostProcessor 后置方法执行
      wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
   }

   return wrappedBean;
}

private void invokeAwareMethods(final String beanName, final Object bean) {
   if (bean instanceof Aware) {
      if (bean instanceof BeanNameAware) {
         ((BeanNameAware) bean).setBeanName(beanName);
      }
      if (bean instanceof BeanClassLoaderAware) {
         ClassLoader bcl = getBeanClassLoader();
         if (bcl != null) {
            ((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
         }
      }
      if (bean instanceof BeanFactoryAware) {
         ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
      }
   }
}

@Override
public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
      throws BeansException {

   Object result = existingBean;
   for (BeanPostProcessor processor : getBeanPostProcessors()) {
      Object current = processor.postProcessBeforeInitialization(result, beanName);
      if (current == null) {
         return result;
      }
      result = current;
   }
   return result;
}

protected void invokeInitMethods(String beanName, final Object bean, @Nullable RootBeanDefinition mbd)
      throws Throwable {


   // 第一部分
   // 是否是 InitializingBean
   boolean isInitializingBean = (bean instanceof InitializingBean);
   // 是否存在方法 "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 {
            // 执行 afterPropertiesSet
            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) {
      // 获取 initMethod 字符串
      String initMethodName = mbd.getInitMethodName();
      if (StringUtils.hasLength(initMethodName) &&
            !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
            !mbd.isExternallyManagedInitMethod(initMethodName)) {
         // 自定义的 init method
         invokeCustomInitMethod(beanName, bean, mbd);
      }
   }
}

protected void invokeCustomInitMethod(String beanName, final Object bean, RootBeanDefinition mbd) throws Throwable {
    // 获取 initMethod 名称
    String initMethodName = mbd.getInitMethodName();
    Assert.state(initMethodName != null, "No init method set");
    // 反射获取方法
    Method initMethod = (mbd.isNonPublicAccessAllowed() ? BeanUtils.findMethod(bean.getClass(), initMethodName) : ClassUtils.getMethodIfAvailable(bean.getClass(), initMethodName));
    // 方法是否存在判断
    if(initMethod == null) {
        if(mbd.isEnforceInitMethod()) {
            throw new BeanDefinitionValidationException("Could not find an init method named '" + initMethodName + "' on bean with name '" + beanName + "'");
        } else {
            return;
        }
    }
    // 尝试获取接口方法
    Method methodToInvoke = ClassUtils.getInterfaceMethodIfPossible(initMethod);
    if(System.getSecurityManager() != null) {
        AccessController.doPrivileged((PrivilegedAction < Object > )() - > {
            ReflectionUtils.makeAccessible(methodToInvoke);
            return null;
        });
        // 反射调用
        AccessController.doPrivileged((PrivilegedExceptionAction < Object > )() - > methodToInvoke.invoke(bean), getAccessControlContext());
    } else {
        // 反射调用
        // setAccessible true
        ReflectionUtils.makeAccessible(methodToInvoke);
        methodToInvoke.invoke(bean);
    }
}

@Override
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
      throws BeansException {

   Object result = existingBean;
   for (BeanPostProcessor processor : getBeanPostProcessors()) {
      // 执行 spring 容器中 BeanPostProcessor
      Object current = processor.postProcessAfterInitialization(result, beanName);
      if (current == null) {
         return result;
      }
      result = current;
   }
   return result;
}

protected void destroyBeans() {
    getBeanFactory().destroySingletons();
}

public void destroySingletons() {
  if (logger.isTraceEnabled()) {
      logger.trace("Destroying singletons in " + this);
  }
  synchronized (this.singletonObjects) {
      this.singletonsCurrentlyInDestruction = true;
  }

  String[] disposableBeanNames;
  synchronized (this.disposableBeans) {
      disposableBeanNames = StringUtils.toStringArray(this.disposableBeans.keySet());
  }
  for (int i = disposableBeanNames.length - 1; i >= 0; i--) {
      destroySingleton(disposableBeanNames[i]);
  }

  this.containedBeanMap.clear();
  this.dependentBeanMap.clear();
  this.dependenciesForBeanMap.clear();

  clearSingletonCache();
}

// 删除异常处理和日志相关代码
protected void destroyBean(String beanName, @Nullable DisposableBean bean) {
  // Trigger destruction of dependent beans first...
  Set<String> dependencies;
  synchronized (this.dependentBeanMap) {
      // Within full synchronization in order to guarantee a disconnected Set
      // 移除依赖bean
      dependencies = this.dependentBeanMap.remove(beanName);
  }
  if (dependencies != null) {
      // 依赖列表里面的也删除
      for (String dependentBeanName : dependencies) {
          destroySingleton(dependentBeanName);
      }
  }

  // Actually destroy the bean now...
  if (bean != null) {
      bean.destroy();

  }

  // Trigger destruction of contained beans...
  Set<String> containedBeans;
  synchronized (this.containedBeanMap) {
      // Within full synchronization in order to guarantee a disconnected Set
      // 别名列表
      containedBeans = this.containedBeanMap.remove(beanName);
  }
  if (containedBeans != null) {
      // 删除 别名列表中的beanName
      for (String containedBeanName : containedBeans) {
          destroySingleton(containedBeanName);
      }
  }

  // Remove destroyed bean from other beans' dependencies.
  synchronized (this.dependentBeanMap) {
      // 依赖beanMap中删除beanName
      for (Iterator<Map.Entry<String, Set<String>>> it = this.dependentBeanMap.entrySet().iterator(); it.hasNext(); ) {
          Map.Entry<String, Set<String>> entry = it.next();
          Set<String> dependenciesToClean = entry.getValue();
          dependenciesToClean.remove(beanName);
          if (dependenciesToClean.isEmpty()) {
              it.remove();
          }
      }
  }

  // Remove destroyed bean's prepared dependency information.
  this.dependenciesForBeanMap.remove(beanName);
}

public void destroy() {
  if(!CollectionUtils.isEmpty(this.beanPostProcessors)) {
      // 找到 DestructionAwareBeanPostProcessor
      for(DestructionAwareBeanPostProcessor processor: this.beanPostProcessors) {
          processor.postProcessBeforeDestruction(this.bean, this.beanName);
      }
  }
  if(this.invokeDisposableBean) {
      // 如果 bean 本身实现了 DisposableBean 接口会进行调用
      if(System.getSecurityManager() != null) {
          AccessController.doPrivileged((PrivilegedExceptionAction < Object > )() - > {
              ((DisposableBean) this.bean).destroy();
              return null;
          }, this.acc);
      } else {
          ((DisposableBean) this.bean).destroy();
      }
  }
  // 自定义摧毁方法的调用
  if(this.destroyMethod != null) {
      invokeCustomDestroyMethod(this.destroyMethod);
  } else if(this.destroyMethodName != null) {
      Method methodToInvoke = determineDestroyMethod(this.destroyMethodName);
      if(methodToInvoke != null) {
          invokeCustomDestroyMethod(ClassUtils.getInterfaceMethodIfPossible(methodToInvoke));
      }
  }
}

@Override
public void destroySingleton(String beanName) {
  // 摧毁方法的调用
  super.destroySingleton(beanName);
  // 删除 manualSingletonNames 中的BeanName
  removeManualSingletonName(beanName);
  //allBeanNamesByType clean
  //singletonBeanNamesByType clean
  clearByTypeCache();
}