Spring IoC 依赖查找

方式

主要有以下几种方式：

  1. 根据 Bean 名称
    1. 实时查找
    2. 延迟查找（ObjectFactory以及 ObjectProvider 提供，对生命周期有好处``
  2. 根据 Bean 类型
    1. 单个 Bean 对象
    2. 集合 Bean 对象
  3. 根据 Bean 名称 + 类型

  4. 根据 Java 注解查找

    1. 单个 Bean 对象

    2. 集合 Bean 对象

      代码

      配置文件：

      1. <?xml version="1.0" encoding="UTF-8"?>
      2. <beans xmlns="http://www.springframework.org/schema/beans"
      3.  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      4.  xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
      6. <bean id="user" class="com.mindartisan.spring.geek.ioc.overview.dependency.domain.User">
      7.   <property name="id" value="1"/>
      8.   <property name="name" value="Steve"/>
      9. </bean>
      11. <bean id="superUser" class="com.mindartisan.spring.geek.ioc.overview.dependency.domain.SuperUser" parent="user"
      12.     primary="true">
      13.   <property name="address" value="北京"/>
      14. </bean>
      16. <!-- 延迟查找使用 -->
      17. <bean id="objectFactoryCreatingFactoryBean"
      18.     class="org.springframework.beans.factory.config.ObjectFactoryCreatingFactoryBean">
      19.   <property name="targetBeanName" value="user"/>
      20. </bean>
      21. </beans>

      User： ```java /**

    • 用户 *
    • @author mindartisan.blog.csdn.net

    • @date */ public class User {

      private Long id;

      private String name;

      public Long getId() { return id; }

      public void setId(Long id) { this.id = id; }

      public String getName() { return name; }

      public void setName(String name) { this.name = name; }

      @Override public String toString() { return “User{“ +

      1.        "id=" + id +
      2.        ", name='" + name + '\'' +
      3.        '}';

      } } Super 注解：java /**

    • super 注解 *
    • @author mindartisan.blog.csdn.net
    • @date / @Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) public @interface Super { } SuperUser：java /*
    • 超级用户 *
    • @author mindartisan.blog.csdn.net

    • @date */ @Super public class SuperUser extends User {

      private String address;

      public String getAddress() { return address; }

      public void setAddress(String address) { this.address = address; }

      @Override public String toString() { return “SuperUser{“ +

      1.        "address='" + address + '\'' +
      2.        "} " + super.toString();

      } } Main 方法：java /**

    • 依赖查找演示 *
    • @author mindartisan.blog.csdn.net
    • @date */ public class DependencyLookUpDemo { public static void main(String[] args) { // 配置 XML 配置文件，两个方式均可 // 启动 Spring 应用上下文 BeanFactory beanFactory = new ClassPathXmlApplicationContext(“META-INF/dependency-lookup-context.xml”); // BeanFactory beanFactory = new ClassPathXmlApplicationContext(“classpath:/META-INF/dependency-lookup-context.xml”); lookupInRealTime(beanFactory); lookupInLazy(beanFactory); lookupSingleByType(beanFactory); lookupCollectionByType(beanFactory); lookupByAnnotationType(beanFactory); }
  1. /**
  2.  * 通过名称：实时查找
  3.  *
  4.  * @param beanFactory bean工厂
  5.  */
  6. private static void lookupInRealTime(BeanFactory beanFactory) {
  7.     User user = (User) beanFactory.getBean("user");
  8.     System.out.println("通过名称，实时查找：" + user);
  9. }
  12. /**
  13.  * 通过名称：延迟查找
  14.  *
  15.  * @param beanFactory bean工厂
  16.  */
  17. private static void lookupInLazy(BeanFactory beanFactory) {
  18.     ObjectFactory<User> objectFactoryCreatingFactoryBean = (ObjectFactory<User>) beanFactory.getBean("objectFactoryCreatingFactoryBean");
  19.     User user = objectFactoryCreatingFactoryBean.getObject();
  20.     System.out.println("通过名称，延迟查找：" + user);
  21. }
  24. /**
  25.  * 按类型查找：单个 bean
  26.  *
  27.  * @param beanFactory bean工厂
  28.  */
  29. private static void lookupSingleByType(BeanFactory beanFactory) {
  30.     User user = beanFactory.getBean(User.class);
  31.     System.out.println("按类型查找，单个 bean：" + user);
  32. }
  35. /**
  36.  * 按类型查找：多个 bean
  37.  *
  38.  * @param beanFactory bean工厂
  39.  */
  40. private static void lookupCollectionByType(BeanFactory beanFactory) {
  41.     if (beanFactory instanceof ListableBeanFactory) {
  42.         ListableBeanFactory listableBeanFactory = (ListableBeanFactory) beanFactory;
  43.         // key 为 bean 名称
  44.         Map<String, User> users = listableBeanFactory.getBeansOfType(User.class);
  45.         System.out.println("按类型查找，多个 bean：" + users);
  46.     }
  47. }
  50. /**
  51.  * 按注解查找
  52.  *
  53.  * @param beanFactory bean工厂
  54.  */
  55. private static void lookupByAnnotationType(BeanFactory beanFactory) {
  56.     if (beanFactory instanceof ListableBeanFactory) {
  57.         ListableBeanFactory listableBeanFactory = (ListableBeanFactory) beanFactory;
  58.         // key 为 bean 名称
  59.         Map<String, User> users = (Map) listableBeanFactory.getBeansWithAnnotation(Super.class);
  60.         System.out.println("按注解查找：" + users);
  61.     }
  62. }

}

  1. <a name="C32iI"></a>
  2. # Spring IoC 依赖注入
  3. <a name="an5X4"></a>
  4. ## 方式
  5. 主要有以下几种方式：
  7. 1. 根据 Bean 名称
  8. 1. 根据 Bean 类型
  9.    1. 单个 Bean 对象
  10.    1. 集合 Bean 对象
  11. 3. 注入容器内建 Bean 对象
  12. 3. 注入非 Bean 对象
  13. 3. 注入类型
  14.    1. 实时注入
  15.    1. 延迟注入
  16. <a name="cpskU"></a>
  17. ## 代码
  18. 配置文件：
  19. ```xml
  20. <?xml version="1.0" encoding="UTF-8"?>
  21. <beans xmlns="http://www.springframework.org/schema/beans"
  22.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:util="http://www.springframework.org/schema/util"
  23.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/util https://www.springframework.org/schema/util/spring-util.xsd">
  25.     <!-- 通过导入复用 dependency-lookup-context.xml -->
  26.     <import resource="dependency-lookup-context.xml"/>
  28.     <bean id="userRepository"
  29.           class="com.mindartisan.spring.geek.ioc.overview.dependency.repository.UserRepository"
  30.           autowire="byType"> <!-- 自动装配 -->
  31.         <!--&lt;!&ndash; 手动配置 &ndash;&gt;-->
  32.         <!--<property name="users">-->
  33.         <!--    <util:list>-->
  34.         <!--        <ref bean="superUser"/>-->
  35.         <!--        <ref bean="user"/>-->
  36.         <!--    </util:list>-->
  37.         <!--</property>-->
  38.     </bean>
  39. </beans>

