ApplicationContext详细介绍

已于 2024-11-15 10:34:22 修改
阅读量1.6k 收藏 21
点赞数 13
分类专栏： java 文章标签： java 开发语言 spring springboot
于 2024-11-14 16:32:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/HDHGJDFGHJDF/article/details/143770901
版权

介绍

        在 Spring 框架中，ApplicationContext 是核心接口之一，主要用于容纳和管理 Spring 容器中的所有 Bean 实例。它扩展了 BeanFactory 接口，并提供了更丰富的功能，包括国际化支持、事件传播、AOP支持等。它是 Spring IoC（Inversion of Control，控制反转）容器的核心接口之一，负责管理应用程序的生命周期和组件依赖关系。

目录

1. ApplicationContext 的概念

2. ApplicationContext 的作用

1. 管理 Bean 的生命周期：

2. 支持国际化（i18n）：

3. 事件发布与监听：

4. Bean 查找：

5. AOP 支持：

3.  ApplicationContext的调用方式

1. 基于 XML 配置的调用方式

2. 基于注解配置的调用方式（Java 配置）

3. 基于 ApplicationContext 的工厂模式（不同类型的 ApplicationContext 实现）

4. ApplicationContext的常用函数

1. getBean()

 2. getBeansOfType() 方法

3. getApplicationName() 方法

4. getParent() 方法

5. containsBean() 方法

6. isPrototype() 和 isSingleton() 方法

5. 在springBoot中使用ApplicationContext

6. ApplicationContext的工作原理

6.1 初始化过程

6.2 如何管理Bean

6.2.1 Bean 定义和注册

6.2.2 Bean 实例化

6.2.3 依赖注入（DI）

6.2.4 Bean 生命周期管理

6.2.5 作用域管理

6.3 BeanFactory与ApplicationContext的关系

7. 总结

1. ApplicationContext 的概念

  ApplicationContext 是一个容器，它负责初始化、配置和管理应用程序中的所有对象（即 Bean）。在 Spring 中，Bean 是由容器管理的 Java 对象，容器根据配置文件（如 XML 文件、注解或 Java 配置类）来实例化和管理这些对象。ApplicationContext 提供了一种标准的方式来访问这些 Bean，并且处理这些 Bean 之间的依赖关系。

2. ApplicationContext 的作用

1. 管理 Bean 的生命周期：

  ApplicationContext 会负责整个应用程序中所有 Bean 的创建、配置和销毁（如果有需要）。通过依赖注入（DI），它将 Bean 的依赖关系注入到每个 Bean 实例中。

2. 支持国际化（i18n）：

  ApplicationContext 提供了国际化支持，允许开发人员在应用程序中根据不同的区域和语言环境加载不同的资源文件。

3. 事件发布与监听：

  ApplicationContext 支持事件的发布和监听。Spring 中的应用事件机制可以让你在容器中发布事件，并允许对象对事件做出响应。

4. Bean 查找：

  ApplicationContext 提供了获取 Bean 实例的功能。可以通过 Bean 的名称或类型获取容器中已经创建好的 Bean。

5. AOP 支持：

  ApplicationContext 支持面向切面编程（AOP），允许你在特定的业务逻辑上增加横切关注点，如日志记录、事务管理等。

3.  ApplicationContext的调用方式

ApplicationContext 可以通过多种方式创建和初始化，通常有以下几种调用方式:

1. 基于 XML 配置的调用方式

Spring 框架最早的配置方式是基于 XML 配置文件，通过 ClassPathXmlApplicationContext 类来加载配置文件并初始化 ApplicationContext。

假设我们有一个名为 beans.xml 的配置文件，里面定义了一些 Bean：

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="myBean" class="com.example.MyBean"/>
</beans>

在 Java 代码中，我们可以通过 ClassPathXmlApplicationContext 来加载这个 XML 配置文件，并初始化 ApplicationContext：

  • ClassPathXmlApplicationContext 会从类路径下加载 beans.xml 配置文件，并根据文件中的定义创建相应的 Bean。
  • 通过 getBean() 方法获取容器中的 Bean 实例。
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyApp {
    public static void main(String[] args) {
        // 加载配置文件，初始化 Spring 容器
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");

        // 获取 Bean
        MyBean myBean = (MyBean) context.getBean("myBean");

        // 使用 Bean
        myBean.someMethod();
    }
}

