From efde86c23a26451ff12b17f39718fca52e1dff44 Mon Sep 17 00:00:00 2001 From: xuchengsheng Date: Wed, 18 Oct 2023 21:04:22 +0800 Subject: [PATCH] =?UTF-8?q?1.=E4=BC=98=E5=8C=96ApplicationEventPublisherAw?= =?UTF-8?q?are=202.=E4=BC=98=E5=8C=96ApplicationStartupAware=203.=E4=BC=98?= =?UTF-8?q?=E5=8C=96BeanClassLoaderAware?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../README.md | 111 +++++++++++------- .../README.md | 105 ++++++++++------- .../README.md | 107 ++++++++++------- 3 files changed, 196 insertions(+), 127 deletions(-) diff --git a/spring-aware/spring-aware-applicationEventPublisherAware/README.md b/spring-aware/spring-aware-applicationEventPublisherAware/README.md index 45dbb2a..e0aab1a 100644 --- a/spring-aware/spring-aware-applicationEventPublisherAware/README.md +++ b/spring-aware/spring-aware-applicationEventPublisherAware/README.md @@ -1,24 +1,30 @@ ## ApplicationEventPublisherAware - [ApplicationEventPublisherAware](#applicationeventpublisheraware) - - [一、接口描述](#一接口描述) - - [二、接口源码](#二接口源码) - - [三、主要功能](#三主要功能) - - [四、最佳实践](#四最佳实践) - - [五、时序图](#五时序图) - - [六、源码分析](#六源码分析) - - [七、注意事项](#七注意事项) - - [八、总结](#八总结) - - [8.1、最佳实践总结](#81最佳实践总结) - - [8.2、源码分析总结](#82源码分析总结) + - [一、基本信息](#一基本信息) + - [二、接口描述](#二接口描述) + - [三、接口源码](#三接口源码) + - [四、主要功能](#四主要功能) + - [五、最佳实践](#五最佳实践) + - [六、时序图](#六时序图) + - [七、源码分析](#七源码分析) + - [八、注意事项](#八注意事项) + - [九、总结](#九总结) + - [最佳实践总结](#最佳实践总结) + - [源码分析总结](#源码分析总结) -### 一、接口描述 + +### 一、基本信息 + +✒️ **作者** - Lex 📝 **博客** - [我的CSDN](https://blog.csdn.net/duzhuang2399/article/details/133914254) 📚 **文章目录** - [所有文章](https://github.com/xuchengsheng/spring-reading) 🔗 **源码地址** - [ApplicationEventPublisherAware源码](https://github.com/xuchengsheng/spring-reading/tree/master/spring-aware/spring-aware-applicationEventPublisherAware) + +### 二、接口描述 `ApplicationEventPublisherAware` 接口，用于给需要发布应用事件的bean提供一个便捷的方式。实现此接口的bean可以接收到一个 `ApplicationEventPublisher` 的引用，这样它们就可以发布事件到 Spring 应用上下文中。 -### 二、接口源码 +### 三、接口源码 -`ApplicationEventPublisherAware` 是 Spring 框架自 1.1.1 开始引入的一个核心接口。需要发布一些事件到Spring上下文，我们可以实现此接口，然后使用注入的 `ApplicationEventPublisher` 来发布事件（通常是 `ApplicationContext`）。 +`ApplicationEventPublisherAware` 是 Spring 框架自 1.1.1 开始引入的一个核心接口。实现`ApplicationEventPublisherAware`接口的对象会在Spring容器中被自动注入一个`ApplicationEventPublisher`（通常是 `ApplicationContext`）实例。 ```java /** @@ -44,15 +50,18 @@ public interface ApplicationEventPublisherAware extends Aware { } ``` -### 三、主要功能 +### 四、主要功能 -**事件发布能力**：它允许 Spring beans 获得事件发布的能力，使它们能够发布事件到 Spring 应用上下文中。 +1. **事件发布能力** + + 它允许 Spring beans 获得事件发布的能力，使它们能够发布事件到 Spring 应用上下文中。 -**回调机制**：当一个 bean 实现了 `ApplicationEventPublisherAware` 接口时，Spring 容器会自动注入 `ApplicationEventPublisher` 实例到该 bean 中。 +2. **回调机制** + + 当一个 bean 实现了 `ApplicationEventPublisherAware` 接口时，Spring 容器会自动注入 `ApplicationEventPublisher` 实例到该 bean 中。 -**与 ApplicationContext 的关联**：通常，所注入的 `ApplicationEventPublisher` 实例实际上就是 `ApplicationContext` 本身，这意味着 beans 可以使用它来发布事件。 +3. **与 ApplicationContext 的关联** + + 通常，所注入的 `ApplicationEventPublisher` 实例实际上就是 `ApplicationContext` 本身，这意味着 beans 可以使用它来发布事件。 -### 四、最佳实践 +### 五、最佳实践 首先来看看启动类入口，上下文环境使用`AnnotationConfigApplicationContext`（此类是使用Java注解来配置Spring容器的方式），构造参数我们给定了一个`MyConfiguration`组件类。然后从Spring上下文中获取一个`MyApplicationEventPublisherAware`类型的bean，最后调用`publish`方法用于发布一个事件。 @@ -139,7 +148,7 @@ public class MyEventListener implements ApplicationListener { Received my event - hello world ``` -### 五、时序图 +### 六、时序图 ~~~mermaid sequenceDiagram @@ -174,7 +183,7 @@ ApplicationContextAwareProcessor->>MyApplicationEventPublisherAware:setApplicati AnnotationConfigApplicationContext-->>ApplicationEventPublisherAwareApplication:初始化完成 ~~~ -### 六、源码分析 +### 七、源码分析 首先来看看启动类入口，上下文环境使用`AnnotationConfigApplicationContext`（此类是使用Java注解来配置Spring容器的方式），构造参数我们给定了一个`MyConfiguration`组件类。然后从Spring上下文中获取一个`MyApplicationEventPublisherAware`类型的bean，最后调用`publish`方法用于发布一个事件。 @@ -461,46 +470,64 @@ public class MyApplicationEventPublisherAware implements ApplicationEventPublish } ``` -### 七、注意事项 +### 八、注意事项 -**确保容器支持**：不是所有的Spring容器都支持 `Aware` 接口。例如，基本的 `BeanFactory` 不支持，而 `ApplicationContext` 支持。确保您的bean是由支持 `ApplicationEventPublisherAware` 的容器管理的。 +1. **确保容器支持** + + 不是所有的Spring容器都支持 `Aware` 接口。例如，基本的 `BeanFactory` 不支持，而 `ApplicationContext` 支持。确保我们的bean是由支持 `ApplicationEventPublisherAware` 的容器管理的。 -**避免复杂的业务逻辑**：在实现的 `setApplicationEventPublisher` 方法中，尽量避免放入复杂的业务逻辑，该方法主要是用于注入 `ApplicationEventPublisher` 的。 +2. **避免复杂的业务逻辑** + + 在实现的 `setApplicationEventPublisher` 方法中，尽量避免放入复杂的业务逻辑，该方法主要是用于注入 `ApplicationEventPublisher` 的。 -**注意事件的目标**：当使用 `ApplicationEventPublisher` 发布事件时，这些事件会被所有相应的监听器捕获。确保你了解这些监听器的存在和它们的行为，以避免出现一些奇奇怪怪的问题。 +3. **注意事件的目标** + + 当使用 `ApplicationEventPublisher` 发布事件时，这些事件会被所有相应的监听器捕获。确保我们了解这些监听器的存在和它们的行为，以避免出现一些奇奇怪怪的问题。 -**不要手动调用**：`setApplicationEventPublisher` 方法是为了由Spring容器调用的，而不是为了应用程序代码调用的。你不应该在业务逻辑中手动调用这个方法。 +4. **不要手动调用** + + `setApplicationEventPublisher` 方法是为了由Spring容器调用的，而不是为了应用程序代码调用的。我们不应该在业务逻辑中手动调用这个方法。 -### 八、总结 +### 九、总结 -#### 8.1、最佳实践总结 +#### 最佳实践总结 -**启动应用**：在 `ApplicationEventPublisherAwareApplication` 的主方法中，使用 `AnnotationConfigApplicationContext` 初始化了 Spring 上下文，并指定了配置类 `MyConfiguration`。 +1. **启动应用** + + 在 `ApplicationEventPublisherAwareApplication` 的主方法中，使用 `AnnotationConfigApplicationContext` 初始化了 Spring 上下文，并指定了配置类 `MyConfiguration`。 -**配置类**：`MyConfiguration` 使用了 `@Configuration` 注解，表示它是一个 Spring 配置类。此类中使用 `@Bean` 注解定义了两个 Bean：`MyApplicationEventPublisherAware` 和 `MyEventListener`，确保它们被 Spring 容器管理。 +2. **配置类** + + `MyConfiguration` 使用了 `@Configuration` 注解，表示它是一个 Spring 配置类。此类中使用 `@Bean` 注解定义了两个 Bean：`MyApplicationEventPublisherAware` 和 `MyEventListener`，确保它们被 Spring 容器管理。 -**事件发布者**：`MyApplicationEventPublisherAware` 类实现了 `ApplicationEventPublisherAware` 接口，从而可以获取 `ApplicationEventPublisher` 的引用。它还定义了一个 `publish` 方法，用于发布自定义的 `MyEvent` 事件。 +3. **事件发布者** + + `MyApplicationEventPublisherAware` 类实现了 `ApplicationEventPublisherAware` 接口，从而可以获取 `ApplicationEventPublisher` 的引用。它还定义了一个 `publish` 方法，用于发布自定义的 `MyEvent` 事件。 -**自定义事件**：`MyEvent` 是一个自定义事件类，继承自 `ApplicationEvent`。它携带一个字符串消息。 +4. **自定义事件** + + `MyEvent` 是一个自定义事件类，继承自 `ApplicationEvent`。它携带一个字符串消息。 -**事件监听器**：`MyEventListener` 是一个事件监听器，它实现了 `ApplicationListener` 并专门用于监听 `MyEvent` 事件。当相应事件被发布时，它的 `onApplicationEvent` 方法会被自动触发。 +5. **事件监听器** + + `MyEventListener` 是一个事件监听器，它实现了 `ApplicationListener` 并专门用于监听 `MyEvent` 事件。当相应事件被发布时，它的 `onApplicationEvent` 方法会被自动触发。 -**执行结果**：当运行 `ApplicationEventPublisherAwareApplication` 主方法时，应用发布了一个 `MyEvent` 事件，携带了 "hello world" 消息。`MyEventListener` 成功捕获此事件，并输出了相应的消息。 +6. **执行结果** + + 当运行 `ApplicationEventPublisherAwareApplication` 主方法时，应用发布了一个 `MyEvent` 事件，携带了 "hello world" 消息。`MyEventListener` 成功捕获此事件，并输出了相应的消息。 -#### 8.2、源码分析总结 +#### 源码分析总结 -**启动应用**：通过 `ApplicationEventPublisherAwareApplication` 的主方法，使用 `AnnotationConfigApplicationContext` 初始化了 Spring 上下文，并指定了配置类 `MyConfiguration`。 +1. **启动应用** + + 通过 `ApplicationEventPublisherAwareApplication` 的主方法，使用 `AnnotationConfigApplicationContext` 初始化了 Spring 上下文，并指定了配置类 `MyConfiguration`。 -**注册和刷新**：在 `AnnotationConfigApplicationContext` 构造函数中，先注册组件类，然后调用 `refresh()` 来启动Spring容器的初始化过程。 +2. **注册和刷新** + + 在 `AnnotationConfigApplicationContext` 构造函数中，先注册组件类，然后调用 `refresh()` 来启动Spring容器的初始化过程。 -**初始化Bean工厂**：在 `AbstractApplicationContext#refresh` 方法中，调用 `finishBeanFactoryInitialization` 以实例化所有非懒加载的单例Bean。 +3. **初始化Bean工厂** + + 在 `AbstractApplicationContext#refresh` 方法中，调用 `finishBeanFactoryInitialization` 以实例化所有非懒加载的单例Bean。 -**预实例化单例**：在 `DefaultListableBeanFactory` 中，通过 `preInstantiateSingletons` 方法预先实例化所有非懒加载的单例Bean。 +4. **预实例化单例** + + 在 `DefaultListableBeanFactory` 中，通过 `preInstantiateSingletons` 方法预先实例化所有非懒加载的单例Bean。 -**Bean创建**：在 `AbstractBeanFactory#getBean` 中，调用 `doGetBean` 来真正执行Bean的创建过程。此方法中涉及到真正的Bean实例化、属性注入和初始化。 +5. **Bean创建** + + 在 `AbstractBeanFactory#getBean` 中，调用 `doGetBean` 来真正执行Bean的创建过程。此方法中涉及到真正的Bean实例化、属性注入和初始化。 -**初始化Bean**：在 `AbstractAutowireCapableBeanFactory` 类中，`initializeBean` 方法用于确保bean完全配置并准备就绪。这个过程中会应用所有的 `BeanPostProcessor`，它们能在bean初始化前后做额外的处理。 +6. **初始化Bean** + + 在 `AbstractAutowireCapableBeanFactory` 类中，`initializeBean` 方法用于确保bean完全配置并准备就绪。这个过程中会应用所有的 `BeanPostProcessor`，它们能在bean初始化前后做额外的处理。 -**处理Aware接口**：在 `ApplicationContextAwareProcessor` 中，`invokeAwareInterfaces` 方法负责处理实现了 `Aware` 接口的beans，为它们自动注入对应的依赖或运行环境信息。 +7. **处理Aware接口** + + 在 `ApplicationContextAwareProcessor` 中，`invokeAwareInterfaces` 方法负责处理实现了 `Aware` 接口的beans，为它们自动注入对应的依赖或运行环境信息。 -**发布事件**：在我们的自定义逻辑中，使用 `ApplicationEventPublisherAware` 接口来获取Spring的事件发布器。然后，使用这个事件发布器，我们可以发布自定义事件。 \ No newline at end of file +8. **发布事件** + + 在我们的自定义逻辑中，使用 `ApplicationEventPublisherAware` 接口来获取Spring的事件发布器。然后，使用这个事件发布器，我们可以发布自定义事件。 \ No newline at end of file diff --git a/spring-aware/spring-aware-applicationStartupAware/README.md b/spring-aware/spring-aware-applicationStartupAware/README.md index a9592f9..8a38bf6 100644 --- a/spring-aware/spring-aware-applicationStartupAware/README.md +++ b/spring-aware/spring-aware-applicationStartupAware/README.md @@ -1,22 +1,28 @@ ## ApplicationStartupAware - [ApplicationStartupAware](#applicationstartupaware) - - [一、接口描述](#一接口描述) - - [二、接口源码](#二接口源码) - - [三、主要功能](#三主要功能) - - [四、最佳实践](#四最佳实践) - - [五、时序图](#五时序图) - - [六、源码分析](#六源码分析) - - [七、注意事项](#七注意事项) - - [八、总结](#八总结) - - [8.1、最佳实践总结](#81最佳实践总结) - - [8.2、源码分析总结](#82源码分析总结) + - [一、基本信息](#一基本信息) + - [二、接口描述](#二接口描述) + - [三、接口源码](#三接口源码) + - [四、主要功能](#四主要功能) + - [五、最佳实践](#五最佳实践) + - [六、时序图](#六时序图) + - [七、源码分析](#七源码分析) + - [八、注意事项](#八注意事项) + - [九、总结](#九总结) + - [最佳实践总结](#最佳实践总结) + - [源码分析总结](#源码分析总结) -### 一、接口描述 -`ApplicationStartup`接口，是为了提供对这一过程的细粒度跟踪。通过`StartupStep`，我们可以定义应用启动过程中的各个步骤，并收集关于它们的性能和上下文信息。 +### 一、基本信息 -### 二、接口源码 +✒️ **作者** - Lex 📝 **博客** - [我的CSDN](https://blog.csdn.net/duzhuang2399/article/details/133914474) 📚 **文章目录** - [所有文章](https://github.com/xuchengsheng/spring-reading) 🔗 **源码地址** - [ApplicationStartupAware源码]() + +### 二、接口描述 + +`ApplicationStartupAware`接口，是为了提供对这一过程的细粒度跟踪。通过`StartupStep`，我们可以定义应用启动过程中的各个步骤，并收集关于它们的性能和上下文信息。 + +### 三、接口源码 `ApplicationStartupAware` 是 Spring 框架自 5.3 开始引入的一个核心接口。实现`ApplicationStartupAware`接口的对象会在Spring容器中被自动注入一个`ApplicationStartup`实例。 @@ -42,15 +48,18 @@ public interface ApplicationStartupAware extends Aware { } ``` -### 三、主要功能 +### 四、主要功能 -**启动性能跟踪**：通过提供对`ApplicationStartup`的访问，实现此接口的beans可以使用`StartupStep`API来跟踪它们在启动过程中的各个步骤。这对于检测和优化启动性能非常有用。 +1. **启动性能跟踪** + + 通过提供对`ApplicationStartup`的访问，实现此接口的beans可以使用`StartupStep`API来跟踪它们在启动过程中的各个步骤。这对于检测和优化启动性能非常有用。 -**为beans提供跟踪能力**：而不仅仅是Spring框架内部使用。这意味着开发者可以为他们的自定义beans或组件提供与Spring框架同样的启动跟踪能力。 +2. **为beans提供跟踪能力** + + 而不仅仅是Spring框架内部使用。这意味着我们可以为他们的自定义beans或组件提供与Spring框架同样的启动跟踪能力。 -**细粒度控制**：与`StartupStep`一起使用，`ApplicationStartupAware`允许beans对其启动过程中的特定部分进行跟踪，例如数据库初始化、外部服务连接或任何其他可能需要时间的操作。 +3. **细粒度控制** + + 与`StartupStep`一起使用，`ApplicationStartupAware`允许beans对其启动过程中的特定部分进行跟踪，例如数据库初始化、外部服务连接或任何其他可能需要时间的操作。 -### 四、最佳实践 +### 五、最佳实践 首先来看看启动类入口，上下文环境使用`AnnotationConfigApplicationContext`（此类是使用Java注解来配置Spring容器的方式），首先设置了`BufferingApplicationStartup`，这是Spring Boot提供的一个`ApplicationStartup`实现，缓存了最后的100个启动步骤。这使得我们可以在应用启动后查看并分析这些步骤，以便了解哪些操作可能会影响启动性能，然后使用`register`方法，我们告诉Spring上下文加载`MyConfiguration`类，最后调用`refresh`方法会触发应用上下文的初始化，包括bean的创建和依赖注入。 @@ -107,7 +116,7 @@ public class MyApplicationStartupAware implements ApplicationStartupAware, Initi } ``` -### 五、时序图 +### 六、时序图 ~~~mermaid sequenceDiagram @@ -142,7 +151,7 @@ sequenceDiagram AnnotationConfigApplicationContext-->>ApplicationStartupAwareApplication:初始化完成 ~~~ -### 六、源码分析 +### 七、源码分析 首先来看看启动类入口，上下文环境使用`AnnotationConfigApplicationContext`（此类是使用Java注解来配置Spring容器的方式），首先设置了`BufferingApplicationStartup`，这是Spring Boot提供的一个`ApplicationStartup`实现，缓存了最后的100个启动步骤。这使得我们可以在应用启动后查看并分析这些步骤，以便了解哪些操作可能会影响启动性能，然后使用`register`方法，我们告诉Spring上下文加载`MyConfiguration`类，最后调用`refresh`方法会触发应用上下文的初始化，包括bean的创建和依赖注入。 @@ -439,42 +448,58 @@ public class MyApplicationStartupAware implements ApplicationStartupAware, Initi } ``` -### 七、注意事项 +### 八、注意事项 -**生命周期时机**：`setApplicationStartup`方法在其他bean属性设置之后、`InitializingBean`的`afterPropertiesSet`方法之前调用。确保你的bean在这一阶段不依赖于其他尚未初始化或注入的属性。 +1. **生命周期时机** + + `setApplicationStartup`方法在其他bean属性设置之后、`InitializingBean`的`afterPropertiesSet`方法之前调用。确保我们的bean在这一阶段不依赖于其他尚未初始化或注入的属性。 -**性能考虑**：虽然启动跟踪对于分析应用程序启动时间很有用，但添加太多的启动步骤跟踪可能会对性能产生微小的影响。在生产环境中，你可能需要权衡跟踪的详细程度和性能的关系。 +2. **性能考虑** + + 虽然启动跟踪对于分析应用程序启动时间很有用，但添加太多的启动步骤跟踪可能会对性能产生微小的影响。在生产环境中，我们可能需要权衡跟踪的详细程度和性能的关系。 -**清晰的步骤名称**：当定义`StartupStep`时，为其提供清晰、描述性的名称，这样其他开发者可以更容易地理解它代表的步骤。 +3. **清晰的步骤名称** + + 当定义`StartupStep`时，为其提供清晰、描述性的名称，这样其他我们可以更容易地理解它代表的步骤。 -**不要滥用**：尽量只为那些真正重要和可能影响启动性能的步骤使用启动跟踪。不需要为每个小操作都添加跟踪。 +4. **不要滥用** + + 尽量只为那些真正重要和可能影响启动性能的步骤使用启动跟踪。不需要为每个小操作都添加跟踪。 -**不要忘记结束步骤**：每当你开始一个`StartupStep`，记得在适当的时机调用`end`方法结束它。否则，该步骤可能会在报告中显示为仍在运行，这可能会导致混淆。 +5. **不要忘记结束步骤** + + 每当我们开始一个`StartupStep`，记得在适当的时机调用`end`方法结束它。否则，该步骤可能会在报告中显示为仍在运行，这可能会导致混淆。 -### 八、总结 +### 九、总结 -#### 8.1、最佳实践总结 +#### 最佳实践总结 -**启动类概述**：使用`AnnotationConfigApplicationContext`，一个基于Java注解的Spring上下文初始化方法。设置`BufferingApplicationStartup`来缓存应用启动过程的最后100个步骤。这样可以分析哪些步骤可能影响启动性能。注册`MyConfiguration`类以加载相应的配置。刷新并初始化应用上下文，从而触发bean的创建和依赖注入。关闭上下文。 +1. **启动类概述** + + 使用`AnnotationConfigApplicationContext`，一个基于Java注解的Spring上下文初始化方法。设置`BufferingApplicationStartup`来缓存应用启动过程的最后100个步骤。这样可以分析哪些步骤可能影响启动性能。注册`MyConfiguration`类以加载相应的配置。刷新并初始化应用上下文，从而触发bean的创建和依赖注入。关闭上下文。 -**配置类概述**：使用`@Configuration`注解标记，告诉Spring这是一个配置类。通过`@Bean`注解定义了`MyApplicationStartupAware` bean。这样可以确保它被Spring容器处理，并在容器启动时执行其生命周期方法。 +2. **配置类概述** + + 使用`@Configuration`注解标记，告诉Spring这是一个配置类。通过`@Bean`注解定义了`MyApplicationStartupAware` bean。这样可以确保它被Spring容器处理，并在容器启动时执行其生命周期方法。 -**`MyApplicationStartupAware`类概述**：实现了`ApplicationStartupAware`接口，允许它在启动时获知`ApplicationStartup`实例。定义了两个启动步骤来模拟潜在的长时间运行任务，并使用`StartupStep`进行跟踪。在每个步骤的末尾，都有一个标记状态为"done"，然后结束该步骤。 +3. **`MyApplicationStartupAware`类概述** + + 实现了`ApplicationStartupAware`接口，允许它在启动时获知`ApplicationStartup`实例。定义了两个启动步骤来模拟潜在的长时间运行任务，并使用`StartupStep`进行跟踪。在每个步骤的末尾，都有一个标记状态为"done"，然后结束该步骤。 -#### 8.2、源码分析总结 +#### 源码分析总结 -**实例化Beans**：在`AbstractApplicationContext`的`refresh()`方法中，`finishBeanFactoryInitialization`方法被调用，确保所有单例Bean被预先实例化。 +1. **实例化Beans** + + 在`AbstractApplicationContext`的`refresh()`方法中，`finishBeanFactoryInitialization`方法被调用，确保所有单例Bean被预先实例化。 -**Bean预实例化**：`DefaultListableBeanFactory`的`preInstantiateSingletons`方法确保所有非懒加载的单例Beans被实例化。核心操作是调用`getBean(beanName)`。 +2. **Bean预实例化** + + `DefaultListableBeanFactory`的`preInstantiateSingletons`方法确保所有非懒加载的单例Beans被实例化。核心操作是调用`getBean(beanName)`。 -**获取Bean实例**：`AbstractBeanFactory`的`getBean`方法进一步调用`doGetBean`来真正实例化Bean，处理异常和依赖，并返回Bean实例。 +3. **获取Bean实例** + + `AbstractBeanFactory`的`getBean`方法进一步调用`doGetBean`来真正实例化Bean，处理异常和依赖，并返回Bean实例。 -**Bean单例获取**：`DefaultSingletonBeanRegistry`的`getSingleton`方法确保Bean以单例形式存在，从缓存获取或使用提供的`ObjectFactory`创建新实例。 +4. **Bean单例获取** + + `DefaultSingletonBeanRegistry`的`getSingleton`方法确保Bean以单例形式存在，从缓存获取或使用提供的`ObjectFactory`创建新实例。 -**创建Bean实例**：`AbstractAutowireCapableBeanFactory`的`createBean`方法调用`doCreateBean`进行Bean的实际实例化，并进行初始化，确保Bean完全配置并准备就绪。 +5. **创建Bean实例** + + `AbstractAutowireCapableBeanFactory`的`createBean`方法调用`doCreateBean`进行Bean的实际实例化，并进行初始化，确保Bean完全配置并准备就绪。 -**Bean初始化**：`AbstractAutowireCapableBeanFactory`的`initializeBean`方法确保Bean被正确初始化，其中调用`applyBeanPostProcessorsBeforeInitialization`方法是Spring生命周期中的关键点，允许BeanPostProcessors在Bean初始化之前进行操作。 +6. **Bean初始化** + + `AbstractAutowireCapableBeanFactory`的`initializeBean`方法确保Bean被正确初始化，其中调用`applyBeanPostProcessorsBeforeInitialization`方法是Spring生命周期中的关键点，允许BeanPostProcessors在Bean初始化之前进行操作。 -**处理Aware接口**：在Bean初始化过程中，`ApplicationContextAwareProcessor`确保实现了`Aware`接口的Beans被正确处理，这些Beans会自动"感知"并获得其运行环境或特定依赖的引用。 +7. **处理Aware接口** + + 在Bean初始化过程中，`ApplicationContextAwareProcessor`确保实现了`Aware`接口的Beans被正确处理，这些Beans会自动"感知"并获得其运行环境或特定依赖的引用。 -**自定义逻辑执行**:`MyApplicationStartupAware`类实现了`ApplicationStartupAware`接口，它将接收一个`ApplicationStartup`实例。 \ No newline at end of file +8. **自定义逻辑执行** + + `MyApplicationStartupAware`类实现了`ApplicationStartupAware`接口，它将接收一个`ApplicationStartup`实例。 \ No newline at end of file diff --git a/spring-aware/spring-aware-beanClassLoaderAware/README.md b/spring-aware/spring-aware-beanClassLoaderAware/README.md index 2abc2bc..223585b 100644 --- a/spring-aware/spring-aware-beanClassLoaderAware/README.md +++ b/spring-aware/spring-aware-beanClassLoaderAware/README.md @@ -1,22 +1,16 @@ ## BeanClassLoaderAware -- [BeanClassLoaderAware](#beanclassloaderaware) - - [一、接口描述](#一接口描述) - - [二、接口源码](#二接口源码) - - [三、主要功能](#三主要功能) - - [四、最佳实践](#四最佳实践) - - [五、时序图](#五时序图) - - [六、源码分析](#六源码分析) - - [七、注意事项](#七注意事项) - - [八、总结](#八总结) - - [8.1、最佳实践总结](#81最佳实践总结) - - [8.2、源码分析总结](#82源码分析总结) -### 一、接口描述 + +### 一、基本信息 + +✒️ **作者** - Lex 📝 **博客** - [我的CSDN]() 📚 **文章目录** - [所有文章](https://github.com/xuchengsheng/spring-reading) 🔗 **源码地址** - [BeanClassLoaderAware源码](https://github.com/xuchengsheng/spring-reading/tree/master/spring-aware/spring-aware-beanClassLoaderAware) + +### 二、接口描述 `BeanClassLoaderAware` 接口，允许 bean 得知其加载的类加载器。当一个 bean 实现了这个接口时，Spring 容器在 bean 初始化的时候会设置它的类加载器。 -### 二、接口源码 +### 三、接口源码 `BeanClassLoaderAware` 是 Spring 框架自 2.0 版本开始引入的一个核心接口。当一个 bean 实现了这个接口，并在 Spring 容器中被初始化时，Spring 容器会自动调用 `setClassLoader` 方法，并将加载该 bean 的类加载器传入。 @@ -50,15 +44,18 @@ public interface BeanClassLoaderAware extends Aware { } ``` -### 三、主要功能 +### 四、主要功能 -**提供类加载器信息**：Bean 可以得知其加载的类加载器，从而可以利用该类加载器进行动态的类加载或资源查找。 +1. **提供类加载器信息** + + Bean 可以得知其加载的类加载器，从而可以利用该类加载器进行动态的类加载或资源查找。 -**框架与应用类加载器隔离**：在某些复杂的环境中，框架类和应用程序类可能是由不同的类加载器加载的。例如，在某些应用服务器环境中，框架可能是由共享的类加载器加载的，而应用程序类是由专门的类加载器加载的。通过 `BeanClassLoaderAware`，框架类可以确保使用正确的类加载器来加载或访问应用程序类。 +2. **框架与应用类加载器隔离** + + 在某些复杂的环境中，框架类和应用程序类可能是由不同的类加载器加载的。例如，在某些应用服务器环境中，框架可能是由共享的类加载器加载的，而应用程序类是由专门的类加载器加载的。通过 `BeanClassLoaderAware`，框架类可以确保使用正确的类加载器来加载或访问应用程序类。 -**生命周期管理**：`setBeanClassLoader` 方法会在填充 bean 的普通属性之后但在调用任何初始化回调（如 `InitializingBean#afterPropertiesSet()`）之前被调用。这确保了在 bean 的生命周期的合适阶段提供类加载器信息。 +3. **生命周期管理** + + `setBeanClassLoader` 方法会在填充 bean 的普通属性之后但在调用任何初始化回调（如 `InitializingBean#afterPropertiesSet()`）之前被调用。这确保了在 bean 的生命周期的合适阶段提供类加载器信息。 -### 四、最佳实践 +### 五、最佳实践 首先来看看启动类入口，上下文环境使用`AnnotationConfigApplicationContext`（此类是使用Java注解来配置Spring容器的方式），构造参数我们给定了一个`MyConfiguration`组件类。然后从Spring上下文中获取一个`MyBeanClassLoaderAware`类型的bean，最后调用`loadAndExecute`方法。 @@ -86,7 +83,7 @@ public class MyConfiguration { } ``` -在`MyBeanClassLoaderAware` 类中，我们实现了 `BeanClassLoaderAware` 接口，允许这个 bean 在初始化时获取其 `ClassLoader`。接着，在 `loadAndExecute` 方法中，你使用这个 `ClassLoader` 来动态加载一个名为 `com.xcs.spring.service.UserServiceImpl` 的类并执行它的 `getUserInfo` 方法。 +在`MyBeanClassLoaderAware` 类中，我们实现了 `BeanClassLoaderAware` 接口，允许这个 bean 在初始化时获取其 `ClassLoader`。接着，在 `loadAndExecute` 方法中，我们使用这个 `ClassLoader` 来动态加载一个名为 `com.xcs.spring.service.UserServiceImpl` 的类并执行它的 `getUserInfo` 方法。 ```java public class MyBeanClassLoaderAware implements BeanClassLoaderAware { @@ -133,7 +130,7 @@ public class UserServiceImpl implements UserService { UserInfo = this is user info ``` -### 五、时序图 +### 六、时序图 ~~~mermaid sequenceDiagram @@ -166,7 +163,7 @@ sequenceDiagram ~~~ -### 六、源码分析 +### 七、源码分析 首先来看看启动类入口，上下文环境使用`AnnotationConfigApplicationContext`（此类是使用Java注解来配置Spring容器的方式），构造参数我们给定了一个`MyConfiguration`组件类。然后从Spring上下文中获取一个`MyBeanClassLoaderAware`类型的bean，最后调用`loadAndExecute`方法。 @@ -425,50 +422,70 @@ public class MyBeanClassLoaderAware implements BeanClassLoaderAware { } ``` -### 七、注意事项 +### 八、注意事项 -**避免过度使用**：只有当你真的需要访问类加载器时才使用 `BeanClassLoaderAware`。不要滥用它，因为这可能会导致代码与Spring框架过度耦合。 +1. **避免过度使用** + + 只有当我们真的需要访问类加载器时才使用 `BeanClassLoaderAware`。不要滥用它，因为这可能会导致代码与Spring框架过度耦合。 -**考虑类加载器层次结构**：在Java中，类加载器通常有一个父子关系。如果你不能使用当前的类加载器找到一个类，可能需要检查其父类加载器。 +2. **考虑类加载器层次结构** + + 在Java中，类加载器通常有一个父子关系。如果我们不能使用当前的类加载器找到一个类，可能需要检查其父类加载器。 -**不要在setter中执行复杂的逻辑**：`setBeanClassLoader` 是一个setter方法，应该避免在其中执行复杂的逻辑。它应该只用于设置类加载器。 +3. **不要在setter中执行复杂的逻辑** + + `setBeanClassLoader` 是一个setter方法，应该避免在其中执行复杂的逻辑。它应该只用于设置类加载器。 -**避免存储状态**：尽量不要在实现了`BeanClassLoaderAware`的bean中存储状态或依赖于其他bean的状态。这会使bean的生命周期和初始化更加复杂。 +4. **避免存储状态** + + 尽量不要在实现了`BeanClassLoaderAware`的bean中存储状态或依赖于其他bean的状态。这会使bean的生命周期和初始化更加复杂。 -**考虑使用其他技术**：在某些情况下，可能有其他技术或方法可以达到同样的目的，而无需使用 `BeanClassLoaderAware`。例如，使用Spring的`@Value`注解或`ResourceLoader`来加载资源，而不是直接使用类加载器。 +5. **考虑使用其他技术** + + 在某些情况下，可能有其他技术或方法可以达到同样的目的，而无需使用 `BeanClassLoaderAware`。例如，使用Spring的`@Value`注解或`ResourceLoader`来加载资源，而不是直接使用类加载器。 -**考虑类加载器层次结构**：在Java中，类加载器通常有一个父子关系。如果你不能使用当前的类加载器找到一个类，可能需要检查其父类加载器。 +6. **考虑类加载器层次结构** + + 在Java中，类加载器通常有一个父子关系。如果我们不能使用当前的类加载器找到一个类，可能需要检查其父类加载器。 -**资源管理**：类加载器不仅可以加载类，还可以用来加载其他资源（例如，属性文件）。但是，要小心确保资源路径正确，并记住类加载器的搜索行为可能与文件系统或其他加载机制不同。 +7. **资源管理** + + 类加载器不仅可以加载类，还可以用来加载其他资源（例如，属性文件）。但是，要小心确保资源路径正确，并记住类加载器的搜索行为可能与文件系统或其他加载机制不同。 -### 八、总结 +### 九、总结 -#### 8.1、最佳实践总结 +#### 最佳实践总结 -**启动及上下文配置：**利用 `AnnotationConfigApplicationContext` 初始化Spring容器，使用 `MyConfiguration` 作为配置类来为Spring上下文提供设置。 +1. **启动及上下文配置** + + 利用 `AnnotationConfigApplicationContext` 初始化Spring容器，使用 `MyConfiguration` 作为配置类来为Spring上下文提供设置。 -**配置类定义：**标记配置类为 `@Configuration`，使用 `@Bean` 注解来确保 `MyBeanClassLoaderAware` 被Spring容器管理。 +2. **配置类定义** + + 标记配置类为 `@Configuration`，使用 `@Bean` 注解来确保 `MyBeanClassLoaderAware` 被Spring容器管理。 -**实现 `BeanClassLoaderAware`：**通过实现 `BeanClassLoaderAware` 接口，bean 可以在初始化时获得其加载的 `ClassLoader`，在 `loadAndExecute` 方法中，动态加载并执行特定的服务方法。 +3. **实现 `BeanClassLoaderAware`** + + 通过实现 `BeanClassLoaderAware` 接口，bean 可以在初始化时获得其加载的 `ClassLoader`，在 `loadAndExecute` 方法中，动态加载并执行特定的服务方法。 -**接口与实现：**定义清晰的 `UserService` 接口和相应的 `UserServiceImpl` 实现。 +4. **接口与实现** + + 定义清晰的 `UserService` 接口和相应的 `UserServiceImpl` 实现。 -**结果及结论：**运行程序后，我们能够看到预期输出，这表明成功地将 `MyBeanClassLoaderAware` 与特定实现解耦。 +5. **结果及结论** + + 运行程序后，我们能够看到预期输出，这表明成功地将 `MyBeanClassLoaderAware` 与特定实现解耦。 -#### 8.2、源码分析总结 +#### 源码分析总结 -**应用启动入口**： 通过`AnnotationConfigApplicationContext`，以`MyConfiguration`为配置类，初始化Spring容器。随后获取`MyBeanClassLoaderAware` bean并调用其`loadAndExecute`方法。 +1. **应用启动入口** + + 通过`AnnotationConfigApplicationContext`，以`MyConfiguration`为配置类，初始化Spring容器。随后获取`MyBeanClassLoaderAware` bean并调用其`loadAndExecute`方法。 -**初始化Spring上下文**： 在`AnnotationConfigApplicationContext`构造函数中，`refresh()`方法被调用来刷新或初始化Spring容器。 +2. **初始化Spring上下文** + + 在`AnnotationConfigApplicationContext`构造函数中，`refresh()`方法被调用来刷新或初始化Spring容器。 -**Bean的预实例化**： 在Spring的上下文初始化的`refresh()`方法中，`finishBeanFactoryInitialization(beanFactory)`方法确保所有非延迟加载的单例bean被实例化。 +3. **Bean的预实例化** + + 在Spring的上下文初始化的`refresh()`方法中，`finishBeanFactoryInitialization(beanFactory)`方法确保所有非延迟加载的单例bean被实例化。 -**单例Bean的创建**： `DefaultListableBeanFactory`中的`preInstantiateSingletons`方法负责预先实例化所有非懒加载的单例bean。它会对容器中的每个单例bean调用`getBean`方法。 +4. **单例Bean的创建** + + `DefaultListableBeanFactory`中的`preInstantiateSingletons`方法负责预先实例化所有非懒加载的单例bean。它会对容器中的每个单例bean调用`getBean`方法。 -**Bean的实例化及初始化**： 在获取bean的过程中，如果bean还未创建，`doCreateBean`方法会被调用，完成bean的实例化、属性填充和初始化。 +5. **Bean的实例化及初始化** + + 在获取bean的过程中，如果bean还未创建，`doCreateBean`方法会被调用，完成bean的实例化、属性填充和初始化。 -**处理Aware接口族**： 在bean的初始化阶段，`invokeAwareMethods`方法确保任何实现了`Aware`接口族（如`BeanNameAware`、`BeanClassLoaderAware`等）的bean都会得到适当的回调。 +6. **处理Aware接口族** + + 在bean的初始化阶段，`invokeAwareMethods`方法确保任何实现了`Aware`接口族（如`BeanNameAware`、`BeanClassLoaderAware`等）的bean都会得到适当的回调。 -**BeanClassLoaderAware的实现**： 对于实现了`BeanClassLoaderAware`接口的bean，Spring容器在初始化阶段会通过`setBeanClassLoader`方法设置bean的`ClassLoader`。 +7. **BeanClassLoaderAware的实现** + + 对于实现了`BeanClassLoaderAware`接口的bean，Spring容器在初始化阶段会通过`setBeanClassLoader`方法设置bean的`ClassLoader`。 -**自定义逻辑的执行**： 在`MyBeanClassLoaderAware`中，已经保存了bean的类加载器，然后在`loadAndExecute`方法中，利用这个类加载器动态加载并执行特定的类和方法。 \ No newline at end of file +8. **自定义逻辑的执行** + + 在`MyBeanClassLoaderAware`中，已经保存了bean的类加载器，然后在`loadAndExecute`方法中，利用这个类加载器动态加载并执行特定的类和方法。 \ No newline at end of file