Spring底层原理(二)_classutils.getdefaultclassloader().getresource

前提:Bean创建的前提，实例化->属性注入->类加载->初始化->初始化前->初始化后

一、doGetBean()方法

 protected <T> T doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly) throws BeansException {
    String beanName = this.transformedBeanName(name);
    Object sharedInstance = this.getSingleton(beanName);
    Object beanInstance;
      if (sharedInstance != null && args == null){....}else{...}
          return this.adaptBeanInstance(name, beanInstance, requiredType);
1
2
3
4
5
6

由于doGetBean方法内容较多，拆分一下，并且我们从一开始单例池中没有Bean(上图代码else逻辑)开始走起，并且忽略一些监控、安全代码

//1.循环依赖处理Bean
if (this.isPrototypeCurrentlyInCreation(beanName)){....}
//2.父BeanFactory中寻找Bean，
if (parentBeanFactory != null && !this.containsBeanDefinition(beanName)){.....}
try {
        if (requiredType != null) {
          beanCreation.tag("beanType", requiredType::toString);
        }

        RootBeanDefinition mbd = this.getMergedLocalBeanDefinition(beanName);
        this.checkMergedBeanDefinition(mbd, beanName, args);
        String[] dependsOn = mbd.getDependsOn();
        String[] var12;
        //3.处理@DependsOn注解
        if (dependsOn != null){.....}
        //4.单例、原型等Bean的处理
         if (mbd.isSingleton()){......}else if (mbd.isPrototype()){.....}else{.....}
          } catch (BeansException var32) {
        beanCreation.tag("exception", var32.getClass().toString());
        beanCreation.tag("message", String.valueOf(var32.getMessage()));
        this.cleanupAfterBeanCreationFailure(beanName);
        throw var32;
      } finally {
        beanCreation.end();
      }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

1.处理@DependsOn注解

        if (dependsOn != null) {
          var12 = dependsOn;
          int var13 = dependsOn.length;

          for(int var14 = 0; var14 < var13; ++var14) {
            String dep = var12[var14];
            if (this.isDependent(beanName, dep)) {
              throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
            }

            this.registerDependentBean(dep, beanName);

            try {
              this.getBean(dep);
            } catch (NoSuchBeanDefinitionException var31) {
              throw new BeanCreationException(mbd.getResourceDescription(), beanName, "'" + beanName + "' depends on missing bean '" + dep + "'", var31);
            }
          }
        }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

直接用例子来解释，假设A类依赖B类、C类那么原理就是要求在A创建出来之前B类、C类要被创建出来
@DepondsOn(“B”,“C”)
class A{
}
isDependent(beanName, dep)方法假设A是beanName，dep是B类的名称
然后代码会去看B类中是否加了@DepoondsOn(“A”)这样的注释如果有就会循环依赖报错

2.单例Bean的创建

if (mbd.isSingleton()){
          sharedInstance = this.getSingleton(beanName, () -> {
            try {
              return this.createBean(beanName, mbd, args);
            } catch (BeansException var5) {
              this.destroySingleton(beanName);
              throw var5;
            }
          });
          beanInstance = this.getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
        }
1
2
3
4
5
6
7
8
9
10
11

这里先看到getSingleton方法里面

  public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
    Assert.notNull(beanName, "Bean name must not be null");
    synchronized(this.singletonObjects) {
      Object singletonObject = this.singletonObjects.get(beanName);
      if (singletonObject == null) {
        if (this.singletonsCurrentlyInDestruction) {
          throw new BeanCreationNotAllowedException(beanName, "Singleton bean creation not allowed while singletons of this factory are in destruction (Do not request a bean from a BeanFactory in a destroy method implementation!)");
        }

        if (this.logger.isDebugEnabled()) {
          this.logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
        }

        this.beforeSingletonCreation(beanName);
        boolean newSingleton = false;
        boolean recordSuppressedExceptions = this.suppressedExceptions == null;
        if (recordSuppressedExceptions) {
          this.suppressedExceptions = new LinkedHashSet();
        }

        try {
          singletonObject = singletonFactory.getObject();
          newSingleton = true;
        } catch (IllegalStateException var16) {
          singletonObject = this.singletonObjects.get(beanName);
          if (singletonObject == null) {
            throw var16;
          }
        } catch (BeanCreationException var17) {
          BeanCreationException ex = var17;
          if (recordSuppressedExceptions) {
            Iterator var8 = this.suppressedExceptions.iterator();

            while(var8.hasNext()) {
              Exception suppressedException = (Exception)var8.next();
              ex.addRelatedCause(suppressedException);
            }
          }

          throw ex;
        } finally {
          if (recordSuppressedExceptions) {
            this.suppressedExceptions = null;
          }

          this.afterSingletonCreation(beanName);
        }

        if (newSingleton) {
          this.addSingleton(beanName, singletonObject);
        }
      }

      return singletonObject;
    }
  }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

