getBean

• 这里便是 bean 初始化的外围逻辑。源码比较复杂，离开说。以 getBean(String name)为例。AbstractBeanFactory.getBean:
• @Overridepublic Object getBean(String name) throws BeansException {

  return doGetBean(name, null, null, false);

  }

• 第二个参数示意 bean 的 Class 类型，第三个示意创立 bean 须要的参数，最初一个示意不须要进行类型查看。

beanName 转化

• final String beanName = transformedBeanName(name);
• 这里是将 FactoryBean 的前缀去掉以及将别名转为实在的名字。

手动注册 bean 检测

• 后面注册环境一节说过，Spring 其实手动注册了一些单例 bean。这一步就是检测是不是这些 bean。如果是，那么再检测是不是工厂 bean，如果是返回其工厂办法返回的实例，如果不是返回 bean 自身。
• Object sharedInstance = getSingleton(beanName);

  if (sharedInstance != null && args == null) {

  bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);

  }

查看父容器

• 如果父容器存在并且存在此 bean 定义，那么交由其父容器初始化:
• BeanFactory parentBeanFactory = getParentBeanFactory();

  if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {

  // Not found -> check parent.

  // 此办法其实是做了后面 beanName 转化的逆操作，因为父容器同样会进行转化操作

  String nameToLookup = originalBeanName(name);

  if (args != null) {

  // Delegation to parent with explicit args.

  return (T) parentBeanFactory.getBean(nameToLookup, args);

  } else {

  // No args -> delegate to standard getBean method.

  return parentBeanFactory.getBean(nameToLookup, requiredType);

  }

  }

依赖初始化

• bean 能够由 depends-on 属性配置依赖的 bean。Spring 会首先初始化依赖的 bean。
• String[] dependsOn = mbd.getDependsOn();

  if (dependsOn != null) {

  for (String dependsOnBean : dependsOn) {

  // 检测是否存在循环依赖

  if (isDependent(beanName, dependsOnBean)) {

  throw new BeanCreationException(mbd.getResourceDescription(), beanName,

  “Circular depends-on relationship between ‘” + beanName + “‘ and ‘” + dependsOnBean + “‘”);

  }

  registerDependentBean(dependsOnBean, beanName);

  getBean(dependsOnBean);

  }

  }

• registerDependentBean 进行了依赖关系的注册，这么做的起因是 Spring 在即进行 bean 销毁的时候会首先销毁被依赖的 bean。依赖关系的保留是通过一个 ConcurrentHashMap<String, Set> 实现的，key 是 bean 的实在名字。

Singleton 初始化

• 尽管这里纲要是 Singleton 初始化，然而 getBean 办法自身是包含所有 scope 的初始化，在这里一次阐明了。
• if (mbd.isSingleton()) {

  sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {

  @Override

  public Object getObject() throws BeansException {

  return createBean(beanName, mbd, args);

  }

  });

  bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);

  }

getSingleton 办法

是否存在

• 首先会检测是否曾经存在，如果存在，间接返回:
• synchronized (this.singletonObjects) {

  Object singletonObject = this.singletonObjects.get(beanName);

  }

• 所有的单例 bean 都保留在这样的数据结构中:ConcurrentHashMap<String, Object>。

bean 创立

• 源码位于 AbstractAutowireCapableBeanFactory.createBean，次要分为几个局部:

lookup-method 检测

• 此局部用于检测 lookup-method 标签配置的办法是否存在:
• RootBeanDefinition mbdToUse = mbd;

  mbdToUse.prepareMethodOverrides();

• prepareMethodOverrides:
• public void prepareMethodOverrides() throws BeanDefinitionValidationException {

  // Check that lookup methods exists.

  MethodOverrides methodOverrides = getMethodOverrides();

  if (!methodOverrides.isEmpty()) {

  Set<MethodOverride> overrides = methodOverrides.getOverrides();

  synchronized (overrides) {

  for (MethodOverride mo : overrides) {

  prepareMethodOverride(mo);

  }

  }

  }

  }