2. 基于注解配置的调用方式（Java 配置）

随着 Spring 的发展，基于注解的配置方式逐渐成为主流。这种方式不需要使用 XML 文件，而是通过 Java 配置类来定义 Bean 和其他配置信息。

使用 AnnotationConfigApplicationContext 来加载 Java 配置类。

假设我们有一个 Java 配置类 AppConfig，通过 @Configuration 注解声明它为配置类，并通过 @Bean 注解定义 Bean。

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class AppConfig {

    @Bean
    public MyBean myBean() {
        return new MyBean();
    }
}

在 Java 代码中，通过 AnnotationConfigApplicationContext 来初始化 ApplicationContext：

  • AnnotationConfigApplicationContext 是用于加载基于 Java 注解配置的容器，它接受一个或多个配置类（如 AppConfig.class）作为参数。
  • 配置类通过 @Configuration 注解声明，并通过 @Bean 注解提供 Bean 的定义。
  • getBean() 方法可以通过 Bean 的类型来获取容器中的 Bean。
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class MyApp {
    public static void main(String[] args) {
        // 创建并初始化 ApplicationContext
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);

        // 获取 Bean
        MyBean myBean = context.getBean(MyBean.class);

        // 使用 Bean
        myBean.someMethod();
    }
}

3. 基于 ApplicationContext 的工厂模式（不同类型的 ApplicationContext 实现）

Spring 提供了多种类型的 ApplicationContext 实现，适用于不同的场景。除了上面介绍的 ClassPathXmlApplicationContext 和 AnnotationConfigApplicationContext，Spring 还提供了以下实现类：

FileSystemXmlApplicationContext（基于文件系统加载）

GenericWebApplicationContext（与 Spring Web 配合使用）

GenericApplicationContext（适用于非 Web 应用程序）

GenericXmlApplicationContext（适用于不在类路径中的 XML 配置文件）

4. ApplicationContext的常用函数

1. getBean()

功能：用于从容器中获取一个 Bean 实例。可以通过 Bean 名称或类型来获取。

常用形式：

Object getBean(String name);  // 通过名称获取 Bean
<T> T getBean(Class<T> requiredType);  // 通过类型获取 Bean
<T> T getBean(String name, Class<T> requiredType);  // 通过名称和类型获取 Bean

 示例：

MyBean myBean = context.getBean("myBean", MyBean.class);

 2. getBeansOfType() 方法

功能：获取容器中指定类型的所有 Bean 实例。

示例：

Map<String, MyBean> beans = context.getBeansOfType(MyBean.class);

3. getApplicationName() 方法

功能：获取当前应用程序的名称（从配置中读取）。

示例：

String appName = context.getApplicationName();

4. getParent() 方法

功能：获取当前 ApplicationContext 的父容器（如果有的话）。

示例：

ApplicationContext parentContext = context.getParent();

5. containsBean() 方法

功能：检查容器中是否存在指定名称的 Bean。

示例：

boolean exists = context.containsBean("myBean");

6. isPrototype() 和 isSingleton() 方法

功能：检查容器中的 Bean 是否为原型模式（每次请求都会创建一个新的实例）或者单例模式（容器中只有一个实例）。

示例：

boolean isSingleton = context.isSingleton("myBean"); boolean isPrototype = context.isPrototype("myBean");

5. 在springBoot中使用ApplicationContext

Spring Boot 项目通常会自动配置并初始化 ApplicationContext，开发者不需要显式创建它。Spring Boot 内部使用了 AnnotationConfigApplicationContext 或者 GenericWebApplicationContext 来加载应用的配置。

在 Spring Boot 中，SpringApplication.run() 会启动一个内嵌的 Spring 容器并初始化 ApplicationContext，而你通常会通过注入依赖（使用 @Autowired）来访问容器中的 Bean，而无需手动获取 ApplicationContext。

@SpringBootApplication
public class MySpringBootApp {
    public static void main(String[] args) {
        SpringApplication.run(MySpringBootApp.class, args);
    }
}

6.ApplicationContext的工作原理

理解 ApplicationContext 的工作原理，关键在于理解它如何管理 Bean 的生命周期和依赖关系。

6.1 初始化过程

当 Spring 容器启动时，ApplicationContext 会执行以下几个步骤来初始化和管理 Bean：