UserRepository：

  1. /**
  2.  * 用户信息库
  3.  *
  4.  * @author mindartisan.blog.csdn.net
  5.  * @date
  6.  */
  7. public class UserRepository {
  9.     /**
  10.      * 内建的非 Bean 对象
  11.      */
  12.     private BeanFactory beanFactory;
  14.     /**
  15.      * 自定义的 Bean 对象
  16.      */
  17.     private Collection<User> users;
  19.     private ObjectFactory<User> userObjectFactory;
  21.     private ObjectFactory<ApplicationContext> applicationContextObjectFactory;
  23.     public BeanFactory getBeanFactory() {
  24.         return beanFactory;
  25.     }
  27.     public void setBeanFactory(BeanFactory beanFactory) {
  28.         this.beanFactory = beanFactory;
  29.     }
  31.     public Collection<User> getUsers() {
  32.         return users;
  33.     }
  35.     public void setUsers(Collection<User> users) {
  36.         this.users = users;
  37.     }
  39.     public ObjectFactory<User> getUserObjectFactory() {
  40.         return userObjectFactory;
  41.     }
  43.     public void setUserObjectFactory(ObjectFactory<User> userObjectFactory) {
  44.         this.userObjectFactory = userObjectFactory;
  45.     }
  47.     public ObjectFactory<ApplicationContext> getApplicationContextObjectFactory() {
  48.         return applicationContextObjectFactory;
  49.     }
  51.     public void setApplicationContextObjectFactory(ObjectFactory<ApplicationContext> applicationContextObjectFactory) {
  52.         this.applicationContextObjectFactory = applicationContextObjectFactory;
  53.     }
  54. }

