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

		if (logger.isTraceEnabled()) {
			logger.trace("Creating instance of bean '" + beanName + "'");
		}
		RootBeanDefinition mbdToUse = mbd;

		// Make sure bean class is actually resolved at this point, and
		// clone the bean definition in case of a dynamically resolved Class
		// which cannot be stored in the shared merged bean definition.
		// 找到需要創(chuàng)建 Bean 對應(yīng)的 Class
		Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
		if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
			mbdToUse = new RootBeanDefinition(mbd);
			mbdToUse.setBeanClass(resolvedClass);
		}
  .......省略與此步驟無關(guān)的代碼
}

@Nullable
protected Class<?> resolveBeanClass(RootBeanDefinition mbd, String beanName, Class<?>... typesToMatch)
      throws CannotLoadBeanClassException {

   try {
      // 判斷 BeanDefinition 中的 beanClass 屬性是不是 Class 類型的
      if (mbd.hasBeanClass()) {
         return mbd.getBeanClass();
      }
      // 執(zhí)行搜索 Bean class
      return doResolveBeanClass(mbd, typesToMatch);
   }  ...省略catch 代碼
   }
}

public boolean hasBeanClass() {

   // 判斷 BeanDefinition 中的 beanClass 屬性是不是屬于 Class 的
   // 因為最開始的時候存入的是 BeanDefinition 對應(yīng)的類的類名
   return (this.beanClass instanceof Class);
}

private Class<?> doResolveBeanClass(RootBeanDefinition mbd, Class<?>... typesToMatch)
      throws ClassNotFoundException {

   // 獲取類加載器
   ClassLoader beanClassLoader = getBeanClassLoader();
   ClassLoader dynamicLoader = beanClassLoader;
   boolean freshResolve = false;

   .... 省略代碼
     
   // 這里就是拿的 RootBeanDefinition 中的 beanClass屬性
   String className = mbd.getBeanClassName();
   if (className != null) {
      // 解析 spring 自己定義的表達式---沒有去了解
      Object evaluated = evaluateBeanDefinitionString(className, mbd);
      if (!className.equals(evaluated)) {
         // A dynamically resolved expression, supported as of 4.2...
         if (evaluated instanceof Class) {
            return (Class<?>) evaluated;
         } else if (evaluated instanceof String) {
            className = (String) evaluated;
            freshResolve = true;
         } else {
            throw new IllegalStateException("Invalid class name expression result: " + evaluated);
         }
      }
      if (freshResolve) {
         // When resolving against a temporary class loader, exit early in order
         // to avoid storing the resolved Class in the bean definition.
         if (dynamicLoader != null) {
            try {
               // 加載類，當(dāng)前 需要創(chuàng)建的 Bean 的 Class文件
               return dynamicLoader.loadClass(className);
            } catch (ClassNotFoundException ex) {
               if (logger.isTraceEnabled()) {
                  logger.trace("Could not load class [" + className + "] from " + dynamicLoader + ": " + ex);
               }
            }
         }
        	// 內(nèi)部 使用了 Class.forName() 去加載這個類:Class.forName(name, false, clToUse);
         return ClassUtils.forName(className, dynamicLoader);
      }
   }
   // 定期解析，將結(jié)果緩存在 BeanDefinition 中
   // Resolve regularly, caching the result in the BeanDefinition...
   return mbd.resolveBeanClass(beanClassLoader);
}