6.1.1. 加载配置文件或配置类，扫描并注册Bean

  ApplicationContext 的初始化过程首先要加载应用程序的配置。这些配置通常是通过 XML 文件、注解配置类或两者结合来完成的。

  • 如果是 XML 配置文件，使用如 ClassPathXmlApplicationContext 或 GenericXmlApplicationContext 类来加载和解析 XML 配置文件。
  • 如果是基于 Java 注解的配置，使用 AnnotationConfigApplicationContext 类来加载 Java 配置类（通常是用 @Configuration 注解的类）。

        Spring 通过类路径扫描来查找和注册 Bean。在 Java 配置类中，@ComponentScan 注解指定了扫描包的位置，Spring 会根据这个包路径来扫描类路径中的所有候选组件类。这些类通常会有 @Component、@Service、@Repository、@Controller 等注解，Spring 将这些类作为 Bean 注册到容器中。

       每当 Spring 扫描到一个符合条件的类时，它会将该类注册为 Bean 定义（BeanDefinition）。每个 Bean 定义包括 Bean 的类名、作用域、依赖、初始化方法、销毁方法等配置信息。注册 Bean 定义后，Spring 容器就能根据这些定义来实例化、初始化和管理这些 Bean。

6.1.2. 实例化 所有的Bean，根据配置的作用域来确定实例化策略

当 ApplicationContext 加载并注册完所有的 Bean 定义后，接下来就会实例化这些 Bean。实例化的过程如下：

  1. 单例 Bean（Singleton Scope）：对于单例作用域的 Bean，Spring 容器会在容器启动时实例化所有的 Bean 并缓存起来。单例 Bean 只会在容器中存在一个实例，整个应用上下文中共享这一个实例。

  2. 原型 Bean（Prototype Scope）：对于原型作用域的 Bean，每次从容器中获取时，Spring 都会创建一个新的实例。

  3. 其他作用域：如请求作用域（Request）、会话作用域（Session）等，Spring 会根据作用域的不同，在不同的生命周期内实例化 Bean。

6.1.3 处理依赖注入
Spring 容器通过依赖注入（DI）机制来管理 Bean 之间的依赖关系。在 Bean 创建后，Spring 会自动注入它们所依赖的其他 Bean。通常，Spring 使用构造器注入、Setter 注入、或字段注入来处理这些依赖关系。

6.1.4 执行Bean 后处理器，允许在Bean初始化前后进行处理
如果注册了 Bean 后处理器（如 BeanPostProcessor），它们会在 Bean 初始化之前和之后进行处理。Bean 后处理器可以用来修改 Bean 的属性，执行额外的逻辑，或者进行某些验证。

BeanPostProcessor 是 Spring 提供的一种机制，允许开发者在 Bean 初始化之前和之后对 Bean 进行处理。Spring 会在 Bean 完成依赖注入后，但在初始化前，调用所有注册的 BeanPostProcessor 的 postProcessBeforeInitialization 方法，然后调用初始化方法（如 @PostConstruct 或 InitializingBean 接口中的 afterPropertiesSet），最后再调用 postProcessAfterInitialization 方法。

6.1.5 生命周期管理
Spring 管理 Bean 的生命周期，包括初始化、销毁等阶段。可以通过实现 InitializingBean 和 DisposableBean 接口，或者在配置文件中指定初始化方法和销毁方法来定制生命周期。

6.2 如何管理Bean

      Spring 通过 ApplicationContext 和 BeanFactory 来管理 Bean。ApplicationContext 继承自 BeanFactory，是一个更高级的容器，它除了提供基本的 IoC 功能（如 Bean 的管理），还包括了事件广播、国际化支持等功能。

6.2.1 Bean 定义和注册

每个 Bean 在 Spring 容器中都对应一个 Bean 定义（BeanDefinition）。BeanDefinition 是一个描述 Bean 配置和属性的元数据，它包括：

  • Bean 类名：Bean 实现的类。
  • 构造器参数：用来创建 Bean 实例的构造器参数。
  • 属性值：Bean 需要注入的属性。
  • 作用域：指定 Bean 的作用域（如单例、原型等）。
  • 生命周期方法：定义初始化和销毁方法。

6.2.2 Bean 实例化

        Spring 容器通过 BeanDefinition 来创建 Bean 实例，通常使用反射机制来实例化 Bean 对象。如果是单例作用域的 Bean，Spring 容器会在启动时就创建这些 Bean 实例；如果是原型作用域的 Bean，则每次请求都会创建新的 Bean 实例。

