基于springboot bean的实例化过程和属性注入过程

目录
  • bean的实例化过程和属性注入过程
  • bean实例化流程说明

bean的实例化过程和属性注入过程

了解过springboot的加载流程的都知道springboot初始化bean都在refresh方法中。

这个方法代码如下:

// Prepare this context for refreshing.
prepareRefresh();
// Tell the subclass to refresh the internal bean factory.新建beanFactory
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// Prepare the bean factory for use in this context.
prepareBeanFactory(beanFactory);
try {
   // Allows post-processing of the bean factory in context subclasses.
   postProcessBeanFactory(beanFactory);
   // Invoke factory processors registered as beans in the context.
   // 加载实现beanFactoryPostProcessor的bean,bean定义的时候执行
   invokeBeanFactoryPostProcessors(beanFactory);
   // Register bean processors that intercept bean creation.
   // 加载实现了beanPostProcessor,在bean实例化前、后执行
   registerBeanPostProcessors(beanFactory);
   // Initialize message source for this context.
   initMessageSource();
   // Initialize event multicaster for this context.
   initApplicationEventMulticaster();
   // Initialize other special beans in specific context subclasses.
   onRefresh();
   // Check for listener beans and register them.
   registerListeners();
   // Instantiate all remaining (non-lazy-init) singletons.
   //实例化非懒加载的bean、bean封装、属性注入、注解注入(主要使用BeanPostProcessor或子类实现)等
   finishBeanFactoryInitialization(beanFactory);
   // Last step: publish corresponding event.
   finishRefresh();

这里我们主要看下finishBeanfactoryInitialization方法。此方法实现了bean的实例和属性注入等。进入此方法的最后一行。

// Instantiate all remaining (non-lazy-init) singletons.
beanFactory.preInstantiateSingletons();

注释写的很清楚,实例化剩余非懒加载的bean。此方法的实现是核心类DefaultLisListableBeanFactory实现。这个方法中有个判断:bean是否是beanFactory的实现类。

如果是则获取bean的时候会从beanFactory实现类的getObject中获取,我们重点看看getBean这个方法。

getBean是spring中最重要、最牛逼的方法之一,具体的逻辑是通过doGetBean方法处理的。

我们看下doGetBean方法,方法很长。我们分成几个部分去看。

1、先判断是否已经存在缓存中,代码如下:

if (sharedInstance != null && args == null) {
   if (logger.isDebugEnabled()) {
      if (isSingletonCurrentlyInCreation(beanName)) {
         logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
               "' that is not fully initialized yet - a consequence of a circular reference");
      }
      else {
         logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
      }
   }
   bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);

2、从父beanfactory中获取

BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
   // Not found -> check parent.
   String nameToLookup = originalBeanName(name);
   if (parentBeanFactory instanceof AbstractBeanFactory) {
      return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
            nameToLookup, requiredType, args, typeCheckOnly);
   }
   else 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);
   }
}

3、直接创建RootBeanDefinition

//mark 给此bean 马克一下。防止重复创建
if (!typeCheckOnly) {
   markBeanAsCreated(beanName);
}
try {
   final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
   checkMergedBeanDefinition(mbd, beanName, args);
   // Guarantee initialization of beans that the current bean depends on.
   String[] dependsOn = mbd.getDependsOn();
   if (dependsOn != null) {
      for (String dep : dependsOn) {
         if (isDependent(beanName, dep)) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                  "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
         }
         registerDependentBean(dep, beanName);
         getBean(dep);
      }
   }

4、是singleton还是prototype类型的,根据不同类型去实例化bean,代码只贴了单例的类型:

// Create bean instance.
if (mbd.isSingleton()) {
   sharedInstance = getSingleton(beanName, () -> {
      try {
         return createBean(beanName, mbd, args);
      }
      catch (BeansException ex) {
         // Explicitly remove instance from singleton cache: It might have been put there
         // eagerly by the creation process, to allow for circular reference resolution.
         // Also remove any beans that received a temporary reference to the bean.
         destroySingleton(beanName);
         throw ex;
      }
   });
   bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);

5、检查bean的类型是否匹配

// Check if required type matches the type of the actual bean instance.
if (requiredType != null && !requiredType.isInstance(bean)) {
   try {
      T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
      if (convertedBean == null) {
         throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
      }
      return convertedBean;
   }
   catch (TypeMismatchException ex) {
      if (logger.isDebugEnabled()) {
         logger.debug("Failed to convert bean '" + name + "' to required type '" +
               ClassUtils.getQualifiedName(requiredType) + "'", ex);
      }
      throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
   }
}