@Nullable
public static ClassLoader getDefaultClassLoader() {
   ClassLoader cl = null;
   try {
      // 獲取當(dāng)前線程的類加載器，可以設(shè)置的 Thread.currentThread().setContextClassLoader();
      cl = Thread.currentThread().getContextClassLoader();
   }
   catch (Throwable ex) {
      // Cannot access thread context ClassLoader - falling back...
   }
  // 使用當(dāng)前類的加載器去加載，有可能返回空，因為 lib 下面的 jar包使用 bootstrap 類加載器去加載的
   if (cl == null) {
      // No thread context class loader -> use class loader of this class.
      cl = ClassUtils.class.getClassLoader();
      if (cl == null) {
         // getClassLoader() returning null indicates the bootstrap ClassLoader
         try {
            // 獲取系統(tǒng)的加載器
            cl = ClassLoader.getSystemClassLoader();
         }
         catch (Throwable ex) {
            // Cannot access system ClassLoader - oh well, maybe the caller can live with null...
         }
      }
   }
   return cl;
}

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

	...... 省略上一步驟的代碼

   try {
      // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
      // 實例化前  InstantiationAwareBeanPostProcessor  使用的是這個 BeanPostprocessor
      Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
      // 如果實例化前，由自己創(chuàng)建類對象則直接返回
      if (bean != null) {
         return bean;
      }
   }
  	// doCreateBean 執(zhí)行創(chuàng)建bean的方法，此方法中就會去實例化對象
  Object beanInstance = doCreateBean(beanName, mbdToUse, args);
		... 省略日志打印
			return beanInstance;
  ..... 省略此步驟無關(guān)代碼
}

public interface InstantiationAwareBeanPostProcessor extends BeanPostProcessor {
	@Nullable
	default Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
		return null;
	}
  .... 省略另外兩個方法
}

protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
   Object bean = null;
   if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
      // Make sure bean class is actually resolved at this point.
      if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
         Class<?> targetType = determineTargetType(beanName, mbd);
         if (targetType != null) {
            // 在實例化前應(yīng)用BeanPostProcessor
            bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
            if (bean != null) {
               // 初始化后的 BeanPostProcessor
               bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
            }
         }
      }
      mbd.beforeInstantiationResolved = (bean != null);
   }
   return bean;
}

	protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
    // 這里拿到的就是 InstantiationAwareBeanPostProcessor 類型的 postProcessor
		for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
			Object result = bp.postProcessBeforeInstantiation(beanClass, beanName);
			// 因為這里是初始化前，所以在執(zhí)行到 beanPostprocessor 返回有對象的時候就直接返回，不會執(zhí)行后續(xù)的 InstantiationAwareBeanPostProcessor
			// 如果第一個處理器就返回了 對象實例，則不會再去執(zhí)行其他的 InstantiationAwareBeanPostProcessor
			if (result != null) {
				return result;
			}
		}
		return null;
	}

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

   // Instantiate the bean.
   // BeanWrapper：持有創(chuàng)建出來的Bean
   BeanWrapper instanceWrapper = null;
   // 判斷當(dāng)前的bean定義是否為單例
   if (mbd.isSingleton()) {
      // 有可能在本 Bean 創(chuàng)建之前就已經(jīng)把當(dāng)前 Bean 給創(chuàng)建出來了（比如在依賴注入過程中）
      instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);// 從工廠bean緩存中移除
   }// 不為空則  代表為 FactoryBean 已經(jīng)創(chuàng)建過，存在緩存中
   if (instanceWrapper == null) {
      /**
       * 創(chuàng)建bean的實例，默認使用無參構(gòu)造器
       * 實例化但是并未初始化，就是沒有給bean的屬性復(fù)制
       * 組建的原始對象就創(chuàng)建了
       */
      instanceWrapper = createBeanInstance(beanName, mbd, args);
   }
   Object bean = instanceWrapper.getWrappedInstance();
   Class<?> beanType = instanceWrapper.getWrappedClass();
   if (beanType != NullBean.class) {
      mbd.resolvedTargetType = beanType;
   }

   // Allow post-processors to modify the merged bean definition.
   // 允許（MergedBeanDefinitionPostProcessor）增強器修改合并的bean definition 修改BD信息
   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;
      }
   }
  ...... 省略代碼 ......
}

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
   // 拿到bean 的 class  Make sure bean class is actually resolved at this point.
   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());
   }
   // 定義bean的提供者  ，存在就使用提供者創(chuàng)建對象：這是一個函數(shù)式接口
   Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
   if (instanceSupplier != null) {
     	// 存在 bean 的提供者，則直接調(diào)用 Supplier 的 get() 方法拿到對象
			return obtainFromSupplier(instanceSupplier, beanName);
   }
 // 使用工廠方法、例如：@Bean注解放在方法上，返回值注入容器，spring 會認為這是一個工廠方法
		if (mbd.getFactoryMethodName() != null) {
			return instantiateUsingFactoryMethod(beanName, mbd, args);
		}

		// Shortcut when re-creating the same bean...
		boolean resolved = false;
		boolean autowireNecessary = false;
		if (args == null) {
			synchronized (mbd.constructorArgumentLock) {
				if (mbd.resolvedConstructorOrFactoryMethod != null) {
					resolved = true;
					autowireNecessary = mbd.constructorArgumentsResolved;
				}
			}
		}
		if (resolved) {
			if (autowireNecessary) {
				return autowireConstructor(beanName, mbd, null, null);
			}
			else {
				return instantiateBean(beanName, mbd);
			}
		}

		// 后置處理器 SmartInstantiationAwareBeanPostProcessor 有機會決定在創(chuàng)建對象錢使用那個構(gòu)造器 Candidate constructors for autowiring?
		Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
		if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
				mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
			return autowireConstructor(beanName, mbd, ctors, args); //有自己指定的構(gòu)造器： 構(gòu)造器方式的自動注入
		}

		// 使用默認的自己設(shè)置的高優(yōu)先級的 構(gòu)造器 Preferred constructors for default construction? // 拿到構(gòu)造器
		ctors = mbd.getPreferredConstructors();
		if (ctors != null) {
			return autowireConstructor(beanName, mbd, ctors, null);
		}
		// 默認使用無參構(gòu)造器
		// No special handling: simply use no-arg constructor. 無需特殊處理：使用簡單的無參構(gòu)造器
		return instantiateBean(beanName, mbd);
}