总体逻辑就是，
1.创建对象添加标记，
2.调用lambda表示式生成对象，
3.移除创建标记，
4.添加到单例池
这里的singletonObject = singletonFactory.getObject();就是创建Bean对象的代码，是引用传进来的lambda表达式代码

3.原型Bean的创建

 else if (mbd.isPrototype()) {
          var12 = null;

          Object prototypeInstance;
          try {
            this.beforePrototypeCreation(beanName);
            prototypeInstance = this.createBean(beanName, mbd, args);
          } finally {
            this.afterPrototypeCreation(beanName);
          }

          beanInstance = this.getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
        }
1
2
3
4
5
6
7
8
9
10
11
12
13

原型Bean比较简单一些，这里耶尔时直接创建Bean

4.其他作用域Bean的创建
如request、session作用域里面的bean(如同一个请求里面拿到的要是同一个Request的Bean对象)
对应注解@RequestScope、@SessionScope

else{
          String scopeName = mbd.getScope();
          if (!StringUtils.hasLength(scopeName)) {
            throw new IllegalStateException("No scope name defined for bean '" + beanName + "'");
          }

          Scope scope = (Scope)this.scopes.get(scopeName);
          if (scope == null) {
            throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
          }

          try {
          //getAttriute()
            Object scopedInstance = scope.get(beanName, () -> {
              this.beforePrototypeCreation(beanName);

              Object var4;
              try {
                var4 = this.createBean(beanName, mbd, args);
              } finally {
                this.afterPrototypeCreation(beanName);
              }

              return var4;
            });
            beanInstance = this.getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
          } catch (IllegalStateException var30) {
            throw new ScopeNotActiveException(beanName, scopeName, var30);
          }
        }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

代码中 Scope scope = (Scope)this.scopes.get(scopeName);
返回了一个Scope对象(这里所用的springframework容器，所以默认情况都是没有值的，但是mvc、springboot在启动的时候是会往容器里面去注册这两种scope)
实际上底层原理request.getAttriute(BeanName)->判断是否存在->不存在就是setAttriute(BeanName)
这边过程在上诉代码中scope.get(beanName,()->{…})

二、createBean()方法

  protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
    if (this.logger.isTraceEnabled()) {
      this.logger.trace("Creating instance of bean '" + beanName + "'");
    }

    RootBeanDefinition mbdToUse = mbd;
    Class<?> resolvedClass = this.resolveBeanClass(mbd, beanName, new Class[0]);
    if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
      mbdToUse = new RootBeanDefinition(mbd);
      mbdToUse.setBeanClass(resolvedClass);
    }

    try {
      mbdToUse.prepareMethodOverrides();
    } catch (BeanDefinitionValidationException var9) {
      throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(), beanName, "Validation of method overrides failed", var9);
    }

    Object beanInstance;
    try {
      beanInstance = this.resolveBeforeInstantiation(beanName, mbdToUse);
      if (beanInstance != null) {
        return beanInstance;
      }
    } catch (Throwable var10) {
      throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "BeanPostProcessor before instantiation of bean failed", var10);
    }

    try {
      beanInstance = this.doCreateBean(beanName, mbdToUse, args);
      if (this.logger.isTraceEnabled()) {
        this.logger.trace("Finished creating instance of bean '" + beanName + "'");
      }

      return beanInstance;
    } catch (ImplicitlyAppearedSingletonException | BeanCreationException var7) {
      throw var7;
    } catch (Throwable var8) {
      throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", var8);
    }
  }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

mdb里面存储的Object存的是类的名字，因此现在要去加载一个类，因此直接走resolveBeanClass()方法

@Nullable
  protected Class<?> resolveBeanClass(RootBeanDefinition mbd, String beanName, Class<?>... typesToMatch) throws CannotLoadBeanClassException {
    try {
    //这里是判断是不是一个class属性
    //因为一开始是一个字符串类名因此走else逻辑
      if (mbd.hasBeanClass()) {
        return mbd.getBeanClass();
      } else {
        return System.getSecurityManager() != null ? (Class)AccessController.doPrivileged(() -> {
          return this.doResolveBeanClass(mbd, typesToMatch);
        }, this.getAccessControlContext()) : this.doResolveBeanClass(mbd, typesToMatch);
      }
    } catch (PrivilegedActionException var6) {
      ClassNotFoundException ex = (ClassNotFoundException)var6.getException();
      throw new CannotLoadBeanClassException(mbd.getResourceDescription(), beanName, mbd.getBeanClassName(), ex);
    } catch (ClassNotFoundException var7) {
      throw new CannotLoadBeanClassException(mbd.getResourceDescription(), beanName, mbd.getBeanClassName(), var7);
    } catch (LinkageError var8) {
      throw new CannotLoadBeanClassException(mbd.getResourceDescription(), beanName, mbd.getBeanClassName(), var8);
    }
  }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

