Spring源码:Bean的生命周期(二)

前言

让我们继续讲解Spring的Bean实例化过程。在上一节中,我们已经讲解了Spring是如何将Bean定义加入到IoC容器中,并使用合并的Bean定义来包装原始的Bean定义。接下来,我们将继续讲解Spring的 getBean() 方法,特别是针对 FactoryBean 的解析。

getBean() 方法中,Spring还支持对 FactoryBean 进行特殊处理。FactoryBean 是一个能够生成Bean实例的工厂Bean,其定义了 getObject() 方法,返回的是一个由工厂Bean管理的对象实例。在使用 getBean() 方法获取 FactoryBean 类型的Bean时,Spring会首先获取 FactoryBean 的实例,然后调用其 getObject() 方法来获取由工厂Bean创建的实际Bean实例。

因此,在使用 getBean() 方法获取Bean实例时,我们需要注意是否需要对 FactoryBean 进行特殊处理。如果需要获取 FactoryBean 的实例而不是它所管理的对象实例,可以在Bean名称前加上 & 符号来进行标识。例如:&myFactoryBean 表示获取 myFactoryBean 的实例。但是博主看到第一篇源码写的篇幅确实有些长,可能对于大家伙的碎片化时间掌握的不是很充分,所以以后我会尽力控制篇幅长度,既保证逻辑的连续性也保证尽快可以看完,那么接下来开始进入正题getbean方法之FactoryBean解析。

FactoryBean

所有符合过滤条件的Bean在Spring解析后都会被转化为合并后的Bean定义。尽管Spring提供了 getBean() 方法用于获取Bean实例,但实际上它底层仍然使用 createBean() 方法来创建Bean实例。在创建Bean实例之前,Spring先对当前Bean定义进行判断,以确定其是否为 FactoryBean 类型:

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.  List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);  
  
   // Trigger initialization of all non-lazy singleton beans...  
  for (String beanName : beanNames) {  
      // 获取合并后的BeanDefinition  
  RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);  
  
      if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {  
         if (isFactoryBean(beanName)) {  
            // 获取FactoryBean对象  
  Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);  
            if (bean instanceof FactoryBean) {  
               FactoryBean<?> factory = (FactoryBean<?>) bean;  
               boolean isEagerInit;  
               if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {  
                  isEagerInit = AccessController.doPrivileged(  
                        (PrivilegedAction<Boolean>) ((SmartFactoryBean<?>) factory)::isEagerInit,  
                        getAccessControlContext());  
               }  
               else {  
                  isEagerInit = (factory instanceof SmartFactoryBean &&  
                        ((SmartFactoryBean<?>) factory).isEagerInit());  
               }  
               if (isEagerInit) {  
                  // 创建真正的Bean对象(getObject()返回的对象)  
  getBean(beanName);  
               }  
            }  
         }  
         else {  
            // 创建Bean对象  
  getBean(beanName);  
         }  
      }  
   }  
  
   // 所有的非懒加载单例Bean都创建完了后  
  // Trigger post-initialization callback for all applicable beans...  
  for (String beanName : beanNames) {  
      Object singletonInstance = getSingleton(beanName);  
      if (singletonInstance instanceof SmartInitializingSingleton) {  
         StartupStep smartInitialize = this.getApplicationStartup().start("spring.beans.smart-initialize")  
               .tag("beanName", beanName);  
         SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;  
         if (System.getSecurityManager() != null) {  
            AccessController.doPrivileged((PrivilegedAction<Object>) () -> {  
               smartSingleton.afterSingletonsInstantiated();  
               return null;  
            }, getAccessControlContext());  
         }  
         else {  
            smartSingleton.afterSingletonsInstantiated();  
         }  
         smartInitialize.end();  
      }  
   }  
}

他的源码逻辑大致如下:

  1. Spring会根据 beanNamebean 定义 Map 中获取当前合并的 Bean 定义。
  2. Spring会对当前 Bean 定义进行判断,包括判断当前 Bean 是否为抽象的、是否为单例、是否懒加载,以及是否为 FactoryBean。如果是 FactoryBean,则会走 FactoryBean 的创建逻辑,否则会走单例 Bean 的创建逻辑。
  3. 当所有单例非懒加载的 Bean 创建完成后,Spring会遍历所有单例 Bean,判断其是否为 SmartInitializingSingleton 类型。如果是,则会自动调用 afterSingletonsInstantiated 方法。