Main 方法：

  1. /**
  2.  * 依赖注入演示
  3.  *
  4.  * @author mindartisan.blog.csdn.net
  5.  * @date
  6.  */
  7. public class DependencyInjectDemo {
  8.     public static void main(String[] args) {
  10.         // 配置 XML 配置文件，两个方式均可
  11.         // 启动 Spring 应用上下文
  12.         BeanFactory beanFactory = new ClassPathXmlApplicationContext("classpath:/META-INF/dependency" +
  13.                 "-injection-context.xml");
  14.         // BeanFactory beanFactory = new ClassPathXmlApplicationContext("META-INF/dependency-injection-context.xml");
  16.         // 自定义 Bean
  17.         UserRepository userRepository = beanFactory.getBean("userRepository", UserRepository.class);
  19.         //「[User{id=1, name='Steve'}, SuperUser{address='北京'} User{id=1, name='Steve'}]」
  20.         System.out.println(userRepository.getUsers());
  22.         // 获取对象依赖注入，输出：「org.springframework.beans.factory.support.DefaultListableBeanFactory@57baeedf: defining beans
  23.         // [user,superUser,objectFactoryCreatingFactoryBean,userRepository]; root of factory hierarchy」
  24.         // 内建的依赖
  25.         System.out.println(userRepository.getBeanFactory());
  27.         // 对比以下代码：
  28.         // 1. BeanFactory beanFactory
  29.         // 2. ObjectFactory<User> userObjectFactory
  30.         // 3. ObjectFactory<ApplicationContext>applicationContextObjectFactory
  32.         // 输出：「false」
  33.         System.out.println((userRepository.getBeanFactory() == beanFactory));
  35.         // 依赖查找：报错「No qualifying bean of type 'org.springframework.beans.factory.BeanFactory' available」
  36.         // 说明：BeanFactory.class 是内建的非 Bean 对象，内建的依赖
  37.         // System.out.println(beanFactory.getBean(BeanFactory.class));
  39.         // ObjectFactory<User> userObjectFactory <--> ObjectFactory<ApplicationContext>applicationContextObjectFactory
  40.         ObjectFactory userObjectFactory = userRepository.getUserObjectFactory();
  41.         // 输出 ：「SuperUser{address='北京'} User{id=1, name='Steve'}」
  42.         System.out.println(userObjectFactory.getObject());
  43.         // 输出：「false」
  44.         System.out.println(userObjectFactory.getObject() == beanFactory);
  46.         ObjectFactory applicationContextObjectFactory = userRepository.getApplicationContextObjectFactory();
  47.         // 输出：「org.springframework.context.support.ClassPathXmlApplicationContext@6f75e721, started on Thu Dec 23
  48.         // 00:55:34 CST 2021」
  49.         System.out.println(applicationContextObjectFactory.getObject());
  51.         // 输出：「true」
  52.         // 说明：ObjectFactory 自动注入的时候给我们注入了 ApplicationContext
  53.         System.out.println(applicationContextObjectFactory.getObject() == beanFactory);
  54.         // 对比结束
  56.         // 容器内建 Bean，输出：「获取 Environment 类型的 Bean：StandardEnvironment {activeProfiles=[],……」
  57.         Environment environment = beanFactory.getBean(Environment.class);
  58.         System.out.println("获取 Environment 类型的 Bean：" + environment);
  60.     }
  62. }

User、SuperUser、@Super 见上节内容

Spring IoC 依赖来源

来源