直接看到主线doResolveBeanClass()方法

 @Nullable
 private Class<?> doResolveBeanClass(RootBeanDefinition mbd, Class<?>... typesToMatch) throws ClassNotFoundException {
   ClassLoader beanClassLoader = this.getBeanClassLoader();
   ClassLoader dynamicLoader = beanClassLoader;
   boolean freshResolve = false;
   if (!ObjectUtils.isEmpty(typesToMatch)) {
     ClassLoader tempClassLoader = this.getTempClassLoader();
     if (tempClassLoader != null) {
       dynamicLoader = tempClassLoader;
       freshResolve = true;
       if (tempClassLoader instanceof DecoratingClassLoader) {
         DecoratingClassLoader dcl = (DecoratingClassLoader)tempClassLoader;
         Class[] var8 = typesToMatch;
         int var9 = typesToMatch.length;

         for(int var10 = 0; var10 < var9; ++var10) {
           Class<?> typeToMatch = var8[var10];
           dcl.excludeClass(typeToMatch.getName());
         }
       }
     }
   }

   String className = mbd.getBeanClassName();
   if (className != null) {
     Object evaluated = this.evaluateBeanDefinitionString(className, mbd);
     if (!className.equals(evaluated)) {
       if (evaluated instanceof Class) {
         return (Class)evaluated;
       }

       if (!(evaluated instanceof String)) {
         throw new IllegalStateException("Invalid class name expression result: " + evaluated);
       }

       className = (String)evaluated;
       freshResolve = true;
     }

     if (freshResolve) {
       if (dynamicLoader != null) {
         try {
           return dynamicLoader.loadClass(className);
         } catch (ClassNotFoundException var12) {
           if (this.logger.isTraceEnabled()) {
             this.logger.trace("Could not load class [" + className + "] from " + dynamicLoader + ": " + var12);
           }
         }
       }

       return ClassUtils.forName(className, dynamicLoader);
     }
   }

   return mbd.resolveBeanClass(beanClassLoader);
 }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

首先我们看到加载Bean使用classLoader是

@Nullable
private ClassLoader beanClassLoader = ClassUtils.getDefaultClassLoader();

getDefaultClassLoader()方法

@Nullable
  public static ClassLoader getDefaultClassLoader() {
    ClassLoader cl = null;

    try {
    //使用当前线程使用的类加载器(可以在启动容器去设置 content.set..)
    //这里可以引申出Tomcat在启动war项目的时候其实自己去修改了类加载器
    //tomcat会用自己写的(一个war对应一个类加载器并且在启动spring的时候也会去
    //调用tomcat自己定义的类加载器，大致明白一下流程不是核心)
      cl = Thread.currentThread().getContextClassLoader();
    } catch (Throwable var3) {
    }
  //假设没有去设置
    if (cl == null) {
    //这里是使用ClassUtils被哪个类加载器加载的就用哪个，
    //ClassUtils是在spring-core的包下的
      cl = ClassUtils.class.getClassLoader();
      if (cl == null) {
      //这里是指假设spring-core的jar包放在了jre/lib下面
      //那么就是被Bootstrap类加载加载
      //所以为空(参考类加载机制)
        try {
        //这里就直接拿AppClassLoader加载
          cl = ClassLoader.getSystemClassLoader();
        } catch (Throwable var2) {
        }
      }
    }

    return cl;
  }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

上述就是spring启动使用类加载器的逻辑，然后我们继续回到doResolveBeanClass方法

@Nullable
private Class<?> doResolveBeanClass(RootBeanDefinition mbd, Class<?>... typesToMatch) throws ClassNotFoundException {
ClassLoader beanClassLoader = this.getBeanClassLoader();
  ClassLoader dynamicLoader = beanClassLoader;
  boolean freshResolve = false;
  if (!ObjectUtils.isEmpty(typesToMatch)){.....}
  String className = mbd.getBeanClassName();
  if (className != null) {
    Object evaluated = this.evaluateBeanDefinitionString(className, mbd);
    //spring通过xml表达式
    if (!className.equals(evaluated)){.....}
     if (freshResolve){.....}
     
    }
     return mbd.resolveBeanClass(beanClassLoader);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

这里if (!className.equals(evaluated)){…} 里面的内容是去解析，spring通过xml配置bean的特殊表达式的逻辑，用的较少，用的spring的解析器去解析，可以先暂且跳过，最后加载类把对象返回，然后我们再回到createBean方法
并且直接看到主线:实例化前

 Object beanInstance;
   try {
     beanInstance = this.resolveBeforeInstantiation(beanName, mbdToUse);
     if (beanInstance != null) {
       return beanInstance;
     }
   } catch (Throwable var10) {
     throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "BeanPostProcessor before instantiation of bean failed", var10);
   }