• prepareMethodOverride:
• protected void prepareMethodOverride(MethodOverride mo) {

  int count = ClassUtils.getMethodCountForName(getBeanClass(), mo.getMethodName());

  if (count == 0) {

  throw new BeanDefinitionValidationException(

  “Invalid method override: no method with name ‘” + mo.getMethodName() +

  “‘ on class [” + getBeanClassName() + “]”);

  } else if (count == 1) {

  // Mark override as not overloaded, to avoid the overhead of arg type checking.

  mo.setOverloaded(false);

  }

  }

InstantiationAwareBeanPostProcessor 触发

• 在这里触发的是其 postProcessBeforeInitialization 和 postProcessAfterInstantiation 办法。
• Object bean = resolveBeforeInstantiation(beanName, mbdToUse);

  if (bean != null) {

  return bean;

  }

  Object beanInstance = doCreateBean(beanName, mbdToUse, args);

  return beanInstance;

• 持续:
• 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) {

  bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);

  if (bean != null) {

  bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);

  }

  }

  }

  mbd.beforeInstantiationResolved = (bean != null);

  }

  return bean;

  }

• 从这里能够看出，如果 InstantiationAwareBeanPostProcessor 返回的不是空，那么将不会继续执行剩下的 Spring 初始化流程，此接口用于初始化自定义的 bean，次要是在 Spring 外部应用。

doCreateBean

• 同样分为几局部。

创立(createBeanInstance)

• 要害代码:
• BeanWrapper instanceWrapper = null;

  if (instanceWrapper == null) {

  instanceWrapper = createBeanInstance(beanName, mbd, args);

  }

• createBeanInstance 的创立过程又分为以下几种状况:
• 工厂 bean:

  调用 instantiateUsingFactoryMethod 办法:

  protected BeanWrapper instantiateUsingFactoryMethod(

  String beanName, RootBeanDefinition mbd, Object[] explicitArgs) {

  return new ConstructorResolver(this).instantiateUsingFactoryMethod(beanName, mbd, explicitArgs);

  }

  留神，此处的工厂 bean 指的是配置了 factory-bean/factory-method 属性的 bean，不是实现了 FacrotyBean 接口的 bean。如果没有配置 factory-bean 属性，那么 factory-method 指向的办法必须是动态的。此办法次要做了这么几件事:

• 初始化一个 BeanWrapperImpl 对象。
• 依据设置的参数列表应用反射的办法寻找相应的办法对象。
• InstantiationStrategy:

  bean 的初始化在此处又抽成了策略模式，类图:

  instantiateUsingFactoryMethod 局部源码:

  beanInstance = this.beanFactory.getInstantiationStrategy().instantiate(

  mbd, beanName, this.beanFactory, factoryBean, factoryMethodToUse, argsToUse);

  getInstantiationStrategy 返回的是 CglibSubclassingInstantiationStrategy 对象。此处 instantiate 实现也很简略，就是调用工厂办法的 Method 对象反射调用其 invoke 即可失去对象，SimpleInstantiationStrategy.

  instantiate 外围源码:

  @Overridepublic Object instantiate(RootBeanDefinition bd, String beanName, BeanFactory owner,

  Object factoryBean, final Method factoryMethod, Object… args) {

  return factoryMethod.invoke(factoryBean, args);

  }

