spring源码学习之bean的加载（三）

　　接着二中的继续写，那个都超过1000行了，哈，需要重新写一个，要不太长了，我都看不下去了

7.4 初始化bean

doCreateBean函数中有这样一行代码：这行代码中initializeBean函数就是初始化bean的逻辑
exposedObject = initializeBean(beanName, exposedObject, mbd);

这个方法在org.springframework.beans.factory.support包下AbstractAutowireCapableBeanFactory类下

 /**
  * Initialize the given bean instance, applying factory callbacks
  * as well as init methods and bean post processors.
  * <p>Called from {@link #createBean} for traditionally defined beans,
  * and from {@link #initializeBean} for existing bean instances.
  * @param beanName the bean name in the factory (for debugging purposes)
  * @param bean the new bean instance we may need to initialize
  * @param mbd the bean definition that the bean was created with
  * (can also be {@code null}, if given an existing bean instance)
  * @return the initialized bean instance (potentially wrapped)
  * @see BeanNameAware
  * @see BeanClassLoaderAware
  * @see BeanFactoryAware
  * @see #applyBeanPostProcessorsBeforeInitialization
  * @see #invokeInitMethods
  * @see #applyBeanPostProcessorsAfterInitialization
  */
 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 {
         // 对特殊的bean处理：Aware、BeanClassLoader、BeanFactoryAware
         invokeAwareMethods(beanName, bean);
     }

     Object wrappedBean = bean;
     if (mbd == null || !mbd.isSynthetic()) {
         // 应用后处理器
         wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
     }

     try {
         // 激活用户自定义的init方法
         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()) {
         // 后处理器应用
         wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
     }

     return wrappedBean;
 }

虽说此函数的目的主要是进行客户设定的初始化方法的调用，但是除此之外还有其他必要的工作

（1）激活Aware方法
理解一下Aware的使用，spring中提供了一些Aware接口，比如好多org.springframework.beans.factory，这个包下好多啊，实现这些Aware接口的bean被初始化之后
可以取得一些相应的资源，例如，实现BeanFactoryAware的bean在初始化后，spring容器会注入BeanFactory的实例，来看一下Aware的使用

 // 定义普通的bean
 public class Hello{
     public void say(){
         System.out.println("hello");
     }
 }

 // 定义BeanFactoryAware类型的bean
 public class Test implements BeanFactoryAware {
     private BeanFactory beanFactory;

     // 声明bean的时候spring会自动注入BeanFactory
     @override
     public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
         this.beanFactory = beanFactory;
     }

     public void testAware(){
         Hello hello = (Hello) beanFactory.getBean("hello");
         hello.say();
     }
 }

基本上就是这样使用的，看一下 源码：
这个方法在org.springframework.beans.factory.support包下AbstractAutowireCapableBeanFactory类下

 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);
         }
     }
 }

（2）处理器的应用

BeanPostProcessor是spring开放式架构中必不可少的亮点，给用户充足的权限去更改或者扩展spring，除了BeanPostProcessor，还有很多PostProcessor，
当然大部分都是以此为基础，继承组BeanPostProcessor，BeanPostProcessor的使用位置就是这里，在调用客户自定义初始方法前以及调用自定义初始方法后
分别会调用BeanPostProcessor的postProcessBeforeInitialization和postProcessAfterInitialization，使用户根据自己的需求进行自己处理
这个方法在org.springframework.beans.factory.support包下AbstractAutowireCapableBeanFactory类下

 @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;
 }

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

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

（3）激活自定义的init方法
客户定制的初始化方法除了我们熟知的使用init-method配置外，还要使用自定义bean实现initializeBean接口，并在afterPropertiesSet中实现自己的初始化逻辑
init-method与afterPropertiesSet都是在初始化bean时执行，指定顺序是afterPropertiesSet先执行，init-method再执行

在invokeInitMethods方法中实现了这部分处理逻辑

 /**
  * Give a bean a chance to react now all its properties are set,
  * and a chance to know about its owning bean factory (this object).
  * This means checking whether the bean implements InitializingBean or defines
  * a custom init method, and invoking the necessary callback(s) if it does.
  * @param beanName the bean name in the factory (for debugging purposes)
  * @param bean the new bean instance we may need to initialize
  * @param mbd the merged bean definition that the bean was created with
  * (can also be {@code null}, if given an existing bean instance)
  * @throws Throwable if thrown by init methods or by the invocation process
  * @see #invokeCustomInitMethod
  */
 protected void invokeInitMethods(String beanName, final Object bean, @Nullable RootBeanDefinition mbd)
         throws Throwable {

     // 首先检查是否是InitializingBean，如果是的话就调用afterPropertiesSet()
     boolean isInitializingBean = (bean instanceof InitializingBean);
     if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
         if (logger.isDebugEnabled()) {
             logger.debug("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 {
             ((InitializingBean) bean).afterPropertiesSet();
         }
     }

     if (mbd != null && bean.getClass() != NullBean.class) {
         String initMethodName = mbd.getInitMethodName();
         if (StringUtils.hasLength(initMethodName) &&
                 !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
                 !mbd.isExternallyManagedInitMethod(initMethodName)) {
             // 调用自定义初始化方法
             invokeCustomInitMethod(beanName, bean, mbd);
         }
     }
 }