isFactoryBean

由于创建 Bean 的逻辑比较复杂,其中包含了许多细节,因此,在这里我们特别提到了一个方法 isFactoryBean()。之所以要提到这个方法,是因为Spring支持使用 FactoryBean 来创建复杂对象。下面是该方法的主要源码:

public boolean isFactoryBean(String name) throws NoSuchBeanDefinitionException {  
   String beanName = transformedBeanName(name);  
   Object beanInstance = getSingleton(beanName, false);  
   if (beanInstance != null) {  
      return (beanInstance instanceof FactoryBean);  
   }  
   // No singleton instance found -> check bean definition.  
  if (!containsBeanDefinition(beanName) && getParentBeanFactory() instanceof ConfigurableBeanFactory) {  
      // No bean definition found in this factory -> delegate to parent.  
  return ((ConfigurableBeanFactory) getParentBeanFactory()).isFactoryBean(name);  
   }  
   return isFactoryBean(beanName, getMergedLocalBeanDefinition(beanName));  
}

大致逻辑如下:

  1. transformedBeanName 的作用是不管传入的参数是 &××× 还是 ×××,都返回 ×××。这是因为Spring标记 FactoryBean 时使用 &××× 作为 FactoryBeanbeanName
  2. getSingleton 方法从单例池中获取 Bean 实例,如果该实例是 FactoryBean,则直接返回该实例。
  3. 如果 BeanFactory 中的 Bean 定义 Map 中不包含该 beanNameBean 定义,并且当前 BeanFactory 的父 BeanFactory 实现了 ConfigurableBeanFactory 接口,那么就需要查看当前父 BeanFactory 中是否有该实例,并且判断该实例是否为 FactoryBean。举个例子来说:
// 创建一个父Spring容器  
AnnotationConfigApplicationContext parent = new AnnotationConfigApplicationContext();  
parent.register(AppConfig.class);  
parent.refresh();  
// 创建一个Spring容器  
AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();  
applicationContext.setParent(parent);  
applicationContext.register(AppConfig1.class);  
applicationContext.refresh();  
UserService bean = applicationContext.getBean(UserService.class);  
bean.test();
  1. 如果并没有实例化出来的bean,那么对bean定义进行判断。
protected boolean isFactoryBean(String beanName, RootBeanDefinition mbd) {  
   Boolean result = mbd.isFactoryBean;  
   if (result == null) {  
      // 根据BeanDefinition推测Bean类型(获取BeanDefinition的beanClass属性)  
  Class<?> beanType = predictBeanType(beanName, mbd, FactoryBean.class);  
      // 判断是不是实现了FactoryBean接口  
  result = (beanType != null && FactoryBean.class.isAssignableFrom(beanType));  
      mbd.isFactoryBean = result;  
   }  
   return result;  
}

注释也基本写好了,基本上就是根据BeanDefinition推测Bean类型(获取BeanDefinition的beanClass属性),再根据bean类型判断是不是实现了FactoryBean接口,然后返回判断结果。

SmartFactoryBean

getBean 方法中,我们可以获取 FactoryBean 的实例并返回。接下来的步骤是判断当前的 FactoryBean 是否实现了 SmartFactoryBean 接口。需要注意的是,SmartFactoryBeanFactoryBean 接口的一个子接口。虽然我们在实现 FactoryBean 接口时不必实现 SmartFactoryBean 接口,但是如果实现了 SmartFactoryBean 接口,那么在创建 FactoryBean 时就会调用 getObject 方法返回实例。正常情况下,只有当容器启动完成后才会调用 getObject 方法。如果我们想在初始化时就调用,可以这样实现:

@Component  
public class UserFactory implements SmartFactoryBean {  
 
   @Override  
  public Object getObject() throws Exception {  
      return new User();  
   }  
  
   @Override  
  public Class<?> getObjectType() {  
      return User.class;  
   }  
  
   @Override  
  public boolean isEagerInit() {  
      return true;  
   }  
}

结语