1
2
3
4
5
6
7
8
9

直接看到实例化前的方法resolveBeforeInstantiation()

  @Nullable
 protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
   Object bean = null;
   if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
     if (!mbd.isSynthetic() && this.hasInstantiationAwareBeanPostProcessors()) {
       Class<?> targetType = this.determineTargetType(beanName, mbd);
       if (targetType != null) {
         bean = this.applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
         if (bean != null) {
           bean = this.applyBeanPostProcessorsAfterInitialization(bean, beanName);
         }
       }
     }

     mbd.beforeInstantiationResolved = bean != null;
   }

   return bean;
 }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

这里我们看到hasInstantiationAwareBeanPostProcessors()方法里面的getBeanPostProcessorCache方法

AbstractBeanFactory.BeanPostProcessorCache getBeanPostProcessorCache() {
    AbstractBeanFactory.BeanPostProcessorCache bpCache = this.beanPostProcessorCache;
    if (bpCache == null) {
      bpCache = new AbstractBeanFactory.BeanPostProcessorCache();
      Iterator var2 = this.beanPostProcessors.iterator();

      while(var2.hasNext()) {
        BeanPostProcessor bp = (BeanPostProcessor)var2.next();
        if (bp instanceof InstantiationAwareBeanPostProcessor) {
          bpCache.instantiationAware.add((InstantiationAwareBeanPostProcessor)bp);
          if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
            bpCache.smartInstantiationAware.add((SmartInstantiationAwareBeanPostProcessor)bp);
          }
        }

        if (bp instanceof DestructionAwareBeanPostProcessor) {
          bpCache.destructionAware.add((DestructionAwareBeanPostProcessor)bp);
        }

        if (bp instanceof MergedBeanDefinitionPostProcessor) {
          bpCache.mergedDefinition.add((MergedBeanDefinitionPostProcessor)bp);
        }
      }

      this.beanPostProcessorCache = bpCache;
    }

    return bpCache;
  }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

这里就是缓存了四个list并且多是beanpostprocessor的子类
这里的逻辑就是去判断实现的BeanPostProcessor的类型
然后存到缓存中。然后再回到实例化前的代码

  @Nullable
  protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
    Object bean = null;
    if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
      if (!mbd.isSynthetic() && this.hasInstantiationAwareBeanPostProcessors()) {
      //类实现了BeanPostProcessor
        Class<?> targetType = this.determineTargetType(beanName, mbd);
        //把实现的方法return回来的类类型拿到
        if (targetType != null) {
          bean = this.applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
          if (bean != null) {
            bean = this.applyBeanPostProcessorsAfterInitialization(bean, beanName);
          }
        }
      }

      mbd.beforeInstantiationResolved = bean != null;
    }

    return bean;
  }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

这里看到applyBeanPostProcessorsBeforeInstantiation()方法里

@Nullable
  protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
    Iterator var3 = this.getBeanPostProcessorCache().instantiationAware.iterator();

    Object result;
    do {
      if (!var3.hasNext()) {
        return null;
      }

      InstantiationAwareBeanPostProcessor bp = (InstantiationAwareBeanPostProcessor)var3.next();
      result = bp.postProcessBeforeInstantiation(beanClass, beanName);
    } while(result == null);

    return result;
  }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

这里的意思就是去执行实现了InstantiationAwareBeanPostProcessor 的BeanPostProcessor返回对象，循环的逻辑是应对如果出现两个这样的BeanPostProcessor返回第一次获取的Object然后结束循环，

例子如下两图分别为DemoBeanPostProcessor1和DemoBeanPostProcessor
假设当逻辑走到bp=DemoBeanPostProcessor1然后执行postProcessBeforeInstantiation方法获取到了result=userService然后就会return并不会继续去执行到DemoBeanPostProcessor的postProcessBeforeInstantiation方法

到这里实例化前的代码就看完了 我们继续回到createBean的实例化前代码那边去往下看

......................
Object beanInstance;
    try {
    //实例化前
      beanInstance = this.resolveBeforeInstantiation(beanName, mbdToUse);
      if (beanInstance != null) {
      //BeanPostProcessor返回的对象直接拿来用return回去结束
      //Bean创建结束
        return beanInstance;
      }
    } catch (Throwable var10) {
      throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "BeanPostProcessor before instantiation of bean failed", var10);
    }
   //正常逻辑
    try {
      beanInstance = this.doCreateBean(beanName, mbdToUse, args);
      if (this.logger.isTraceEnabled()) {
        this.logger.trace("Finished creating instance of bean '" + beanName + "'");
      }

      return beanInstance;
    } catch (ImplicitlyAppearedSingletonException | BeanCreationException var7) {
      throw var7;
    } catch (Throwable var8) {
      throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", var8);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26