7.5 注册DisposableBean
spring中不但提供了对于初始化方法的扩展入口，同样也提供了销毁的扩展入口，对于销毁方法的扩展，除了我们熟知的配置属性destroy-method方法，用户还
可以注册后处理器DestructionAwareBeanPostProcessor来统一处理bean的销毁方法

 /**
  * Add the given bean to the list of disposable beans in this factory,
  * registering its DisposableBean interface and/or the given destroy method
  * to be called on factory shutdown (if applicable). Only applies to singletons.
  * @param beanName the name of the bean
  * @param bean the bean instance
  * @param mbd the bean definition for the bean
  * @see RootBeanDefinition#isSingleton
  * @see RootBeanDefinition#getDependsOn
  * @see #registerDisposableBean
  * @see #registerDependentBean
  */
 protected void registerDisposableBeanIfNecessary(String beanName, Object bean, RootBeanDefinition mbd) {
     AccessControlContext acc = (System.getSecurityManager() != null ? getAccessControlContext() : null);
     if (!mbd.isPrototype() && requiresDestruction(bean, mbd)) {
         if (mbd.isSingleton()) {
             // Register a DisposableBean implementation that performs all destruction
             // work for the given bean: DestructionAwareBeanPostProcessors,
             // DisposableBean interface, custom destroy method.
             // 单例模式下注册需要销毁的bean，此方法中会处理实现DisposableBean的bean，
             // 并且对所有的bean使用DestructionAwareBeanPostProcessor处理DisposableBean
             registerDisposableBean(beanName,
                     new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));
         }
         else {
             // A bean with a custom scope...
             // 自定义scope处理
             Scope scope = this.scopes.get(mbd.getScope());
             if (scope == null) {
                 throw new IllegalStateException("No Scope registered for scope name '" + mbd.getScope() + "'");
             }
             scope.registerDestructionCallback(beanName,
                     new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));
         }
     }
 }

 // DisposableBeanAdapter类的构造方法
 public DisposableBeanAdapter(Object bean, String beanName, RootBeanDefinition beanDefinition,
         List<BeanPostProcessor> postProcessors, @Nullable AccessControlContext acc) {

     Assert.notNull(bean, "Disposable bean must not be null");
     this.bean = bean;
     this.beanName = beanName;
     this.invokeDisposableBean =
             (this.bean instanceof DisposableBean && !beanDefinition.isExternallyManagedDestroyMethod("destroy"));
     this.nonPublicAccessAllowed = beanDefinition.isNonPublicAccessAllowed();
     this.acc = acc;
     String destroyMethodName = inferDestroyMethodIfNecessary(bean, beanDefinition);
     if (destroyMethodName != null && !(this.invokeDisposableBean && "destroy".equals(destroyMethodName)) &&
             !beanDefinition.isExternallyManagedDestroyMethod(destroyMethodName)) {
         this.destroyMethodName = destroyMethodName;
         this.destroyMethod = determineDestroyMethod(destroyMethodName);
         if (this.destroyMethod == null) {
             if (beanDefinition.isEnforceDestroyMethod()) {
                 throw new BeanDefinitionValidationException("Could not find a destroy method named '" +
                         destroyMethodName + "' on bean with name '" + beanName + "'");
             }
         }
         else {
             Class<?>[] paramTypes = this.destroyMethod.getParameterTypes();
             if (paramTypes.length > 1) {
                 throw new BeanDefinitionValidationException("Method '" + destroyMethodName + "' of bean '" +
                         beanName + "' has more than one parameter - not supported as destroy method");
             }
             else if (paramTypes.length == 1 && boolean.class != paramTypes[0]) {
                 throw new BeanDefinitionValidationException("Method '" + destroyMethodName + "' of bean '" +
                         beanName + "' has a non-boolean parameter - not supported as destroy method");
             }
         }
     }
     this.beanPostProcessors = filterPostProcessors(postProcessors, bean);
 }

 /**
  * Search for all DestructionAwareBeanPostProcessors in the List.
  * @param processors the List to search
  * @return the filtered List of DestructionAwareBeanPostProcessors
  */
 @Nullable
 private List<DestructionAwareBeanPostProcessor> filterPostProcessors(List<BeanPostProcessor> processors, Object bean) {
     List<DestructionAwareBeanPostProcessor> filteredPostProcessors = null;
     if (!CollectionUtils.isEmpty(processors)) {
         filteredPostProcessors = new ArrayList<>(processors.size());
         for (BeanPostProcessor processor : processors) {
             if (processor instanceof DestructionAwareBeanPostProcessor) {
                 DestructionAwareBeanPostProcessor dabpp = (DestructionAwareBeanPostProcessor) processor;
                 if (dabpp.requiresDestruction(bean)) {
                     filteredPostProcessors.add(dabpp);
                 }
             }
         }
     }
     return filteredPostProcessors;
 }