FactoryBean 和 BeanFactory 是两个不同的概念。前者是一个接口,我们可以在实现该接口时通过调用 getObject 方法来返回实例,同时 FactoryBean 本身也是一个实例。后者是 Spring 容器的工厂,通过其中的 bean 定义 Map 一个一个地实例化我们通过注解等方式注入进去的 bean 工厂。在判断 FactoryBean 时,如果当前 BeanFactory 中没有对应的 bean 定义,那么就会去父容器中寻找相应的 bean 定义并进行判断。如果我们的类实现了 SmartFactoryBean 接口,那么它将会在 Spring 容器启动时就会调用 getObject 方法创建实例。接下来,我们将分几个小节来讲解 getBean 方法是如何实例化 bean 的,因为篇幅过长会影响读者的注意力和学习效果。

公众号

原文链接:https://www.cnblogs.com/guoxiaoyu/p/17367019.html

本站文章如无特殊说明,均为本站原创,如若转载,请注明出处:Spring源码:Bean的生命周期(二) - Python技术站

(0)
上一篇 2023年5月1日
下一篇 2023年5月2日

相关文章

  • 使用Gson将字符串转换成JsonObject和JsonArray

    使用Gson库将字符串转换为JsonObject或JsonArray是Java开发中常见的数据处理任务。下面是详细的攻略: 导入Gson库 要使用Gson库,需要在项目中引入Gson的依赖。可以通过在maven或gradle中添加以下代码来引入Gson库。 Maven: <dependency> <groupId>com.google…

    Java 2023年5月26日
    00
  • java对数组进行排序的方法

    以下是Java对数组进行排序的方法的完整攻略。 1. Java中的排序方法 Java提供了一系列快速且易用的排序方法,可用于对数组进行排序: Arrays.sort(int[] arr): 对整形数组进行快速排序; Arrays.sort(char[] arr): 对字符数组进行快速排序; Arrays.sort(double[] arr): 对双精度浮点型…

    Java 2023年5月20日
    00
  • eclipse如何clean? java项目进行clean的技巧

    要进行clean操作,首先需要在Eclipse的菜单栏中找到“Project”选项,并在弹出菜单中选择“Clean”。 接下来,在弹出的窗口中选择需要clean的项目,并勾选“Start a build immediately”,最后点击“OK”按钮即可开始执行clean操作。 clean操作的主要作用是清理项目中的临时文件和缓存,以提高系统的稳定性和性能。…

    Java 2023年5月26日
    00
  • Java SpringBoot启动指定profile的8种方式详解

    这篇文章的主要目的是详细讲解如何启动Java Spring Boot应用程序时指定不同的profile配置,并提供了8种实现方式。以下是详细攻略: 一、什么是profile Profile是Spring Boot中一个非常重要的概念,可以理解为一组predefined configurations,因此我们可以在不同的环境中使用不同的profiles来运行应…

    Java 2023年5月19日
    00
  • [推荐]Win2003 服务器的详细架设

    [推荐]Win2003 服务器的详细架设 介绍 本攻略将讲解如何在Win2003上架设服务器,并安装IIS和SQL Server,适用于需要搭建Web应用或开发环境的用户。 系统要求 Windows Server 2003操作系统 硬件配置:最低Pentium III 550MHz、256MB RAM、3GB硬盘空间,推荐Pentium 4或以上、512MB…

    Java 2023年6月15日
    00
  • maven加入spring框架的详细教程

    下面是关于“maven加入spring框架的详细教程”的完整攻略,包含两个示例说明。 maven加入spring框架的详细教程 Maven是一个流行的Java项目管理工具,它可以帮助我们更加方便地管理项目依赖关系。在Java项目中,Spring框架是一个非常流行的框架,它可以帮助我们更加方便地构建现代化的企业应用程序。本文将介绍如何使用Maven将Sprin…

    Java 2023年5月17日
    00
  • 两种用空格分隔的java字符串的方式

    确实,Java中有两种使用空格分隔字符串的方法: 使用split方法: split方法允许您将字符串分裂成子字符串数组,方法如下: String[] strArray = "Hello World".split(" "); 这将创建一个字符串数组,其中包含两个元素: “Hello” 和 “World”。您可以使用for…

    Java 2023年5月27日
    00
  • 详解eclipse下创建第一个spring boot项目

    Eclipse 下创建第一个 Spring Boot 项目的完整攻略 在本文中,我们将详细介绍如何在 Eclipse 下创建第一个 Spring Boot 项目。我们将介绍 Spring Boot 的概念、Eclipse 的配置和使用,并提供两个示例。 Spring Boot 概念 Spring Boot 是一个用于创建独立的、生产级别的 Spring 应用…

    Java 2023年5月15日
    00
合作推广
合作推广
分享本页
返回顶部