6.2.3 依赖注入（DI）

依赖注入（DI）是 Spring 管理 Bean 之间依赖关系的核心机制。ApplicationContext 负责注入依赖并管理 Bean 间的关系。

Spring 支持三种常见的依赖注入方式：

  1. 构造器注入：通过构造方法传入依赖的 Bean。
  2. Setter 注入：通过 setter 方法设置依赖的 Bean。
  3. 字段注入：直接通过反射注入 Bean（使用 @Autowired 注解）。

6.2.4 Bean 生命周期管理

        Spring 提供了强大的 Bean 生命周期管理机制，涵盖了 Bean 的初始化和销毁过程。Spring 容器会在适当的时机调用 @PostConstruct 和 @PreDestroy 注解标记的方法，或者调用实现了 InitializingBean 和 DisposableBean 接口的相关方法。

6.2.5 作用域管理

Spring 支持多种 Bean 作用域，控制 Bean 的生命周期：

  • 单例（Singleton）：默认作用域，Spring 容器只会创建一个 Bean 实例，并在整个应用上下文中共享该实例。
  • 原型（Prototype）：每次从容器获取 Bean 时，都会创建一个新的实例。
  • 请求（Request）：每次 HTTP 请求都会创建一个新的 Bean 实例，适用于 Web 应用。
  • 会话（Session）：每个 HTTP 会话创建一个新的 Bean 实例，适用于 Web 应用。
  • 全局会话（Global Session）：每个全局 HTTP 会话创建一个新的 Bean 实例，适用于基于 Portlet 的应用。

6.3 BeanFactory与ApplicationContext的关系

BeanFactory 是 Spring 容器的最基本接口，它只提供最基本的 Bean 创建和管理功能。而 ApplicationContext 扩展了 BeanFactory，提供了更多的功能。ApplicationContext 允许通过以下方式来管理 Bean：

  1. 自动装配（Autowiring）：通过 @Autowired 注解自动满足依赖关系。
  2. 事件机制：ApplicationContext 可以广播事件，并提供事件监听器（ApplicationListener）来处理这些事件。
  3. 国际化支持：ApplicationContext 支持通过 MessageSource 进行消息资源的管理。

7. 总结

   ApplicationContext 作为 Spring 的核心容器，通过管理 Bean 的生命周期、依赖注入、事件机制、AOP、作用域等，来提供丰富的功能。它通过对 BeanDefinition 的管理来定义和注册 Bean，并通过依赖注入的方式将它们组合成一个完整的应用程序。ApplicationContext 继承自 BeanFactory，提供了更高级的功能，使得 Spring 成为一个功能全面且灵活的框架。