主要有以下：

  1. 自定义 Bean -> 比如：业务上的 Bean 对象
  2. 容器内建 Bean 对象 -> 比如：Environment.class

  3. 容器内建依赖 -> 比如：BeanFactory.class

    代码

    参考：Spring IoC 依赖注入部分

    Spring IoC 配置元信息

  4. Bean 定义配置

    1. 基于 XML 文件
    2. 基于 Properties 文件
    3. 基于 Java 注解
    4. 基于 Java API
  5. IoC 容器配置
    1. 基于 XML 文件
    2. 基于 Java 注解
    3. 基于 Java API
  6. 外部化属性配置
    1. 基于 Java 注解

      Spring IoC 容器

      来看下 Spring 文档：

      The org.springframework.beans and org.springframework.context packages are the basis for Spring Framework’s IoC container. The [BeanFactory](https://docs.spring.io/spring-framework/docs/5.2.12.RELEASE/javadoc-api/org/springframework/beans/factory/BeanFactory.html)interface provides an advanced configuration mechanism capable of managing any type of object. [ApplicationContext](https://docs.spring.io/spring-framework/docs/5.2.12.RELEASE/javadoc-api/org/springframework/context/ApplicationContext.html) is a sub-interface of BeanFactory. It adds:

      • Easier integration with Spring’s AOP features
      • Message resource handling (for use in internationalization)
      • Event publication
      • Application-layer specific contexts such as the WebApplicationContext for use in web applications.

      In short, the BeanFactory provides the configuration framework and basic functionality, and the ApplicationContext adds more enterprise-specific functionality. The ApplicationContext is a complete superset of the BeanFactory and is used exclusively in this chapter in descriptions of Spring’s IoC container. For more information on using the BeanFactory instead of the ApplicationContext, see [BeanFactory](https://docs.spring.io/spring-framework/docs/5.2.12.RELEASE/spring-framework-reference/core.html#beans-beanfactory).

      —— Introduction to the Spring IoC Container and Beans

大概意思就是说 BeanFactory 是 ApplicationContext 的父接口，提供了基本功能，而后者添加了更多的企业性的特性：

  1. 更方便基础 Spring AOP 特性
  2. 国际化处理
  3. 事件发布
  4. 提供了特定的上下文

可以看下 UML 图验证：
image.png

简单来个结论：

  1. BeanFactory 是 Spring 底层的 IoC 容器
  2. 从功能上来说，ApplicationContext 是 BeanFactory 的超集

  3. 二者不是对等的

    Spring 应用上下文

    ApplicationContext 接口除了上述的「容器」的功能，还有以下功能：

  4. 面向切面（AOP）

  5. 配置元信息（Configuration Metadata）
  6. 资源管理（Resources）
  7. 事件（Events）
  8. 国际化（il8n）
  9. 注解（Annotations）

  10. Environment 抽象（Environment Abstraction）

    使用 Spring IoC 容器

    使用 BeanFactory

    此处的 DefaultListableBeanFactory 为 BeanFactory 的实现：
    image.png

    1. **
    2. * BeanFactory 作为 IoC 容器示例
    3. *
    4. * @author mindartisan.blog.csdn.net
    5. * @date
    6. */
    7. public class BeanFactoryAsIoCContainerDemo {
    8.  public static void main(String[] args) {
    9.      // 创建 BeanFactory 容器
    10.      DefaultListableBeanFactory defaultListableBeanFactory = new DefaultListableBeanFactory();
    12.      XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(defaultListableBeanFactory);
    13.      String location = "classpath:/META-INF/dependency-lookup-context.xml";
    14.      // 加载配置
    15.      int beanDefinitionsCount = reader.loadBeanDefinitions(location);
    16.      System.out.println("Bean 定义加载的数量："+beanDefinitionsCount);
    18.      // 依赖查找集合对象
    19.      // 简单说明不用 ApplicationContext 的时候也能加载 Bean
    20.      lookupCollectionByType(defaultListableBeanFactory);
    21.  }
    23.  /**
    24.   * 按类型查找：多个 bean
    25.   *
    26.   * @param beanFactory bean工厂
    27.   */
    28.  private static void lookupCollectionByType(BeanFactory beanFactory) {
    29.      if (beanFactory instanceof ListableBeanFactory) {
    30.          ListableBeanFactory listableBeanFactory = (ListableBeanFactory) beanFactory;
    31.          // key 为 bean 名称
    32.          Map<String, User> users = listableBeanFactory.getBeansOfType(User.class);
    33.          System.out.println("按类型查找，多个 bean：" + users);
    34.      }
    35.  }
    36. }

    使用 ApplicationContext

    此处的 AnnotationConfigApplicationContext 为 ApplicationContext 的实现：
    image.png ```java /**

    • 注解能力的 ApplicationContext 作为 IoC 容器示例 *
    • @author mindartisan.blog.csdn.net

    • @date */ @Configuration public class AnnotationApplicationContextAsIoCContainerDemo { public static void main(String[] args) { // 创建 BeanFactory 容器 AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext(); // 将当前类作为配置类 annotationConfigApplicationContext.register(AnnotationApplicationContextAsIoCContainerDemo.class); annotationConfigApplicationContext.refresh(); // 依赖查找集合对象 // 使用 AnnotationConfigApplicationContext 当做 IoC 容器 lookupCollectionByType(annotationConfigApplicationContext); }

      @Bean public User user() { User user = new User(); user.setId(1L); user.setName(“Steve”); return user; }

      /**

      • 按类型查找：多个 bean *
      • @param beanFactory bean工厂 */ private static void lookupCollectionByType(BeanFactory beanFactory) { if (beanFactory instanceof ListableBeanFactory) {
        1.  ListableBeanFactory listableBeanFactory = (ListableBeanFactory) beanFactory;
        2.  // key 为 bean 名称
        3.  Map<String, User> users = listableBeanFactory.getBeansOfType(User.class);
        4.  System.out.println("按类型查找，多个 bean：" + users);
        } } }
  1. <a name="NffWX"></a>
  2. # Spring IoC 容器生命周期
  3. <a name="cMnCL"></a>
  4. ## 启动
  5. <a name="G7Ilw"></a>
  6. ### AbstractApplicationContext#refresh()
  7. ```java
  8. public void refresh() throws BeansException, IllegalStateException {
  9.         // 不知道当前用户的线程安全不安全
  10.         synchronized (this.startupShutdownMonitor) {
  11.             // Prepare this context for refreshing.
  12.             // 准备阶段
  13.             prepareRefresh();
  15.             // Tell the subclass to refresh the internal bean factory.
  16.             // 让子类去刷新内置的 BeanFactory，
  17.             ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
  19.             // Prepare the bean factory for use in this context.
  20.             prepareBeanFactory(beanFactory);
  22.             try {
  23.                 // Allows post-processing of the bean factory in context subclasses.
  24.                 // 加载 bean，但不实例化 bean：
  25.                 postProcessBeanFactory(beanFactory);
  27.                 // Invoke factory processors registered as beans in the context.
  28.                 // 调用在上下文中注册为 bean的 factory processor，BeanFactory 扩展点
  29.                 invokeBeanFactoryPostProcessors(beanFactory);
  31.                 // Register bean processors that intercept bean creation.
  32.                 // 实例化并注册所有 BeanPostProcessor bean，Bean 扩展
  33.                 registerBeanPostProcessors(beanFactory);
  35.                 // Initialize message source for this context.
  36.                 // 国际化
  37.                 initMessageSource();
  39.                 // Initialize event multicaster for this context.
  40.                 // 事件广播
  41.                 initApplicationEventMulticaster();
  43.                 // Initialize other special beans in specific context subclasses.
  44.                 // 初始化特定上下文的其他特殊 bean
  45.                 onRefresh();
  47.                 // Check for listener beans and register them.
  48.                 // 注册监听器
  49.                 registerListeners();
  51.                 // Instantiate all remaining (non-lazy-init) singletons.
  52.                 // 实例化所有的单例 bean
  53.                 finishBeanFactoryInitialization(beanFactory);
  55.                 // Last step: publish corresponding event.
  56.                 // 完成上下文刷新
  57.                 finishRefresh();
  58.             }
  60.             catch (BeansException ex) {
  61.                 if (logger.isWarnEnabled()) {
  62.                     logger.warn("Exception encountered during context initialization - " +
  63.                             "cancelling refresh attempt: " + ex);
  64.                 }
  66.                 // Destroy already created singletons to avoid dangling resources.
  67.                 // 有异常了销毁 bean
  68.                 destroyBeans();
  70.                 // Reset 'active' flag.
  71.                 cancelRefresh(ex);
  73.                 // Propagate exception to caller.
  74.                 throw ex;
  75.             }
  77.             finally {
  78.                 // Reset common introspection caches in Spring's core, since we
  79.                 // might not ever need metadata for singleton beans anymore...
  80.                 resetCommonCaches();
  81.             }
  82.         }
  83.     }

AbstractApplicationContext#prepareRefresh()

  1. protected void prepareRefresh() {
  2.         // Switch to active.
  3.         // 记录启动时间，算运行时间
  4.         this.startupDate = System.currentTimeMillis();
  5.         this.closed.set(false);
  6.         this.active.set(true);
  8.         if (logger.isDebugEnabled()) {
  9.             if (logger.isTraceEnabled()) {
  10.                 logger.trace("Refreshing " + this);
  11.             }
  12.             else {
  13.                 logger.debug("Refreshing " + getDisplayName());
  14.             }
  15.         }
  16.         // 初始化 PropertySources
  17.         // Initialize any placeholder property sources in the context environment.
  18.         initPropertySources();
  20.         // Validate that all properties marked as required are resolvable:
  21.         // see ConfigurablePropertyResolver#setRequiredProperties
  22.         // 校验需要的 Properties
  23.         getEnvironment().validateRequiredProperties();
  25.         // Store pre-refresh ApplicationListeners...
  26.         if (this.earlyApplicationListeners == null) {
  27.             this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);
  28.         }
  29.         else {
  30.             // Reset local application listeners to pre-refresh state.
  31.             this.applicationListeners.clear();
  32.             this.applicationListeners.addAll(this.earlyApplicationListeners);
  33.         }
  35.         // Allow for the collection of early ApplicationEvents,
  36.         // to be published once the multicaster is available...
  37.         this.earlyApplicationEvents = new LinkedHashSet<>();
  38.     }

停止

AbstractApplicationContext#close()

  1. public void close() {
  2.         synchronized (this.startupShutdownMonitor) {
  3.             // 关闭
  4.             doClose();
  5.             // If we registered a JVM shutdown hook, we don't need it anymore now:
  6.             // We've already explicitly closed the context.
  7.             if (this.shutdownHook != null) {
  8.                 try {
  9.                     Runtime.getRuntime().removeShutdownHook(this.shutdownHook);
  10.                 }
  11.                 catch (IllegalStateException ex) {
  12.                     // ignore - VM is already shutting down
  13.                 }
  14.             }
  15.         }
  16.     }

AbstractApplicationContext#doClose()

  1. protected void doClose() {
  2.         // Check whether an actual close attempt is necessary...
  3.         if (this.active.get() && this.closed.compareAndSet(false, true)) {
  4.             if (logger.isDebugEnabled()) {
  5.                 logger.debug("Closing " + this);
  6.             }
  8.             LiveBeansView.unregisterApplicationContext(this);
  10.             try {
  11.                 // Publish shutdown event.
  12.                 publishEvent(new ContextClosedEvent(this));
  13.             }
  14.             catch (Throwable ex) {
  15.                 logger.warn("Exception thrown from ApplicationListener handling ContextClosedEvent", ex);
  16.             }
  18.             // Stop all Lifecycle beans, to avoid delays during individual destruction.
  19.             if (this.lifecycleProcessor != null) {
  20.                 try {
  21.                     this.lifecycleProcessor.onClose();
  22.                 }
  23.                 catch (Throwable ex) {
  24.                     logger.warn("Exception thrown from LifecycleProcessor on context close", ex);
  25.                 }
  26.             }
  28.             // Destroy all cached singletons in the context's BeanFactory.
  29.             // 销毁 bean
  30.             destroyBeans();
  32.             // Close the state of this context itself.
  33.             // 关闭 BeanFactory
  34.             closeBeanFactory();
  36.             // Let subclasses do some final clean-up if they wish...
  37.             onClose();
  39.             // Reset local application listeners to pre-refresh state.
  40.             if (this.earlyApplicationListeners != null) {
  41.                 this.applicationListeners.clear();
  42.                 this.applicationListeners.addAll(this.earlyApplicationListeners);
  43.             }
  45.             // Switch to inactive.
  46.             this.active.set(false);
  47.         }
  48.     }