<bean id="userService" class="cn.baldhead.service.UserService" factory-method="createUserService" />

public class UserService {

	public static UserService createUserService() {
		System.out.println("執(zhí)行createUserService()");
		UserService userService = new UserService();
		return userService;
	}

	public void test() {
		System.out.println("test");
	}

}

<bean id="commonService" class="cn.baldhead.service.CommonService"/>
<bean id="userService1" factory-bean="commonService" factory-method="createUserService" />

@Component
public class UserService {

	private OrderService orderService;

	public void test() {
		OrderService orderService = createOrderService();
		System.out.println(orderService);
	}

	@Lookup("orderService")
	public OrderService createOrderService() {
		return null;
	}

}

@Component
public class BaldHeadMergedBeanDefinitionPostProcessor implements MergedBeanDefinitionPostProcessor {

	@Override
	public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
        // 可以手動給 beanDefinition 得ptopertyValues 添加一個屬性賦值，屬性名-值（bean中的屬性賦值）
		if ("baldHeadService".equals(beanName)) {
			beanDefinition.getPropertyValues().add("orderService", new OrderService());
		}
	}
}

/ Allow post-processors to modify the merged bean definition.
		// 允許（MergedBeanDefinitionPostProcessor）增強器修改合并的bean definition 修改BD信息
		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;
			}
		}

// 設(shè)置屬性注入   之前bean的狀態(tài)，例如，屬性賦值之前后置處理器可以提前處理些東西
// 支持字段注入  （但是在此處什么事都沒做）
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
   for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
      if (!bp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
         return;
      }
   }
}

	// 獲取所有屬性的值
		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. 通過名稱自動注入?yún)?shù)的值
			if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
				autowireByName(beanName, mbd, bw, newPvs);
			}
			// Add property values based on autowire by type if applicable. 通過類型注入?yún)?shù)的值
			if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
				autowireByType(beanName, mbd, bw, newPvs);
			}
			pvs = newPvs;
		}

@Component
public class BaldHeadInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor {

	@Override
	public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
		if ("baldHeadService".equals(beanName)) {
			for (Field field : bean.getClass().getFields()) {
				if (field.isAnnotationPresent(BaldHeadInject.class)) {
					field.setAccessible(true);
					try {
						field.set(bean, "123");
					} catch (IllegalAccessException e) {
						e.printStackTrace();
					}
				}
			}
		}