整个doGetBean方法改成这5个部分,重点看下第4个部分中的createBean和getObjectForBeanInstance方法。

1、createBean方法,里面主要是2个部分,bean直接是通过BeanPostProcessor的postProcessBeforeIntantiation方法获取的。

注释也是描述的很清楚:Give BeanPostProcessors a chance to return a proxy instead of the bean instance(英语渣渣不敢瞎翻译误导大家,理解就好)

代码如下:

try {
   // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
   Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
   if (bean != null) {
      return bean;
   }
}
catch (Throwable ex) {
   throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
         "BeanPostProcessor before instantiation of bean failed", ex);
}

第一个部分自己实现,那么createBean方法第2个部分毋庸置疑肯定是spring去实例化bean,代码如下:

try {
   Object beanInstance = doCreateBean(beanName, mbdToUse, args);
   if (logger.isDebugEnabled()) {
      logger.debug("Finished creating instance of bean '" + beanName + "'");
   }
   return beanInstance;
}

又是do开头的方法,说明这个也是一个创建方法,spring中一般do开头的都是用于创建某个对象。跟着代码走,看下doCreateBean方法,在查看此方法之前,可能需要了解下BeanWarpper这个封装类。bean的封装、属性注入等都是用BeanWarpper去完成的。

看下代码:

// Instantiate the bean.
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
   instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
   instanceWrapper = createBeanInstance(beanName, mbd, args);
}

进入createBeanInstance方法中,就是调用构造器去实例化bean,返回beanWrapper。通过构造器获取实例代码如下:

// Need to determine the constructor...
Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
if (ctors != null ||
      mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
      mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args))  {
   return autowireConstructor(beanName, mbd, ctors, args);
}
// No special handling: simply use no-arg constructor.
return instantiateBean(beanName, mbd);

这里实例化我一开始以为就是简单的反射,后面我点进去时候发现里面一直提策略实例化,我目前了解的是可以解决Override的问题等。如果有兴趣的可以自行查看。到这里为止。我们终于实例化bean了。下面看下第二步bean的属性注入等。

代码如下:

Object exposedObject = bean;
try {
   populateBean(beanName, mbd, instanceWrapper);
   exposedObject = initializeBean(beanName, exposedObject, mbd);
}
catch (Throwable ex) {
   if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
      throw (BeanCreationException) ex;
   }
   else {
      throw new BeanCreationException(
            mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
   }
}

populateBean方法名称就暴露他是干啥的:填充bean。我放一段比较重要的部分:

if (hasInstAwareBpps || needsDepCheck) {
   if (pvs == null) {
      pvs = mbd.getPropertyValues();
   }
   PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
   if (hasInstAwareBpps) {
      for (BeanPostProcessor bp : getBeanPostProcessors()) {
         if (bp instanceof InstantiationAwareBeanPostProcessor) {
            InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
            pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
            if (pvs == null) {
               return;
            }
         }
      }
   }
   if (needsDepCheck) {
      checkDependencies(beanName, mbd, filteredPds, pvs);
   }
}

这段代码貌似没有什么注入、填充什么的,我们看下InstantiationAwareBeanPostProcessor这个接口,发现这个接口有个很熟悉的实现类是:AutowiredAnnotationBeanPostProcessor。这个类的方法中我们看到终于看到了jnject方法。但是在inject之前需要调用下findAutowiringMatedata方法获取一下元数据:

// Fall back to class name as cache key, for backwards compatibility with custom callers.
String cacheKey = (StringUtils.hasLength(beanName) ? beanName : clazz.getName());
// Quick check on the concurrent map first, with minimal locking.
InjectionMetadata metadata = this.injectionMetadataCache.get(cacheKey);
if (InjectionMetadata.needsRefresh(metadata, clazz)) {
   synchronized (this.injectionMetadataCache) {
      metadata = this.injectionMetadataCache.get(cacheKey);
      if (InjectionMetadata.needsRefresh(metadata, clazz)) {
         if (metadata != null) {
            metadata.clear(pvs);
         }
         metadata = buildAutowiringMetadata(clazz);
         this.injectionMetadataCache.put(cacheKey, metadata);
      }
   }
}
return metadata;