• 结构器主动拆卸

  createBeanInstance 局部源码:

  // Need to determine the constructor…Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);

  if (ctors != null ||

  mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||

  // 配置了 <constructor-arg> 子元素

  mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {

  return autowireConstructor(beanName, mbd, ctors, args);

  }

  determineConstructorsFromBeanPostProcessors 源码:

  protected Constructor<?>[] determineConstructorsFromBeanPostProcessors(Class<?> beanClass, String beanName) {

  if (beanClass != null && hasInstantiationAwareBeanPostProcessors()) {

  for (BeanPostProcessor bp : getBeanPostProcessors()) {

  if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {

  SmartInstantiationAwareBeanPostProcessor ibp =

  (SmartInstantiationAwareBeanPostProcessor) bp;

  Constructor<?>[] ctors = ibp.determineCandidateConstructors(beanClass, beanName);

  if (ctors != null) {

  return ctors;

  }

  }

  }

  }

  return null;

  }

  可见是由 SmartInstantiationAwareBeanPostProcessor 决定的，默认是没有配置这种货色的。

  之后就是判断 bean 的主动拆卸模式，能够通过如下形式配置:

  <bean id=”student” class=”base.Student” primary=”true” autowire=”default” />

  autowire 共有以下几种选项:

• no: 默认的，不进行主动拆卸。在这种状况下，只能通过 ref 形式援用其它 bean。
• byName: 依据 bean 外面属性的名字在 BeanFactory 中进行查找并拆卸。
• byType: 按类型。
• constructor: 以 byType 的形式查找 bean 的结构参数列表。
• default: 由父 bean 决定。
• 参考:Spring – bean 的 autowire 属性(主动拆卸)
• autowireConstructor 调用的是 ConstructorResolver.autowireConstructor，此办法次要做了两件事:
• 失去适合的结构器对象。
• 依据结构器参数的类型去 BeanFactory 查找相应的 bean:

  入口办法在 ConstructorResolver.resolveAutowiredArgument:

  protected Object resolveAutowiredArgument(

  MethodParameter param, String beanName, Set<String> autowiredBeanNames,

  TypeConverter typeConverter) {

  return this.beanFactory.resolveDependency(

  new DependencyDescriptor(param, true), beanName,

  autowiredBeanNames, typeConverter);

  }

• 最终调用的还是 CglibSubclassingInstantiationStrategy.instantiate 办法，要害源码:
• @Overridepublic Object instantiate(RootBeanDefinition bd, String beanName, BeanFactory owner,

  final Constructor<?> ctor, Object… args) {

  if (bd.getMethodOverrides().isEmpty()) {

  // 反射调用

  return BeanUtils.instantiateClass(ctor, args);

  } else {

  return instantiateWithMethodInjection(bd, beanName, owner, ctor, args);

  }

  }

• 能够看出，如果配置了 lookup-method 标签，失去的实际上是用 Cglib 生成的指标类的代理子类。
• CglibSubclassingInstantiationStrategy.instantiateWithMethodInjection:
• @Overrideprotected Object instantiateWithMethodInjection(RootBeanDefinition bd, String beanName, BeanFactory owner,Constructor<?> ctor, Object… args) {

  // Must generate CGLIB subclass…

  return new CglibSubclassCreator(bd, owner).instantiate(ctor, args);

  }

• 默认结构器

  一行代码，很简略:

  // No special handling: simply use no-arg constructor.return instantiateBean(beanName, mbd);

MergedBeanDefinitionPostProcessor

• 触发源码:
• synchronized (mbd.postProcessingLock) {

  if (!mbd.postProcessed) {

  applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);

  mbd.postProcessed = true;

  }

  }

• 此接口也是 Spring 外部应用的，不论它了。

属性解析

• 入口办法: AbstractAutowireCapableBeanFactory.populateBean，它的作用是: 依据 autowire 类型进行 autowire by name，by type 或者是间接进行设置，简略后的源码:
• protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {

  // 所有 <property> 的值

  PropertyValues pvs = mbd.getPropertyValues();

  if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||

  mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {

  MutablePropertyValues newPvs = new MutablePropertyValues(pvs);

  // Add property values based on autowire by name if applicable.

  if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {

  autowireByName(beanName, mbd, bw, newPvs);

  }

  // Add property values based on autowire by type if applicable.

  if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {

  autowireByType(beanName, mbd, bw, newPvs);

  }

  pvs = newPvs;

  }

  // 设值

  applyPropertyValues(beanName, mbd, bw, pvs);

  }

• autowireByName 源码:
• protected void autowireByName(

  String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {

  // 返回所有援用 (ref=”XXX”) 的 bean 名称

  String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);

  for (String propertyName : propertyNames) {

  if (containsBean(propertyName)) {

  // 从 BeanFactory 获取

  Object bean = getBean(propertyName);

  pvs.add(propertyName, bean);

  registerDependentBean(propertyName, beanName);

  }

  }

  }

• autowireByType 也是同样的套路，所以能够得出结论:autowireByName 和 autowireByType 办法只是先获取到援用的 bean，真正的设值是在 applyPropertyValues 中进行的。

属性设置

• Spring 判断一个属性可不可以被设置 (存不存在) 是通过 java bean 的内省操作来实现的，也就是说，属性能够被设置的条件是此属性领有 public 的 setter 办法，并且注入时的属性名应该是 setter 的名字。

