[Java] 深入理解：Spring ApplicationContext/HierarchicalBeanFactory：应用上下文的层次结构

前言

  • 先说大前提、大结论: Spring ApplicationContext(应用上下文)的层次结构特性，是基于继承了HierarchicalBeanFactory接口这一事实之上。

推荐文献: [Java/Spring] 深入理解 : Spring ApplicationContext - 博客园/千千寰宇

  • org.springframework.context.ApplicationContext接口
package org.springframework.context;

public interface ApplicationContext extends EnvironmentCapable, ListableBeanFactory, HierarchicalBeanFactory,
		MessageSource, ApplicationEventPublisher, ResourcePatternResolver {
   ...
}

MessageSource : 涉及多语言等国际化能力

  • org.springframework.beans.factory.HierarchicalBeanFactory接口

We can have multiple application contexts that share a parent-child relationship.A context hierarchy allows multiple child contexts to share beans which reside in the parent context. Each child context can override configuration inherited from the parent context.
我们可以有多个共享父子关系的应用程序上下文。上下文层次结构允许多个子上下文共享驻留在父上下文中的bean。每个子上下文都可以覆盖从父上下文继承的配置。

package org.springframework.beans.factory;

import org.springframework.lang.Nullable;

public interface HierarchicalBeanFactory extends BeanFactory {
    @Nullable
    BeanFactory getParentBeanFactory();

    boolean containsLocalBean(String var1);
}

好了，步入正题。

  • 在使用 Spring 框架进行应用程序开发时，Spring 上下文（Context）是一个非常重要的概念。
  • Spring 上下文提供了一个环境，用于管理应用程序中的对象（通常称为 Bean）及其之间的依赖关系。
  • 在复杂的应用程序中，可能存在多个上下文对象，而这些上下文对象之间可以形成一种层次结构。

本文将深入探讨 Spring 上下文的层次结构，并介绍如何在实际项目中应用这种结构。

1 什么是 Spring 上下文（Context）

在 Spring 框架中，上下文（Context）是一个重要的概念，它代表了 Spring 容器中的一个环境，负责管理 Bean 对象及其之间的依赖关系。
Spring 上下文可以从 XML 文件、Java 注解或者 Java 代码中加载配置信息，并将这些配置信息转换成应用程序中的对象。
通常情况下，我们使用 ApplicationContext 接口来表示 Spring 上下文。

2 什么是上下文层次结构

在大型的应用程序中，可能存在多个模块或者子系统，它们之间存在依赖关系，并且可能共享一些资源或者配置信息。
为了更好地管理这些依赖关系和资源，Spring 引入了上下文层次结构的概念。
上下文层次结构允许我们在应用程序中创建多个上下文对象，并且这些上下文对象之间存在父子关系，从而形成一个层次结构。

3 Spring 上下文层次结构的组成

Spring 上下文层次结构通常由一个顶层的父上下文和多个子上下文组成。
父上下文负责管理一些全局性的资源和配置信息，而子上下文则负责管理特定于某个模块或子系统的资源和配置信息。
子上下文可以访问父上下文中定义的 Bean 对象和配置信息，从而实现资源的共享和依赖的管理。

4 如何使用 Spring 上下文层次结构

在实际项目中，我们可以通过 XML 文件或者 Java 代码来配置 Spring 上下文的层次结构。

首先，我们需要定义父上下文中的配置信息，包括共享的资源和配置信息
然后，我们可以创建子上下文，并且通过构造方法或者 setParent() 方法将父上下文与子上下文关联起来。
最后，我们可以在子上下文中定义特定于该子系统或者模块的 Bean 对象，并且可以通过依赖注入的方式来获取这些 Bean 对象。

Spring 上下文的层次结构使用流程：

// 定义一个父上下文的配置类
public class ParentContextConfig {
    // 省略配置信息
}

// 定义一个子上下文的配置类
public class ChildContextConfig {
    // 省略配置信息
}

public class Main {
    public static void main(String[] args) {
        // 创建父上下文
        AnnotationConfigApplicationContext parentContext = new AnnotationConfigApplicationContext();
        parentContext.register(ParentContextConfig.class);
        parentContext.refresh();

        // 创建子上下文，设置其父上下文
        AnnotationConfigApplicationContext childContext = new AnnotationConfigApplicationContext();
        childContext.register(ChildContextConfig.class);
        childContext.setParent(parentContext);
        childContext.refresh();

        // 在子上下文中获取 bean
        SomeBean bean = childContext.getBean(SomeBean.class);

        // 关闭上下文
        childContext.close();
        parentContext.close();
    }
}

5 Spring MVC 中的上下文层次结构

Spring 上下文层次结构最经典的一个应用，便是在 Spring MVC 中。

首先，假设我们有一个全局应用程序配置类 AppConfig 和一个 Servlet 配置类 ServletConfig。

@Configuration
public class AppConfig {
    @Bean
    public DataSource dataSource() {
        // 返回数据源配置
    }

    @Bean
    public TransactionManager transactionManager() {
        // 返回事务管理器配置
    }
}

.

@Configuration
public class ServletConfig {
    @Autowired
    private DataSource dataSource; // 从全局应用程序上下文中注入数据源
    
    @Autowired
    private TransactionManager transactionManager; // 从全局应用程序上下文中注入事务管理器
    
    @Bean
    public SomeService someService() {
        // 返回服务 Bean 配置，可能需要使用全局数据源和事务管理器
    }
}

然后，在应用程序初始化时，我们可以创建全局应用程序上下文和 Servlet 上下文。

public class MyAppInitializer implements WebApplicationInitializer {
    
    @Override
    public void onStartup(ServletContext servletContext) throws ServletException {
        // 创建全局应用程序上下文
        AnnotationConfigWebApplicationContext rootContext = new AnnotationConfigWebApplicationContext();
        rootContext.register(AppConfig.class);
        servletContext.addListener(new ContextLoaderListener(rootContext));

        // 创建 Servlet 上下文
        AnnotationConfigWebApplicationContext servletContext = new AnnotationConfigWebApplicationContext();
        servletContext.setParent(rootContext); // 将全局应用程序上下文设置为父上下文
        servletContext.register(ServletConfig.class);
        
        // 将 Servlet 上下文注册到 Servlet 容器中
        ServletRegistration.Dynamic dispatcher = servletContext.addServlet("dispatcher", new DispatcherServlet(servletContext));
        dispatcher.setLoadOnStartup(1);
        dispatcher.addMapping("/");
    }

6 小结

通过 Spring 上下文的层次结构，我们可以更好地管理应用程序中的依赖关系和资源，提高了代码的模块化和可维护性。在实际项目中，合理地使用上下文层次结构可以带来很多好处，例如资源共享、依赖隔离以及作用域管理等。

Y 推荐文献

X 参考文献

posted @ 2024-10-11 00:15  千千寰宇  阅读(195)  评论(0)    收藏  举报