那么问题又来了,这个injectionMetadataCache集合值是从那里来的呢?AutowiredAnnotationBeanPostProcessor实现了MergeBeandefinitionPostProcessor,那么就好了,肯定是在bean实例的时候调用了postProcessMergedBeanDefintion这个方法。

果然在doCreateBean方法中有这么一段:

// Allow post-processors to modify the merged bean definition.
synchronized (mbd.postProcessingLock) {
   if (!mbd.postProcessed) {
      try {
         //通过 BeanPostProcessor将需要注解的元数据 放到Map中
         applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
      }
      catch (Throwable ex) {
         throw new BeanCreationException(mbd.getResourceDescription(), beanName,
               "Post-processing of merged bean definition failed", ex);
      }
      mbd.postProcessed = true;
   }
}

哎,spring缜密啊。元数据有了,下面我们看下element.inject()方法是如何操作的:

if (this.isField) {
   Field field = (Field) this.member;
   ReflectionUtils.makeAccessible(field);
   field.set(target, getResourceToInject(target, requestingBeanName));
}
else {
   if (checkPropertySkipping(pvs)) {
      return;
   }
   try {
      Method method = (Method) this.member;
      ReflectionUtils.makeAccessible(method);
      method.invoke(target, getResourceToInject(target, requestingBeanName));
   }
   catch (InvocationTargetException ex) {
      throw ex.getTargetException();
   }
}

方法简单明了,直接使用反射将值set到属性中,至此 bean的实例、属性注入基本完成,下面我们回头来看doGetBean的另一个方法getObjectForBeanInstance。

2、getObjectForBeanInstance方法。对于是FactoryBean类型的 bean通过getObject获取到bean的代理实例,跟着方法一直走下去会到getObejct()方法中。

if (System.getSecurityManager() != null) {
   AccessControlContext acc = getAccessControlContext();
   try {
      object = AccessController.doPrivileged((PrivilegedExceptionAction<Object>) factory::getObject, acc);
   }
   catch (PrivilegedActionException pae) {
      throw pae.getException();
   }
}
else {
   //从FactoryBean实现bean中getObejct获取到bean
   object = factory.getObject();
}

到此 finishBeanfactoryInitialization方法执行结束!

bean实例化流程说明

bean实例化流程流程是在onRefresh方法的finishBeanFactoryInitialization中。进入该方法

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
        // Initialize conversion service for this context.
        if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
                beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
            beanFactory.setConversionService(
                    beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
        }

        // Register a default embedded value resolver if no bean post-processor
        // (such as a PropertyPlaceholderConfigurer bean) registered any before:
        // at this point, primarily for resolution in annotation attribute values.
        if (!beanFactory.hasEmbeddedValueResolver()) {
            beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
        }

        // Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
        String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
        for (String weaverAwareName : weaverAwareNames) {
            getBean(weaverAwareName);
        }

        // Stop using the temporary ClassLoader for type matching.
        beanFactory.setTempClassLoader(null);

        // Allow for caching all bean definition metadata, not expecting further changes.
        beanFactory.freezeConfiguration();

        // Instantiate all remaining (non-lazy-init) singletons.
        beanFactory.preInstantiateSingletons();
    }

1、beanFactory.freezeConfiguration(); 标记正在实例化

当前有183个bean正在实例化中。

2、调用beanFactory.preInstantiateSingletons(); 实例化bean

以上为个人经验,希望能给大家一个参考,也希望大家多多支持我们。

(0)

