spring 是如何创建对象的

spring 是如何创建对象的

推断构造方法 进行实例化bean

1、在Spring中，什么是Bean？跟对象有什么区别？

通过new关键字，反射，克隆等手段创建出来的就是对象。在Spring中，Bean一定是一个对象，但是对象不一定是一个Bean，一个被创建出来的对象要变成一个Bean要经过很多复杂的工序，例如需要被我们的BeanPostProcessor处理，需要经过初始化，需要经过AOP（AOP本身也是由后置处理器完成的）等。

spring完成一些组件的注册和准备工作

// 完成beanFactory的初始化（实例化非懒加载的单例bean）
finishBeanFactoryInitialization(beanFactory);

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
   

   // Initialize conversion service for this context.
   // 如果BeanFactory中存在ConversionService,则设置BeanFactory的ConversionService属性
   // ConversionService是用来进行类型转化的
   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.
   // 添加一个StringValueResolver，用于处理占位符，可以看到，默认情况下就是使用环境中的属性值来替代占位符中的属性
   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.
   // 冻结所有已经注册了的BeanDefinition，后续不能被修改和处理
   beanFactory.freezeConfiguration();

   // Instantiate all remaining (non-lazy-init) singletons.
   // 实例化所有非懒加载的bean
   beanFactory.preInstantiateSingletons();
}

beanFactory.preInstantiateSingletons(); 是创建Bean的方法

@Override
public void preInstantiateSingletons() throws BeansException {
   
   if (logger.isTraceEnabled()) {
   
      logger.trace("Pre-instantiating singletons in " + this);
   }

   // Iterate over a copy to allow for init methods which in turn register new bean definitions.
   // While this may not be part of the regular factory bootstrap, it does otherwise work fine.
   // 所有的bd名称 beanDefinitionNames 在准备工作已经注入
   List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

   // Trigger initialization of all non-lazy singleton beans...
   // 循环bd，实例化单例bean
   for (String beanName : beanNames) {
   
      // 对beanDefinition进行合并，基于合并后的BeanDefinition去创建bean
      RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);

      // 非抽象，单例，非懒加载
      if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
   

         // FactoryBean
         // 判断是不是一个FactoryBean
         if (isFactoryBean(beanName)) {
   
            //  根据&beanName创建一个LubanFactoryBean的对象
            Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
            if (bean instanceof FactoryBean) {
   
               final FactoryBean<?> factory = (FactoryBean<?>) bean;
               boolean isEagerInit;
               // eager：急切的意思，立马初始化
               if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
   
                  isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
                              ((SmartFactoryBean<?>) factory)::isEagerInit,
                        getAccessControlContext());
               }
               else {
   
                  // 判断是否是一个SmartFactoryBean，并且不是懒加载的，就意味着，在创建了这个factoryBean之后要立马调用它的getObject方法创建另外一个Bean
                  isEagerInit = (factory instanceof SmartFactoryBean &&
                        ((SmartFactoryBean<?>) factory).isEagerInit());
               }
               if (isEagerInit) {
   
                  // 根据beanName去创建bean
                  getBean(beanName);
               }
            }
         }
         else {
   
            // 根据beanName去创建bean
            getBean(beanName);
         }
      }
   }

   // Trigger post-initialization callback for all applicable beans...
   for (String beanName : beanNames) {
   
      // 这一步其实是从缓存中获取对应的创建的Bean，这里获取到的必定是单例的
      Object singletonInstance = getSingleton(beanName);
      //            // 判断是否是一个SmartInitializingSingleton，
      //            最典型的就是我们之前分析过的EventListenerMethodProcessor，在这一步完成了对已经创建好的Bean的解析，会判断其方法上是否有
      //            @EventListener注解，会将这个注解标注的方法通过EventListenerFactory转换成一个事件监听器并添加到监听器的集合中
      if (singletonInstance instanceof SmartInitializingSingleton) {
   
         final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
         if (System.getSecurityManager() != null) {
   
            AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
   
               smartSingleton.afterSingletonsInstantiated();
               return null;
            }, getAccessControlContext());
         }
         else {
   
            smartSingleton.afterSingletonsInstantiated();
         }
      }
   }
}

doGetBean

从上面的代码分析中我们可以知道，Spring最终都会调用到getBean方法，而getBean并不是真正干活的，doGetBean才是。另外doGetBean可以分为两种情况

• 创建的是一个FactoryBean，此时实际传入的name = & + beanName
• 创建的是一个普通Bean，此时传入的name = beanName

protected <T> T doGetBean(final String name