BeanFactory和ApplicationContext区别及详解
m0_59092234的博客
09-09 764
Spring 框架带有两个 IOC 容器——BeanFactory_和_ApplicationContext。_BeanFactory_是 IOC 容器的最基本版本，_ApplicationContext_扩展了_BeanFactory_的特性。Spring容器最基本的接口就是BeanFactory。BeanFactory负责配置、创建、管理Bean，它有一个子接口ApplicationContext，也被称为Spring上下文，容器同时还管理着Bean和Bean之间的依赖关系。
ApplicationContext介绍
热门推荐
mrdu_somefun的博客
12-18 1万+
如果说BeanFactory是Spring的心脏，那么ApplicationContext就是完整的身躯了。ApplicationContext由BeanFactory派生而来，提供了更多面向实际应用的功能。 ApplicationContext类体系结构 ApplicationContext的主要实现类是ClassPathXmlApplicationContext和FileSys
【Springframework系列 ApplicationContext介绍】
最新发布
Nanashi_wumi的博客
04-11 658
国际化（Internationalization，简称 i18n，因为“internationalization”这个单词有 18 个字母中间被省略）是指使应用程序能够轻松适应不同语言和地区设置的过程。在 Java 尤其是 Spring 框架中，国际化的核心就是根据不同的语言环境，动态加载对应语言的资源文件（class path\resources），比如中文、英文等，从而显示不同的文本。第三方库通常不以 message.properties 配置的方式实现国际化。创建 message 配置文件。
applicationContext
11-07
applicationContext applicationContext
ApplicationContext及它的3种实现
zhouwubin123的专栏
09-16 756
ApplicationContext 是 BeanFactory 接口的子接口，它增强了 BeanFactory 的功能，处于 context 包下。很多时候， ApplicationContext 允许以声明式方式操作容器，无须手动创建。可利用如 ContextLoader 的
ApplicationContext介绍 ApplicationContext是什么？
Move on
03-08 1万+
如果说BeanFactory是Spring的心脏，那么ApplicationContext就是完整的身躯了。ApplicationContext由BeanFactory派生而来，提供了更多面向实际应用的功能。 ApplicationContext类体系结构 ApplicationContext的主要实现类是ClassPathXmlApplicationContext和FileSystemXmlApplicationContext，前者默认从类路径加载配置文件，后者默认从文件系统中装载配置文件
SpringBoot获取ApplicationContext的3种方式
08-25
下面，我们将详细介绍获取ApplicationContext的3种方式： 第一种方式：使用@Autowired注入 在SpringBoot中，我们可以使用@Autowired注解来注入ApplicationContext。下面是一个简单的示例代码： ```java @...
spring中通过ApplicationContext getBean获取注入对象的方法实例
08-26
本文将详细介绍如何在Spring中通过`ApplicationContext`的`getBean`方法获取注入对象，并通过实例来展示其使用。 首先，我们来看`ApplicationContextAware`接口，它是Spring提供的一个回调接口。当Spring容器创建了...
Spring获取ApplicationContext对象工具类的实现方法
10-19
本文将详细介绍Spring中获取ApplicationContext对象的工具类实现方法。 在Spring中，典型的获取ApplicationContext对象的方式是使用ApplicationContext接口的一个实现类，如ClassPathXmlApplicationContext。这是一...
applicationContext.xml等文件.rar
03-05
下面将详细介绍这些文件的作用和相关知识点。 1. **`applicationContext.xml`**： 这是Spring框架的核心配置文件，主要用于定义bean的声明、依赖注入（Dependency Injection，DI）以及bean之间的关系。在Spring中...
ApplicationContext
ksidgx的博客
11-24 588
ApplicationContext：BeanFactory的“身体”
spring之ApplicationContext
lgh3293的博客
03-13 224
context的核心作用是ApplicationContext接口，这是由BeanFactory接口派生而来。同时，context还提供了以下的功能：1) MessageSource,提供国际化的消息访问2)资源访问，如URL和文件3）事件传播，实现了ApplicationListener接口的bean4)惯入多个上文，使得每一个上下文都专注于一个特定的层次，比如应用的web层.   1.Me...
ApplicationContext 详细介绍
ls188665的博客
07-18 636
的所有功能，还添加了国际化支持、资源访问、事件传播、以及更高级的容器特性，如自动装配和生命周期管理等。它是Spring应用中的核心容器，负责管理和配置应用中的对象（称为beans）。，开发者可以轻松地管理应用中的对象（Bean），并利用Spring提供的各种特性，如依赖注入、国际化支持、事件传播等，来构建松耦合、可扩展的应用。的配置可以通过多种方式实现，包括基于XML的配置文件、基于注解的配置（如。是Spring框架中的一个核心接口，它扩展了。接口，并提供了更全面的功能。接口，并提供了更全面的功能。
手动获取spring的ApplicationContext和bean对象
zhongyangjian的专栏
04-20 1061
转：http://www.cnblogs.com/yangzhilong/p/3949332.html WEB项目： 方法1： 1 ApplicationContext ac1 = WebApplicationContextUtils.getRequiredWebApplicationContext(ServletContext sc
applicationcontext的作用
gdhgr的博客
10-12 1885
1 String xmlPath = "com/itheima/c_inject/c_factory/beans.xml"; ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);  UserService userService = applicationContext.g
详细介绍 ApplicationListener
04-10
<think>好的，我现在需要详细回答用户关于Spring ApplicationListener的问题。首先，我要确保自己正确理解这个接口的作用和用法。ApplicationListener是Spring框架中的一个事件监听接口，基于观察者模式，用于处理应用程序事件。用户可能需要了解如何实现它，以及在实际项目中的使用场景。 首先，我需要回顾ApplicationListener的基本定义。它位于org.springframework.context包中，是一个泛型接口，需要实现onApplicationEvent方法。当特定类型的事件发布时，监听器会被触发。例如，Spring内置了一些事件，如ContextRefreshedEvent、ContextStartedEvent等，用户也可以自定义事件。 接下来，用户可能想知道如何实现一个ApplicationListener。根据引用中的例子，比如引用[2]和引用[3]，实现步骤包括创建一个类实现ApplicationListener接口，指定事件类型，并重写onApplicationEvent方法。然后，需要将监听器注册到Spring容器中，可以通过@Component注解或XML配置。 然后，使用场景部分需要详细说明。引用[4]提到可以监听原生事件如RequestHandledEvent，或者自定义事件。常见的应用包括初始化操作、资源释放、日志记录等。例如，在应用启动完成后进行一些数据加载，或者在请求处理完成后记录日志。 另外，需要比较ApplicationListener与其他类似接口，比如ApplicationRunner或CommandLineRunner。根据引用[1]，ApplicationListener更灵活，属于Spring Context，而SpringApplicationRunListener属于Spring Boot，可能更底层。需要指出ApplicationListener的适用性和优势。 还要注意提到一些高级用法，比如使用@EventListener注解替代实现接口的方式，这在Spring 4.2之后支持，使代码更简洁。同时，需要强调监听器的执行顺序和异步处理的可能性，但用户可能需要自行配置异步支持。 最后，确保回答结构清晰，分点说明，并引用提供的参考资料。例如，在实现步骤部分引用[2]和[3]，在应用场景部分引用[4]。同时，生成的相关问题要围绕可能延伸的内容，比如与ApplicationRunner的区别、自定义事件的方法、执行顺序控制等。</think>### Spring ApplicationListener 详细介绍及使用场景 #### 一、基本定义与核心机制 $ApplicationListener$ 是 Spring 框架中基于**观察者模式**的事件监听接口，用于接收并处理应用程序事件。它属于 `org.springframework.context` 包，通过实现 `onApplicationEvent` 方法响应特定类型的事件[^3]。例如： ```java public interface ApplicationListener<E extends ApplicationEvent> extends EventListener { void onApplicationEvent(E event); } ``` #### 二、实现步骤 1. **定义监听器类**：实现 `ApplicationListener` 接口，并指定监听的事件类型（如内置事件或自定义事件）。 ```java @Component public class CustomListener implements ApplicationListener<ContextRefreshedEvent> { @Override public void onApplicationEvent(ContextRefreshedEvent event) { // 处理逻辑 } } ``` 引用示例见[^2][^4]。 2. **注册监听器**： - 使用 `@Component` 注解自动扫描注册； - 或通过 XML 配置 `<bean class="com.example.CustomListener"/>`。 #### 三、内置事件类型 1. **ContextRefreshedEvent**：容器刷新完成时触发（如应用启动完成）[^3]； 2. **RequestHandledEvent**：HTTP 请求处理完成后触发，可获取请求路径、响应时间等信息[^4]； 3. **ContextClosedEvent**：容器关闭时触发，用于资源释放。 #### 四、使用场景 1. **初始化操作**：监听 `ContextRefreshedEvent` 执行数据预加载或配置检查； ```java public void onApplicationEvent(ContextRefreshedEvent event) { if (event.getApplicationContext().getParent() == null) { // 根容器初始化完成时执行 } } ``` 2. **请求监控**：通过 `RequestHandledEvent` 记录请求耗时或异常信息； 3. **自定义事件**：扩展 `ApplicationEvent` 实现业务解耦，例如订单创建后触发通知： ```java public class OrderCreatedEvent extends ApplicationEvent { public OrderCreatedEvent(Order order) { super(order); } } ``` 发布事件： ```java applicationContext.publishEvent(new OrderCreatedEvent(order)); ``` #### 五、与其他接口对比 - **ApplicationRunner**：在 Spring Boot 启动后执行，仅触发一次，适用于命令行参数处理； - **ApplicationListener**：更通用，支持多种事件类型和多次触发[^1]。 #### 六、高级用法 1. **条件过滤**：通过 `@EventListener` 注解结合 SpEL 表达式选择特定事件； ```java @EventListener(condition = "#event.success") public void handleRequest(RequestHandledEvent event) { // 仅处理成功请求 } ``` 2. **异步处理**：结合 `@Async` 实现异步事件处理（需启用异步支持）。 ---
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值