相关推荐

  • 这一次搞懂Spring的Bean实例化原理操作

    前言 前两篇文章分析了Spring XML和注解的解析原理,并将其封装为BeanDefinition对象存放到IOC容器中,而这些只是refresh方法中的其中一个步骤--obtainFreshBeanFactory,接下来就将围绕着这些BeanDefinition对象进行一系列的处理,如BeanDefinitionRegistryPostProcessor对象方法的调用.BeanFactoryPostProcessor对象方法的调用以及Bean实例的创建都离不开这些BeanDefinition

  • Spring boot将配置属性注入到bean类中

    一.@ConfigurationProperties注解的使用 看配置文件,我的是yaml格式的配置: // file application.yml my: servers: - dev.bar.com - foo.bar.com - jiaobuchong.com 下面我要将上面的配置属性注入到一个Java Bean类中,看码: import org.springframework.boot.context.properties.ConfigurationProperties; import

  • springboot 实现bean手动注入操作

    1.springboot启动类实现接口ApplicationListener<ContextRefreshedEvent>,实现方法onApplicationEvent,初始化上下文 package test.projectTest; import org.mybatis.spring.boot.autoconfigure.MybatisAutoConfiguration; import org.springframework.boot.SpringApplication; import or

  • 基于springboot bean的实例化过程和属性注入过程

    目录 bean的实例化过程和属性注入过程 bean实例化流程说明 bean的实例化过程和属性注入过程 了解过springboot的加载流程的都知道springboot初始化bean都在refresh方法中. 这个方法代码如下: // Prepare this context for refreshing. prepareRefresh(); // Tell the subclass to refresh the internal bean factory.新建beanFactory Config

  • Spring bean的实例化和IOC依赖注入详解

    前言 我们知道,IOC是Spring的核心.它来负责控制对象的生命周期和对象间的关系. 举个例子,我们如何来找对象的呢?常见的情况是,在路上要到处去看哪个MM既漂亮身材又好,符合我们的口味.就打听她们的电话号码,制造关联想办法认识她们,然后...这里省略N步,最后谈恋爱结婚. IOC在这里就像婚介所,里面有很多适婚男女的资料,如果你有需求,直接告诉它你需要个什么样的女朋友就好了.它会给我们提供一个MM,直接谈恋爱结婚,完美! 下面就来看Spring是如何生成并管理这些对象的呢? 1.方法入口 o

  • springboot bean循环依赖实现以及源码分析

    前言 本文基于springboot版本2.5.1 <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.5.1</version> <relativePath/> <!-- lookup parent from repositor

  • 基于@Bean修饰的方法参数的注入方式

    目录 @Bean修饰的方法参数的注入 Bean的四种注入方式 1.set注入 2.构造器注入 3.静态工厂注入 4.实例工厂注入 @Bean修饰的方法参数的注入 方法参数默认注入方式为Autowired,即先根据类型匹配,若有多个在根据名称进行匹配. 1:复杂类型可以通过@Qualifier(value="XXX")限定 2:对于普通类型使用@Value(XXX)指定 @PropertySource("classpath:db.properties") public

  • Spring Bean的实例化之属性注入源码剖析过程

    前言 这一章节我们来讨论创建Bean过程中的属性注入,在Spring的IOC容器启动过程中,会把定义的Bean封装成BeanDefinition注册到一个ConcurrentHashMap中,Bean注册完成后,就会对单利的且lazy-init=false 的Bean进行实例化.创建Bean的代码在 AbstractAutowireCapableBeanFactory#doCreateBean 中,当Bean创建成功之后,会调用AbstractAutowireCapableBeanFactory

  • 基于springboot实现整合shiro实现登录认证以及授权过程解析

    这篇文章主要介绍了基于springboot实现整合shiro实现登录认证以及授权过程解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 1.添加shiro的依赖 <dependency> <groupId>org.apache.shiro</groupId> <artifactId>shiro-spring-boot-web- starter</artifactId> <version&g

  • 基于springboot处理date参数过程解析

    这篇文章主要介绍了基于springboot处理date参数过程解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 前言 最近在后台开发中遇到了时间参数的坑,就单独把这个问题提出来找时间整理了一下: 正文 测试方法 bean代码: public class DateModelNoAnnotation { private Integer id; private Date receiveDate; } controller代码: @RestContr

  • 基于springboot集成hbase过程解析

    这篇文章主要介绍了基于springboot集成hbase过程解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 springboot-habse: https://github.com/spring-projects/spring-hadoop-samples/tree/master/hbase 依赖: <dependency> <groupId>org.springframework.data</groupId> &

  • Spring bean对象实例化实现过程图解

    好了 我们聊聊 Bean 的实例化过程的几个重要角色 BeanDefinitionRegistryPostProcessor 接口 Refresh().invokeBeanFactoryPostProcessors 这个方法里面. BeanDefinitionRegistryPostProcessor 这个接口的调用分为三部: 1.调用实现了 PriorityOrdered 排序接口 2.调用实现了 Ordered 排序接口 3.没有实现接口的调用 这个接口我的理解:获取 BeanDefinit

  • 基于SPRINGBOOT配置文件占位符过程解析

    这篇文章主要介绍了基于SPRINGBOOT配置文件占位符过程解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 一.配置文件占位符 1.application.properties server.port=8088 debug=false product.id=ID:${random.uuid} product.name=da mao mao product.weight=${random.int} product.fristLinePrice

随机推荐