初始化

• 此处的初始化指的是 bean 曾经结构实现，执行诸如调用其 init 办法的操作。相干源码:
• // Initialize the bean instance.Object exposedObject = bean;

  try {

  populateBean(beanName, mbd, instanceWrapper);

  if (exposedObject != null) {

  exposedObject = initializeBean(beanName, exposedObject, mbd);

  }

  }

• initializeBean:
• protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {

  if (System.getSecurityManager() != null) {

  AccessController.doPrivileged(new PrivilegedAction<Object>() {

  @Override

  public Object run() {

  invokeAwareMethods(beanName, bean);

  return null;

  }

  }, getAccessControlContext());

  }

  else {

  invokeAwareMethods(beanName, bean);

  }

  Object wrappedBean = bean;

  if (mbd == null || !mbd.isSynthetic()) {

  wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);

  }

  invokeInitMethods(beanName, wrappedBean, mbd);

  if (mbd == null || !mbd.isSynthetic()) {

  wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);

  }

  return wrappedBean;

  }

• 次要的操作步骤高深莫测。
• Aware 办法触发:

  咱们的 bean 有可能实现了一些 XXXAware 接口，此处就是负责调用它们:

  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) {

  ((BeanClassLoaderAware) bean).setBeanClassLoader(getBeanClassLoader());

  }

  if (bean instanceof BeanFactoryAware) {

  ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);

  }

  }

  }

• BeanPostProcessor 触发，没什么好说的
• 调用 init 办法:

  在 XML 配置中，bean 能够有一个 init-method 属性来指定初始化时调用的办法。从原理来说，其实就是一个反射调用。不过留神这里有一个 InitializingBean 的概念。

  此接口只有一个办法：

  void afterPropertiesSet() throws Exception;

  如果咱们的 bean 实现了此接口，那么此办法会首先被调用。此接口的意义在于: 当此 bean 的所有属性都被设置 (注入) 后，给 bean 一个利用现有属性从新组织或是查看属性的机会。感觉和 init 办法有些抵触，不过此接口在 Spring 被宽泛应用。

getObjectForBeanInstance

• 位于 AbstractBeanFactory，此办法的目标在于如果 bean 是 FactoryBean，那么返回其工厂办法创立的 bean，而不是本身。

Prototype 初始化

• AbstractBeanFactory.doGetBean 相干源码:
• else if (mbd.isPrototype()) {

  // It’s a prototype -> create a new instance.

  Object prototypeInstance = null;

  try {

  beforePrototypeCreation(beanName);

  prototypeInstance = createBean(beanName, mbd, args);

  }

  finally {

  afterPrototypeCreation(beanName);

  }

  bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);

  }

beforePrototypeCreation

• 此办法用于确保在同一时刻只能有一个此 bean 在初始化。

createBean

• 和单例的是一样的，不在赘述。

afterPrototypeCreation

• 和 beforePrototypeCreation 对应的，你懂的。

总结

• 能够看出，初始化其实和单例是一样的，只不过单例多了一个是否曾经存在的查看。

其它 Scope 初始化

• 其它就指的是 request、session。此局部源码:
• else {

  String scopeName = mbd.getScope();

  final Scope scope = this.scopes.get(scopeName);

  if (scope == null) {

  throw new IllegalStateException(“No Scope registered for scope name ‘” + scopeName + “‘”);

  }

  Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() {

  @Override

  public Object getObject() throws BeansException {

  beforePrototypeCreation(beanName);

  try {

  return createBean(beanName, mbd, args);

  }

  finally {

  afterPrototypeCreation(beanName);

  }

  }

  });

  bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);

  }

• scopes 是一个 LinkedHashMap<String, Scope>，能够调用 ConfigurableBeanFactory 定义的 registerScope 办法注册其值。
• Scope 接口继承体系:

• 依据 socpe.get 的正文，此办法如果找到了叫做 beanName 的 bean，那么返回，如果没有，将调用 ObjectFactory 创立之。Scope 的实现参考类图.

本文来源于：宋文超 super，专属平台有 csdn、思否(SegmentFault)、简书、开源中国(oschina)，转载请注明出处。