		return pvs;
	}
}

@Component
public class BaldHeadBeanPostProcessor implements BeanPostProcessor {

	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		if ("baldHeadService".equals(beanName)) {
			System.out.println("初始化前");
		}

		return bean;
	}
}

	private LifecycleMetadata buildLifecycleMetadata(final Class<?> clazz) {
		if (!AnnotationUtils.isCandidateClass(clazz, Arrays.asList(this.initAnnotationType, this.destroyAnnotationType))) {
			return this.emptyLifecycleMetadata;
		}

        // 這里面就會有 @PostConstruct 的，并且初始化方法有先后執(zhí)行順序，父類的排在前面，子類的在后面
        // 父類優(yōu)先執(zhí)行
		List<LifecycleElement> initMethods = new ArrayList<>();
        // 這里面會有 @PreDestroy 的
		List<LifecycleElement> destroyMethods = new ArrayList<>();
		Class<?> targetClass = clazz;

		do {
			final List<LifecycleElement> currInitMethods = new ArrayList<>();
			final List<LifecycleElement> currDestroyMethods = new ArrayList<>();

			ReflectionUtils.doWithLocalMethods(targetClass, method -> {
				if (this.initAnnotationType != null && method.isAnnotationPresent(this.initAnnotationType)) {
					LifecycleElement element = new LifecycleElement(method);
					currInitMethods.add(element);
					if (logger.isTraceEnabled()) {
						logger.trace("Found init method on class [" + clazz.getName() + "]: " + method);
					}
				}
				if (this.destroyAnnotationType != null && method.isAnnotationPresent(this.destroyAnnotationType)) {
					currDestroyMethods.add(new LifecycleElement(method));
					if (logger.isTraceEnabled()) {
						logger.trace("Found destroy method on class [" + clazz.getName() + "]: " + method);
					}
				}
			});
			// 父類的初始化方法在前，也就是有一個先后順序，先執(zhí)行父類的 init-method 方法
			initMethods.addAll(0, currInitMethods);
			destroyMethods.addAll(currDestroyMethods);
			targetClass = targetClass.getSuperclass();
		}
		while (targetClass != null && targetClass != Object.class);

		return (initMethods.isEmpty() && destroyMethods.isEmpty() ? this.emptyLifecycleMetadata :
				new LifecycleMetadata(clazz, initMethods, destroyMethods));
	}

protected void invokeInitMethods(String beanName, Object bean, @Nullable RootBeanDefinition mbd)
			throws Throwable {
		// 檢查是否實現(xiàn)了 InitializingBean 接口
		boolean isInitializingBean = (bean instanceof InitializingBean);
		if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
			if (logger.isTraceEnabled()) {
				logger.trace("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
			}
			// 實現(xiàn)了 InitializingBean 接口，執(zhí)行調(diào)用 afterPropertiesSet 方法
			// 使用了多態(tài)的操作方式 將 bean 轉(zhuǎn)換為一個接口（initializingBean）
			((InitializingBean) bean).afterPropertiesSet();
		}

		if (mbd != null && bean.getClass() != NullBean.class) {
			// 獲取自定一個init-method方法
			String initMethodName = mbd.getInitMethodName();
			if (StringUtils.hasLength(initMethodName) &&
					!(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
					!mbd.isExternallyManagedInitMethod(initMethodName)) {
				// 執(zhí)行自定一個init-method方法,通過反射 method.invoke()
				invokeCustomInitMethod(beanName, bean, mbd);
			}
		}
	}

@Component
public class BaldHeadBeanPostProcessor implements BeanPostProcessor {

	@Override
	public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		if ("baldHeadService".equals(beanName)) {
			System.out.println("初始化后");
		}

		return bean;
	}
}

if (mbd == null || !mbd.isSynthetic()) { // 初始化后執(zhí)行，postProcessor
			wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
		}