调整项目结构

README.md

@@ -39,52 +39,31 @@
 + IOC容器
   + [关于IOC容器源码分析](spring-core-ioc/README.md)
 + 后置处理器与初始化
-  + [关于BeanFactoryPostProcessor源码分析](spring-interface-beanFactoryPostProcessor/README.md)
+  + [关于BeanFactoryPostProcessor源码分析](spring-interface/spring-interface-beanFactoryPostProcessor/README.md)
-  + [关于BeanDefinitionRegistryPostProcessor源码分析](spring-interface-beanDefinitionRegistryPostProcessor/README.md)
+  + [关于BeanDefinitionRegistryPostProcessor源码分析](spring-interface/spring-interface-beanDefinitionRegistryPostProcessor/README.md)
-  + [关于BeanPostProcessor源码分析](spring-interface-beanPostProcessor/README.md)
+  + [关于BeanPostProcessor源码分析](spring-interface/spring-interface-beanPostProcessor/README.md)
-  + [关于InstantiationAwareBeanPostProcessor源码分析](spring-interface-instantiationAwareBeanPostProcessor/README.md)
+  + [关于InstantiationAwareBeanPostProcessor源码分析](spring-interface/spring-interface-instantiationAwareBeanPostProcessor/README.md)
-  + [关于DestructionAwareBeanPostProcessor源码分析](spring-interface-destructionAwareBeanPostProcessor/README.md)
+  + [关于DestructionAwareBeanPostProcessor源码分析](spring-interface/spring-interface-destructionAwareBeanPostProcessor/README.md)
-  + [关于MergedBeanDefinitionPostProcessor源码分析](spring-interface-mergedBeanDefinitionPostProcessor/README.md)
+  + [关于MergedBeanDefinitionPostProcessor源码分析](spring-interface/spring-interface-mergedBeanDefinitionPostProcessor/README.md)
-  + [关于SmartInstantiationAwareBeanPostProcessor源码分析](spring-interface-smartInstantiationAwareBeanPostProcessor/README.md)
+  + [关于SmartInstantiationAwareBeanPostProcessor源码分析](spring-interface/spring-interface-smartInstantiationAwareBeanPostProcessor/README.md)
-  + [关于InitializingBean源码分析](spring-interface-initializingBean/README.md)
+  + [关于InitializingBean源码分析](spring-interface/spring-interface-initializingBean/README.md)
-  + [关于DisposableBean源码分析](spring-interface-disposableBean/README.md)
+  + [关于DisposableBean源码分析](spring-interface/spring-interface-disposableBean/README.md)
-  + [关于SmartInitializingSingleton源码分析](spring-interface-smartInitializingSingleton/README.md)
+  + [关于SmartInitializingSingleton源码分析](spring-interface/spring-interface-smartInitializingSingleton/README.md)
 + Aware接口
-  + [关于BeanNameAware源码分析](spring-aware-beanNameAware/README.md)
+  + [关于BeanNameAware源码分析](spring-aware/spring-aware-beanNameAware/README.md)
-  + [关于BeanClassLoaderAware源码分析](spring-aware-beanClassLoaderAware/README.md)
+  + [关于BeanClassLoaderAware源码分析](spring-aware/spring-aware-beanClassLoaderAware/README.md)
-  + [关于BeanFactoryAware源码分析](spring-aware-beanFactoryAware/README.md)
+  + [关于BeanFactoryAware源码分析](spring-aware/spring-aware-beanFactoryAware/README.md)
-  + [关于EnvironmentAware源码分析](spring-aware-environmentAware/README.md)
+  + [关于EnvironmentAware源码分析](spring-aware/spring-aware-environmentAware/README.md)
-  + [关于EmbeddedValueResolverAware源码分析](spring-aware-embeddedValueResolverAware/README.md)
+  + [关于EmbeddedValueResolverAware源码分析](spring-aware/spring-aware-embeddedValueResolverAware/README.md)
-  + [关于ResourceLoaderAware源码分析](spring-aware-resourceLoaderAware/README.md)
+  + [关于ResourceLoaderAware源码分析](spring-aware/spring-aware-resourceLoaderAware/README.md)
-  + [关于ApplicationEventPublisherAware源码分析](spring-aware-applicationEventPublisherAware/README.md)
+  + [关于ApplicationEventPublisherAware源码分析](spring-aware/spring-aware-applicationEventPublisherAware/README.md)
-  + [关于MessageSourceAware源码分析](spring-aware-messageSourceAware/README.md)
+  + [关于MessageSourceAware源码分析](spring-aware/spring-aware-messageSourceAware/README.md)
-  + [关于ApplicationStartupAware源码分析](spring-aware-applicationStartupAware/README.md)
+  + [关于ApplicationStartupAware源码分析](spring-aware/spring-aware-applicationStartupAware/README.md)
-  + [关于ApplicationContextAware源码分析](spring-aware-applicationContextAware/README.md)
+  + [关于ApplicationContextAware源码分析](spring-aware/spring-aware-applicationContextAware/README.md)
-  + [关于ImportAware源码分析](spring-aware-importAware/README.md)
+  + [关于ImportAware源码分析](spring-aware/spring-aware-importAware/README.md)
 + 核心注解
-  + [关于@Configuration源码分析](spring-annotation-configuration/README.md)
+  + [关于@Configuration源码分析](spring-annotation/spring-annotation-configuration/README.md)
-  + [关于@ComponentScan源码分析](spring-annotation-componentScan/README.md)
+  + [关于@ComponentScan源码分析](spring-annotation/spring-annotation-componentScan/README.md)
-  + [关于@Bean源码分析](spring-annotation-bean/README.md)
+  + [关于@Bean源码分析](spring-annotation/spring-annotation-bean/README.md)
-  + [关于@Import源码分析](spring-annotation-import/README.md)
+  + [关于@Import源码分析](spring-annotation/spring-annotation-import/README.md)
-  + [关于@PropertySource源码分析](spring-annotation-propertySource/README.md)
+  + [关于@PropertySource源码分析](spring-annotation/spring-annotation-propertySource/README.md)
-+ Bean工厂
-  + 关于BeanFactory源码分析
-  + 关于HierarchicalBeanFactory源码分析
-  + 关于ListableBeanFactory源码分析
-  + 关于AutowireCapableBeanFactory源码分析
-  + 关于ConfigurableBeanFactory源码分析
-  + 关于SingletonBeanRegistry源码分析
-  + 关于BeanDefinition源码分析
-  + 关于BeanDefinitionRegistry源码分析
-  + 关于FactoryBean源码分析
-+ 应用上下文
-  - 关于ApplicationContext源码分析
-  - 关于ConfigurableApplicationContext源码分析
-  - 关于WebApplicationContext源码分析
-  - 关于ApplicationEventPublisher源码分析
-  - 关于ApplicationListener源码分析
-+ 环境变量
-  - 关于Environment源码分析
-  - 关于PropertyResolver源码分析
-  - 关于PropertySources源码分析
-  - 关于Profile源码分析

pom.xml

@@ -18,40 +18,10 @@
     </properties>
 
     <modules>
-        <module>spring-annotation-configuration</module>
-        <module>spring-annotation-bean</module>
-        <module>spring-annotation-import</module>
-        <module>spring-annotation-propertySource</module>
-        <module>spring-annotation-componentScan</module>
-        <module>spring-interface-beanFactoryPostProcessor</module>
-        <module>spring-interface-beanPostProcessor</module>
-        <module>spring-interface-environment</module>
-        <module>spring-interface-applicationListener</module>
-        <module>spring-interface-importSelector</module>
-        <module>spring-interface-importBeanDefinitionRegistrar</module>
-        <module>spring-interface-resource</module>
-        <module>spring-interface-embeddedValueResolver</module>
-        <module>spring-interface-factoryBean</module>
-        <module>spring-interface-beanDefinitionRegistryPostProcessor</module>
-        <module>spring-interface-instantiationAwareBeanPostProcessor</module>
-        <module>spring-interface-destructionAwareBeanPostProcessor</module>
-        <module>spring-interface-mergedBeanDefinitionPostProcessor</module>
-        <module>spring-interface-smartInstantiationAwareBeanPostProcessor</module>
-        <module>spring-interface-initializingBean</module>
-        <module>spring-interface-disposableBean</module>
         <module>spring-core-ioc</module>
-        <module>spring-interface-smartInitializingSingleton</module>
+        <module>spring-annotation</module>
-        <module>spring-aware-beanNameAware</module>
+        <module>spring-aware</module>
-        <module>spring-aware-beanFactoryAware</module>
+        <module>spring-interface</module>
-        <module>spring-aware-beanClassLoaderAware</module>
-        <module>spring-aware-applicationContextAware</module>
-        <module>spring-aware-applicationEventPublisherAware</module>
-        <module>spring-aware-environmentAware</module>
-        <module>spring-aware-resourceLoaderAware</module>
-        <module>spring-aware-embeddedValueResolverAware</module>
-        <module>spring-aware-messageSourceAware</module>
-        <module>spring-aware-applicationStartupAware</module>
-        <module>spring-aware-importAware</module>
     </modules>
 
     <dependencies>

spring-annotation/pom.xml

@@ -7,13 +7,17 @@
         <groupId>com.xcs.spring</groupId>
         <version>0.0.1-SNAPSHOT</version>
     </parent>
+
     <modelVersion>4.0.0</modelVersion>
+    <artifactId>spring-annotation</artifactId>
+    <packaging>pom</packaging>
 
-    <artifactId>spring-aware-beanClassLoaderAware</artifactId>
+    <modules>
-
+        <module>spring-annotation-configuration</module>
-    <properties>
+        <module>spring-annotation-bean</module>
-        <maven.compiler.source>11</maven.compiler.source>
+        <module>spring-annotation-import</module>
-        <maven.compiler.target>11</maven.compiler.target>
+        <module>spring-annotation-propertySource</module>
-    </properties>
+        <module>spring-annotation-componentScan</module>
+    </modules>
 
 </project>

spring-annotation/spring-annotation-bean/README.md

@@ -25,7 +25,7 @@
 
 ### 一、前置条件
 
-+ [关于BeanDefinitionRegistryPostProcessor源码分析](../spring-interface-beanDefinitionRegistryPostProcessor/README.md)
++ [关于BeanDefinitionRegistryPostProcessor源码分析](../../spring-interface/spring-interface-beanDefinitionRegistryPostProcessor/README.md)
 
 ### 二、注解描述
 

spring-annotation/spring-annotation-bean/pom.xml

@@ -3,7 +3,7 @@
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <parent>
-        <artifactId>spring-reading</artifactId>
+        <artifactId>spring-annotation</artifactId>
         <groupId>com.xcs.spring</groupId>
         <version>0.0.1-SNAPSHOT</version>
     </parent>

spring-annotation/spring-annotation-bean/src/main/java/com/xcs/spring/config/MyConfiguration.java

@@ -2,7 +2,6 @@ package com.xcs.spring.config;
 
 import com.xcs.spring.bean.MyBean;
 import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.ComponentScan;
 import org.springframework.context.annotation.Configuration;
 
 /**

spring-annotation/spring-annotation-componentScan/pom.xml

@@ -3,7 +3,7 @@
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <parent>
-        <artifactId>spring-reading</artifactId>
+        <artifactId>spring-annotation</artifactId>
         <groupId>com.xcs.spring</groupId>
         <version>0.0.1-SNAPSHOT</version>
     </parent>

spring-annotation/spring-annotation-configuration/pom.xml

@@ -3,7 +3,7 @@
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <parent>
-        <artifactId>spring-reading</artifactId>
+        <artifactId>spring-annotation</artifactId>
         <groupId>com.xcs.spring</groupId>
         <version>0.0.1-SNAPSHOT</version>
     </parent>

spring-annotation/spring-annotation-import/pom.xml

@@ -3,7 +3,7 @@
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <parent>
-        <artifactId>spring-reading</artifactId>
+        <artifactId>spring-annotation</artifactId>
         <groupId>com.xcs.spring</groupId>
         <version>0.0.1-SNAPSHOT</version>
     </parent>

spring-annotation/spring-annotation-propertySource/pom.xml

@@ -3,7 +3,7 @@
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <parent>
-        <artifactId>spring-reading</artifactId>
+        <artifactId>spring-annotation</artifactId>
         <groupId>com.xcs.spring</groupId>
         <version>0.0.1-SNAPSHOT</version>
     </parent>

spring-aware-beanFactoryAware/pom.xml

@@ -1,19 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0"
-         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-    <parent>
-        <artifactId>spring-reading</artifactId>
-        <groupId>com.xcs.spring</groupId>
-        <version>0.0.1-SNAPSHOT</version>
-    </parent>
-    <modelVersion>4.0.0</modelVersion>
-
-    <artifactId>spring-aware-beanFactoryAware</artifactId>
-
-    <properties>
-        <maven.compiler.source>11</maven.compiler.source>
-        <maven.compiler.target>11</maven.compiler.target>
-    </properties>
-
-</project>

spring-aware-beanNameAware/pom.xml

@@ -1,19 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0"
-         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-    <parent>
-        <artifactId>spring-reading</artifactId>
-        <groupId>com.xcs.spring</groupId>
-        <version>0.0.1-SNAPSHOT</version>
-    </parent>
-    <modelVersion>4.0.0</modelVersion>
-
-    <artifactId>spring-aware-beanNameAware</artifactId>
-
-    <properties>
-        <maven.compiler.source>11</maven.compiler.source>
-        <maven.compiler.target>11</maven.compiler.target>
-    </properties>
-
-</project>

spring-aware-resourceLoaderAware/pom.xml

@@ -1,19 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0"
-         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-    <parent>
-        <artifactId>spring-reading</artifactId>
-        <groupId>com.xcs.spring</groupId>
-        <version>0.0.1-SNAPSHOT</version>
-    </parent>
-    <modelVersion>4.0.0</modelVersion>
-
-    <artifactId>spring-aware-resourceLoaderAware</artifactId>
-
-    <properties>
-        <maven.compiler.source>11</maven.compiler.source>
-        <maven.compiler.target>11</maven.compiler.target>
-    </properties>
-
-</project>

spring-aware/pom.xml

@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <parent>
+        <artifactId>spring-reading</artifactId>
+        <groupId>com.xcs.spring</groupId>
+        <version>0.0.1-SNAPSHOT</version>
+    </parent>
+
+    <modelVersion>4.0.0</modelVersion>
+    <artifactId>spring-aware</artifactId>
+    <packaging>pom</packaging>
+
+    <modules>
+        <module>spring-aware-beanNameAware</module>
+        <module>spring-aware-beanFactoryAware</module>
+        <module>spring-aware-beanClassLoaderAware</module>
+        <module>spring-aware-applicationContextAware</module>
+        <module>spring-aware-applicationEventPublisherAware</module>
+        <module>spring-aware-environmentAware</module>
+        <module>spring-aware-resourceLoaderAware</module>
+        <module>spring-aware-embeddedValueResolverAware</module>
+        <module>spring-aware-messageSourceAware</module>
+        <module>spring-aware-applicationStartupAware</module>
+        <module>spring-aware-importAware</module>
+    </modules>
+
+</project>

spring-aware/spring-aware-applicationContextAware/pom.xml

@@ -3,7 +3,7 @@
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <parent>
-        <artifactId>spring-reading</artifactId>
+        <artifactId>spring-aware</artifactId>
         <groupId>com.xcs.spring</groupId>
         <version>0.0.1-SNAPSHOT</version>
     </parent>

spring-aware/spring-aware-applicationContextAware/src/main/java/com/xcs/spring/config/MyApplicationContextAware.java

@@ -1,20 +1,20 @@
-package com.xcs.spring.config;
+package com.xcs.spring.config;
-
+
-import com.xcs.spring.event.MyEvent;
+import com.xcs.spring.event.MyEvent;
-import org.springframework.beans.BeansException;
+import org.springframework.beans.BeansException;
-import org.springframework.context.ApplicationContext;
+import org.springframework.context.ApplicationContext;
-import org.springframework.context.ApplicationContextAware;
+import org.springframework.context.ApplicationContextAware;
-
+
-public class MyApplicationContextAware implements ApplicationContextAware {
+public class MyApplicationContextAware implements ApplicationContextAware {
-
+
-    private ApplicationContext context;
+    private ApplicationContext context;
-
+
-    @Override
+    @Override
-    public void setApplicationContext(ApplicationContext context) throws BeansException {
+    public void setApplicationContext(ApplicationContext context) throws BeansException {
-        this.context = context;
+        this.context = context;
-    }
+    }
-
+
-    public void publish(String message) {
+    public void publish(String message) {
-        context.publishEvent(new MyEvent(this, message));
+        context.publishEvent(new MyEvent(this, message));
-    }
+    }
-}
+}

spring-aware/spring-aware-applicationContextAware/src/main/java/com/xcs/spring/event/MyEvent.java

@@ -1,17 +1,17 @@
-package com.xcs.spring.event;
+package com.xcs.spring.event;
-
+
-import org.springframework.context.ApplicationEvent;
+import org.springframework.context.ApplicationEvent;
-
+
-public class MyEvent extends ApplicationEvent {
+public class MyEvent extends ApplicationEvent {
-
+
-    private final String message;
+    private final String message;
-
+
-    public MyEvent(Object source, String message) {
+    public MyEvent(Object source, String message) {
-        super(source);
+        super(source);
-        this.message = message;
+        this.message = message;
-    }
+    }
-
+
-    public String getMessage() {
+    public String getMessage() {
-        return message;
+        return message;
-    }
+    }
 }

spring-aware/spring-aware-applicationContextAware/src/main/java/com/xcs/spring/event/MyEventListener.java

@@ -1,11 +1,11 @@
-package com.xcs.spring.event;
+package com.xcs.spring.event;
-
+
-import org.springframework.context.ApplicationListener;
+import org.springframework.context.ApplicationListener;
-
+
-public class MyEventListener implements ApplicationListener<MyEvent> {
+public class MyEventListener implements ApplicationListener<MyEvent> {
-
+
-    @Override
+    @Override
-    public void onApplicationEvent(MyEvent event) {
+    public void onApplicationEvent(MyEvent event) {
-        System.out.println("Received my event - " + event.getMessage());
+        System.out.println("Received my event - " + event.getMessage());
-    }
+    }
 }

spring-aware/spring-aware-applicationEventPublisherAware/pom.xml

@@ -3,7 +3,7 @@
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <parent>
-        <artifactId>spring-reading</artifactId>
+        <artifactId>spring-aware</artifactId>
         <groupId>com.xcs.spring</groupId>
         <version>0.0.1-SNAPSHOT</version>
     </parent>

spring-aware/spring-aware-applicationEventPublisherAware/src/main/java/com/xcs/spring/config/MyApplicationEventPublisherAware.java

@@ -1,19 +1,19 @@
-package com.xcs.spring.config;
+package com.xcs.spring.config;
-
+
-import com.xcs.spring.event.MyEvent;
+import com.xcs.spring.event.MyEvent;
-import org.springframework.context.ApplicationEventPublisher;
+import org.springframework.context.ApplicationEventPublisher;
-import org.springframework.context.ApplicationEventPublisherAware;
+import org.springframework.context.ApplicationEventPublisherAware;
-
+
-public class MyApplicationEventPublisherAware implements ApplicationEventPublisherAware {
+public class MyApplicationEventPublisherAware implements ApplicationEventPublisherAware {
-
+
-    private ApplicationEventPublisher publisher;
+    private ApplicationEventPublisher publisher;
-
+
-    @Override
+    @Override
-    public void setApplicationEventPublisher(ApplicationEventPublisher publisher) {
+    public void setApplicationEventPublisher(ApplicationEventPublisher publisher) {
-        this.publisher = publisher;
+        this.publisher = publisher;
-    }
+    }
-
+
-    public void publish(String message) {
+    public void publish(String message) {
-        publisher.publishEvent(new MyEvent(this, message));
+        publisher.publishEvent(new MyEvent(this, message));
-    }
+    }
-}
+}

spring-aware/spring-aware-applicationEventPublisherAware/src/main/java/com/xcs/spring/event/MyEvent.java

@@ -1,17 +1,17 @@
-package com.xcs.spring.event;
+package com.xcs.spring.event;
-
+
-import org.springframework.context.ApplicationEvent;
+import org.springframework.context.ApplicationEvent;
-
+
-public class MyEvent extends ApplicationEvent {
+public class MyEvent extends ApplicationEvent {
-
+
-    private final String message;
+    private final String message;
-
+
-    public MyEvent(Object source, String message) {
+    public MyEvent(Object source, String message) {
-        super(source);
+        super(source);
-        this.message = message;
+        this.message = message;
-    }
+    }
-
+
-    public String getMessage() {
+    public String getMessage() {
-        return message;
+        return message;
-    }
+    }
 }

spring-aware/spring-aware-applicationEventPublisherAware/src/main/java/com/xcs/spring/event/MyEventListener.java

@@ -1,11 +1,11 @@
-package com.xcs.spring.event;
+package com.xcs.spring.event;
-
+
-import org.springframework.context.ApplicationListener;
+import org.springframework.context.ApplicationListener;
-
+
-public class MyEventListener implements ApplicationListener<MyEvent> {
+public class MyEventListener implements ApplicationListener<MyEvent> {
-
+
-    @Override
+    @Override
-    public void onApplicationEvent(MyEvent event) {
+    public void onApplicationEvent(MyEvent event) {
-        System.out.println("Received my event - " + event.getMessage());
+        System.out.println("Received my event - " + event.getMessage());
-    }
+    }
 }

spring-aware/spring-aware-applicationStartupAware/README.md

@@ -1,480 +1,480 @@
-## ApplicationStartupAware
+## ApplicationStartupAware
-
+
-- [ApplicationStartupAware](#applicationstartupaware)
+- [ApplicationStartupAware](#applicationstartupaware)
-  - [一、接口描述](#一接口描述)
+  - [一、接口描述](#一接口描述)
-  - [二、接口源码](#二接口源码)
+  - [二、接口源码](#二接口源码)
-  - [三、主要功能](#三主要功能)
+  - [三、主要功能](#三主要功能)
-  - [四、最佳实践](#四最佳实践)
+  - [四、最佳实践](#四最佳实践)
-  - [五、时序图](#五时序图)
+  - [五、时序图](#五时序图)
-  - [六、源码分析](#六源码分析)
+  - [六、源码分析](#六源码分析)
-  - [七、注意事项](#七注意事项)
+  - [七、注意事项](#七注意事项)
-  - [八、总结](#八总结)
+  - [八、总结](#八总结)
-    - [8.1、最佳实践总结](#81最佳实践总结)
+    - [8.1、最佳实践总结](#81最佳实践总结)
-    - [8.2、源码分析总结](#82源码分析总结)
+    - [8.2、源码分析总结](#82源码分析总结)
-
+
-### 一、接口描述
+### 一、接口描述
-
+
-`ApplicationStartup`接口，是为了提供对这一过程的细粒度跟踪。通过`StartupStep`，我们可以定义应用启动过程中的各个步骤，并收集关于它们的性能和上下文信息。
+`ApplicationStartup`接口，是为了提供对这一过程的细粒度跟踪。通过`StartupStep`，我们可以定义应用启动过程中的各个步骤，并收集关于它们的性能和上下文信息。
-
+
-### 二、接口源码
+### 二、接口源码
-
+
-`ApplicationStartupAware` 是 Spring 框架自 5.3 开始引入的一个核心接口。实现`ApplicationStartupAware`接口的对象会在Spring容器中被自动注入一个`ApplicationStartup`实例。
+`ApplicationStartupAware` 是 Spring 框架自 5.3 开始引入的一个核心接口。实现`ApplicationStartupAware`接口的对象会在Spring容器中被自动注入一个`ApplicationStartup`实例。
-
+
-```java
+```java
-/**
+/**
- * 任何希望在运行时被通知其关联的ApplicationStartup实例的对象都应实现此接口。
+ * 任何希望在运行时被通知其关联的ApplicationStartup实例的对象都应实现此接口。
- * 在更简单的术语中，这是一个使bean意识到应用启动跟踪机制的接口。
+ * 在更简单的术语中，这是一个使bean意识到应用启动跟踪机制的接口。
- * 
+ * 
- * @author Brian Clozel
+ * @author Brian Clozel
- * @since 5.3
+ * @since 5.3
- * @see ApplicationContextAware
+ * @see ApplicationContextAware
- */
+ */
-public interface ApplicationStartupAware extends Aware {
+public interface ApplicationStartupAware extends Aware {
-
+
-    /**
+    /**
-     * 设置此对象运行时的ApplicationStartup。
+     * 设置此对象运行时的ApplicationStartup。
-     * 此方法的调用时机为正常bean属性填充之后，但在任何初始化回调（例如InitializingBean的afterPropertiesSet或自定义的初始化方法）之前。
+     * 此方法的调用时机为正常bean属性填充之后，但在任何初始化回调（例如InitializingBean的afterPropertiesSet或自定义的初始化方法）之前。
-     * 并且在ApplicationContextAware的setApplicationContext之前调用。
+     * 并且在ApplicationContextAware的setApplicationContext之前调用。
-     * 
+     * 
-     * @param applicationStartup 由此对象使用的application startup实例
+     * @param applicationStartup 由此对象使用的application startup实例
-     */
+     */
-    void setApplicationStartup(ApplicationStartup applicationStartup);
+    void setApplicationStartup(ApplicationStartup applicationStartup);
-}
+}
-```
+```
-
+
-### 三、主要功能
+### 三、主要功能
-
+
-**启动性能跟踪**：通过提供对`ApplicationStartup`的访问，实现此接口的beans可以使用`StartupStep`API来跟踪它们在启动过程中的各个步骤。这对于检测和优化启动性能非常有用。
+**启动性能跟踪**：通过提供对`ApplicationStartup`的访问，实现此接口的beans可以使用`StartupStep`API来跟踪它们在启动过程中的各个步骤。这对于检测和优化启动性能非常有用。
-
+
-**为beans提供跟踪能力**：而不仅仅是Spring框架内部使用。这意味着开发者可以为他们的自定义beans或组件提供与Spring框架同样的启动跟踪能力。
+**为beans提供跟踪能力**：而不仅仅是Spring框架内部使用。这意味着开发者可以为他们的自定义beans或组件提供与Spring框架同样的启动跟踪能力。
-
+
-**细粒度控制**：与`StartupStep`一起使用，`ApplicationStartupAware`允许beans对其启动过程中的特定部分进行跟踪，例如数据库初始化、外部服务连接或任何其他可能需要时间的操作。
+**细粒度控制**：与`StartupStep`一起使用，`ApplicationStartupAware`允许beans对其启动过程中的特定部分进行跟踪，例如数据库初始化、外部服务连接或任何其他可能需要时间的操作。
-
+
-### 四、最佳实践
+### 四、最佳实践
-
+
-首先来看看启动类入口，上下文环境使用`AnnotationConfigApplicationContext`（此类是使用Java注解来配置Spring容器的方式），首先设置了`BufferingApplicationStartup`，这是Spring Boot提供的一个`ApplicationStartup`实现，缓存了最后的100个启动步骤。这使得我们可以在应用启动后查看并分析这些步骤，以便了解哪些操作可能会影响启动性能，然后使用`register`方法，我们告诉Spring上下文加载`MyConfiguration`类，最后调用`refresh`方法会触发应用上下文的初始化，包括bean的创建和依赖注入。
+首先来看看启动类入口，上下文环境使用`AnnotationConfigApplicationContext`（此类是使用Java注解来配置Spring容器的方式），首先设置了`BufferingApplicationStartup`，这是Spring Boot提供的一个`ApplicationStartup`实现，缓存了最后的100个启动步骤。这使得我们可以在应用启动后查看并分析这些步骤，以便了解哪些操作可能会影响启动性能，然后使用`register`方法，我们告诉Spring上下文加载`MyConfiguration`类，最后调用`refresh`方法会触发应用上下文的初始化，包括bean的创建和依赖注入。
-
+
-```java
+```java
-public class ApplicationStartupAwareApplication {
+public class ApplicationStartupAwareApplication {
-
+
-    public static void main(String[] args) {
+    public static void main(String[] args) {
-        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
+        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
-        context.setApplicationStartup(new BufferingApplicationStartup(100));
+        context.setApplicationStartup(new BufferingApplicationStartup(100));
-        context.register(MyConfiguration.class);
+        context.register(MyConfiguration.class);
-        context.refresh();
+        context.refresh();
-        context.close();
+        context.close();
-    }
+    }
-}
+}
-```
+```
-
+
-这里使用`@Bean`注解，定义了一个Bean，是为了确保 `MyApplicationStartupAware` 被 Spring 容器执行。
+这里使用`@Bean`注解，定义了一个Bean，是为了确保 `MyApplicationStartupAware` 被 Spring 容器执行。
-
+
-```java
+```java
-@Configuration
+@Configuration
-public class MyConfiguration {
+public class MyConfiguration {
-
+
-    @Bean
+    @Bean
-    public MyApplicationStartupAware myApplicationStartupAware(){
+    public MyApplicationStartupAware myApplicationStartupAware(){
-        return new MyApplicationStartupAware();
+        return new MyApplicationStartupAware();
-    }
+    }
-}
+}
-```
+```
-
+
-`MyApplicationStartupAware`类的主要目的是展示如何使用`ApplicationStartup`来跟踪Spring应用程序启动过程中的特定逻辑。这对于我们程序来说是有用的，因为我们可以看到哪些启动步骤是最消耗时间的，然后据此进行优化。在这个具体的实现中，仅仅模拟了两个步骤，但在实际应用中，可以跟踪任意数量和类型的步骤。
+`MyApplicationStartupAware`类的主要目的是展示如何使用`ApplicationStartup`来跟踪Spring应用程序启动过程中的特定逻辑。这对于我们程序来说是有用的，因为我们可以看到哪些启动步骤是最消耗时间的，然后据此进行优化。在这个具体的实现中，仅仅模拟了两个步骤，但在实际应用中，可以跟踪任意数量和类型的步骤。
-
+
-```java
+```java
-public class MyApplicationStartupAware implements ApplicationStartupAware, InitializingBean {
+public class MyApplicationStartupAware implements ApplicationStartupAware, InitializingBean {
-
+
-    private ApplicationStartup applicationStartup;
+    private ApplicationStartup applicationStartup;
-
+
-    @Override
+    @Override
-    public void setApplicationStartup(ApplicationStartup applicationStartup) {
+    public void setApplicationStartup(ApplicationStartup applicationStartup) {
-        this.applicationStartup = applicationStartup;
+        this.applicationStartup = applicationStartup;
-    }
+    }
-
+
-    @Override
+    @Override
-    public void afterPropertiesSet() throws Exception {
+    public void afterPropertiesSet() throws Exception {
-        StartupStep step1 = applicationStartup.start("MyApplicationStartupAware Logic Step 1");
+        StartupStep step1 = applicationStartup.start("MyApplicationStartupAware Logic Step 1");
-        // 自定义逻辑
+        // 自定义逻辑
-        Thread.sleep(200);
+        Thread.sleep(200);
-        step1.tag("status", "done").end();
+        step1.tag("status", "done").end();
-
+
-        StartupStep step2 = applicationStartup.start("MyApplicationStartupAware Logic Step 2");
+        StartupStep step2 = applicationStartup.start("MyApplicationStartupAware Logic Step 2");
-        // 自定义逻辑
+        // 自定义逻辑
-        Thread.sleep(300);
+        Thread.sleep(300);
-        step2.tag("status", "done").end();
+        step2.tag("status", "done").end();
-    }
+    }
-}
+}
-```
+```
-
+
-### 五、时序图
+### 五、时序图
-
+
-~~~mermaid
+~~~mermaid
-sequenceDiagram
+sequenceDiagram
-    Title: ApplicationStartupAware时序图
+    Title: ApplicationStartupAware时序图
-    participant ApplicationStartupAwareApplication
+    participant ApplicationStartupAwareApplication
-    participant AnnotationConfigApplicationContext
+    participant AnnotationConfigApplicationContext
-    participant AbstractApplicationContext
+    participant AbstractApplicationContext
-    participant DefaultListableBeanFactory
+    participant DefaultListableBeanFactory
-    participant AbstractBeanFactory
+    participant AbstractBeanFactory
-    participant DefaultSingletonBeanRegistry
+    participant DefaultSingletonBeanRegistry
-    participant AbstractAutowireCapableBeanFactory
+    participant AbstractAutowireCapableBeanFactory
-    participant ApplicationContextAwareProcessor
+    participant ApplicationContextAwareProcessor
-    participant MyApplicationStartupAware
+    participant MyApplicationStartupAware
-    
+    
-    ApplicationStartupAwareApplication->>AnnotationConfigApplicationContext:AnnotationConfigApplicationContext(componentClasses)<br>创建上下文
+    ApplicationStartupAwareApplication->>AnnotationConfigApplicationContext:AnnotationConfigApplicationContext(componentClasses)<br>创建上下文
-    AnnotationConfigApplicationContext->>AbstractApplicationContext:refresh()<br>刷新上下文
+    AnnotationConfigApplicationContext->>AbstractApplicationContext:refresh()<br>刷新上下文
-    AbstractApplicationContext->>AbstractApplicationContext:finishBeanFactoryInitialization(beanFactory)<br>初始化Bean工厂
+    AbstractApplicationContext->>AbstractApplicationContext:finishBeanFactoryInitialization(beanFactory)<br>初始化Bean工厂
-    AbstractApplicationContext->>DefaultListableBeanFactory:preInstantiateSingletons()<br>实例化单例
+    AbstractApplicationContext->>DefaultListableBeanFactory:preInstantiateSingletons()<br>实例化单例
-    DefaultListableBeanFactory->>AbstractBeanFactory:getBean(name)<br>获取Bean
+    DefaultListableBeanFactory->>AbstractBeanFactory:getBean(name)<br>获取Bean
-    AbstractBeanFactory->>AbstractBeanFactory:doGetBean(name,requiredType,args,typeCheckOnly)<br>执行获取Bean
+    AbstractBeanFactory->>AbstractBeanFactory:doGetBean(name,requiredType,args,typeCheckOnly)<br>执行获取Bean
-    AbstractBeanFactory->>DefaultSingletonBeanRegistry:getSingleton(beanName,singletonFactory)<br>获取单例Bean
+    AbstractBeanFactory->>DefaultSingletonBeanRegistry:getSingleton(beanName,singletonFactory)<br>获取单例Bean
-    DefaultSingletonBeanRegistry-->>AbstractBeanFactory:getObject()<br>获取Bean实例
+    DefaultSingletonBeanRegistry-->>AbstractBeanFactory:getObject()<br>获取Bean实例
-    AbstractBeanFactory->>AbstractAutowireCapableBeanFactory:createBean(beanName,mbd,args)<br>创建Bean
+    AbstractBeanFactory->>AbstractAutowireCapableBeanFactory:createBean(beanName,mbd,args)<br>创建Bean
-    AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:doCreateBean(beanName,mbd,args)<br>执行Bean创建
+    AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:doCreateBean(beanName,mbd,args)<br>执行Bean创建
-    AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:initializeBean(beanName,bean,mbd)<br>负责bean的初始化
+    AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:initializeBean(beanName,bean,mbd)<br>负责bean的初始化
-	AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:applyBeanPostProcessorsBeforeInitialization(existingBean, beanName)<br>调用前置处理器
+	AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:applyBeanPostProcessorsBeforeInitialization(existingBean, beanName)<br>调用前置处理器
-    AbstractAutowireCapableBeanFactory->>ApplicationContextAwareProcessor:postProcessBeforeInitialization(bean,beanName)<br>触发Aware处理
+    AbstractAutowireCapableBeanFactory->>ApplicationContextAwareProcessor:postProcessBeforeInitialization(bean,beanName)<br>触发Aware处理
-    ApplicationContextAwareProcessor->>ApplicationContextAwareProcessor:invokeAwareInterfaces(bean)<br>执行Aware回调
+    ApplicationContextAwareProcessor->>ApplicationContextAwareProcessor:invokeAwareInterfaces(bean)<br>执行Aware回调
-    ApplicationContextAwareProcessor->>MyApplicationStartupAware:setApplicationStartup(applicationStartup)<br>设置运行环境
+    ApplicationContextAwareProcessor->>MyApplicationStartupAware:setApplicationStartup(applicationStartup)<br>设置运行环境
-    AbstractAutowireCapableBeanFactory-->>AbstractBeanFactory:返回Bean对象
+    AbstractAutowireCapableBeanFactory-->>AbstractBeanFactory:返回Bean对象
-    AbstractBeanFactory-->>DefaultListableBeanFactory:返回Bean对象
+    AbstractBeanFactory-->>DefaultListableBeanFactory:返回Bean对象
-    AnnotationConfigApplicationContext-->>ApplicationStartupAwareApplication:初始化完成
+    AnnotationConfigApplicationContext-->>ApplicationStartupAwareApplication:初始化完成
-~~~
+~~~
-
+
-### 六、源码分析
+### 六、源码分析
-
+
-首先来看看启动类入口，上下文环境使用`AnnotationConfigApplicationContext`（此类是使用Java注解来配置Spring容器的方式），首先设置了`BufferingApplicationStartup`，这是Spring Boot提供的一个`ApplicationStartup`实现，缓存了最后的100个启动步骤。这使得我们可以在应用启动后查看并分析这些步骤，以便了解哪些操作可能会影响启动性能，然后使用`register`方法，我们告诉Spring上下文加载`MyConfiguration`类，最后调用`refresh`方法会触发应用上下文的初始化，包括bean的创建和依赖注入。
+首先来看看启动类入口，上下文环境使用`AnnotationConfigApplicationContext`（此类是使用Java注解来配置Spring容器的方式），首先设置了`BufferingApplicationStartup`，这是Spring Boot提供的一个`ApplicationStartup`实现，缓存了最后的100个启动步骤。这使得我们可以在应用启动后查看并分析这些步骤，以便了解哪些操作可能会影响启动性能，然后使用`register`方法，我们告诉Spring上下文加载`MyConfiguration`类，最后调用`refresh`方法会触发应用上下文的初始化，包括bean的创建和依赖注入。
-
+
-```java
+```java
-public class ApplicationStartupAwareApplication {
+public class ApplicationStartupAwareApplication {
-
+
-    public static void main(String[] args) {
+    public static void main(String[] args) {
-        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
+        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
-        context.setApplicationStartup(new BufferingApplicationStartup(100));
+        context.setApplicationStartup(new BufferingApplicationStartup(100));
-        context.register(MyConfiguration.class);
+        context.register(MyConfiguration.class);
-        context.refresh();
+        context.refresh();
-        context.close();
+        context.close();
-    }
+    }
-}
+}
-```
+```
-
+
-在`org.springframework.context.annotation.AnnotationConfigApplicationContext#AnnotationConfigApplicationContext`构造函数中，执行了三个步骤，我们重点关注`refresh()`方法
+在`org.springframework.context.annotation.AnnotationConfigApplicationContext#AnnotationConfigApplicationContext`构造函数中，执行了三个步骤，我们重点关注`refresh()`方法
-
+
-```java
+```java
-public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
+public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
-    this();
+    this();
-    register(componentClasses);
+    register(componentClasses);
-    refresh();
+    refresh();
-```
+```
-
+
-在`org.springframework.context.support.AbstractApplicationContext#refresh`方法中我们重点关注一下`finishBeanFactoryInitialization(beanFactory)`这方法会对实例化所有剩余非懒加载的单列Bean对象，其他方法不是本次源码阅读的重点暂时忽略。
+在`org.springframework.context.support.AbstractApplicationContext#refresh`方法中我们重点关注一下`finishBeanFactoryInitialization(beanFactory)`这方法会对实例化所有剩余非懒加载的单列Bean对象，其他方法不是本次源码阅读的重点暂时忽略。
-
+
-```java
+```java
-@Override
+@Override
-public void refresh() throws BeansException, IllegalStateException {
+public void refresh() throws BeansException, IllegalStateException {
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-    // Instantiate all remaining (non-lazy-init) singletons.
+    // Instantiate all remaining (non-lazy-init) singletons.
-    finishBeanFactoryInitialization(beanFactory);
+    finishBeanFactoryInitialization(beanFactory);
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-}
+}
-```
+```
-
+
-在`org.springframework.context.support.AbstractApplicationContext#finishBeanFactoryInitialization`方法中，会继续调用`DefaultListableBeanFactory`类中的`preInstantiateSingletons`方法来完成所有剩余非懒加载的单列Bean对象。
+在`org.springframework.context.support.AbstractApplicationContext#finishBeanFactoryInitialization`方法中，会继续调用`DefaultListableBeanFactory`类中的`preInstantiateSingletons`方法来完成所有剩余非懒加载的单列Bean对象。
-
+
-```java
+```java
-/**
+/**
- * 完成此工厂的bean初始化，实例化所有剩余的非延迟初始化单例bean。
+ * 完成此工厂的bean初始化，实例化所有剩余的非延迟初始化单例bean。
- * 
+ * 
- * @param beanFactory 要初始化的bean工厂
+ * @param beanFactory 要初始化的bean工厂
- */
+ */
-protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
+protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-    // 完成所有剩余非懒加载的单列Bean对象。
+    // 完成所有剩余非懒加载的单列Bean对象。
-    beanFactory.preInstantiateSingletons();
+    beanFactory.preInstantiateSingletons();
-}
+}
-```
+```
-
+
-在`org.springframework.beans.factory.support.DefaultListableBeanFactory#preInstantiateSingletons`方法中，主要的核心目的是预先实例化所有非懒加载的单例bean。在Spring的上下文初始化完成后，该方法会被触发，以确保所有单例bean都被正确地创建并初始化。其中`getBean(beanName)`是此方法的核心操作。对于容器中定义的每一个单例bean，它都会调用`getBean`方法，这将触发bean的实例化、初始化及其依赖的注入。如果bean之前没有被创建过，那么这个调用会导致其被实例化和初始化。
+在`org.springframework.beans.factory.support.DefaultListableBeanFactory#preInstantiateSingletons`方法中，主要的核心目的是预先实例化所有非懒加载的单例bean。在Spring的上下文初始化完成后，该方法会被触发，以确保所有单例bean都被正确地创建并初始化。其中`getBean(beanName)`是此方法的核心操作。对于容器中定义的每一个单例bean，它都会调用`getBean`方法，这将触发bean的实例化、初始化及其依赖的注入。如果bean之前没有被创建过，那么这个调用会导致其被实例化和初始化。
-
+
-```java
+```java
-public void preInstantiateSingletons() throws BeansException {
+public void preInstantiateSingletons() throws BeansException {
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-    // 循环遍历所有bean的名称
+    // 循环遍历所有bean的名称
-    for (String beanName : beanNames) {
+    for (String beanName : beanNames) {
-        getBean(beanName);
+        getBean(beanName);
-    }
+    }
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-}
+}
-```
+```
-
+
-在`org.springframework.beans.factory.support.AbstractBeanFactory#getBean()`方法中，又调用了`doGetBean`方法来实际执行创建Bean的过程，传递给它bean的名称和一些其他默认的参数值。此处，`doGetBean`负责大部分工作，如查找bean定义、创建bean（如果尚未创建）、处理依赖关系等。
+在`org.springframework.beans.factory.support.AbstractBeanFactory#getBean()`方法中，又调用了`doGetBean`方法来实际执行创建Bean的过程，传递给它bean的名称和一些其他默认的参数值。此处，`doGetBean`负责大部分工作，如查找bean定义、创建bean（如果尚未创建）、处理依赖关系等。
-
+
-```java
+```java
-@Override
+@Override
-public Object getBean(String name) throws BeansException {
+public Object getBean(String name) throws BeansException {
-    return doGetBean(name, null, null, false);
+    return doGetBean(name, null, null, false);
-}
+}
-```
+```
-
+
-在`org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean`方法中，首先检查所请求的bean是否是一个单例并且已经创建。如果尚未创建，它将创建一个新的实例。在这个过程中，它处理可能的异常情况，如循环引用，并确保返回的bean是正确的类型。这是Spring容器bean生命周期管理的核心部分。
+在`org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean`方法中，首先检查所请求的bean是否是一个单例并且已经创建。如果尚未创建，它将创建一个新的实例。在这个过程中，它处理可能的异常情况，如循环引用，并确保返回的bean是正确的类型。这是Spring容器bean生命周期管理的核心部分。
-
+
-```java
+```java
-protected <T> T doGetBean(
+protected <T> T doGetBean(
-        String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
+        String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
-        throws BeansException {
+        throws BeansException {
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-
+
-    // 开始创建bean实例
+    // 开始创建bean实例
-    if (mbd.isSingleton()) {
+    if (mbd.isSingleton()) {
-        // 如果bean是单例的，我们会尝试从单例缓存中获取它
+        // 如果bean是单例的，我们会尝试从单例缓存中获取它
-        // 如果不存在，则使用lambda创建一个新的实例
+        // 如果不存在，则使用lambda创建一个新的实例
-        sharedInstance = getSingleton(beanName, () -> {
+        sharedInstance = getSingleton(beanName, () -> {
-            try {
+            try {
-                // 尝试创建bean实例
+                // 尝试创建bean实例
-                return createBean(beanName, mbd, args);
+                return createBean(beanName, mbd, args);
-            }
+            }
-            catch (BeansException ex) {
+            catch (BeansException ex) {
-                // ... [代码部分省略以简化]
+                // ... [代码部分省略以简化]
-            }
+            }
-        });
+        });
-        // 对于某些bean（例如FactoryBeans），可能需要进一步处理以获取真正的bean实例
+        // 对于某些bean（例如FactoryBeans），可能需要进一步处理以获取真正的bean实例
-        beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
+        beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
-    }
+    }
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-
+
-    // 确保返回的bean实例与请求的类型匹配
+    // 确保返回的bean实例与请求的类型匹配
-    return adaptBeanInstance(name, beanInstance, requiredType);
+    return adaptBeanInstance(name, beanInstance, requiredType);
-}
+}
-```
+```
-
+
-在`org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton()`方法中，主要负责从单例缓存中获取一个已存在的bean实例，或者使用提供的`ObjectFactory`创建一个新的实例。这是确保bean在Spring容器中作为单例存在的关键部分。
+在`org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton()`方法中，主要负责从单例缓存中获取一个已存在的bean实例，或者使用提供的`ObjectFactory`创建一个新的实例。这是确保bean在Spring容器中作为单例存在的关键部分。
-
+
-```java
+```java
-public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
+public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
-    // 断言bean名称不能为空
+    // 断言bean名称不能为空
-    Assert.notNull(beanName, "Bean name must not be null");
+    Assert.notNull(beanName, "Bean name must not be null");
-
+
-    // 同步访问单例对象缓存，确保线程安全
+    // 同步访问单例对象缓存，确保线程安全
-    synchronized (this.singletonObjects) {
+    synchronized (this.singletonObjects) {
-        // 从缓存中获取单例对象
+        // 从缓存中获取单例对象
-        Object singletonObject = this.singletonObjects.get(beanName);
+        Object singletonObject = this.singletonObjects.get(beanName);
-
+
-        // 如果缓存中没有找到
+        // 如果缓存中没有找到
-        if (singletonObject == null) {
+        if (singletonObject == null) {
-            // ... [代码部分省略以简化]
+            // ... [代码部分省略以简化]
-
+
-            try {
+            try {
-                // 使用工厂创建新的单例实例
+                // 使用工厂创建新的单例实例
-                singletonObject = singletonFactory.getObject();
+                singletonObject = singletonFactory.getObject();
-                newSingleton = true;
+                newSingleton = true;
-            }
+            }
-            catch (IllegalStateException ex) {
+            catch (IllegalStateException ex) {
-                // ... [代码部分省略以简化]
+                // ... [代码部分省略以简化]
-            }
+            }
-            catch (BeanCreationException ex) {
+            catch (BeanCreationException ex) {
-                // ... [代码部分省略以简化]
+                // ... [代码部分省略以简化]
-            }
+            }
-            finally {
+            finally {
-                // ... [代码部分省略以简化]
+                // ... [代码部分省略以简化]
-            }
+            }
-
+
-            // ... [代码部分省略以简化]
+            // ... [代码部分省略以简化]
-        }
+        }
-
+
-        // 返回单例对象
+        // 返回单例对象
-        return singletonObject;
+        return singletonObject;
-    }
+    }
-}
+}
-```
+```
-
+
-在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBean()`方法中，主要的逻辑是调用 `doCreateBean`，这是真正进行 bean 实例化、属性填充和初始化的地方。这个方法会返回新创建的 bean 实例。
+在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBean()`方法中，主要的逻辑是调用 `doCreateBean`，这是真正进行 bean 实例化、属性填充和初始化的地方。这个方法会返回新创建的 bean 实例。
-
+
-```java
+```java
-@Override
+@Override
-protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
+protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
-    throws BeanCreationException {
+    throws BeanCreationException {
-    
+    
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-    
+    
-    try {
+    try {
-        // 正常的bean实例化、属性注入和初始化。
+        // 正常的bean实例化、属性注入和初始化。
-        // 这里是真正进行bean创建的部分。
+        // 这里是真正进行bean创建的部分。
-        Object beanInstance = doCreateBean(beanName, mbdToUse, args);
+        Object beanInstance = doCreateBean(beanName, mbdToUse, args);
-        // 记录bean成功创建的日志
+        // 记录bean成功创建的日志
-        if (logger.isTraceEnabled()) {
+        if (logger.isTraceEnabled()) {
-            logger.trace("Finished creating instance of bean '" + beanName + "'");
+            logger.trace("Finished creating instance of bean '" + beanName + "'");
-        }
+        }
-        return beanInstance;
+        return beanInstance;
-    }
+    }
-    catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
+    catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
-        // ... [代码部分省略以简化]
+        // ... [代码部分省略以简化]
-    }
+    }
-    catch (Throwable ex) {
+    catch (Throwable ex) {
-        // ... [代码部分省略以简化]
+        // ... [代码部分省略以简化]
-    }
+    }
-}
+}
-```
+```
-
+
-在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean`方法中，`initializeBean`方法是bean初始化，确保bean是完全配置和准备好的。
+在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean`方法中，`initializeBean`方法是bean初始化，确保bean是完全配置和准备好的。
-
+
-```java
+```java
-protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
+protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
-        throws BeanCreationException {
+        throws BeanCreationException {
-
+
-    // 声明一个对象，后续可能用于存放初始化后的bean或它的代理对象
+    // 声明一个对象，后续可能用于存放初始化后的bean或它的代理对象
-    Object exposedObject = bean;
+    Object exposedObject = bean;
-
+
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-    
+    
-    try {
+    try {
-        // ... [代码部分省略以简化]
+        // ... [代码部分省略以简化]
-        
+        
-        // bean初始化
+        // bean初始化
-        exposedObject = initializeBean(beanName, exposedObject, mbd);
+        exposedObject = initializeBean(beanName, exposedObject, mbd);
-    } 
+    } 
-    catch (Throwable ex) {
+    catch (Throwable ex) {
-        // ... [代码部分省略以简化]
+        // ... [代码部分省略以简化]
-    }
+    }
-
+
-    // 返回创建和初始化后的bean
+    // 返回创建和初始化后的bean
-    return exposedObject;
+    return exposedObject;
-}
+}
-```
+```
-
+
-在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#initializeBean`方法中，如果条件满足（即 bean 不是合成的），那么它会调用 `applyBeanPostProcessorsBeforeInitialization` 方法。这个方法是 Spring 生命周期中的一个关键点，它会遍历所有已注册的 `BeanPostProcessor` 实现，并调用它们的 `postProcessBeforeInitialization` 方法。这允许我们和内部处理器在 bean 初始化之前对其进行修改或执行其他操作。
+在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#initializeBean`方法中，如果条件满足（即 bean 不是合成的），那么它会调用 `applyBeanPostProcessorsBeforeInitialization` 方法。这个方法是 Spring 生命周期中的一个关键点，它会遍历所有已注册的 `BeanPostProcessor` 实现，并调用它们的 `postProcessBeforeInitialization` 方法。这允许我们和内部处理器在 bean 初始化之前对其进行修改或执行其他操作。
-
+
-```java
+```java
-protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
+protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
-
+
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-    
+    
-    Object wrappedBean = bean;
+    Object wrappedBean = bean;
-    if (mbd == null || !mbd.isSynthetic()) {
+    if (mbd == null || !mbd.isSynthetic()) {
-        wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
+        wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
-    }
+    }
-    
+    
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-
+
-    return wrappedBean;
+    return wrappedBean;
-}
+}
-```
+```
-
+
-在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsBeforeInitialization`方法中，遍历每一个 `BeanPostProcessor` 的 `postProcessBeforeInitialization` 方法都有机会对bean进行修改或增强
+在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsBeforeInitialization`方法中，遍历每一个 `BeanPostProcessor` 的 `postProcessBeforeInitialization` 方法都有机会对bean进行修改或增强
-
+
-```java
+```java
-@Override
+@Override
-public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
+public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
-    throws BeansException {
+    throws BeansException {
-
+
-    Object result = existingBean;
+    Object result = existingBean;
-    for (BeanPostProcessor processor : getBeanPostProcessors()) {
+    for (BeanPostProcessor processor : getBeanPostProcessors()) {
-        Object current = processor.postProcessBeforeInitialization(result, beanName);
+        Object current = processor.postProcessBeforeInitialization(result, beanName);
-        if (current == null) {
+        if (current == null) {
-            return result;
+            return result;
-        }
+        }
-        result = current;
+        result = current;
-    }
+    }
-    return result;
+    return result;
-}
+}
-```
+```
-
+
-在`org.springframework.context.support.ApplicationContextAwareProcessor#postProcessBeforeInitialization`方法中，在这个方法的实现特别关注那些实现了 "aware" 接口的 beans，并为它们提供所需的运行环境信息。
+在`org.springframework.context.support.ApplicationContextAwareProcessor#postProcessBeforeInitialization`方法中，在这个方法的实现特别关注那些实现了 "aware" 接口的 beans，并为它们提供所需的运行环境信息。
-
+
-```java
+```java
-@Override
+@Override
-@Nullable
+@Nullable
-public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
+public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
-    if (!(bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware ||
+    if (!(bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware ||
-          bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware ||
+          bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware ||
-          bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware ||
+          bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware ||
-          bean instanceof ApplicationStartupAware)) {
+          bean instanceof ApplicationStartupAware)) {
-        return bean;
+        return bean;
-    }
+    }
-
+
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-    
+    
-    invokeAwareInterfaces(bean);
+    invokeAwareInterfaces(bean);
-
+
-    return bean;
+    return bean;
-}
+}
-```
+```
-
+
-在`org.springframework.context.support.ApplicationContextAwareProcessor#invokeAwareInterfaces`方法中，用于处理实现了"Aware"接口的beans。这些接口使得beans能够被自动"感知"并获得对其运行环境或特定依赖的引用，而不需要显式地进行查找或注入。
+在`org.springframework.context.support.ApplicationContextAwareProcessor#invokeAwareInterfaces`方法中，用于处理实现了"Aware"接口的beans。这些接口使得beans能够被自动"感知"并获得对其运行环境或特定依赖的引用，而不需要显式地进行查找或注入。
-
+
-```java
+```java
-private void invokeAwareInterfaces(Object bean) {
+private void invokeAwareInterfaces(Object bean) {
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-	if (bean instanceof ApplicationStartupAware) {
+	if (bean instanceof ApplicationStartupAware) {
-        ((ApplicationStartupAware) bean).setApplicationStartup(this.applicationContext.getApplicationStartup());
+        ((ApplicationStartupAware) bean).setApplicationStartup(this.applicationContext.getApplicationStartup());
-    }
+    }
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-}
+}
-```
+```
-
+
-最后执行到我们自定义的逻辑中，`MyApplicationStartupAware`类的主要目的是展示如何使用`ApplicationStartup`来跟踪Spring应用程序启动过程中的特定逻辑。这对于我们程序来说是有用的，因为我们可以看到哪些启动步骤是最消耗时间的，然后据此进行优化。在这个具体的实现中，仅仅模拟了两个步骤，但在实际应用中，可以跟踪任意数量和类型的步骤。
+最后执行到我们自定义的逻辑中，`MyApplicationStartupAware`类的主要目的是展示如何使用`ApplicationStartup`来跟踪Spring应用程序启动过程中的特定逻辑。这对于我们程序来说是有用的，因为我们可以看到哪些启动步骤是最消耗时间的，然后据此进行优化。在这个具体的实现中，仅仅模拟了两个步骤，但在实际应用中，可以跟踪任意数量和类型的步骤。
-
+
-```java
+```java
-public class MyApplicationStartupAware implements ApplicationStartupAware, InitializingBean {
+public class MyApplicationStartupAware implements ApplicationStartupAware, InitializingBean {
-
+
-    private ApplicationStartup applicationStartup;
+    private ApplicationStartup applicationStartup;
-
+
-    @Override
+    @Override
-    public void setApplicationStartup(ApplicationStartup applicationStartup) {
+    public void setApplicationStartup(ApplicationStartup applicationStartup) {
-        this.applicationStartup = applicationStartup;
+        this.applicationStartup = applicationStartup;
-    }
+    }
-
+
-    @Override
+    @Override
-    public void afterPropertiesSet() throws Exception {
+    public void afterPropertiesSet() throws Exception {
-        StartupStep step1 = applicationStartup.start("MyApplicationStartupAware Logic Step 1");
+        StartupStep step1 = applicationStartup.start("MyApplicationStartupAware Logic Step 1");
-        // 自定义逻辑
+        // 自定义逻辑
-        Thread.sleep(200);
+        Thread.sleep(200);
-        step1.tag("status", "done").end();
+        step1.tag("status", "done").end();
-
+
-        StartupStep step2 = applicationStartup.start("MyApplicationStartupAware Logic Step 2");
+        StartupStep step2 = applicationStartup.start("MyApplicationStartupAware Logic Step 2");
-        // 自定义逻辑
+        // 自定义逻辑
-        Thread.sleep(300);
+        Thread.sleep(300);
-        step2.tag("status", "done").end();
+        step2.tag("status", "done").end();
-    }
+    }
-}
+}
-```
+```
-
+
-### 七、注意事项
+### 七、注意事项
-
+
-**生命周期时机**：`setApplicationStartup`方法在其他bean属性设置之后、`InitializingBean`的`afterPropertiesSet`方法之前调用。确保你的bean在这一阶段不依赖于其他尚未初始化或注入的属性。
+**生命周期时机**：`setApplicationStartup`方法在其他bean属性设置之后、`InitializingBean`的`afterPropertiesSet`方法之前调用。确保你的bean在这一阶段不依赖于其他尚未初始化或注入的属性。
-
+
-**性能考虑**：虽然启动跟踪对于分析应用程序启动时间很有用，但添加太多的启动步骤跟踪可能会对性能产生微小的影响。在生产环境中，你可能需要权衡跟踪的详细程度和性能的关系。
+**性能考虑**：虽然启动跟踪对于分析应用程序启动时间很有用，但添加太多的启动步骤跟踪可能会对性能产生微小的影响。在生产环境中，你可能需要权衡跟踪的详细程度和性能的关系。
-
+
-**清晰的步骤名称**：当定义`StartupStep`时，为其提供清晰、描述性的名称，这样其他开发者可以更容易地理解它代表的步骤。
+**清晰的步骤名称**：当定义`StartupStep`时，为其提供清晰、描述性的名称，这样其他开发者可以更容易地理解它代表的步骤。
-
+
-**不要滥用**：尽量只为那些真正重要和可能影响启动性能的步骤使用启动跟踪。不需要为每个小操作都添加跟踪。
+**不要滥用**：尽量只为那些真正重要和可能影响启动性能的步骤使用启动跟踪。不需要为每个小操作都添加跟踪。
-
+
-**不要忘记结束步骤**：每当你开始一个`StartupStep`，记得在适当的时机调用`end`方法结束它。否则，该步骤可能会在报告中显示为仍在运行，这可能会导致混淆。
+**不要忘记结束步骤**：每当你开始一个`StartupStep`，记得在适当的时机调用`end`方法结束它。否则，该步骤可能会在报告中显示为仍在运行，这可能会导致混淆。
-
+
-### 八、总结
+### 八、总结
-
+
-#### 8.1、最佳实践总结
+#### 8.1、最佳实践总结
-
+
-**启动类概述**：使用`AnnotationConfigApplicationContext`，一个基于Java注解的Spring上下文初始化方法。设置`BufferingApplicationStartup`来缓存应用启动过程的最后100个步骤。这样可以分析哪些步骤可能影响启动性能。注册`MyConfiguration`类以加载相应的配置。刷新并初始化应用上下文，从而触发bean的创建和依赖注入。关闭上下文。
+**启动类概述**：使用`AnnotationConfigApplicationContext`，一个基于Java注解的Spring上下文初始化方法。设置`BufferingApplicationStartup`来缓存应用启动过程的最后100个步骤。这样可以分析哪些步骤可能影响启动性能。注册`MyConfiguration`类以加载相应的配置。刷新并初始化应用上下文，从而触发bean的创建和依赖注入。关闭上下文。
-
+
-**配置类概述**：使用`@Configuration`注解标记，告诉Spring这是一个配置类。通过`@Bean`注解定义了`MyApplicationStartupAware` bean。这样可以确保它被Spring容器处理，并在容器启动时执行其生命周期方法。
+**配置类概述**：使用`@Configuration`注解标记，告诉Spring这是一个配置类。通过`@Bean`注解定义了`MyApplicationStartupAware` bean。这样可以确保它被Spring容器处理，并在容器启动时执行其生命周期方法。
-
+
-**`MyApplicationStartupAware`类概述**：实现了`ApplicationStartupAware`接口，允许它在启动时获知`ApplicationStartup`实例。定义了两个启动步骤来模拟潜在的长时间运行任务，并使用`StartupStep`进行跟踪。在每个步骤的末尾，都有一个标记状态为"done"，然后结束该步骤。
+**`MyApplicationStartupAware`类概述**：实现了`ApplicationStartupAware`接口，允许它在启动时获知`ApplicationStartup`实例。定义了两个启动步骤来模拟潜在的长时间运行任务，并使用`StartupStep`进行跟踪。在每个步骤的末尾，都有一个标记状态为"done"，然后结束该步骤。
-
+
-#### 8.2、源码分析总结
+#### 8.2、源码分析总结
-
+
-**实例化Beans**：在`AbstractApplicationContext`的`refresh()`方法中，`finishBeanFactoryInitialization`方法被调用，确保所有单例Bean被预先实例化。
+**实例化Beans**：在`AbstractApplicationContext`的`refresh()`方法中，`finishBeanFactoryInitialization`方法被调用，确保所有单例Bean被预先实例化。
-
+
-**Bean预实例化**：`DefaultListableBeanFactory`的`preInstantiateSingletons`方法确保所有非懒加载的单例Beans被实例化。核心操作是调用`getBean(beanName)`。
+**Bean预实例化**：`DefaultListableBeanFactory`的`preInstantiateSingletons`方法确保所有非懒加载的单例Beans被实例化。核心操作是调用`getBean(beanName)`。
-
+
-**获取Bean实例**：`AbstractBeanFactory`的`getBean`方法进一步调用`doGetBean`来真正实例化Bean，处理异常和依赖，并返回Bean实例。
+**获取Bean实例**：`AbstractBeanFactory`的`getBean`方法进一步调用`doGetBean`来真正实例化Bean，处理异常和依赖，并返回Bean实例。
-
+
-**Bean单例获取**：`DefaultSingletonBeanRegistry`的`getSingleton`方法确保Bean以单例形式存在，从缓存获取或使用提供的`ObjectFactory`创建新实例。
+**Bean单例获取**：`DefaultSingletonBeanRegistry`的`getSingleton`方法确保Bean以单例形式存在，从缓存获取或使用提供的`ObjectFactory`创建新实例。
-
+
-**创建Bean实例**：`AbstractAutowireCapableBeanFactory`的`createBean`方法调用`doCreateBean`进行Bean的实际实例化，并进行初始化，确保Bean完全配置并准备就绪。
+**创建Bean实例**：`AbstractAutowireCapableBeanFactory`的`createBean`方法调用`doCreateBean`进行Bean的实际实例化，并进行初始化，确保Bean完全配置并准备就绪。
-
+
-**Bean初始化**：`AbstractAutowireCapableBeanFactory`的`initializeBean`方法确保Bean被正确初始化，其中调用`applyBeanPostProcessorsBeforeInitialization`方法是Spring生命周期中的关键点，允许BeanPostProcessors在Bean初始化之前进行操作。
+**Bean初始化**：`AbstractAutowireCapableBeanFactory`的`initializeBean`方法确保Bean被正确初始化，其中调用`applyBeanPostProcessorsBeforeInitialization`方法是Spring生命周期中的关键点，允许BeanPostProcessors在Bean初始化之前进行操作。
-
+
-**处理Aware接口**：在Bean初始化过程中，`ApplicationContextAwareProcessor`确保实现了`Aware`接口的Beans被正确处理，这些Beans会自动"感知"并获得其运行环境或特定依赖的引用。
+**处理Aware接口**：在Bean初始化过程中，`ApplicationContextAwareProcessor`确保实现了`Aware`接口的Beans被正确处理，这些Beans会自动"感知"并获得其运行环境或特定依赖的引用。
-
+
 **自定义逻辑执行**:`MyApplicationStartupAware`类实现了`ApplicationStartupAware`接口，它将接收一个`ApplicationStartup`实例。

spring-aware/spring-aware-applicationStartupAware/pom.xml

@@ -3,7 +3,7 @@
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <parent>
-        <artifactId>spring-reading</artifactId>
+        <artifactId>spring-aware</artifactId>
         <groupId>com.xcs.spring</groupId>
         <version>0.0.1-SNAPSHOT</version>
     </parent>

spring-aware/spring-aware-applicationStartupAware/src/main/java/com/xcs/spring/config/MyApplicationStartupAware.java

@@ -1,31 +1,31 @@
-package com.xcs.spring.config;
+package com.xcs.spring.config;
-
+
-import org.springframework.beans.factory.InitializingBean;
+import org.springframework.beans.factory.InitializingBean;
-import org.springframework.context.ApplicationStartupAware;
+import org.springframework.context.ApplicationStartupAware;
-import org.springframework.context.EnvironmentAware;
+import org.springframework.context.EnvironmentAware;
-import org.springframework.core.env.Environment;
+import org.springframework.core.env.Environment;
-import org.springframework.core.metrics.ApplicationStartup;
+import org.springframework.core.metrics.ApplicationStartup;
-import org.springframework.core.metrics.StartupStep;
+import org.springframework.core.metrics.StartupStep;
-
+
-public class MyApplicationStartupAware implements ApplicationStartupAware, InitializingBean {
+public class MyApplicationStartupAware implements ApplicationStartupAware, InitializingBean {
-
+
-    private ApplicationStartup applicationStartup;
+    private ApplicationStartup applicationStartup;
-
+
-    @Override
+    @Override
-    public void setApplicationStartup(ApplicationStartup applicationStartup) {
+    public void setApplicationStartup(ApplicationStartup applicationStartup) {
-        this.applicationStartup = applicationStartup;
+        this.applicationStartup = applicationStartup;
-    }
+    }
-
+
-    @Override
+    @Override
-    public void afterPropertiesSet() throws Exception {
+    public void afterPropertiesSet() throws Exception {
-        StartupStep step1 = applicationStartup.start("MyApplicationStartupAware Logic Step 1");
+        StartupStep step1 = applicationStartup.start("MyApplicationStartupAware Logic Step 1");
-        // 自定义逻辑
+        // 自定义逻辑
-        Thread.sleep(200);
+        Thread.sleep(200);
-        step1.tag("status", "done").end();
+        step1.tag("status", "done").end();
-
+
-        StartupStep step2 = applicationStartup.start("MyApplicationStartupAware Logic Step 2");
+        StartupStep step2 = applicationStartup.start("MyApplicationStartupAware Logic Step 2");
-        // 自定义逻辑
+        // 自定义逻辑
-        Thread.sleep(300);
+        Thread.sleep(300);
-        step2.tag("status", "done").end();
+        step2.tag("status", "done").end();
-    }
+    }
-}
+}

spring-aware/spring-aware-beanClassLoaderAware/README.md

@@ -1,474 +1,474 @@
-## BeanClassLoaderAware
+## BeanClassLoaderAware
-
+
-- [BeanClassLoaderAware](#beanclassloaderaware)
+- [BeanClassLoaderAware](#beanclassloaderaware)
-  - [一、接口描述](#一接口描述)
+  - [一、接口描述](#一接口描述)
-  - [二、接口源码](#二接口源码)
+  - [二、接口源码](#二接口源码)
-  - [三、主要功能](#三主要功能)
+  - [三、主要功能](#三主要功能)
-  - [四、最佳实践](#四最佳实践)
+  - [四、最佳实践](#四最佳实践)
-  - [五、时序图](#五时序图)
+  - [五、时序图](#五时序图)
-  - [六、源码分析](#六源码分析)
+  - [六、源码分析](#六源码分析)
-  - [七、注意事项](#七注意事项)
+  - [七、注意事项](#七注意事项)
-  - [八、总结](#八总结)
+  - [八、总结](#八总结)
-    - [8.1、最佳实践总结](#81最佳实践总结)
+    - [8.1、最佳实践总结](#81最佳实践总结)
-    - [8.2、源码分析总结](#82源码分析总结)
+    - [8.2、源码分析总结](#82源码分析总结)
-
+
-### 一、接口描述
+### 一、接口描述
-
+
-`BeanClassLoaderAware` 接口，允许 bean 得知其加载的类加载器。当一个 bean 实现了这个接口时，Spring 容器在 bean 初始化的时候会设置它的类加载器。
+`BeanClassLoaderAware` 接口，允许 bean 得知其加载的类加载器。当一个 bean 实现了这个接口时，Spring 容器在 bean 初始化的时候会设置它的类加载器。
-
+
-### 二、接口源码
+### 二、接口源码
-
+
-`BeanClassLoaderAware` 是 Spring 框架自 2.0 版本开始引入的一个核心接口。当一个 bean 实现了这个接口，并在 Spring 容器中被初始化时，Spring 容器会自动调用 `setClassLoader` 方法，并将加载该 bean 的类加载器传入。
+`BeanClassLoaderAware` 是 Spring 框架自 2.0 版本开始引入的一个核心接口。当一个 bean 实现了这个接口，并在 Spring 容器中被初始化时，Spring 容器会自动调用 `setClassLoader` 方法，并将加载该 bean 的类加载器传入。
-
+
-```java
+```java
-/**
+/**
- * 回调接口，允许 bean 了解其所使用的 ClassLoader 类加载器；
+ * 回调接口，允许 bean 了解其所使用的 ClassLoader 类加载器；
- * 也就是当前 bean 工厂用于加载 bean 类的类加载器。
+ * 也就是当前 bean 工厂用于加载 bean 类的类加载器。
- * 
+ * 
- * 主要目的是供那些需要按名称选择应用类的框架类实现，尽管这些框架类可能是由共享的类加载器加载的。
+ * 主要目的是供那些需要按名称选择应用类的框架类实现，尽管这些框架类可能是由共享的类加载器加载的。
- *
+ *
- * 对于所有 bean 生命周期方法的列表，请参阅 BeanFactory BeanFactory 的 javadocs。
+ * 对于所有 bean 生命周期方法的列表，请参阅 BeanFactory BeanFactory 的 javadocs。
- *
+ *
- * @author Juergen Hoeller
+ * @author Juergen Hoeller
- * @author Chris Beams
+ * @author Chris Beams
- * @since 2.0
+ * @since 2.0
- * @see BeanNameAware
+ * @see BeanNameAware
- * @see BeanFactoryAware
+ * @see BeanFactoryAware
- * @see InitializingBean
+ * @see InitializingBean
- */
+ */
-public interface BeanClassLoaderAware extends Aware {
+public interface BeanClassLoaderAware extends Aware {
-
+
-    /**
+    /**
-     * 提供 bean 的 ClassLoader 类加载器 的回调方法。
+     * 提供 bean 的 ClassLoader 类加载器 的回调方法。
-     * 在填充普通的 bean 属性之后但在初始化回调（如 InitializingBean InitializingBean 的
+     * 在填充普通的 bean 属性之后但在初始化回调（如 InitializingBean InitializingBean 的
-     * InitializingBean#afterPropertiesSet() 方法或自定义初始化方法）之前调用此方法。
+     * InitializingBean#afterPropertiesSet() 方法或自定义初始化方法）之前调用此方法。
-     * 
+     * 
-     * @param classLoader 拥有的类加载器
+     * @param classLoader 拥有的类加载器
-     */
+     */
-    void setBeanClassLoader(ClassLoader classLoader);
+    void setBeanClassLoader(ClassLoader classLoader);
-
+
-}
+}
-```
+```
-
+
-### 三、主要功能
+### 三、主要功能
-
+
-**提供类加载器信息**：Bean 可以得知其加载的类加载器，从而可以利用该类加载器进行动态的类加载或资源查找。
+**提供类加载器信息**：Bean 可以得知其加载的类加载器，从而可以利用该类加载器进行动态的类加载或资源查找。
-
+
-**框架与应用类加载器隔离**：在某些复杂的环境中，框架类和应用程序类可能是由不同的类加载器加载的。例如，在某些应用服务器环境中，框架可能是由共享的类加载器加载的，而应用程序类是由专门的类加载器加载的。通过 `BeanClassLoaderAware`，框架类可以确保使用正确的类加载器来加载或访问应用程序类。
+**框架与应用类加载器隔离**：在某些复杂的环境中，框架类和应用程序类可能是由不同的类加载器加载的。例如，在某些应用服务器环境中，框架可能是由共享的类加载器加载的，而应用程序类是由专门的类加载器加载的。通过 `BeanClassLoaderAware`，框架类可以确保使用正确的类加载器来加载或访问应用程序类。
-
+
-**生命周期管理**：`setBeanClassLoader` 方法会在填充 bean 的普通属性之后但在调用任何初始化回调（如 `InitializingBean#afterPropertiesSet()`）之前被调用。这确保了在 bean 的生命周期的合适阶段提供类加载器信息。
+**生命周期管理**：`setBeanClassLoader` 方法会在填充 bean 的普通属性之后但在调用任何初始化回调（如 `InitializingBean#afterPropertiesSet()`）之前被调用。这确保了在 bean 的生命周期的合适阶段提供类加载器信息。
-
+
-### 四、最佳实践
+### 四、最佳实践
-
+
-首先来看看启动类入口，上下文环境使用`AnnotationConfigApplicationContext`（此类是使用Java注解来配置Spring容器的方式），构造参数我们给定了一个`MyConfiguration`组件类。然后从Spring上下文中获取一个`MyBeanClassLoaderAware`类型的bean，最后调用`loadAndExecute`方法。
+首先来看看启动类入口，上下文环境使用`AnnotationConfigApplicationContext`（此类是使用Java注解来配置Spring容器的方式），构造参数我们给定了一个`MyConfiguration`组件类。然后从Spring上下文中获取一个`MyBeanClassLoaderAware`类型的bean，最后调用`loadAndExecute`方法。
-
+
-```java
+```java
-public class BeanClassLoaderAwareApplication {
+public class BeanClassLoaderAwareApplication {
-
+
-    public static void main(String[] args) {
+    public static void main(String[] args) {
-        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyConfiguration.class);
+        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyConfiguration.class);
-        MyBeanClassLoaderAware myBeanClassLoaderAware = context.getBean(MyBeanClassLoaderAware.class);
+        MyBeanClassLoaderAware myBeanClassLoaderAware = context.getBean(MyBeanClassLoaderAware.class);
-        myBeanClassLoaderAware.loadAndExecute();
+        myBeanClassLoaderAware.loadAndExecute();
-    }
+    }
-}
+}
-```
+```
-
+
-这里使用`@Bean`注解，定义了一个Bean，是为了确保`MyBeanClassLoaderAware` 被 Spring 容器执行
+这里使用`@Bean`注解，定义了一个Bean，是为了确保`MyBeanClassLoaderAware` 被 Spring 容器执行
-
+
-```java
+```java
-@Configuration
+@Configuration
-public class MyConfiguration {
+public class MyConfiguration {
-
+
-    @Bean
+    @Bean
-    public MyBeanClassLoaderAware myBeanClassLoaderAware(){
+    public MyBeanClassLoaderAware myBeanClassLoaderAware(){
-        return new MyBeanClassLoaderAware();
+        return new MyBeanClassLoaderAware();
-    }
+    }
-}
+}
-```
+```
-
+
-在`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
+```java
-public class MyBeanClassLoaderAware implements BeanClassLoaderAware {
+public class MyBeanClassLoaderAware implements BeanClassLoaderAware {
-
+
-    private ClassLoader classLoader;
+    private ClassLoader classLoader;
-
+
-    @Override
+    @Override
-    public void setBeanClassLoader(ClassLoader classLoader) {
+    public void setBeanClassLoader(ClassLoader classLoader) {
-        this.classLoader = classLoader;
+        this.classLoader = classLoader;
-    }
+    }
-
+
-    public void loadAndExecute() {
+    public void loadAndExecute() {
-        try {
+        try {
-            Class<?> clazz = classLoader.loadClass("com.xcs.spring.service.UserServiceImpl");
+            Class<?> clazz = classLoader.loadClass("com.xcs.spring.service.UserServiceImpl");
-            UserServiceImpl instance = (UserServiceImpl) clazz.getDeclaredConstructor().newInstance();
+            UserServiceImpl instance = (UserServiceImpl) clazz.getDeclaredConstructor().newInstance();
-            System.out.println("UserInfo = " + instance.getUserInfo());
+            System.out.println("UserInfo = " + instance.getUserInfo());
-        } catch (Exception e) {
+        } catch (Exception e) {
-            e.printStackTrace();
+            e.printStackTrace();
-        }
+        }
-    }
+    }
-}
+}
-```
+```
-
+
-定义一个接口与此接口的实现类。
+定义一个接口与此接口的实现类。
-
+
-```java
+```java
-package com.xcs.spring.service;
+package com.xcs.spring.service;
-
+
-public interface UserService {
+public interface UserService {
-    String getUserInfo();
+    String getUserInfo();
-}
+}
-
+
-public class UserServiceImpl implements UserService {
+public class UserServiceImpl implements UserService {
-    @Override
+    @Override
-    public String getUserInfo() {
+    public String getUserInfo() {
-        return "this is user info";
+        return "this is user info";
-    }
+    }
-}
+}
-```
+```
-
+
-运行结果发现，通过这种方式，我们保证了`MyBeanClassLoaderAware`的代码与`UserServiceImpl`的具体实现解耦。这意味着，如果`UserServiceImpl`的具体实现发生了变化，或者有了新的实现，只要我们遵循`UserService`接口，我们的`MyBeanClassLoaderAware`代码就不需要任何更改。
+运行结果发现，通过这种方式，我们保证了`MyBeanClassLoaderAware`的代码与`UserServiceImpl`的具体实现解耦。这意味着，如果`UserServiceImpl`的具体实现发生了变化，或者有了新的实现，只要我们遵循`UserService`接口，我们的`MyBeanClassLoaderAware`代码就不需要任何更改。
-
+
-```java
+```java
-UserInfo = this is user info
+UserInfo = this is user info
-```
+```
-
+
-### 五、时序图
+### 五、时序图
-
+
-~~~mermaid
+~~~mermaid
-sequenceDiagram
+sequenceDiagram
-    Title: BeanClassLoaderAware时序图
+    Title: BeanClassLoaderAware时序图
-    participant BeanFactoryAwareApplication
+    participant BeanFactoryAwareApplication
-    participant AnnotationConfigApplicationContext
+    participant AnnotationConfigApplicationContext
-    participant AbstractApplicationContext
+    participant AbstractApplicationContext
-    participant DefaultListableBeanFactory
+    participant DefaultListableBeanFactory
-    participant AbstractBeanFactory
+    participant AbstractBeanFactory
-    participant DefaultSingletonBeanRegistry
+    participant DefaultSingletonBeanRegistry
-    participant AbstractAutowireCapableBeanFactory
+    participant AbstractAutowireCapableBeanFactory
-    participant BeanClassLoaderAware
+    participant BeanClassLoaderAware
-    
+    
-    BeanFactoryAwareApplication->>AnnotationConfigApplicationContext:AnnotationConfigApplicationContext(componentClasses)<br>创建上下文
+    BeanFactoryAwareApplication->>AnnotationConfigApplicationContext:AnnotationConfigApplicationContext(componentClasses)<br>创建上下文
-    AnnotationConfigApplicationContext->>AbstractApplicationContext:refresh()<br>刷新上下文
+    AnnotationConfigApplicationContext->>AbstractApplicationContext:refresh()<br>刷新上下文
-    AbstractApplicationContext->>AbstractApplicationContext:finishBeanFactoryInitialization(beanFactory)<br>初始化Bean工厂
+    AbstractApplicationContext->>AbstractApplicationContext:finishBeanFactoryInitialization(beanFactory)<br>初始化Bean工厂
-    AbstractApplicationContext->>DefaultListableBeanFactory:preInstantiateSingletons()<br>实例化单例
+    AbstractApplicationContext->>DefaultListableBeanFactory:preInstantiateSingletons()<br>实例化单例
-    DefaultListableBeanFactory->>AbstractBeanFactory:getBean(name)<br>获取Bean
+    DefaultListableBeanFactory->>AbstractBeanFactory:getBean(name)<br>获取Bean
-    AbstractBeanFactory->>AbstractBeanFactory:doGetBean(name,requiredType,args,typeCheckOnly)<br>执行获取Bean
+    AbstractBeanFactory->>AbstractBeanFactory:doGetBean(name,requiredType,args,typeCheckOnly)<br>执行获取Bean
-    AbstractBeanFactory->>DefaultSingletonBeanRegistry:getSingleton(beanName,singletonFactory)<br>获取单例Bean
+    AbstractBeanFactory->>DefaultSingletonBeanRegistry:getSingleton(beanName,singletonFactory)<br>获取单例Bean
-    DefaultSingletonBeanRegistry-->>AbstractBeanFactory:getObject()<br>获取Bean实例
+    DefaultSingletonBeanRegistry-->>AbstractBeanFactory:getObject()<br>获取Bean实例
-    AbstractBeanFactory->>AbstractAutowireCapableBeanFactory:createBean(beanName,mbd,args)<br>创建Bean
+    AbstractBeanFactory->>AbstractAutowireCapableBeanFactory:createBean(beanName,mbd,args)<br>创建Bean
-    AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:doCreateBean(beanName,mbd,args)<br>执行Bean创建
+    AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:doCreateBean(beanName,mbd,args)<br>执行Bean创建
-    AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:initializeBean(beanName,bean,mbd)<br>负责bean的初始化
+    AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:initializeBean(beanName,bean,mbd)<br>负责bean的初始化
-    AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:invokeAwareMethods(beanName, bean)<br>调用Aware方法
+    AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:invokeAwareMethods(beanName, bean)<br>调用Aware方法
-    AbstractAutowireCapableBeanFactory->>BeanClassLoaderAware:setBeanClassLoader(classLoader)<br>设置classLoader
+    AbstractAutowireCapableBeanFactory->>BeanClassLoaderAware:setBeanClassLoader(classLoader)<br>设置classLoader
-    AbstractAutowireCapableBeanFactory-->>AbstractBeanFactory:返回Bean对象
+    AbstractAutowireCapableBeanFactory-->>AbstractBeanFactory:返回Bean对象
-    AbstractBeanFactory-->>DefaultListableBeanFactory:返回Bean对象
+    AbstractBeanFactory-->>DefaultListableBeanFactory:返回Bean对象
-    AnnotationConfigApplicationContext-->>BeanFactoryAwareApplication:初始化完成
+    AnnotationConfigApplicationContext-->>BeanFactoryAwareApplication:初始化完成
-
+
-~~~
+~~~
-
+
-### 六、源码分析
+### 六、源码分析
-
+
-首先来看看启动类入口，上下文环境使用`AnnotationConfigApplicationContext`（此类是使用Java注解来配置Spring容器的方式），构造参数我们给定了一个`MyConfiguration`组件类。然后从Spring上下文中获取一个`MyBeanClassLoaderAware`类型的bean，最后调用`loadAndExecute`方法。
+首先来看看启动类入口，上下文环境使用`AnnotationConfigApplicationContext`（此类是使用Java注解来配置Spring容器的方式），构造参数我们给定了一个`MyConfiguration`组件类。然后从Spring上下文中获取一个`MyBeanClassLoaderAware`类型的bean，最后调用`loadAndExecute`方法。
-
+
-```java
+```java
-public class BeanClassLoaderAwareApplication {
+public class BeanClassLoaderAwareApplication {
-
+
-    public static void main(String[] args) {
+    public static void main(String[] args) {
-        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyConfiguration.class);
+        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyConfiguration.class);
-        MyBeanClassLoaderAware myBeanClassLoaderAware = context.getBean(MyBeanClassLoaderAware.class);
+        MyBeanClassLoaderAware myBeanClassLoaderAware = context.getBean(MyBeanClassLoaderAware.class);
-        myBeanClassLoaderAware.loadAndExecute();
+        myBeanClassLoaderAware.loadAndExecute();
-    }
+    }
-}
+}
-```
+```
-
+
-在`org.springframework.context.annotation.AnnotationConfigApplicationContext#AnnotationConfigApplicationContext`构造函数中，执行了三个步骤，我们重点关注`refresh()`方法
+在`org.springframework.context.annotation.AnnotationConfigApplicationContext#AnnotationConfigApplicationContext`构造函数中，执行了三个步骤，我们重点关注`refresh()`方法
-
+
-```java
+```java
-public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
+public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
-    this();
+    this();
-    register(componentClasses);
+    register(componentClasses);
-    refresh();
+    refresh();
-
+
-```
+```
-
+
-在`org.springframework.context.support.AbstractApplicationContext#refresh`方法中我们重点关注一下`finishBeanFactoryInitialization(beanFactory)`这方法会对实例化所有剩余非懒加载的单列Bean对象，其他方法不是本次源码阅读的重点暂时忽略。
+在`org.springframework.context.support.AbstractApplicationContext#refresh`方法中我们重点关注一下`finishBeanFactoryInitialization(beanFactory)`这方法会对实例化所有剩余非懒加载的单列Bean对象，其他方法不是本次源码阅读的重点暂时忽略。
-
+
-```java
+```java
-@Override
+@Override
-public void refresh() throws BeansException, IllegalStateException {
+public void refresh() throws BeansException, IllegalStateException {
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-    // Instantiate all remaining (non-lazy-init) singletons.
+    // Instantiate all remaining (non-lazy-init) singletons.
-    finishBeanFactoryInitialization(beanFactory);
+    finishBeanFactoryInitialization(beanFactory);
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-}
+}
-```
+```
-
+
-在`org.springframework.context.support.AbstractApplicationContext#finishBeanFactoryInitialization`方法中，会继续调用`DefaultListableBeanFactory`类中的`preInstantiateSingletons`方法来完成所有剩余非懒加载的单列Bean对象。
+在`org.springframework.context.support.AbstractApplicationContext#finishBeanFactoryInitialization`方法中，会继续调用`DefaultListableBeanFactory`类中的`preInstantiateSingletons`方法来完成所有剩余非懒加载的单列Bean对象。
-
+
-```java
+```java
-/**
+/**
- * 完成此工厂的bean初始化，实例化所有剩余的非延迟初始化单例bean。
+ * 完成此工厂的bean初始化，实例化所有剩余的非延迟初始化单例bean。
- * 
+ * 
- * @param beanFactory 要初始化的bean工厂
+ * @param beanFactory 要初始化的bean工厂
- */
+ */
-protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
+protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-    // 完成所有剩余非懒加载的单列Bean对象。
+    // 完成所有剩余非懒加载的单列Bean对象。
-    beanFactory.preInstantiateSingletons();
+    beanFactory.preInstantiateSingletons();
-}
+}
-```
+```
-
+
-在`org.springframework.beans.factory.support.DefaultListableBeanFactory#preInstantiateSingletons`方法中，主要的核心目的是预先实例化所有非懒加载的单例bean。在Spring的上下文初始化完成后，该方法会被触发，以确保所有单例bean都被正确地创建并初始化。其中`getBean(beanName)`是此方法的核心操作。对于容器中定义的每一个单例bean，它都会调用`getBean`方法，这将触发bean的实例化、初始化及其依赖的注入。如果bean之前没有被创建过，那么这个调用会导致其被实例化和初始化。
+在`org.springframework.beans.factory.support.DefaultListableBeanFactory#preInstantiateSingletons`方法中，主要的核心目的是预先实例化所有非懒加载的单例bean。在Spring的上下文初始化完成后，该方法会被触发，以确保所有单例bean都被正确地创建并初始化。其中`getBean(beanName)`是此方法的核心操作。对于容器中定义的每一个单例bean，它都会调用`getBean`方法，这将触发bean的实例化、初始化及其依赖的注入。如果bean之前没有被创建过，那么这个调用会导致其被实例化和初始化。
-
+
-```java
+```java
-public void preInstantiateSingletons() throws BeansException {
+public void preInstantiateSingletons() throws BeansException {
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-    // 循环遍历所有bean的名称
+    // 循环遍历所有bean的名称
-    for (String beanName : beanNames) {
+    for (String beanName : beanNames) {
-        getBean(beanName);
+        getBean(beanName);
-    }
+    }
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-}
+}
-```
+```
-
+
-在`org.springframework.beans.factory.support.AbstractBeanFactory#getBean()`方法中，又调用了`doGetBean`方法来实际执行创建Bean的过程，传递给它bean的名称和一些其他默认的参数值。此处，`doGetBean`负责大部分工作，如查找bean定义、创建bean（如果尚未创建）、处理依赖关系等。
+在`org.springframework.beans.factory.support.AbstractBeanFactory#getBean()`方法中，又调用了`doGetBean`方法来实际执行创建Bean的过程，传递给它bean的名称和一些其他默认的参数值。此处，`doGetBean`负责大部分工作，如查找bean定义、创建bean（如果尚未创建）、处理依赖关系等。
-
+
-```java
+```java
-@Override
+@Override
-public Object getBean(String name) throws BeansException {
+public Object getBean(String name) throws BeansException {
-    return doGetBean(name, null, null, false);
+    return doGetBean(name, null, null, false);
-}
+}
-```
+```
-
+
-在`org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean`方法中，首先检查所请求的bean是否是一个单例并且已经创建。如果尚未创建，它将创建一个新的实例。在这个过程中，它处理可能的异常情况，如循环引用，并确保返回的bean是正确的类型。这是Spring容器bean生命周期管理的核心部分。
+在`org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean`方法中，首先检查所请求的bean是否是一个单例并且已经创建。如果尚未创建，它将创建一个新的实例。在这个过程中，它处理可能的异常情况，如循环引用，并确保返回的bean是正确的类型。这是Spring容器bean生命周期管理的核心部分。
-
+
-```java
+```java
-protected <T> T doGetBean(
+protected <T> T doGetBean(
-        String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
+        String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
-        throws BeansException {
+        throws BeansException {
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-
+
-    // 开始创建bean实例
+    // 开始创建bean实例
-    if (mbd.isSingleton()) {
+    if (mbd.isSingleton()) {
-        // 如果bean是单例的，我们会尝试从单例缓存中获取它
+        // 如果bean是单例的，我们会尝试从单例缓存中获取它
-        // 如果不存在，则使用lambda创建一个新的实例
+        // 如果不存在，则使用lambda创建一个新的实例
-        sharedInstance = getSingleton(beanName, () -> {
+        sharedInstance = getSingleton(beanName, () -> {
-            try {
+            try {
-                // 尝试创建bean实例
+                // 尝试创建bean实例
-                return createBean(beanName, mbd, args);
+                return createBean(beanName, mbd, args);
-            }
+            }
-            catch (BeansException ex) {
+            catch (BeansException ex) {
-                // ... [代码部分省略以简化]
+                // ... [代码部分省略以简化]
-            }
+            }
-        });
+        });
-        // 对于某些bean（例如FactoryBeans），可能需要进一步处理以获取真正的bean实例
+        // 对于某些bean（例如FactoryBeans），可能需要进一步处理以获取真正的bean实例
-        beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
+        beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
-    }
+    }
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-
+
-    // 确保返回的bean实例与请求的类型匹配
+    // 确保返回的bean实例与请求的类型匹配
-    return adaptBeanInstance(name, beanInstance, requiredType);
+    return adaptBeanInstance(name, beanInstance, requiredType);
-}
+}
-```
+```
-
+
-在`org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton()`方法中，主要负责从单例缓存中获取一个已存在的bean实例，或者使用提供的`ObjectFactory`创建一个新的实例。这是确保bean在Spring容器中作为单例存在的关键部分。
+在`org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton()`方法中，主要负责从单例缓存中获取一个已存在的bean实例，或者使用提供的`ObjectFactory`创建一个新的实例。这是确保bean在Spring容器中作为单例存在的关键部分。
-
+
-```java
+```java
-public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
+public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
-    // 断言bean名称不能为空
+    // 断言bean名称不能为空
-    Assert.notNull(beanName, "Bean name must not be null");
+    Assert.notNull(beanName, "Bean name must not be null");
-
+
-    // 同步访问单例对象缓存，确保线程安全
+    // 同步访问单例对象缓存，确保线程安全
-    synchronized (this.singletonObjects) {
+    synchronized (this.singletonObjects) {
-        // 从缓存中获取单例对象
+        // 从缓存中获取单例对象
-        Object singletonObject = this.singletonObjects.get(beanName);
+        Object singletonObject = this.singletonObjects.get(beanName);
-
+
-        // 如果缓存中没有找到
+        // 如果缓存中没有找到
-        if (singletonObject == null) {
+        if (singletonObject == null) {
-            // ... [代码部分省略以简化]
+            // ... [代码部分省略以简化]
-
+
-            try {
+            try {
-                // 使用工厂创建新的单例实例
+                // 使用工厂创建新的单例实例
-                singletonObject = singletonFactory.getObject();
+                singletonObject = singletonFactory.getObject();
-                newSingleton = true;
+                newSingleton = true;
-            }
+            }
-            catch (IllegalStateException ex) {
+            catch (IllegalStateException ex) {
-                // ... [代码部分省略以简化]
+                // ... [代码部分省略以简化]
-            }
+            }
-            catch (BeanCreationException ex) {
+            catch (BeanCreationException ex) {
-                // ... [代码部分省略以简化]
+                // ... [代码部分省略以简化]
-            }
+            }
-            finally {
+            finally {
-                // ... [代码部分省略以简化]
+                // ... [代码部分省略以简化]
-            }
+            }
-
+
-            // ... [代码部分省略以简化]
+            // ... [代码部分省略以简化]
-        }
+        }
-
+
-        // 返回单例对象
+        // 返回单例对象
-        return singletonObject;
+        return singletonObject;
-    }
+    }
-}
+}
-```
+```
-
+
-在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBean()`方法中，主要的逻辑是调用 `doCreateBean`，这是真正进行 bean 实例化、属性填充和初始化的地方。这个方法会返回新创建的 bean 实例。
+在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBean()`方法中，主要的逻辑是调用 `doCreateBean`，这是真正进行 bean 实例化、属性填充和初始化的地方。这个方法会返回新创建的 bean 实例。
-
+
-```java
+```java
-@Override
+@Override
-protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
+protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
-    throws BeanCreationException {
+    throws BeanCreationException {
-    
+    
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-    
+    
-    try {
+    try {
-        // 正常的bean实例化、属性注入和初始化。
+        // 正常的bean实例化、属性注入和初始化。
-        // 这里是真正进行bean创建的部分。
+        // 这里是真正进行bean创建的部分。
-        Object beanInstance = doCreateBean(beanName, mbdToUse, args);
+        Object beanInstance = doCreateBean(beanName, mbdToUse, args);
-        // 记录bean成功创建的日志
+        // 记录bean成功创建的日志
-        if (logger.isTraceEnabled()) {
+        if (logger.isTraceEnabled()) {
-            logger.trace("Finished creating instance of bean '" + beanName + "'");
+            logger.trace("Finished creating instance of bean '" + beanName + "'");
-        }
+        }
-        return beanInstance;
+        return beanInstance;
-    }
+    }
-    catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
+    catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
-        // ... [代码部分省略以简化]
+        // ... [代码部分省略以简化]
-    }
+    }
-    catch (Throwable ex) {
+    catch (Throwable ex) {
-        // ... [代码部分省略以简化]
+        // ... [代码部分省略以简化]
-    }
+    }
-}
+}
-```
+```
-
+
-在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean`方法中，`initializeBean`方法是bean初始化，确保bean是完全配置和准备好的。
+在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean`方法中，`initializeBean`方法是bean初始化，确保bean是完全配置和准备好的。
-
+
-```java
+```java
-protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
+protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
-        throws BeanCreationException {
+        throws BeanCreationException {
-
+
-    // 声明一个对象，后续可能用于存放初始化后的bean或它的代理对象
+    // 声明一个对象，后续可能用于存放初始化后的bean或它的代理对象
-    Object exposedObject = bean;
+    Object exposedObject = bean;
-
+
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-    
+    
-    try {
+    try {
-        // ... [代码部分省略以简化]
+        // ... [代码部分省略以简化]
-        
+        
-        // bean初始化
+        // bean初始化
-        exposedObject = initializeBean(beanName, exposedObject, mbd);
+        exposedObject = initializeBean(beanName, exposedObject, mbd);
-    } 
+    } 
-    catch (Throwable ex) {
+    catch (Throwable ex) {
-        // ... [代码部分省略以简化]
+        // ... [代码部分省略以简化]
-    }
+    }
-
+
-    // 返回创建和初始化后的bean
+    // 返回创建和初始化后的bean
-    return exposedObject;
+    return exposedObject;
-}
+}
-```
+```
-
+
-在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#initializeBean`方法中，`invokeAwareMethods(beanName, bean)`是一个非常重要的步骤。这个方法是为了处理实现了Spring的`Aware`接口族的Beans（例如`BeanNameAware`, `BeanFactoryAware`等）。如果提供的bean实现了任何这些接口，该方法会回调相应的`Aware`方法。
+在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#initializeBean`方法中，`invokeAwareMethods(beanName, bean)`是一个非常重要的步骤。这个方法是为了处理实现了Spring的`Aware`接口族的Beans（例如`BeanNameAware`, `BeanFactoryAware`等）。如果提供的bean实现了任何这些接口，该方法会回调相应的`Aware`方法。
-
+
-```java
+```java
-protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
+protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
-
+
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-    
+    
-    invokeAwareMethods(beanName, bean);
+    invokeAwareMethods(beanName, bean);
-    
+    
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-
+
-    return wrappedBean;
+    return wrappedBean;
-}
+}
-```
+```
-
+
-在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#invokeAwareMethods`方法中，用于处理实现了 Spring `Aware` 接口族的 beans。当一个 bean 实现了如 `BeanNameAware`、`BeanClassLoaderAware` 或 `BeanFactoryAware` 等接口时，此方法确保正确的回调方法被调用，从而为 bean 提供关于其运行环境或其他相关信息。
+在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#invokeAwareMethods`方法中，用于处理实现了 Spring `Aware` 接口族的 beans。当一个 bean 实现了如 `BeanNameAware`、`BeanClassLoaderAware` 或 `BeanFactoryAware` 等接口时，此方法确保正确的回调方法被调用，从而为 bean 提供关于其运行环境或其他相关信息。
-
+
-```java
+```java
-private void invokeAwareMethods(String beanName, Object bean) {
+private void invokeAwareMethods(String beanName, Object bean) {
-    if (bean instanceof Aware) {
+    if (bean instanceof Aware) {
-        if (bean instanceof BeanNameAware) {
+        if (bean instanceof BeanNameAware) {
-            // ... [代码部分省略以简化]
+            // ... [代码部分省略以简化]
-        }
+        }
-        if (bean instanceof BeanClassLoaderAware) {
+        if (bean instanceof BeanClassLoaderAware) {
-            ClassLoader bcl = getBeanClassLoader();
+            ClassLoader bcl = getBeanClassLoader();
-            if (bcl != null) {
+            if (bcl != null) {
-                ((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
+                ((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
-            }
+            }
-        }
+        }
-        if (bean instanceof BeanFactoryAware) {
+        if (bean instanceof BeanFactoryAware) {
-            // ... [代码部分省略以简化]
+            // ... [代码部分省略以简化]
-        }
+        }
-    }
+    }
-}
+}
-```
+```
-
+
-最后执行到我们自定义的逻辑中，我们实现了 `BeanClassLoaderAware` 接口，允许这个 bean 在初始化时获取其 `ClassLoader`。
+最后执行到我们自定义的逻辑中，我们实现了 `BeanClassLoaderAware` 接口，允许这个 bean 在初始化时获取其 `ClassLoader`。
-
+
-```java
+```java
-public class MyBeanClassLoaderAware implements BeanClassLoaderAware {
+public class MyBeanClassLoaderAware implements BeanClassLoaderAware {
-
+
-    private ClassLoader classLoader;
+    private ClassLoader classLoader;
-
+
-    @Override
+    @Override
-    public void setBeanClassLoader(ClassLoader classLoader) {
+    public void setBeanClassLoader(ClassLoader classLoader) {
-        this.classLoader = classLoader;
+        this.classLoader = classLoader;
-    }
+    }
-
+
-    public void loadAndExecute() {
+    public void loadAndExecute() {
-        try {
+        try {
-            Class<?> clazz = classLoader.loadClass("com.xcs.spring.service.UserServiceImpl");
+            Class<?> clazz = classLoader.loadClass("com.xcs.spring.service.UserServiceImpl");
-            UserServiceImpl instance = (UserServiceImpl) clazz.getDeclaredConstructor().newInstance();
+            UserServiceImpl instance = (UserServiceImpl) clazz.getDeclaredConstructor().newInstance();
-            System.out.println("UserInfo = " + instance.getUserInfo());
+            System.out.println("UserInfo = " + instance.getUserInfo());
-        } catch (Exception e) {
+        } catch (Exception e) {
-            e.printStackTrace();
+            e.printStackTrace();
-        }
+        }
-    }
+    }
-}
+}
-```
+```
-
+
-### 七、注意事项
+### 七、注意事项
-
+
-**避免过度使用**：只有当你真的需要访问类加载器时才使用 `BeanClassLoaderAware`。不要滥用它，因为这可能会导致代码与Spring框架过度耦合。
+**避免过度使用**：只有当你真的需要访问类加载器时才使用 `BeanClassLoaderAware`。不要滥用它，因为这可能会导致代码与Spring框架过度耦合。
-
+
-**考虑类加载器层次结构**：在Java中，类加载器通常有一个父子关系。如果你不能使用当前的类加载器找到一个类，可能需要检查其父类加载器。
+**考虑类加载器层次结构**：在Java中，类加载器通常有一个父子关系。如果你不能使用当前的类加载器找到一个类，可能需要检查其父类加载器。
-
+
-**不要在setter中执行复杂的逻辑**：`setBeanClassLoader` 是一个setter方法，应该避免在其中执行复杂的逻辑。它应该只用于设置类加载器。
+**不要在setter中执行复杂的逻辑**：`setBeanClassLoader` 是一个setter方法，应该避免在其中执行复杂的逻辑。它应该只用于设置类加载器。
-
+
-**避免存储状态**：尽量不要在实现了`BeanClassLoaderAware`的bean中存储状态或依赖于其他bean的状态。这会使bean的生命周期和初始化更加复杂。
+**避免存储状态**：尽量不要在实现了`BeanClassLoaderAware`的bean中存储状态或依赖于其他bean的状态。这会使bean的生命周期和初始化更加复杂。
-
+
-**考虑使用其他技术**：在某些情况下，可能有其他技术或方法可以达到同样的目的，而无需使用 `BeanClassLoaderAware`。例如，使用Spring的`@Value`注解或`ResourceLoader`来加载资源，而不是直接使用类加载器。
+**考虑使用其他技术**：在某些情况下，可能有其他技术或方法可以达到同样的目的，而无需使用 `BeanClassLoaderAware`。例如，使用Spring的`@Value`注解或`ResourceLoader`来加载资源，而不是直接使用类加载器。
-
+
-**考虑类加载器层次结构**：在Java中，类加载器通常有一个父子关系。如果你不能使用当前的类加载器找到一个类，可能需要检查其父类加载器。
+**考虑类加载器层次结构**：在Java中，类加载器通常有一个父子关系。如果你不能使用当前的类加载器找到一个类，可能需要检查其父类加载器。
-
+
-**资源管理**：类加载器不仅可以加载类，还可以用来加载其他资源（例如，属性文件）。但是，要小心确保资源路径正确，并记住类加载器的搜索行为可能与文件系统或其他加载机制不同。
+**资源管理**：类加载器不仅可以加载类，还可以用来加载其他资源（例如，属性文件）。但是，要小心确保资源路径正确，并记住类加载器的搜索行为可能与文件系统或其他加载机制不同。
-
+
-### 八、总结
+### 八、总结
-
+
-#### 8.1、最佳实践总结
+#### 8.1、最佳实践总结
-
+
-**启动及上下文配置：**利用 `AnnotationConfigApplicationContext` 初始化Spring容器，使用 `MyConfiguration` 作为配置类来为Spring上下文提供设置。
+**启动及上下文配置：**利用 `AnnotationConfigApplicationContext` 初始化Spring容器，使用 `MyConfiguration` 作为配置类来为Spring上下文提供设置。
-
+
-**配置类定义：**标记配置类为 `@Configuration`，使用 `@Bean` 注解来确保 `MyBeanClassLoaderAware` 被Spring容器管理。
+**配置类定义：**标记配置类为 `@Configuration`，使用 `@Bean` 注解来确保 `MyBeanClassLoaderAware` 被Spring容器管理。
-
+
-**实现 `BeanClassLoaderAware`：**通过实现 `BeanClassLoaderAware` 接口，bean 可以在初始化时获得其加载的 `ClassLoader`，在 `loadAndExecute` 方法中，动态加载并执行特定的服务方法。
+**实现 `BeanClassLoaderAware`：**通过实现 `BeanClassLoaderAware` 接口，bean 可以在初始化时获得其加载的 `ClassLoader`，在 `loadAndExecute` 方法中，动态加载并执行特定的服务方法。
-
+
-**接口与实现：**定义清晰的 `UserService` 接口和相应的 `UserServiceImpl` 实现。
+**接口与实现：**定义清晰的 `UserService` 接口和相应的 `UserServiceImpl` 实现。
-
+
-**结果及结论：**运行程序后，我们能够看到预期输出，这表明成功地将 `MyBeanClassLoaderAware` 与特定实现解耦。
+**结果及结论：**运行程序后，我们能够看到预期输出，这表明成功地将 `MyBeanClassLoaderAware` 与特定实现解耦。
-
+
-#### 8.2、源码分析总结
+#### 8.2、源码分析总结
-
+
-**应用启动入口**： 通过`AnnotationConfigApplicationContext`，以`MyConfiguration`为配置类，初始化Spring容器。随后获取`MyBeanClassLoaderAware` bean并调用其`loadAndExecute`方法。
+**应用启动入口**： 通过`AnnotationConfigApplicationContext`，以`MyConfiguration`为配置类，初始化Spring容器。随后获取`MyBeanClassLoaderAware` bean并调用其`loadAndExecute`方法。
-
+
-**初始化Spring上下文**： 在`AnnotationConfigApplicationContext`构造函数中，`refresh()`方法被调用来刷新或初始化Spring容器。
+**初始化Spring上下文**： 在`AnnotationConfigApplicationContext`构造函数中，`refresh()`方法被调用来刷新或初始化Spring容器。
-
+
-**Bean的预实例化**： 在Spring的上下文初始化的`refresh()`方法中，`finishBeanFactoryInitialization(beanFactory)`方法确保所有非延迟加载的单例bean被实例化。
+**Bean的预实例化**： 在Spring的上下文初始化的`refresh()`方法中，`finishBeanFactoryInitialization(beanFactory)`方法确保所有非延迟加载的单例bean被实例化。
-
+
-**单例Bean的创建**： `DefaultListableBeanFactory`中的`preInstantiateSingletons`方法负责预先实例化所有非懒加载的单例bean。它会对容器中的每个单例bean调用`getBean`方法。
+**单例Bean的创建**： `DefaultListableBeanFactory`中的`preInstantiateSingletons`方法负责预先实例化所有非懒加载的单例bean。它会对容器中的每个单例bean调用`getBean`方法。
-
+
-**Bean的实例化及初始化**： 在获取bean的过程中，如果bean还未创建，`doCreateBean`方法会被调用，完成bean的实例化、属性填充和初始化。
+**Bean的实例化及初始化**： 在获取bean的过程中，如果bean还未创建，`doCreateBean`方法会被调用，完成bean的实例化、属性填充和初始化。
-
+
-**处理Aware接口族**： 在bean的初始化阶段，`invokeAwareMethods`方法确保任何实现了`Aware`接口族（如`BeanNameAware`、`BeanClassLoaderAware`等）的bean都会得到适当的回调。
+**处理Aware接口族**： 在bean的初始化阶段，`invokeAwareMethods`方法确保任何实现了`Aware`接口族（如`BeanNameAware`、`BeanClassLoaderAware`等）的bean都会得到适当的回调。
-
+
-**BeanClassLoaderAware的实现**： 对于实现了`BeanClassLoaderAware`接口的bean，Spring容器在初始化阶段会通过`setBeanClassLoader`方法设置bean的`ClassLoader`。
+**BeanClassLoaderAware的实现**： 对于实现了`BeanClassLoaderAware`接口的bean，Spring容器在初始化阶段会通过`setBeanClassLoader`方法设置bean的`ClassLoader`。
-
+
 **自定义逻辑的执行**： 在`MyBeanClassLoaderAware`中，已经保存了bean的类加载器，然后在`loadAndExecute`方法中，利用这个类加载器动态加载并执行特定的类和方法。

spring-aware/spring-aware-beanClassLoaderAware/pom.xml

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <parent>
+        <artifactId>spring-aware</artifactId>
+        <groupId>com.xcs.spring</groupId>
+        <version>0.0.1-SNAPSHOT</version>
+    </parent>
+
+    <modelVersion>4.0.0</modelVersion>
+    <artifactId>spring-aware-beanClassLoaderAware</artifactId>
+
+</project>

spring-aware/spring-aware-beanClassLoaderAware/src/main/java/com/xcs/spring/config/MyBeanClassLoaderAware.java

@@ -1,24 +1,24 @@
-package com.xcs.spring.config;
+package com.xcs.spring.config;
-
+
-import com.xcs.spring.service.UserServiceImpl;
+import com.xcs.spring.service.UserServiceImpl;
-import org.springframework.beans.factory.BeanClassLoaderAware;
+import org.springframework.beans.factory.BeanClassLoaderAware;
-
+
-public class MyBeanClassLoaderAware implements BeanClassLoaderAware {
+public class MyBeanClassLoaderAware implements BeanClassLoaderAware {
-
+
-    private ClassLoader classLoader;
+    private ClassLoader classLoader;
-
+
-    @Override
+    @Override
-    public void setBeanClassLoader(ClassLoader classLoader) {
+    public void setBeanClassLoader(ClassLoader classLoader) {
-        this.classLoader = classLoader;
+        this.classLoader = classLoader;
-    }
+    }
-
+
-    public void loadAndExecute() {
+    public void loadAndExecute() {
-        try {
+        try {
-            Class<?> clazz = classLoader.loadClass("com.xcs.spring.service.UserServiceImpl");
+            Class<?> clazz = classLoader.loadClass("com.xcs.spring.service.UserServiceImpl");
-            UserServiceImpl instance = (UserServiceImpl) clazz.getDeclaredConstructor().newInstance();
+            UserServiceImpl instance = (UserServiceImpl) clazz.getDeclaredConstructor().newInstance();
-            System.out.println("UserInfo = " + instance.getUserInfo());
+            System.out.println("UserInfo = " + instance.getUserInfo());
-        } catch (Exception e) {
+        } catch (Exception e) {
-            e.printStackTrace();
+            e.printStackTrace();
-        }
+        }
-    }
+    }
-}
+}

spring-aware/spring-aware-beanClassLoaderAware/src/main/java/com/xcs/spring/service/UserService.java

@@ -1,6 +1,6 @@
-package com.xcs.spring.service;
+package com.xcs.spring.service;
-
+
-public interface UserService {
+public interface UserService {
-
+
-    String getUserInfo();
+    String getUserInfo();
-}
+}

spring-aware/spring-aware-beanClassLoaderAware/src/main/java/com/xcs/spring/service/UserServiceImpl.java

@@ -1,8 +1,8 @@
-package com.xcs.spring.service;
+package com.xcs.spring.service;
-
+
-public class UserServiceImpl implements UserService {
+public class UserServiceImpl implements UserService {
-    @Override
+    @Override
-    public String getUserInfo() {
+    public String getUserInfo() {
-        return "this is user info";
+        return "this is user info";
-    }
+    }
-}
+}

spring-aware/spring-aware-beanFactoryAware/README.md

@@ -1,494 +1,494 @@
-## BeanFactoryAware
+## BeanFactoryAware
-
+
-- [BeanFactoryAware](#beanfactoryaware)
+- [BeanFactoryAware](#beanfactoryaware)
-  - [一、接口描述](#一接口描述)
+  - [一、接口描述](#一接口描述)
-  - [二、接口源码](#二接口源码)
+  - [二、接口源码](#二接口源码)
-  - [三、主要功能](#三主要功能)
+  - [三、主要功能](#三主要功能)
-  - [四、最佳实践](#四最佳实践)
+  - [四、最佳实践](#四最佳实践)
-  - [五、时序图](#五时序图)
+  - [五、时序图](#五时序图)
-  - [六、源码分析](#六源码分析)
+  - [六、源码分析](#六源码分析)
-  - [七、注意事项](#七注意事项)
+  - [七、注意事项](#七注意事项)
-  - [八、总结](#八总结)
+  - [八、总结](#八总结)
-    - [8.1、最佳实践总结](#81最佳实践总结)
+    - [8.1、最佳实践总结](#81最佳实践总结)
-    - [8.2、源码分析总结](#82源码分析总结)
+    - [8.2、源码分析总结](#82源码分析总结)
-
+
-### 一、接口描述
+### 一、接口描述
-
+
-`BeanFactoryAware` 接口，允许 Spring bean 获得其所在的 `BeanFactory` 的引用。当一个 bean 实现了这个接口，Spring 容器在初始化该 bean 时，会自动调用 `setBeanFactory()` 方法，并传递一个 `BeanFactory` 实例。
+`BeanFactoryAware` 接口，允许 Spring bean 获得其所在的 `BeanFactory` 的引用。当一个 bean 实现了这个接口，Spring 容器在初始化该 bean 时，会自动调用 `setBeanFactory()` 方法，并传递一个 `BeanFactory` 实例。
-
+
-### 二、接口源码
+### 二、接口源码
-
+
-`BeanFactoryAware` 是 Spring 框架自 11.03.2003 开始引入的一个核心接口。允许 Spring beans 获知并与其所在的 `BeanFactory` 进行交互。这为 beans 提供了直接访问 `BeanFactory` 的能力，进而可以查询和交互其他的 beans。
+`BeanFactoryAware` 是 Spring 框架自 11.03.2003 开始引入的一个核心接口。允许 Spring beans 获知并与其所在的 `BeanFactory` 进行交互。这为 beans 提供了直接访问 `BeanFactory` 的能力，进而可以查询和交互其他的 beans。
-
+
-```java
+```java
-/**
+/**
- * 由希望知道其所属的 BeanFactory 的 beans 实现的接口。
+ * 由希望知道其所属的 BeanFactory 的 beans 实现的接口。
- *
+ *
- * 例如，beans 可以通过工厂查找合作的 beans（依赖查找）。
+ * 例如，beans 可以通过工厂查找合作的 beans（依赖查找）。
- * 请注意，大多数 beans 会选择通过相应的 bean 属性或构造函数参数
+ * 请注意，大多数 beans 会选择通过相应的 bean 属性或构造函数参数
- * 接收对合作 beans 的引用（依赖注入）。
+ * 接收对合作 beans 的引用（依赖注入）。
- *
+ *
- * 有关所有 bean 生命周期方法的列表，请参阅
+ * 有关所有 bean 生命周期方法的列表，请参阅
- * BeanFactory BeanFactory javadocs。
+ * BeanFactory BeanFactory javadocs。
- *
+ *
- * @author Rod Johnson
+ * @author Rod Johnson
- * @author Chris Beams
+ * @author Chris Beams
- * @since 11.03.2003
+ * @since 11.03.2003
- * @see BeanNameAware
+ * @see BeanNameAware
- * @see BeanClassLoaderAware
+ * @see BeanClassLoaderAware
- * @see InitializingBean
+ * @see InitializingBean
- * @see org.springframework.context.ApplicationContextAware
+ * @see org.springframework.context.ApplicationContextAware
- */
+ */
-public interface BeanFactoryAware extends Aware {
+public interface BeanFactoryAware extends Aware {
-
+
-	/**
+	/**
-	 * 向 bean 实例提供其拥有的工厂的回调。
+	 * 向 bean 实例提供其拥有的工厂的回调。
-	 * 在正常 bean 属性填充之后但在初始化回调之前（如
+	 * 在正常 bean 属性填充之后但在初始化回调之前（如
-	 * InitializingBean#afterPropertiesSet() 或自定义的初始化方法）调用。
+	 * InitializingBean#afterPropertiesSet() 或自定义的初始化方法）调用。
-	 * @param beanFactory 拥有的 BeanFactory（永远不会是 null）。
+	 * @param beanFactory 拥有的 BeanFactory（永远不会是 null）。
-	 * bean 可以立即调用工厂上的方法。
+	 * bean 可以立即调用工厂上的方法。
-	 * @throws BeansException 初始化错误的情况下
+	 * @throws BeansException 初始化错误的情况下
-	 * @see BeanInitializationException
+	 * @see BeanInitializationException
-	 */
+	 */
-	void setBeanFactory(BeanFactory beanFactory) throws BeansException;
+	void setBeanFactory(BeanFactory beanFactory) throws BeansException;
-
+
-}
+}
-```
+```
-
+
-### 三、主要功能
+### 三、主要功能
-
+
-**获取 `BeanFactory` 引用**： 通过实现 `BeanFactoryAware` 接口并重写 `setBeanFactory` 方法，bean 在初始化过程中会收到其所属的 `BeanFactory` 的引用。Spring 容器会自动为实现了该接口的 bean 调用 `setBeanFactory` 方法。
+**获取 `BeanFactory` 引用**： 通过实现 `BeanFactoryAware` 接口并重写 `setBeanFactory` 方法，bean 在初始化过程中会收到其所属的 `BeanFactory` 的引用。Spring 容器会自动为实现了该接口的 bean 调用 `setBeanFactory` 方法。
-
+
-**依赖查找**： 一旦 bean 有了 `BeanFactory` 的引用，它就可以使用这个工厂来动态地查找其他 beans。这种方式被称为“依赖查找”（Dependency Lookup），与常见的“依赖注入”（Dependency Injection）方式相对。
+**依赖查找**： 一旦 bean 有了 `BeanFactory` 的引用，它就可以使用这个工厂来动态地查找其他 beans。这种方式被称为“依赖查找”（Dependency Lookup），与常见的“依赖注入”（Dependency Injection）方式相对。
-
+
-**与 `BeanFactory` 进行交互**： 获取 `BeanFactory` 的引用不仅仅是为了查找其他 beans，bean 还可以与其所在的 `BeanFactory` 进行更广泛的互动，例如检查 bean 的作用域、检查 bean 是否为单例、或获取 bean 的别名等。
+**与 `BeanFactory` 进行交互**： 获取 `BeanFactory` 的引用不仅仅是为了查找其他 beans，bean 还可以与其所在的 `BeanFactory` 进行更广泛的互动，例如检查 bean 的作用域、检查 bean 是否为单例、或获取 bean 的别名等。
-
+
-### 四、最佳实践
+### 四、最佳实践
-
+
-首先来看看启动类入口，上下文环境使用`AnnotationConfigApplicationContext`（此类是使用Java注解来配置Spring容器的方式），构造参数我们给定了一个`MyConfiguration`组件类。然后从Spring上下文中获取一个`UserService`类型的bean，最后调用`validateUser`方法。
+首先来看看启动类入口，上下文环境使用`AnnotationConfigApplicationContext`（此类是使用Java注解来配置Spring容器的方式），构造参数我们给定了一个`MyConfiguration`组件类。然后从Spring上下文中获取一个`UserService`类型的bean，最后调用`validateUser`方法。
-
+
-```java
+```java
-public class BeanNameAwareApplication {
+public class BeanNameAwareApplication {
-
+
-    public static void main(String[] args) {
+    public static void main(String[] args) {
-        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyConfiguration.class);
+        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyConfiguration.class);
-        UserService userService = context.getBean(UserService.class);
+        UserService userService = context.getBean(UserService.class);
-        userService.validateUser("root", "123456");
+        userService.validateUser("root", "123456");
-    }
+    }
-}
+}
-```
+```
-
+
-使用`@ComponentScan`注解，告诉 Spring 容器去 "`com.xcs.spring.validate`" "`com.xcs.spring.service`"扫描包及其子包
+使用`@ComponentScan`注解，告诉 Spring 容器去 "`com.xcs.spring.validate`" "`com.xcs.spring.service`"扫描包及其子包
-
+
-```java
+```java
-@Configuration
+@Configuration
-@ComponentScan({"com.xcs.spring.validate", "com.xcs.spring.service"})
+@ComponentScan({"com.xcs.spring.validate", "com.xcs.spring.service"})
-public class MyConfiguration {
+public class MyConfiguration {
-
+
-}
+}
-```
+```
-
+
-**UserValidator**是一个简单的验证器接口，具有一个方法 `validate`，用于验证用户名和密码是否有效。SimpleUserValidator是一个实现。它进行简单的验证，仅检查用户名和密码是否为非空。`ComplexUserValidator` 是 `UserValidator` 接口的另一个实现。这个验证器有点复杂，除了检查用户名和密码是否为空外，还检查用户名的长度是否大于 5 以及密码的长度是否大于 8。
+**UserValidator**是一个简单的验证器接口，具有一个方法 `validate`，用于验证用户名和密码是否有效。SimpleUserValidator是一个实现。它进行简单的验证，仅检查用户名和密码是否为非空。`ComplexUserValidator` 是 `UserValidator` 接口的另一个实现。这个验证器有点复杂，除了检查用户名和密码是否为空外，还检查用户名的长度是否大于 5 以及密码的长度是否大于 8。
-
+
-```java
+```java
-public interface UserValidator {
+public interface UserValidator {
-    boolean validate(String username, String password);
+    boolean validate(String username, String password);
-}
+}
-
+
-@Component("simpleUserValidator")
+@Component("simpleUserValidator")
-public class SimpleUserValidator implements UserValidator {
+public class SimpleUserValidator implements UserValidator {
-    @Override
+    @Override
-    public boolean validate(String username, String password) {
+    public boolean validate(String username, String password) {
-        System.out.println("使用SimpleUserValidator");
+        System.out.println("使用SimpleUserValidator");
-        return username != null && password != null;
+        return username != null && password != null;
-    }
+    }
-}
+}
-
+
-@Component("complexUserValidator")
+@Component("complexUserValidator")
-public class ComplexUserValidator implements UserValidator {
+public class ComplexUserValidator implements UserValidator {
-    @Override
+    @Override
-    public boolean validate(String username, String password) {
+    public boolean validate(String username, String password) {
-        System.out.println("使用ComplexUserValidator");
+        System.out.println("使用ComplexUserValidator");
-        return username != null && username.length() > 5 && password != null && password.length() > 8;
+        return username != null && username.length() > 5 && password != null && password.length() > 8;
-    }
+    }
-}
+}
-```
+```
-
+
-`UserService` 类利用了 Spring 的 `BeanFactoryAware` 和 `InitializingBean` 接口，动态地选择了一个验证器。这种设计提供了极大的灵活性，允许 `UserService` 根据不同的配置或条件使用不同的验证方法。这也意味着在未来，如果需要添加更多的验证方法，只需简单地添加新的验证器实现，然后在 `someConfigurationMethod()` 中进行相应的调整。
+`UserService` 类利用了 Spring 的 `BeanFactoryAware` 和 `InitializingBean` 接口，动态地选择了一个验证器。这种设计提供了极大的灵活性，允许 `UserService` 根据不同的配置或条件使用不同的验证方法。这也意味着在未来，如果需要添加更多的验证方法，只需简单地添加新的验证器实现，然后在 `someConfigurationMethod()` 中进行相应的调整。
-
+
-```java
+```java
-@Service
+@Service
-public class UserService implements BeanFactoryAware, InitializingBean {
+public class UserService implements BeanFactoryAware, InitializingBean {
-
+
-    private BeanFactory beanFactory;
+    private BeanFactory beanFactory;
-    private UserValidator userValidator;
+    private UserValidator userValidator;
-
+
-    @Override
+    @Override
-    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
+    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
-        this.beanFactory = beanFactory;
+        this.beanFactory = beanFactory;
-    }
+    }
-
+
-    @Override
+    @Override
-    public void afterPropertiesSet() throws Exception {
+    public void afterPropertiesSet() throws Exception {
-        if (someConfigurationMethod()) {
+        if (someConfigurationMethod()) {
-            userValidator = beanFactory.getBean("simpleUserValidator", UserValidator.class);
+            userValidator = beanFactory.getBean("simpleUserValidator", UserValidator.class);
-        } else {
+        } else {
-            userValidator = beanFactory.getBean("complexUserValidator", UserValidator.class);
+            userValidator = beanFactory.getBean("complexUserValidator", UserValidator.class);
-        }
+        }
-    }
+    }
-
+
-    public void validateUser(String username, String password) {
+    public void validateUser(String username, String password) {
-        boolean success = userValidator.validate(username, password);
+        boolean success = userValidator.validate(username, password);
-        if (success){
+        if (success){
-            System.out.println("验证账号密码成功");
+            System.out.println("验证账号密码成功");
-        }else{
+        }else{
-            System.out.println("验证账号密码失败");
+            System.out.println("验证账号密码失败");
-        }
+        }
-    }
+    }
-
+
-    private boolean someConfigurationMethod() {
+    private boolean someConfigurationMethod() {
-        return true;
+        return true;
-    }
+    }
-}
+}
-```
+```
-
+
-运行结果发现，使用了`SimpleUserValidator`来验证账号密码，并且验证成功。
+运行结果发现，使用了`SimpleUserValidator`来验证账号密码，并且验证成功。
-
+
-```java
+```java
-使用SimpleUserValidator
+使用SimpleUserValidator
-验证账号密码成功
+验证账号密码成功
-```
+```
-
+
-### 五、时序图
+### 五、时序图
-
+
-~~~mermaid
+~~~mermaid
-sequenceDiagram
+sequenceDiagram
-    Title: BeanFactoryAware时序图
+    Title: BeanFactoryAware时序图
-    participant BeanFactoryAwareApplication
+    participant BeanFactoryAwareApplication
-    participant AnnotationConfigApplicationContext
+    participant AnnotationConfigApplicationContext
-    participant AbstractApplicationContext
+    participant AbstractApplicationContext
-    participant DefaultListableBeanFactory
+    participant DefaultListableBeanFactory
-    participant AbstractBeanFactory
+    participant AbstractBeanFactory
-    participant DefaultSingletonBeanRegistry
+    participant DefaultSingletonBeanRegistry
-    participant AbstractAutowireCapableBeanFactory
+    participant AbstractAutowireCapableBeanFactory
-    participant UserService
+    participant UserService
-    
+    
-    BeanFactoryAwareApplication->>AnnotationConfigApplicationContext:AnnotationConfigApplicationContext(componentClasses)<br>创建上下文
+    BeanFactoryAwareApplication->>AnnotationConfigApplicationContext:AnnotationConfigApplicationContext(componentClasses)<br>创建上下文
-    AnnotationConfigApplicationContext->>AbstractApplicationContext:refresh()<br>刷新上下文
+    AnnotationConfigApplicationContext->>AbstractApplicationContext:refresh()<br>刷新上下文
-    AbstractApplicationContext->>AbstractApplicationContext:finishBeanFactoryInitialization(beanFactory)<br>初始化Bean工厂
+    AbstractApplicationContext->>AbstractApplicationContext:finishBeanFactoryInitialization(beanFactory)<br>初始化Bean工厂
-    AbstractApplicationContext->>DefaultListableBeanFactory:preInstantiateSingletons()<br>实例化单例
+    AbstractApplicationContext->>DefaultListableBeanFactory:preInstantiateSingletons()<br>实例化单例
-    DefaultListableBeanFactory->>AbstractBeanFactory:getBean(name)<br>获取Bean
+    DefaultListableBeanFactory->>AbstractBeanFactory:getBean(name)<br>获取Bean
-    AbstractBeanFactory->>AbstractBeanFactory:doGetBean(name,requiredType,args,typeCheckOnly)<br>执行获取Bean
+    AbstractBeanFactory->>AbstractBeanFactory:doGetBean(name,requiredType,args,typeCheckOnly)<br>执行获取Bean
-    AbstractBeanFactory->>DefaultSingletonBeanRegistry:getSingleton(beanName,singletonFactory)<br>获取单例Bean
+    AbstractBeanFactory->>DefaultSingletonBeanRegistry:getSingleton(beanName,singletonFactory)<br>获取单例Bean
-    DefaultSingletonBeanRegistry-->>AbstractBeanFactory:getObject()<br>获取Bean实例
+    DefaultSingletonBeanRegistry-->>AbstractBeanFactory:getObject()<br>获取Bean实例
-    AbstractBeanFactory->>AbstractAutowireCapableBeanFactory:createBean(beanName,mbd,args)<br>创建Bean
+    AbstractBeanFactory->>AbstractAutowireCapableBeanFactory:createBean(beanName,mbd,args)<br>创建Bean
-    AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:doCreateBean(beanName,mbd,args)<br>执行Bean创建
+    AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:doCreateBean(beanName,mbd,args)<br>执行Bean创建
-    AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:initializeBean(beanName,bean,mbd)<br>负责bean的初始化
+    AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:initializeBean(beanName,bean,mbd)<br>负责bean的初始化
-    AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:invokeAwareMethods(beanName, bean)<br>调用Aware方法
+    AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:invokeAwareMethods(beanName, bean)<br>调用Aware方法
-    AbstractAutowireCapableBeanFactory->>UserService:setBeanFactory(beanFactory)<br>设置beanFactory
+    AbstractAutowireCapableBeanFactory->>UserService:setBeanFactory(beanFactory)<br>设置beanFactory
-    AbstractAutowireCapableBeanFactory-->>AbstractBeanFactory:返回Bean对象
+    AbstractAutowireCapableBeanFactory-->>AbstractBeanFactory:返回Bean对象
-    AbstractBeanFactory-->>DefaultListableBeanFactory:返回Bean对象
+    AbstractBeanFactory-->>DefaultListableBeanFactory:返回Bean对象
-    AnnotationConfigApplicationContext-->>BeanFactoryAwareApplication:初始化完成
+    AnnotationConfigApplicationContext-->>BeanFactoryAwareApplication:初始化完成
-
+
-~~~
+~~~
-
+
-### 六、源码分析
+### 六、源码分析
-
+
-首先来看看启动类入口，上下文环境使用`AnnotationConfigApplicationContext`（此类是使用Java注解来配置Spring容器的方式），构造参数我们给定了一个`MyConfiguration`组件类。然后从Spring上下文中获取一个`UserService`类型的bean，最后调用`validateUser`方法。
+首先来看看启动类入口，上下文环境使用`AnnotationConfigApplicationContext`（此类是使用Java注解来配置Spring容器的方式），构造参数我们给定了一个`MyConfiguration`组件类。然后从Spring上下文中获取一个`UserService`类型的bean，最后调用`validateUser`方法。
-
+
-```java
+```java
-public class BeanNameAwareApplication {
+public class BeanNameAwareApplication {
-
+
-    public static void main(String[] args) {
+    public static void main(String[] args) {
-        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyConfiguration.class);
+        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyConfiguration.class);
-        UserService userService = context.getBean(UserService.class);
+        UserService userService = context.getBean(UserService.class);
-        userService.validateUser("root", "123456");
+        userService.validateUser("root", "123456");
-    }
+    }
-}
+}
-```
+```
-
+
-在`org.springframework.context.annotation.AnnotationConfigApplicationContext#AnnotationConfigApplicationContext`构造函数中，执行了三个步骤，我们重点关注`refresh()`方法
+在`org.springframework.context.annotation.AnnotationConfigApplicationContext#AnnotationConfigApplicationContext`构造函数中，执行了三个步骤，我们重点关注`refresh()`方法
-
+
-```java
+```java
-public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
+public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
-    this();
+    this();
-    register(componentClasses);
+    register(componentClasses);
-    refresh();
+    refresh();
-}
+}
-```
+```
-
+
-在`org.springframework.context.support.AbstractApplicationContext#refresh`方法中我们重点关注一下`finishBeanFactoryInitialization(beanFactory)`这方法会对实例化所有剩余非懒加载的单列Bean对象，其他方法不是本次源码阅读的重点暂时忽略。
+在`org.springframework.context.support.AbstractApplicationContext#refresh`方法中我们重点关注一下`finishBeanFactoryInitialization(beanFactory)`这方法会对实例化所有剩余非懒加载的单列Bean对象，其他方法不是本次源码阅读的重点暂时忽略。
-
+
-```java
+```java
-@Override
+@Override
-public void refresh() throws BeansException, IllegalStateException {
+public void refresh() throws BeansException, IllegalStateException {
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-    // Instantiate all remaining (non-lazy-init) singletons.
+    // Instantiate all remaining (non-lazy-init) singletons.
-    finishBeanFactoryInitialization(beanFactory);
+    finishBeanFactoryInitialization(beanFactory);
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-}
+}
-```
+```
-
+
-在`org.springframework.context.support.AbstractApplicationContext#finishBeanFactoryInitialization`方法中，会继续调用`DefaultListableBeanFactory`类中的`preInstantiateSingletons`方法来完成所有剩余非懒加载的单列Bean对象。
+在`org.springframework.context.support.AbstractApplicationContext#finishBeanFactoryInitialization`方法中，会继续调用`DefaultListableBeanFactory`类中的`preInstantiateSingletons`方法来完成所有剩余非懒加载的单列Bean对象。
-
+
-```java
+```java
-/**
+/**
- * 完成此工厂的bean初始化，实例化所有剩余的非延迟初始化单例bean。
+ * 完成此工厂的bean初始化，实例化所有剩余的非延迟初始化单例bean。
- * 
+ * 
- * @param beanFactory 要初始化的bean工厂
+ * @param beanFactory 要初始化的bean工厂
- */
+ */
-protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
+protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-    // 完成所有剩余非懒加载的单列Bean对象。
+    // 完成所有剩余非懒加载的单列Bean对象。
-    beanFactory.preInstantiateSingletons();
+    beanFactory.preInstantiateSingletons();
-}
+}
-```
+```
-
+
-在`org.springframework.beans.factory.support.DefaultListableBeanFactory#preInstantiateSingletons`方法中，主要的核心目的是预先实例化所有非懒加载的单例bean。在Spring的上下文初始化完成后，该方法会被触发，以确保所有单例bean都被正确地创建并初始化。其中`getBean(beanName)`是此方法的核心操作。对于容器中定义的每一个单例bean，它都会调用`getBean`方法，这将触发bean的实例化、初始化及其依赖的注入。如果bean之前没有被创建过，那么这个调用会导致其被实例化和初始化。
+在`org.springframework.beans.factory.support.DefaultListableBeanFactory#preInstantiateSingletons`方法中，主要的核心目的是预先实例化所有非懒加载的单例bean。在Spring的上下文初始化完成后，该方法会被触发，以确保所有单例bean都被正确地创建并初始化。其中`getBean(beanName)`是此方法的核心操作。对于容器中定义的每一个单例bean，它都会调用`getBean`方法，这将触发bean的实例化、初始化及其依赖的注入。如果bean之前没有被创建过，那么这个调用会导致其被实例化和初始化。
-
+
-```java
+```java
-public void preInstantiateSingletons() throws BeansException {
+public void preInstantiateSingletons() throws BeansException {
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-    // 循环遍历所有bean的名称
+    // 循环遍历所有bean的名称
-    for (String beanName : beanNames) {
+    for (String beanName : beanNames) {
-        getBean(beanName);
+        getBean(beanName);
-    }
+    }
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-}
+}
-```
+```
-
+
-在`org.springframework.beans.factory.support.AbstractBeanFactory#getBean()`方法中，又调用了`doGetBean`方法来实际执行创建Bean的过程，传递给它bean的名称和一些其他默认的参数值。此处，`doGetBean`负责大部分工作，如查找bean定义、创建bean（如果尚未创建）、处理依赖关系等。
+在`org.springframework.beans.factory.support.AbstractBeanFactory#getBean()`方法中，又调用了`doGetBean`方法来实际执行创建Bean的过程，传递给它bean的名称和一些其他默认的参数值。此处，`doGetBean`负责大部分工作，如查找bean定义、创建bean（如果尚未创建）、处理依赖关系等。
-
+
-```java
+```java
-@Override
+@Override
-public Object getBean(String name) throws BeansException {
+public Object getBean(String name) throws BeansException {
-    return doGetBean(name, null, null, false);
+    return doGetBean(name, null, null, false);
-}
+}
-```
+```
-
+
-在`org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean`方法中，首先检查所请求的bean是否是一个单例并且已经创建。如果尚未创建，它将创建一个新的实例。在这个过程中，它处理可能的异常情况，如循环引用，并确保返回的bean是正确的类型。这是Spring容器bean生命周期管理的核心部分。
+在`org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean`方法中，首先检查所请求的bean是否是一个单例并且已经创建。如果尚未创建，它将创建一个新的实例。在这个过程中，它处理可能的异常情况，如循环引用，并确保返回的bean是正确的类型。这是Spring容器bean生命周期管理的核心部分。
-
+
-```java
+```java
-protected <T> T doGetBean(
+protected <T> T doGetBean(
-        String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
+        String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
-        throws BeansException {
+        throws BeansException {
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-
+
-    // 开始创建bean实例
+    // 开始创建bean实例
-    if (mbd.isSingleton()) {
+    if (mbd.isSingleton()) {
-        // 如果bean是单例的，我们会尝试从单例缓存中获取它
+        // 如果bean是单例的，我们会尝试从单例缓存中获取它
-        // 如果不存在，则使用lambda创建一个新的实例
+        // 如果不存在，则使用lambda创建一个新的实例
-        sharedInstance = getSingleton(beanName, () -> {
+        sharedInstance = getSingleton(beanName, () -> {
-            try {
+            try {
-                // 尝试创建bean实例
+                // 尝试创建bean实例
-                return createBean(beanName, mbd, args);
+                return createBean(beanName, mbd, args);
-            }
+            }
-            catch (BeansException ex) {
+            catch (BeansException ex) {
-                // ... [代码部分省略以简化]
+                // ... [代码部分省略以简化]
-            }
+            }
-        });
+        });
-        // 对于某些bean（例如FactoryBeans），可能需要进一步处理以获取真正的bean实例
+        // 对于某些bean（例如FactoryBeans），可能需要进一步处理以获取真正的bean实例
-        beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
+        beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
-    }
+    }
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-
+
-    // 确保返回的bean实例与请求的类型匹配
+    // 确保返回的bean实例与请求的类型匹配
-    return adaptBeanInstance(name, beanInstance, requiredType);
+    return adaptBeanInstance(name, beanInstance, requiredType);
-}
+}
-```
+```
-
+
-在`org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton()`方法中，主要负责从单例缓存中获取一个已存在的bean实例，或者使用提供的`ObjectFactory`创建一个新的实例。这是确保bean在Spring容器中作为单例存在的关键部分。
+在`org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton()`方法中，主要负责从单例缓存中获取一个已存在的bean实例，或者使用提供的`ObjectFactory`创建一个新的实例。这是确保bean在Spring容器中作为单例存在的关键部分。
-
+
-```java
+```java
-public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
+public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
-    // 断言bean名称不能为空
+    // 断言bean名称不能为空
-    Assert.notNull(beanName, "Bean name must not be null");
+    Assert.notNull(beanName, "Bean name must not be null");
-
+
-    // 同步访问单例对象缓存，确保线程安全
+    // 同步访问单例对象缓存，确保线程安全
-    synchronized (this.singletonObjects) {
+    synchronized (this.singletonObjects) {
-        // 从缓存中获取单例对象
+        // 从缓存中获取单例对象
-        Object singletonObject = this.singletonObjects.get(beanName);
+        Object singletonObject = this.singletonObjects.get(beanName);
-
+
-        // 如果缓存中没有找到
+        // 如果缓存中没有找到
-        if (singletonObject == null) {
+        if (singletonObject == null) {
-            // ... [代码部分省略以简化]
+            // ... [代码部分省略以简化]
-
+
-            try {
+            try {
-                // 使用工厂创建新的单例实例
+                // 使用工厂创建新的单例实例
-                singletonObject = singletonFactory.getObject();
+                singletonObject = singletonFactory.getObject();
-                newSingleton = true;
+                newSingleton = true;
-            }
+            }
-            catch (IllegalStateException ex) {
+            catch (IllegalStateException ex) {
-                // ... [代码部分省略以简化]
+                // ... [代码部分省略以简化]
-            }
+            }
-            catch (BeanCreationException ex) {
+            catch (BeanCreationException ex) {
-                // ... [代码部分省略以简化]
+                // ... [代码部分省略以简化]
-            }
+            }
-            finally {
+            finally {
-                // ... [代码部分省略以简化]
+                // ... [代码部分省略以简化]
-            }
+            }
-
+
-            // ... [代码部分省略以简化]
+            // ... [代码部分省略以简化]
-        }
+        }
-
+
-        // 返回单例对象
+        // 返回单例对象
-        return singletonObject;
+        return singletonObject;
-    }
+    }
-}
+}
-```
+```
-
+
-在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBean()`方法中，主要的逻辑是调用 `doCreateBean`，这是真正进行 bean 实例化、属性填充和初始化的地方。这个方法会返回新创建的 bean 实例。
+在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBean()`方法中，主要的逻辑是调用 `doCreateBean`，这是真正进行 bean 实例化、属性填充和初始化的地方。这个方法会返回新创建的 bean 实例。
-
+
-```java
+```java
-@Override
+@Override
-protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
+protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
-    throws BeanCreationException {
+    throws BeanCreationException {
-    
+    
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-    
+    
-    try {
+    try {
-        // 正常的bean实例化、属性注入和初始化。
+        // 正常的bean实例化、属性注入和初始化。
-        // 这里是真正进行bean创建的部分。
+        // 这里是真正进行bean创建的部分。
-        Object beanInstance = doCreateBean(beanName, mbdToUse, args);
+        Object beanInstance = doCreateBean(beanName, mbdToUse, args);
-        // 记录bean成功创建的日志
+        // 记录bean成功创建的日志
-        if (logger.isTraceEnabled()) {
+        if (logger.isTraceEnabled()) {
-            logger.trace("Finished creating instance of bean '" + beanName + "'");
+            logger.trace("Finished creating instance of bean '" + beanName + "'");
-        }
+        }
-        return beanInstance;
+        return beanInstance;
-    }
+    }
-    catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
+    catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
-        // ... [代码部分省略以简化]
+        // ... [代码部分省略以简化]
-    }
+    }
-    catch (Throwable ex) {
+    catch (Throwable ex) {
-        // ... [代码部分省略以简化]
+        // ... [代码部分省略以简化]
-    }
+    }
-}
+}
-```
+```
-
+
-在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean`方法中，`initializeBean`方法是bean初始化，确保bean是完全配置和准备好的。
+在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean`方法中，`initializeBean`方法是bean初始化，确保bean是完全配置和准备好的。
-
+
-```java
+```java
-protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
+protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
-        throws BeanCreationException {
+        throws BeanCreationException {
-
+
-    // 声明一个对象，后续可能用于存放初始化后的bean或它的代理对象
+    // 声明一个对象，后续可能用于存放初始化后的bean或它的代理对象
-    Object exposedObject = bean;
+    Object exposedObject = bean;
-
+
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-    
+    
-    try {
+    try {
-        // ... [代码部分省略以简化]
+        // ... [代码部分省略以简化]
-        
+        
-        // bean初始化
+        // bean初始化
-        exposedObject = initializeBean(beanName, exposedObject, mbd);
+        exposedObject = initializeBean(beanName, exposedObject, mbd);
-    } 
+    } 
-    catch (Throwable ex) {
+    catch (Throwable ex) {
-        // ... [代码部分省略以简化]
+        // ... [代码部分省略以简化]
-    }
+    }
-
+
-    // 返回创建和初始化后的bean
+    // 返回创建和初始化后的bean
-    return exposedObject;
+    return exposedObject;
-}
+}
-```
+```
-
+
-在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#initializeBean`方法中，`invokeAwareMethods(beanName, bean)`是一个非常重要的步骤。这个方法是为了处理实现了Spring的`Aware`接口族的Beans（例如`BeanNameAware`, `BeanFactoryAware`等）。如果提供的bean实现了任何这些接口，该方法会回调相应的`Aware`方法。
+在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#initializeBean`方法中，`invokeAwareMethods(beanName, bean)`是一个非常重要的步骤。这个方法是为了处理实现了Spring的`Aware`接口族的Beans（例如`BeanNameAware`, `BeanFactoryAware`等）。如果提供的bean实现了任何这些接口，该方法会回调相应的`Aware`方法。
-
+
-```java
+```java
-protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
+protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
-
+
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-    
+    
-    invokeAwareMethods(beanName, bean);
+    invokeAwareMethods(beanName, bean);
-    
+    
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-
+
-    return wrappedBean;
+    return wrappedBean;
-}
+}
-```
+```
-
+
-在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#invokeAwareMethods`方法中，用于处理实现了 Spring `Aware` 接口族的 beans。当一个 bean 实现了如 `BeanNameAware`、`BeanClassLoaderAware` 或 `BeanFactoryAware` 等接口时，此方法确保正确的回调方法被调用，从而为 bean 提供关于其运行环境或其他相关信息。
+在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#invokeAwareMethods`方法中，用于处理实现了 Spring `Aware` 接口族的 beans。当一个 bean 实现了如 `BeanNameAware`、`BeanClassLoaderAware` 或 `BeanFactoryAware` 等接口时，此方法确保正确的回调方法被调用，从而为 bean 提供关于其运行环境或其他相关信息。
-
+
-```java
+```java
-private void invokeAwareMethods(String beanName, Object bean) {
+private void invokeAwareMethods(String beanName, Object bean) {
-    if (bean instanceof Aware) {
+    if (bean instanceof Aware) {
-        if (bean instanceof BeanNameAware) {
+        if (bean instanceof BeanNameAware) {
-            // ... [代码部分省略以简化]
+            // ... [代码部分省略以简化]
-        }
+        }
-        if (bean instanceof BeanClassLoaderAware) {
+        if (bean instanceof BeanClassLoaderAware) {
-            // ... [代码部分省略以简化]
+            // ... [代码部分省略以简化]
-        }
+        }
-        if (bean instanceof BeanFactoryAware) {
+        if (bean instanceof BeanFactoryAware) {
-            ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
+            ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
-        }
+        }
-    }
+    }
-}
+}
-```
+```
-
+
-最后执行到我们自定义的逻辑中，容器将调用 `setBeanFactory()` 方法，并将当前的 bean factory 实例作为参数传递。
+最后执行到我们自定义的逻辑中，容器将调用 `setBeanFactory()` 方法，并将当前的 bean factory 实例作为参数传递。
-
+
-```java
+```java
-@Service
+@Service
-public class UserService implements BeanFactoryAware, InitializingBean {
+public class UserService implements BeanFactoryAware, InitializingBean {
-
+
-    private BeanFactory beanFactory;
+    private BeanFactory beanFactory;
-    private UserValidator userValidator;
+    private UserValidator userValidator;
-
+
-    @Override
+    @Override
-    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
+    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
-        this.beanFactory = beanFactory;
+        this.beanFactory = beanFactory;
-    }
+    }
-
+
-    @Override
+    @Override
-    public void afterPropertiesSet() throws Exception {
+    public void afterPropertiesSet() throws Exception {
-        // ... [代码部分省略以简化]
+        // ... [代码部分省略以简化]
-    }
+    }
-
+
-    public void validateUser(String username, String password) {
+    public void validateUser(String username, String password) {
-        // ... [代码部分省略以简化]
+        // ... [代码部分省略以简化]
-    }
+    }
-
+
-    private boolean someConfigurationMethod() {
+    private boolean someConfigurationMethod() {
-        return true;
+        return true;
-    }
+    }
-}
+}
-```
+```
-
+
-### 七、注意事项
+### 七、注意事项
-
+
-**生命周期时机**：`setBeanFactory` 方法是在 bean 属性设置之后但在其他初始化方法（如 `@PostConstruct`、`InitializingBean#afterPropertiesSet` 或指定的初始化方法）之前调用的。
+**生命周期时机**：`setBeanFactory` 方法是在 bean 属性设置之后但在其他初始化方法（如 `@PostConstruct`、`InitializingBean#afterPropertiesSet` 或指定的初始化方法）之前调用的。
-
+
-**避免循环依赖**：当 beans 通过 `BeanFactory` 查找其他 beans 时，可能会出现循环依赖的情况。例如，bean A 在其 `setBeanFactory` 方法中查找 bean B，而 bean B 在其 `setBeanFactory` 方法中查找 bean A。这种情况会导致容器初始化失败。
+**避免循环依赖**：当 beans 通过 `BeanFactory` 查找其他 beans 时，可能会出现循环依赖的情况。例如，bean A 在其 `setBeanFactory` 方法中查找 bean B，而 bean B 在其 `setBeanFactory` 方法中查找 bean A。这种情况会导致容器初始化失败。
-
+
-**知道 bean 的作用域**：当从 `BeanFactory` 获取 beans 时，请记住 bean 的作用域。如果 bean 是原型作用域的，每次 `getBean` 调用都会返回一个新的实例。
+**知道 bean 的作用域**：当从 `BeanFactory` 获取 beans 时，请记住 bean 的作用域。如果 bean 是原型作用域的，每次 `getBean` 调用都会返回一个新的实例。
-
+
-**不要过度自定义**：除非有很好的理由，否则应避免在 `setBeanFactory` 方法中执行大量的自定义逻辑。这会使 bean 的初始化过程变得复杂，并可能导致不可预见的副作用。
+**不要过度自定义**：除非有很好的理由，否则应避免在 `setBeanFactory` 方法中执行大量的自定义逻辑。这会使 bean 的初始化过程变得复杂，并可能导致不可预见的副作用。
-
+
-### 八、总结
+### 八、总结
-
+
-#### 8.1、最佳实践总结
+#### 8.1、最佳实践总结
-
+
-**构建与配置**：在 `BeanNameAwareApplication` 启动类中，使用了 `AnnotationConfigApplicationContext` 来基于 Java 配置类 (`MyConfiguration`) 初始化 Spring 上下文。这是一个 Java-based 的配置方法，与传统的 XML-based 配置相比，更加直观和灵活。
+**构建与配置**：在 `BeanNameAwareApplication` 启动类中，使用了 `AnnotationConfigApplicationContext` 来基于 Java 配置类 (`MyConfiguration`) 初始化 Spring 上下文。这是一个 Java-based 的配置方法，与传统的 XML-based 配置相比，更加直观和灵活。
-
+
-**组件扫描**：`MyConfiguration` 配置类使用 `@ComponentScan` 注解指定了需要被扫描的包路径。Spring 容器会自动扫描这些包以及其子包下的组件，并将它们注册为 Spring beans。
+**组件扫描**：`MyConfiguration` 配置类使用 `@ComponentScan` 注解指定了需要被扫描的包路径。Spring 容器会自动扫描这些包以及其子包下的组件，并将它们注册为 Spring beans。
-
+
-**验证器设计**：我们设计了一个 `UserValidator` 接口，以及两个实现该接口的类：`SimpleUserValidator` 和 `ComplexUserValidator`。这两个验证器具有不同的验证逻辑，以满足不同的验证需求。
+**验证器设计**：我们设计了一个 `UserValidator` 接口，以及两个实现该接口的类：`SimpleUserValidator` 和 `ComplexUserValidator`。这两个验证器具有不同的验证逻辑，以满足不同的验证需求。
-
+
-**动态选择验证器**：`UserService` 类是此应用的核心，它根据某些配置动态地从 `BeanFactory` 中选择一个验证器。这是通过实现 `BeanFactoryAware` 和 `InitializingBean` 接口来完成的：`BeanFactoryAware` 允许 `UserService` 访问 Spring 容器的 `BeanFactory`。InitializingBean` 确保在所有属性（例如依赖注入）设置完毕后，选择合适的验证器。
+**动态选择验证器**：`UserService` 类是此应用的核心，它根据某些配置动态地从 `BeanFactory` 中选择一个验证器。这是通过实现 `BeanFactoryAware` 和 `InitializingBean` 接口来完成的：`BeanFactoryAware` 允许 `UserService` 访问 Spring 容器的 `BeanFactory`。InitializingBean` 确保在所有属性（例如依赖注入）设置完毕后，选择合适的验证器。
-
+
-**运行与输出**：当调用 `validateUser` 方法验证用户名和密码时，根据所选择的验证器（在此示例中是 `SimpleUserValidator`），将输出相应的验证信息。此外，验证器本身也输出了它正在使用的验证方法。
+**运行与输出**：当调用 `validateUser` 方法验证用户名和密码时，根据所选择的验证器（在此示例中是 `SimpleUserValidator`），将输出相应的验证信息。此外，验证器本身也输出了它正在使用的验证方法。
-
+
-#### 8.2、源码分析总结
+#### 8.2、源码分析总结
-
+
-**应用启动与上下文初始化**: 当启动类 `BeanNameAwareApplication` 被执行，一个新的 `AnnotationConfigApplicationContext` 被创建并初始化，其中传入了配置类 `MyConfiguration`。
+**应用启动与上下文初始化**: 当启动类 `BeanNameAwareApplication` 被执行，一个新的 `AnnotationConfigApplicationContext` 被创建并初始化，其中传入了配置类 `MyConfiguration`。
-
+
-**配置类与组件扫描**: `MyConfiguration` 是一个 Java 配置类，它告诉 Spring 容器去扫描特定的包以查找组件。
+**配置类与组件扫描**: `MyConfiguration` 是一个 Java 配置类，它告诉 Spring 容器去扫描特定的包以查找组件。
-
+
-**单例bean的预实例化**: 在上下文的 `refresh()` 方法中，Spring 会预先实例化所有非懒加载的单例bean。这意味着在容器启动时，这些bean会被初始化。
+**单例bean的预实例化**: 在上下文的 `refresh()` 方法中，Spring 会预先实例化所有非懒加载的单例bean。这意味着在容器启动时，这些bean会被初始化。
-
+
-**Bean的实例化和初始化**: 在上下文刷新的过程中，Spring 容器会逐个创建并初始化所有的单例bean。`doCreateBean` 方法负责实例化bean、注入依赖、并调用任何初始化方法。
+**Bean的实例化和初始化**: 在上下文刷新的过程中，Spring 容器会逐个创建并初始化所有的单例bean。`doCreateBean` 方法负责实例化bean、注入依赖、并调用任何初始化方法。
-
+
-**处理 Aware 接口**: 对于实现了 `Aware` 接口的bean，如 `BeanFactoryAware`，在初始化过程中，Spring 容器会调用相应的 `Aware` 方法（例如，`setBeanFactory`）。这使得bean可以获得关于其运行环境的信息或其他 Spring 功能。
+**处理 Aware 接口**: 对于实现了 `Aware` 接口的bean，如 `BeanFactoryAware`，在初始化过程中，Spring 容器会调用相应的 `Aware` 方法（例如，`setBeanFactory`）。这使得bean可以获得关于其运行环境的信息或其他 Spring 功能。
-
+
-**自定义逻辑执行**: 一旦bean被初始化，并且所有的 `Aware` 方法都被调用，就可以执行自定义逻辑。在这个例子中，这是通过 `UserService` 的 `validateUser` 方法来完成的。
+**自定义逻辑执行**: 一旦bean被初始化，并且所有的 `Aware` 方法都被调用，就可以执行自定义逻辑。在这个例子中，这是通过 `UserService` 的 `validateUser` 方法来完成的。
-
+
 **BeanFactoryAware 的特性**: 通过实现 `BeanFactoryAware`，`UserService` 能够获得对 `BeanFactory` 的访问权限。这使得它可以在运行时动态地从 `BeanFactory` 中获取bean，如在示例中的 `UserValidator`。

spring-aware/spring-aware-beanFactoryAware/pom.xml

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <parent>
+        <artifactId>spring-aware</artifactId>
+        <groupId>com.xcs.spring</groupId>
+        <version>0.0.1-SNAPSHOT</version>
+    </parent>
+
+    <modelVersion>4.0.0</modelVersion>
+    <artifactId>spring-aware-beanFactoryAware</artifactId>
+
+</project>

spring-aware/spring-aware-beanFactoryAware/src/main/java/com/xcs/spring/service/UserService.java

@@ -1,42 +1,42 @@
-package com.xcs.spring.service;
+package com.xcs.spring.service;
-
+
-import com.xcs.spring.validate.UserValidator;
+import com.xcs.spring.validate.UserValidator;
-import org.springframework.beans.BeansException;
+import org.springframework.beans.BeansException;
-import org.springframework.beans.factory.BeanFactory;
+import org.springframework.beans.factory.BeanFactory;
-import org.springframework.beans.factory.BeanFactoryAware;
+import org.springframework.beans.factory.BeanFactoryAware;
-import org.springframework.beans.factory.InitializingBean;
+import org.springframework.beans.factory.InitializingBean;
-import org.springframework.stereotype.Service;
+import org.springframework.stereotype.Service;
-
+
-@Service
+@Service
-public class UserService implements BeanFactoryAware, InitializingBean {
+public class UserService implements BeanFactoryAware, InitializingBean {
-
+
-    private BeanFactory beanFactory;
+    private BeanFactory beanFactory;
-    private UserValidator userValidator;
+    private UserValidator userValidator;
-
+
-    @Override
+    @Override
-    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
+    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
-        this.beanFactory = beanFactory;
+        this.beanFactory = beanFactory;
-    }
+    }
-
+
-    @Override
+    @Override
-    public void afterPropertiesSet() throws Exception {
+    public void afterPropertiesSet() throws Exception {
-        if (someConfigurationMethod()) {
+        if (someConfigurationMethod()) {
-            userValidator = beanFactory.getBean("simpleUserValidator", UserValidator.class);
+            userValidator = beanFactory.getBean("simpleUserValidator", UserValidator.class);
-        } else {
+        } else {
-            userValidator = beanFactory.getBean("complexUserValidator", UserValidator.class);
+            userValidator = beanFactory.getBean("complexUserValidator", UserValidator.class);
-        }
+        }
-    }
+    }
-
+
-    public void validateUser(String username, String password) {
+    public void validateUser(String username, String password) {
-        boolean success = userValidator.validate(username, password);
+        boolean success = userValidator.validate(username, password);
-        if (success){
+        if (success){
-            System.out.println("验证账号密码成功");
+            System.out.println("验证账号密码成功");
-        }else{
+        }else{
-            System.out.println("验证账号密码失败");
+            System.out.println("验证账号密码失败");
-        }
+        }
-    }
+    }
-
+
-    private boolean someConfigurationMethod() {
+    private boolean someConfigurationMethod() {
-        return true;
+        return true;
-    }
+    }
-}
+}

spring-aware/spring-aware-beanFactoryAware/src/main/java/com/xcs/spring/validate/ComplexUserValidator.java

@@ -1,12 +1,12 @@
-package com.xcs.spring.validate;
+package com.xcs.spring.validate;
-
+
-import org.springframework.stereotype.Component;
+import org.springframework.stereotype.Component;
-
+
-@Component("complexUserValidator")
+@Component("complexUserValidator")
-public class ComplexUserValidator implements UserValidator {
+public class ComplexUserValidator implements UserValidator {
-    @Override
+    @Override
-    public boolean validate(String username, String password) {
+    public boolean validate(String username, String password) {
-        System.out.println("使用ComplexUserValidator");
+        System.out.println("使用ComplexUserValidator");
-        return username != null && username.length() > 5 && password != null && password.length() > 8;
+        return username != null && username.length() > 5 && password != null && password.length() > 8;
-    }
+    }
-}
+}

spring-aware/spring-aware-beanFactoryAware/src/main/java/com/xcs/spring/validate/SimpleUserValidator.java

@@ -1,12 +1,12 @@
-package com.xcs.spring.validate;
+package com.xcs.spring.validate;
-
+
-import org.springframework.stereotype.Component;
+import org.springframework.stereotype.Component;
-
+
-@Component("simpleUserValidator")
+@Component("simpleUserValidator")
-public class SimpleUserValidator implements UserValidator {
+public class SimpleUserValidator implements UserValidator {
-    @Override
+    @Override
-    public boolean validate(String username, String password) {
+    public boolean validate(String username, String password) {
-        System.out.println("使用SimpleUserValidator");
+        System.out.println("使用SimpleUserValidator");
-        return username != null && password != null;
+        return username != null && password != null;
-    }
+    }
-}
+}

spring-aware/spring-aware-beanFactoryAware/src/main/java/com/xcs/spring/validate/UserValidator.java

@@ -1,5 +1,5 @@
-package com.xcs.spring.validate;
+package com.xcs.spring.validate;
-
+
-public interface UserValidator {
+public interface UserValidator {
-    boolean validate(String username, String password);
+    boolean validate(String username, String password);
-}
+}

spring-aware/spring-aware-beanNameAware/README.md

@@ -1,454 +1,454 @@
-## BeanNameAware
+## BeanNameAware
-
+
-- [BeanNameAware](#beannameaware)
+- [BeanNameAware](#beannameaware)
-  - [一、接口描述](#一接口描述)
+  - [一、接口描述](#一接口描述)
-  - [二、接口源码](#二接口源码)
+  - [二、接口源码](#二接口源码)
-  - [三、主要功能](#三主要功能)
+  - [三、主要功能](#三主要功能)
-  - [四、最佳实践](#四最佳实践)
+  - [四、最佳实践](#四最佳实践)
-  - [五、时序图](#五时序图)
+  - [五、时序图](#五时序图)
-  - [六、源码分析](#六源码分析)
+  - [六、源码分析](#六源码分析)
-  - [七、注意事项](#七注意事项)
+  - [七、注意事项](#七注意事项)
-  - [八、总结](#八总结)
+  - [八、总结](#八总结)
-    - [8.1、最佳实践总结](#81最佳实践总结)
+    - [8.1、最佳实践总结](#81最佳实践总结)
-    - [8.2、源码分析总结](#82源码分析总结)
+    - [8.2、源码分析总结](#82源码分析总结)
-
+
-### 一、接口描述
+### 一、接口描述
-
+
-`BeanNameAware` 接口。当一个 Bean 实现了此接口，可以感知其在 Spring 容器中的名称。
+`BeanNameAware` 接口。当一个 Bean 实现了此接口，可以感知其在 Spring 容器中的名称。
-
+
-### 二、接口源码
+### 二、接口源码
-
+
-`BeanNameAware` 是 Spring 框架自 01.11.2003 开始引入的一个核心接口。这个接口是为那些想要了解其在 bean 工厂中的名称的 beans 设计的。
+`BeanNameAware` 是 Spring 框架自 01.11.2003 开始引入的一个核心接口。这个接口是为那些想要了解其在 bean 工厂中的名称的 beans 设计的。
-
+
-```java
+```java
-/**
+/**
- * 由希望知道其在 bean 工厂中名称的 beans 实现的接口。
+ * 由希望知道其在 bean 工厂中名称的 beans 实现的接口。
- * 注意通常不推荐一个对象依赖于其 bean 名称，因为这可能导致对外部配置的脆弱依赖，
+ * 注意通常不推荐一个对象依赖于其 bean 名称，因为这可能导致对外部配置的脆弱依赖，
- * 以及可能的不必要的对 Spring API 的依赖。
+ * 以及可能的不必要的对 Spring API 的依赖。
- *
+ *
- * 有关所有 bean 生命周期方法的列表，请参见
+ * 有关所有 bean 生命周期方法的列表，请参见
- * BeanFactory BeanFactory javadocs。
+ * BeanFactory BeanFactory javadocs。
- *
+ *
- * @author Juergen Hoeller
+ * @author Juergen Hoeller
- * @author Chris Beams
+ * @author Chris Beams
- * @since 01.11.2003
+ * @since 01.11.2003
- * @see BeanClassLoaderAware
+ * @see BeanClassLoaderAware
- * @see BeanFactoryAware
+ * @see BeanFactoryAware
- * @see InitializingBean
+ * @see InitializingBean
- */
+ */
-public interface BeanNameAware extends Aware {
+public interface BeanNameAware extends Aware {
-
+
-	/**
+	/**
-	 * 设置在创建此 bean 的 bean 工厂中的 bean 的名称。
+	 * 设置在创建此 bean 的 bean 工厂中的 bean 的名称。
-	 * 此方法在填充常规 bean 属性之后被调用，但在如 InitializingBean#afterPropertiesSet() 这样的
+	 * 此方法在填充常规 bean 属性之后被调用，但在如 InitializingBean#afterPropertiesSet() 这样的
-	 * 初始化回调或自定义初始化方法之前被调用。
+	 * 初始化回调或自定义初始化方法之前被调用。
-	 * @param name 工厂中的 bean 的名称。注意，这个名称是工厂中使用的实际 bean 名称，
+	 * @param name 工厂中的 bean 的名称。注意，这个名称是工厂中使用的实际 bean 名称，
-     * 这可能与最初指定的名称不同：尤其对于内部 bean 名称，实际的 bean 名称可能已通过添加 "#..." 后缀变得唯一。
+     * 这可能与最初指定的名称不同：尤其对于内部 bean 名称，实际的 bean 名称可能已通过添加 "#..." 后缀变得唯一。
-     * 如果需要，可以使用 BeanFactoryUtils#originalBeanName(String) 方法来提取没有后缀的原始 bean 名称。
+     * 如果需要，可以使用 BeanFactoryUtils#originalBeanName(String) 方法来提取没有后缀的原始 bean 名称。
-	 */
+	 */
-	void setBeanName(String name);
+	void setBeanName(String name);
-
+
-}
+}
-```
+```
-
+
-### 三、主要功能
+### 三、主要功能
-
+
-**提供 `setBeanName` 方法**：当一个 Bean 实现了 `BeanNameAware` 接口，它需要提供 `setBeanName` 方法的实现。这个方法有一个参数，即该 Bean 在 Spring 容器中的名称。
+**提供 `setBeanName` 方法**：当一个 Bean 实现了 `BeanNameAware` 接口，它需要提供 `setBeanName` 方法的实现。这个方法有一个参数，即该 Bean 在 Spring 容器中的名称。
-
+
-**自动回调**：当 Spring 容器创建并配置一个实现了 `BeanNameAware` 接口的 Bean 时，容器会自动回调 `setBeanName` 方法，并传入该 Bean 在容器中的名称。这意味着开发者不需要显式地调用这个方法；Spring 容器会自动处理。
+**自动回调**：当 Spring 容器创建并配置一个实现了 `BeanNameAware` 接口的 Bean 时，容器会自动回调 `setBeanName` 方法，并传入该 Bean 在容器中的名称。这意味着开发者不需要显式地调用这个方法；Spring 容器会自动处理。
-
+
-**获取 Bean 的名称**：有时，Bean 可能需要知道其在容器中的名称以执行特定的逻辑或功能，或者为了日志记录或其他目的。通过实现 `BeanNameAware`，Bean 可以轻松获得此信息。
+**获取 Bean 的名称**：有时，Bean 可能需要知道其在容器中的名称以执行特定的逻辑或功能，或者为了日志记录或其他目的。通过实现 `BeanNameAware`，Bean 可以轻松获得此信息。
-
+
-### 四、最佳实践
+### 四、最佳实践
-
+
-首先来看看启动类入口，上下文环境使用`AnnotationConfigApplicationContext`（此类是使用Java注解来配置Spring容器的方式），构造参数我们给定了一个`MyConfiguration`组件类。
+首先来看看启动类入口，上下文环境使用`AnnotationConfigApplicationContext`（此类是使用Java注解来配置Spring容器的方式），构造参数我们给定了一个`MyConfiguration`组件类。
-
+
-```java
+```java
-public class BeanNameAwareApplication {
+public class BeanNameAwareApplication {
-
+
-    public static void main(String[] args) {
+    public static void main(String[] args) {
-        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyConfiguration.class);
+        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyConfiguration.class);
-    }
+    }
-}
+}
-```
+```
-
+
-使用`@ComponentScan`注解，告诉 Spring 容器去 "`com.xcs.spring.service`" 扫描包及其子包
+使用`@ComponentScan`注解，告诉 Spring 容器去 "`com.xcs.spring.service`" 扫描包及其子包
-
+
-```java
+```java
-@Configuration
+@Configuration
-@ComponentScan("com.xcs.spring.service")
+@ComponentScan("com.xcs.spring.service")
-public class MyConfiguration {
+public class MyConfiguration {
-
+
-}
+}
-```
+```
-
+
-`MyBasePayService` 是一个抽象类，结合了 Spring 的三个特殊接口：`BeanNameAware`（让 Bean 知道其名字）、`InitializingBean`（Bean 属性设置后的初始化操作）和 `DisposableBean`（Bean 销毁前的操作）。
+`MyBasePayService` 是一个抽象类，结合了 Spring 的三个特殊接口：`BeanNameAware`（让 Bean 知道其名字）、`InitializingBean`（Bean 属性设置后的初始化操作）和 `DisposableBean`（Bean 销毁前的操作）。
-
+
-```java
+```java
-public abstract class MyBasePayService implements BeanNameAware, InitializingBean, DisposableBean {
+public abstract class MyBasePayService implements BeanNameAware, InitializingBean, DisposableBean {
-
+
-    private String beanName;
+    private String beanName;
-
+
-    @Override
+    @Override
-    public void setBeanName(String beanName) {
+    public void setBeanName(String beanName) {
-        this.beanName = beanName;
+        this.beanName = beanName;
-    }
+    }
-
+
-    @Override
+    @Override
-    public void afterPropertiesSet() throws Exception {
+    public void afterPropertiesSet() throws Exception {
-        System.out.println("Module " + beanName + " has been registered.");
+        System.out.println("Module " + beanName + " has been registered.");
-    }
+    }
-
+
-    @Override
+    @Override
-    public void destroy() throws Exception {
+    public void destroy() throws Exception {
-        System.out.println("Module " + beanName + " has been unregistered.");
+        System.out.println("Module " + beanName + " has been unregistered.");
-    }
+    }
-}
+}
-```
+```
-
+
-`MyAliPayService` 和 `MyWeChatPayService` 是两个支付服务类，都继承自 `MyBasePayService`，因此它们会自动获得与 Spring 容器生命周期相关的基本功能。这种设计方式为多个支付服务提供了一个共同的生命周期管理模式，同时允许每个服务添加其特定的支付逻辑。
+`MyAliPayService` 和 `MyWeChatPayService` 是两个支付服务类，都继承自 `MyBasePayService`，因此它们会自动获得与 Spring 容器生命周期相关的基本功能。这种设计方式为多个支付服务提供了一个共同的生命周期管理模式，同时允许每个服务添加其特定的支付逻辑。
-
+
-```java
+```java
-@Service
+@Service
-public class MyAliPayService extends MyBasePayService{
+public class MyAliPayService extends MyBasePayService{
-    
+    
-}
+}
-
+
-@Service
+@Service
-public class MyWeChatPayService extends MyBasePayService{
+public class MyWeChatPayService extends MyBasePayService{
-    
+    
-}
+}
-```
+```
-
+
-运行结果发现，当 Spring 容器启动并初始化 Beans 时，它正确地识别并实例化了 `MyAliPayService` 和 `MyWeChatPayService` 这两个服务。由于这两个服务都继承自 `MyBasePayService`，在 Bean 的属性被设置之后（即在 `afterPropertiesSet()` 方法中），它们分别打印出了 "Module myAliPayService has been registered." 和 "Module myWeChatPayService has been registered." 这两条信息，提供了一个共同的生命周期管理模式。
+运行结果发现，当 Spring 容器启动并初始化 Beans 时，它正确地识别并实例化了 `MyAliPayService` 和 `MyWeChatPayService` 这两个服务。由于这两个服务都继承自 `MyBasePayService`，在 Bean 的属性被设置之后（即在 `afterPropertiesSet()` 方法中），它们分别打印出了 "Module myAliPayService has been registered." 和 "Module myWeChatPayService has been registered." 这两条信息，提供了一个共同的生命周期管理模式。
-
+
-```java
+```java
-Module myAliPayService has been registered.
+Module myAliPayService has been registered.
-Module myWeChatPayService has been registered.
+Module myWeChatPayService has been registered.
-```
+```
-
+
-### 五、时序图
+### 五、时序图
-
+
-~~~mermaid
+~~~mermaid
-sequenceDiagram
+sequenceDiagram
-    Title: BeanNameAware时序图
+    Title: BeanNameAware时序图
-    participant BeanNameAwareApplication
+    participant BeanNameAwareApplication
-    participant AnnotationConfigApplicationContext
+    participant AnnotationConfigApplicationContext
-    participant AbstractApplicationContext
+    participant AbstractApplicationContext
-    participant DefaultListableBeanFactory
+    participant DefaultListableBeanFactory
-    participant AbstractBeanFactory
+    participant AbstractBeanFactory
-    participant DefaultSingletonBeanRegistry
+    participant DefaultSingletonBeanRegistry
-    participant AbstractAutowireCapableBeanFactory
+    participant AbstractAutowireCapableBeanFactory
-    participant MyBasePayService
+    participant MyBasePayService
-    
+    
-    BeanNameAwareApplication->>AnnotationConfigApplicationContext:AnnotationConfigApplicationContext(componentClasses)<br>创建上下文
+    BeanNameAwareApplication->>AnnotationConfigApplicationContext:AnnotationConfigApplicationContext(componentClasses)<br>创建上下文
-    AnnotationConfigApplicationContext->>AbstractApplicationContext:refresh()<br>刷新上下文
+    AnnotationConfigApplicationContext->>AbstractApplicationContext:refresh()<br>刷新上下文
-    AbstractApplicationContext->>AbstractApplicationContext:finishBeanFactoryInitialization(beanFactory)<br>初始化Bean工厂
+    AbstractApplicationContext->>AbstractApplicationContext:finishBeanFactoryInitialization(beanFactory)<br>初始化Bean工厂
-    AbstractApplicationContext->>DefaultListableBeanFactory:preInstantiateSingletons()<br>实例化单例
+    AbstractApplicationContext->>DefaultListableBeanFactory:preInstantiateSingletons()<br>实例化单例
-    DefaultListableBeanFactory->>AbstractBeanFactory:getBean(name)<br>获取Bean
+    DefaultListableBeanFactory->>AbstractBeanFactory:getBean(name)<br>获取Bean
-    AbstractBeanFactory->>AbstractBeanFactory:doGetBean(name,requiredType,args,typeCheckOnly)<br>执行获取Bean
+    AbstractBeanFactory->>AbstractBeanFactory:doGetBean(name,requiredType,args,typeCheckOnly)<br>执行获取Bean
-    AbstractBeanFactory->>DefaultSingletonBeanRegistry:getSingleton(beanName,singletonFactory)<br>获取单例Bean
+    AbstractBeanFactory->>DefaultSingletonBeanRegistry:getSingleton(beanName,singletonFactory)<br>获取单例Bean
-    DefaultSingletonBeanRegistry-->>AbstractBeanFactory:getObject()<br>获取Bean实例
+    DefaultSingletonBeanRegistry-->>AbstractBeanFactory:getObject()<br>获取Bean实例
-    AbstractBeanFactory->>AbstractAutowireCapableBeanFactory:createBean(beanName,mbd,args)<br>创建Bean
+    AbstractBeanFactory->>AbstractAutowireCapableBeanFactory:createBean(beanName,mbd,args)<br>创建Bean
-    AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:doCreateBean(beanName,mbd,args)<br>执行Bean创建
+    AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:doCreateBean(beanName,mbd,args)<br>执行Bean创建
-    AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:initializeBean(beanName,bean,mbd)<br>负责bean的初始化
+    AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:initializeBean(beanName,bean,mbd)<br>负责bean的初始化
-    AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:invokeAwareMethods(beanName, bean)<br>调用Aware方法
+    AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:invokeAwareMethods(beanName, bean)<br>调用Aware方法
-    AbstractAutowireCapableBeanFactory->>MyBasePayService:setBeanName(beanName)<br>设置Bean名称
+    AbstractAutowireCapableBeanFactory->>MyBasePayService:setBeanName(beanName)<br>设置Bean名称
-    AbstractAutowireCapableBeanFactory-->>AbstractBeanFactory:返回Bean对象
+    AbstractAutowireCapableBeanFactory-->>AbstractBeanFactory:返回Bean对象
-    AbstractBeanFactory-->>DefaultListableBeanFactory:返回Bean对象
+    AbstractBeanFactory-->>DefaultListableBeanFactory:返回Bean对象
-    AnnotationConfigApplicationContext-->>BeanNameAwareApplication:初始化完成
+    AnnotationConfigApplicationContext-->>BeanNameAwareApplication:初始化完成
-~~~
+~~~
-
+
-### 六、源码分析
+### 六、源码分析
-
+
-首先来看看启动类入口，上下文环境使用`AnnotationConfigApplicationContext`（此类是使用Java注解来配置Spring容器的方式），构造参数我们给定了一个`MyConfiguration`组件类。
+首先来看看启动类入口，上下文环境使用`AnnotationConfigApplicationContext`（此类是使用Java注解来配置Spring容器的方式），构造参数我们给定了一个`MyConfiguration`组件类。
-
+
-```java
+```java
-public class BeanNameAwareApplication {
+public class BeanNameAwareApplication {
-
+
-    public static void main(String[] args) {
+    public static void main(String[] args) {
-        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyConfiguration.class);
+        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyConfiguration.class);
-    }
+    }
-}
+}
-```
+```
-
+
-在`org.springframework.context.annotation.AnnotationConfigApplicationContext#AnnotationConfigApplicationContext`构造函数中，执行了三个步骤，我们重点关注`refresh()`方法
+在`org.springframework.context.annotation.AnnotationConfigApplicationContext#AnnotationConfigApplicationContext`构造函数中，执行了三个步骤，我们重点关注`refresh()`方法
-
+
-```java
+```java
-public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
+public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
-    this();
+    this();
-    register(componentClasses);
+    register(componentClasses);
-    refresh();
+    refresh();
-}
+}
-```
+```
-
+
-在`org.springframework.context.support.AbstractApplicationContext#refresh`方法中我们重点关注一下`finishBeanFactoryInitialization(beanFactory)`这方法会对实例化所有剩余非懒加载的单列Bean对象，其他方法不是本次源码阅读的重点暂时忽略。
+在`org.springframework.context.support.AbstractApplicationContext#refresh`方法中我们重点关注一下`finishBeanFactoryInitialization(beanFactory)`这方法会对实例化所有剩余非懒加载的单列Bean对象，其他方法不是本次源码阅读的重点暂时忽略。
-
+
-```java
+```java
-@Override
+@Override
-public void refresh() throws BeansException, IllegalStateException {
+public void refresh() throws BeansException, IllegalStateException {
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-    // Instantiate all remaining (non-lazy-init) singletons.
+    // Instantiate all remaining (non-lazy-init) singletons.
-    finishBeanFactoryInitialization(beanFactory);
+    finishBeanFactoryInitialization(beanFactory);
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-}
+}
-```
+```
-
+
-在`org.springframework.context.support.AbstractApplicationContext#finishBeanFactoryInitialization`方法中，会继续调用`DefaultListableBeanFactory`类中的`preInstantiateSingletons`方法来完成所有剩余非懒加载的单列Bean对象。
+在`org.springframework.context.support.AbstractApplicationContext#finishBeanFactoryInitialization`方法中，会继续调用`DefaultListableBeanFactory`类中的`preInstantiateSingletons`方法来完成所有剩余非懒加载的单列Bean对象。
-
+
-```java
+```java
-/**
+/**
- * 完成此工厂的bean初始化，实例化所有剩余的非延迟初始化单例bean。
+ * 完成此工厂的bean初始化，实例化所有剩余的非延迟初始化单例bean。
- * 
+ * 
- * @param beanFactory 要初始化的bean工厂
+ * @param beanFactory 要初始化的bean工厂
- */
+ */
-protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
+protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-    // 完成所有剩余非懒加载的单列Bean对象。
+    // 完成所有剩余非懒加载的单列Bean对象。
-    beanFactory.preInstantiateSingletons();
+    beanFactory.preInstantiateSingletons();
-}
+}
-```
+```
-
+
-在`org.springframework.beans.factory.support.DefaultListableBeanFactory#preInstantiateSingletons`方法中，主要的核心目的是预先实例化所有非懒加载的单例bean。在Spring的上下文初始化完成后，该方法会被触发，以确保所有单例bean都被正确地创建并初始化。其中`getBean(beanName)`是此方法的核心操作。对于容器中定义的每一个单例bean，它都会调用`getBean`方法，这将触发bean的实例化、初始化及其依赖的注入。如果bean之前没有被创建过，那么这个调用会导致其被实例化和初始化。
+在`org.springframework.beans.factory.support.DefaultListableBeanFactory#preInstantiateSingletons`方法中，主要的核心目的是预先实例化所有非懒加载的单例bean。在Spring的上下文初始化完成后，该方法会被触发，以确保所有单例bean都被正确地创建并初始化。其中`getBean(beanName)`是此方法的核心操作。对于容器中定义的每一个单例bean，它都会调用`getBean`方法，这将触发bean的实例化、初始化及其依赖的注入。如果bean之前没有被创建过，那么这个调用会导致其被实例化和初始化。
-
+
-```java
+```java
-public void preInstantiateSingletons() throws BeansException {
+public void preInstantiateSingletons() throws BeansException {
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-    // 循环遍历所有bean的名称
+    // 循环遍历所有bean的名称
-    for (String beanName : beanNames) {
+    for (String beanName : beanNames) {
-        getBean(beanName);
+        getBean(beanName);
-    }
+    }
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-}
+}
-```
+```
-
+
-在`org.springframework.beans.factory.support.AbstractBeanFactory#getBean()`方法中，又调用了`doGetBean`方法来实际执行创建Bean的过程，传递给它bean的名称和一些其他默认的参数值。此处，`doGetBean`负责大部分工作，如查找bean定义、创建bean（如果尚未创建）、处理依赖关系等。
+在`org.springframework.beans.factory.support.AbstractBeanFactory#getBean()`方法中，又调用了`doGetBean`方法来实际执行创建Bean的过程，传递给它bean的名称和一些其他默认的参数值。此处，`doGetBean`负责大部分工作，如查找bean定义、创建bean（如果尚未创建）、处理依赖关系等。
-
+
-```java
+```java
-@Override
+@Override
-public Object getBean(String name) throws BeansException {
+public Object getBean(String name) throws BeansException {
-    return doGetBean(name, null, null, false);
+    return doGetBean(name, null, null, false);
-}
+}
-```
+```
-
+
-在`org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean`方法中，首先检查所请求的bean是否是一个单例并且已经创建。如果尚未创建，它将创建一个新的实例。在这个过程中，它处理可能的异常情况，如循环引用，并确保返回的bean是正确的类型。这是Spring容器bean生命周期管理的核心部分。
+在`org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean`方法中，首先检查所请求的bean是否是一个单例并且已经创建。如果尚未创建，它将创建一个新的实例。在这个过程中，它处理可能的异常情况，如循环引用，并确保返回的bean是正确的类型。这是Spring容器bean生命周期管理的核心部分。
-
+
-```java
+```java
-protected <T> T doGetBean(
+protected <T> T doGetBean(
-        String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
+        String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
-        throws BeansException {
+        throws BeansException {
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-
+
-    // 开始创建bean实例
+    // 开始创建bean实例
-    if (mbd.isSingleton()) {
+    if (mbd.isSingleton()) {
-        // 如果bean是单例的，我们会尝试从单例缓存中获取它
+        // 如果bean是单例的，我们会尝试从单例缓存中获取它
-        // 如果不存在，则使用lambda创建一个新的实例
+        // 如果不存在，则使用lambda创建一个新的实例
-        sharedInstance = getSingleton(beanName, () -> {
+        sharedInstance = getSingleton(beanName, () -> {
-            try {
+            try {
-                // 尝试创建bean实例
+                // 尝试创建bean实例
-                return createBean(beanName, mbd, args);
+                return createBean(beanName, mbd, args);
-            }
+            }
-            catch (BeansException ex) {
+            catch (BeansException ex) {
-                // ... [代码部分省略以简化]
+                // ... [代码部分省略以简化]
-            }
+            }
-        });
+        });
-        // 对于某些bean（例如FactoryBeans），可能需要进一步处理以获取真正的bean实例
+        // 对于某些bean（例如FactoryBeans），可能需要进一步处理以获取真正的bean实例
-        beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
+        beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
-    }
+    }
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-
+
-    // 确保返回的bean实例与请求的类型匹配
+    // 确保返回的bean实例与请求的类型匹配
-    return adaptBeanInstance(name, beanInstance, requiredType);
+    return adaptBeanInstance(name, beanInstance, requiredType);
-}
+}
-```
+```
-
+
-在`org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton()`方法中，主要负责从单例缓存中获取一个已存在的bean实例，或者使用提供的`ObjectFactory`创建一个新的实例。这是确保bean在Spring容器中作为单例存在的关键部分。
+在`org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton()`方法中，主要负责从单例缓存中获取一个已存在的bean实例，或者使用提供的`ObjectFactory`创建一个新的实例。这是确保bean在Spring容器中作为单例存在的关键部分。
-
+
-```java
+```java
-public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
+public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
-    // 断言bean名称不能为空
+    // 断言bean名称不能为空
-    Assert.notNull(beanName, "Bean name must not be null");
+    Assert.notNull(beanName, "Bean name must not be null");
-
+
-    // 同步访问单例对象缓存，确保线程安全
+    // 同步访问单例对象缓存，确保线程安全
-    synchronized (this.singletonObjects) {
+    synchronized (this.singletonObjects) {
-        // 从缓存中获取单例对象
+        // 从缓存中获取单例对象
-        Object singletonObject = this.singletonObjects.get(beanName);
+        Object singletonObject = this.singletonObjects.get(beanName);
-
+
-        // 如果缓存中没有找到
+        // 如果缓存中没有找到
-        if (singletonObject == null) {
+        if (singletonObject == null) {
-            // ... [代码部分省略以简化]
+            // ... [代码部分省略以简化]
-
+
-            try {
+            try {
-                // 使用工厂创建新的单例实例
+                // 使用工厂创建新的单例实例
-                singletonObject = singletonFactory.getObject();
+                singletonObject = singletonFactory.getObject();
-                newSingleton = true;
+                newSingleton = true;
-            }
+            }
-            catch (IllegalStateException ex) {
+            catch (IllegalStateException ex) {
-                // ... [代码部分省略以简化]
+                // ... [代码部分省略以简化]
-            }
+            }
-            catch (BeanCreationException ex) {
+            catch (BeanCreationException ex) {
-                // ... [代码部分省略以简化]
+                // ... [代码部分省略以简化]
-            }
+            }
-            finally {
+            finally {
-                // ... [代码部分省略以简化]
+                // ... [代码部分省略以简化]
-            }
+            }
-
+
-            // ... [代码部分省略以简化]
+            // ... [代码部分省略以简化]
-        }
+        }
-
+
-        // 返回单例对象
+        // 返回单例对象
-        return singletonObject;
+        return singletonObject;
-    }
+    }
-}
+}
-```
+```
-
+
-在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBean()`方法中，主要的逻辑是调用 `doCreateBean`，这是真正进行 bean 实例化、属性填充和初始化的地方。这个方法会返回新创建的 bean 实例。
+在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBean()`方法中，主要的逻辑是调用 `doCreateBean`，这是真正进行 bean 实例化、属性填充和初始化的地方。这个方法会返回新创建的 bean 实例。
-
+
-```java
+```java
-@Override
+@Override
-protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
+protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
-    throws BeanCreationException {
+    throws BeanCreationException {
-    
+    
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-    
+    
-    try {
+    try {
-        // 正常的bean实例化、属性注入和初始化。
+        // 正常的bean实例化、属性注入和初始化。
-        // 这里是真正进行bean创建的部分。
+        // 这里是真正进行bean创建的部分。
-        Object beanInstance = doCreateBean(beanName, mbdToUse, args);
+        Object beanInstance = doCreateBean(beanName, mbdToUse, args);
-        // 记录bean成功创建的日志
+        // 记录bean成功创建的日志
-        if (logger.isTraceEnabled()) {
+        if (logger.isTraceEnabled()) {
-            logger.trace("Finished creating instance of bean '" + beanName + "'");
+            logger.trace("Finished creating instance of bean '" + beanName + "'");
-        }
+        }
-        return beanInstance;
+        return beanInstance;
-    }
+    }
-    catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
+    catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
-        // ... [代码部分省略以简化]
+        // ... [代码部分省略以简化]
-    }
+    }
-    catch (Throwable ex) {
+    catch (Throwable ex) {
-        // ... [代码部分省略以简化]
+        // ... [代码部分省略以简化]
-    }
+    }
-}
+}
-```
+```
-
+
-在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean`方法中，`initializeBean`方法是bean初始化，确保bean是完全配置和准备好的。
+在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean`方法中，`initializeBean`方法是bean初始化，确保bean是完全配置和准备好的。
-
+
-```java
+```java
-protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
+protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
-        throws BeanCreationException {
+        throws BeanCreationException {
-
+
-    // 声明一个对象，后续可能用于存放初始化后的bean或它的代理对象
+    // 声明一个对象，后续可能用于存放初始化后的bean或它的代理对象
-    Object exposedObject = bean;
+    Object exposedObject = bean;
-
+
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-    
+    
-    try {
+    try {
-        // ... [代码部分省略以简化]
+        // ... [代码部分省略以简化]
-        
+        
-        // bean初始化
+        // bean初始化
-        exposedObject = initializeBean(beanName, exposedObject, mbd);
+        exposedObject = initializeBean(beanName, exposedObject, mbd);
-    } 
+    } 
-    catch (Throwable ex) {
+    catch (Throwable ex) {
-        // ... [代码部分省略以简化]
+        // ... [代码部分省略以简化]
-    }
+    }
-
+
-    // 返回创建和初始化后的bean
+    // 返回创建和初始化后的bean
-    return exposedObject;
+    return exposedObject;
-}
+}
-```
+```
-
+
-在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#initializeBean`方法中，`invokeAwareMethods(beanName, bean)`是一个非常重要的步骤。这个方法是为了处理实现了Spring的`Aware`接口族的Beans（例如`BeanNameAware`, `BeanFactoryAware`等）。如果提供的bean实现了任何这些接口，该方法会回调相应的`Aware`方法。
+在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#initializeBean`方法中，`invokeAwareMethods(beanName, bean)`是一个非常重要的步骤。这个方法是为了处理实现了Spring的`Aware`接口族的Beans（例如`BeanNameAware`, `BeanFactoryAware`等）。如果提供的bean实现了任何这些接口，该方法会回调相应的`Aware`方法。
-
+
-```java
+```java
-protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
+protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
-
+
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-    
+    
-    invokeAwareMethods(beanName, bean);
+    invokeAwareMethods(beanName, bean);
-    
+    
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-
+
-    return wrappedBean;
+    return wrappedBean;
-}
+}
-```
+```
-
+
-在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#invokeAwareMethods`方法中，用于处理实现了 Spring `Aware` 接口族的 beans。当一个 bean 实现了如 `BeanNameAware`、`BeanClassLoaderAware` 或 `BeanFactoryAware` 等接口时，此方法确保正确的回调方法被调用，从而为 bean 提供关于其运行环境或其他相关信息。
+在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#invokeAwareMethods`方法中，用于处理实现了 Spring `Aware` 接口族的 beans。当一个 bean 实现了如 `BeanNameAware`、`BeanClassLoaderAware` 或 `BeanFactoryAware` 等接口时，此方法确保正确的回调方法被调用，从而为 bean 提供关于其运行环境或其他相关信息。
-
+
-```java
+```java
-private void invokeAwareMethods(String beanName, Object bean) {
+private void invokeAwareMethods(String beanName, Object bean) {
-    if (bean instanceof Aware) {
+    if (bean instanceof Aware) {
-        if (bean instanceof BeanNameAware) {
+        if (bean instanceof BeanNameAware) {
-            ((BeanNameAware) bean).setBeanName(beanName);
+            ((BeanNameAware) bean).setBeanName(beanName);
-        }
+        }
-        if (bean instanceof BeanClassLoaderAware) {
+        if (bean instanceof BeanClassLoaderAware) {
-            // ... [代码部分省略以简化]
+            // ... [代码部分省略以简化]
-        }
+        }
-        if (bean instanceof BeanFactoryAware) {
+        if (bean instanceof BeanFactoryAware) {
-            // ... [代码部分省略以简化]
+            // ... [代码部分省略以简化]
-        }
+        }
-    }
+    }
-}
+}
-```
+```
-
+
-最后执行到我们自定义的逻辑中，我们将这个名称存储在 `beanName` 变量中，以便后续使用。
+最后执行到我们自定义的逻辑中，我们将这个名称存储在 `beanName` 变量中，以便后续使用。
-
+
-```java
+```java
-public abstract class MyBasePayService implements BeanNameAware, InitializingBean, DisposableBean {
+public abstract class MyBasePayService implements BeanNameAware, InitializingBean, DisposableBean {
-
+
-    private String beanName;
+    private String beanName;
-
+
-    @Override
+    @Override
-    public void setBeanName(String beanName) {
+    public void setBeanName(String beanName) {
-        this.beanName = beanName;
+        this.beanName = beanName;
-    }
+    }
-
+
-    @Override
+    @Override
-    public void afterPropertiesSet() throws Exception {
+    public void afterPropertiesSet() throws Exception {
-        System.out.println("Module " + beanName + " has been registered.");
+        System.out.println("Module " + beanName + " has been registered.");
-    }
+    }
-
+
-    @Override
+    @Override
-    public void destroy() throws Exception {
+    public void destroy() throws Exception {
-        System.out.println("Module " + beanName + " has been unregistered.");
+        System.out.println("Module " + beanName + " has been unregistered.");
-    }
+    }
-}
+}
-```
+```
-
+
-### 七、注意事项
+### 七、注意事项
-
+
-**与其他生命周期方法的顺序**：`setBeanName` 方法的调用是在其他许多生命周期方法之前的，例如 `InitializingBean#afterPropertiesSet` 和任何定义的初始化方法。因此，我们不应该在 `setBeanName` 方法内部预期其他配置或初始化逻辑已经完成。
+**与其他生命周期方法的顺序**：`setBeanName` 方法的调用是在其他许多生命周期方法之前的，例如 `InitializingBean#afterPropertiesSet` 和任何定义的初始化方法。因此，我们不应该在 `setBeanName` 方法内部预期其他配置或初始化逻辑已经完成。
-
+
-**仅在容器管理的 Beans 中有效**：只有当 bean 是由 Spring 容器管理时，`BeanNameAware` 才会生效。简单地创建一个类的实例（例如通过 `new` 关键字）并不会触发 `BeanNameAware` 功能。
+**仅在容器管理的 Beans 中有效**：只有当 bean 是由 Spring 容器管理时，`BeanNameAware` 才会生效。简单地创建一个类的实例（例如通过 `new` 关键字）并不会触发 `BeanNameAware` 功能。
-
+
-**与其他 Aware 接口的组合使用**：当一个 bean 同时实现多个 `Aware` 接口时，需要注意它们的调用顺序。例如，`BeanNameAware`、`BeanFactoryAware` 和 `ApplicationContextAware` 的回调方法调用顺序是固定的。
+**与其他 Aware 接口的组合使用**：当一个 bean 同时实现多个 `Aware` 接口时，需要注意它们的调用顺序。例如，`BeanNameAware`、`BeanFactoryAware` 和 `ApplicationContextAware` 的回调方法调用顺序是固定的。
-
+
-**Bean 名称的唯一性**：Spring 容器内的 bean 名称是唯一的，但如果使用别名，同一个 bean 可能会有多个名称。当实现 `BeanNameAware` 时，我们获得的是 bean 的主要名称。
+**Bean 名称的唯一性**：Spring 容器内的 bean 名称是唯一的，但如果使用别名，同一个 bean 可能会有多个名称。当实现 `BeanNameAware` 时，我们获得的是 bean 的主要名称。
-
+
-### 八、总结
+### 八、总结
-
+
-#### 8.1、最佳实践总结
+#### 8.1、最佳实践总结
-
+
-**启动及配置**：我们使用了 `AnnotationConfigApplicationContext` 作为 Spring 容器的入口，专门为基于 Java 的配置设计。该容器被初始化并加载了 `MyConfiguration` 类，它定义了应用的主要配置。
+**启动及配置**：我们使用了 `AnnotationConfigApplicationContext` 作为 Spring 容器的入口，专门为基于 Java 的配置设计。该容器被初始化并加载了 `MyConfiguration` 类，它定义了应用的主要配置。
-
+
-**组件扫描**：通过在 `MyConfiguration` 类中使用 `@ComponentScan` 注解，我们告诉 Spring 容器去扫描 "`com.xcs.spring.service`" 包及其子包，以找到和管理 Beans。
+**组件扫描**：通过在 `MyConfiguration` 类中使用 `@ComponentScan` 注解，我们告诉 Spring 容器去扫描 "`com.xcs.spring.service`" 包及其子包，以找到和管理 Beans。
-
+
-**生命周期管理**：**MyBasePayService** 类展示了如何利用 Spring 的特殊接口，例如 `BeanNameAware`、`InitializingBean` 和 `DisposableBean`，来插入到 Bean 的生命周期的特定阶段。当一个 Bean 实例被创建并管理 by Spring, 它会被赋予一个名称（通过 `BeanNameAware`）、在所有属性设置后初始化（通过 `InitializingBean`）以及在应用结束或 Bean 被销毁时执行特定操作（通过 `DisposableBean`）。
+**生命周期管理**：**MyBasePayService** 类展示了如何利用 Spring 的特殊接口，例如 `BeanNameAware`、`InitializingBean` 和 `DisposableBean`，来插入到 Bean 的生命周期的特定阶段。当一个 Bean 实例被创建并管理 by Spring, 它会被赋予一个名称（通过 `BeanNameAware`）、在所有属性设置后初始化（通过 `InitializingBean`）以及在应用结束或 Bean 被销毁时执行特定操作（通过 `DisposableBean`）。
-
+
-**具体的服务实现**：有两个具体的支付服务，`MyAliPayService` 和 `MyWeChatPayService`，它们都继承了 `MyBasePayService`。这意味着它们都自动继承了上述的生命周期管理功能。当 Spring 容器启动时，这两个服务的相关生命周期方法会被调用，如我们从打印的消息中所看到的。
+**具体的服务实现**：有两个具体的支付服务，`MyAliPayService` 和 `MyWeChatPayService`，它们都继承了 `MyBasePayService`。这意味着它们都自动继承了上述的生命周期管理功能。当 Spring 容器启动时，这两个服务的相关生命周期方法会被调用，如我们从打印的消息中所看到的。
-
+
-**实际效果**：当应用运行时，每个服务类都会打印出其已经被注册和注销的消息，这是由于它们都继承了 `MyBasePayService` 中定义的生命周期方法。
+**实际效果**：当应用运行时，每个服务类都会打印出其已经被注册和注销的消息，这是由于它们都继承了 `MyBasePayService` 中定义的生命周期方法。
-
+
-#### 8.2、源码分析总结
+#### 8.2、源码分析总结
-
+
-**启动和上下文初始化**：使用`AnnotationConfigApplicationContext`初始化Spring容器，其中传递了配置类`MyConfiguration`。
+**启动和上下文初始化**：使用`AnnotationConfigApplicationContext`初始化Spring容器，其中传递了配置类`MyConfiguration`。
-
+
-**注册和刷新上下文**：在`AnnotationConfigApplicationContext`构造函数中，`register()`方法注册配置类，而`refresh()`方法开始加载和初始化beans。
+**注册和刷新上下文**：在`AnnotationConfigApplicationContext`构造函数中，`register()`方法注册配置类，而`refresh()`方法开始加载和初始化beans。
-
+
-**开始bean的实例化**：`refresh()`方法进一步调用了`finishBeanFactoryInitialization(beanFactory)`，该方法负责预先实例化所有非懒加载的单例bean。
+**开始bean的实例化**：`refresh()`方法进一步调用了`finishBeanFactoryInitialization(beanFactory)`，该方法负责预先实例化所有非懒加载的单例bean。
-
+
-**实例化单例bean**：`preInstantiateSingletons()`方法遍历所有bean名称，并通过调用`getBean(beanName)`来实例化和初始化bean。
+**实例化单例bean**：`preInstantiateSingletons()`方法遍历所有bean名称，并通过调用`getBean(beanName)`来实例化和初始化bean。
-
+
-**创建bean实例**：`doGetBean()`是实际进行bean创建的核心方法，它处理了bean的实例化、依赖注入和初始化等逻辑。
+**创建bean实例**：`doGetBean()`是实际进行bean创建的核心方法，它处理了bean的实例化、依赖注入和初始化等逻辑。
-
+
-**处理Aware接口族**：在bean的初始化过程中，`invokeAwareMethods(beanName, bean)`被调用，负责处理实现了`Aware`接口族的beans。这是我们的`BeanNameAware`接口发挥作用的地方，当bean实现此接口时，其`setBeanName`方法会被调用。
+**处理Aware接口族**：在bean的初始化过程中，`invokeAwareMethods(beanName, bean)`被调用，负责处理实现了`Aware`接口族的beans。这是我们的`BeanNameAware`接口发挥作用的地方，当bean实现此接口时，其`setBeanName`方法会被调用。
-
+
 **用户定义的逻辑**：在`MyBasePayService`类中，我们实现了`BeanNameAware`接口，并重写了`setBeanName`方法来保存bean的名称。此外，还使用了`InitializingBean`和`DisposableBean`接口来在bean的生命周期的特定时刻执行自定义的逻辑。

spring-aware/spring-aware-beanNameAware/pom.xml

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <parent>
+        <artifactId>spring-aware</artifactId>
+        <groupId>com.xcs.spring</groupId>
+        <version>0.0.1-SNAPSHOT</version>
+    </parent>
+
+    <modelVersion>4.0.0</modelVersion>
+    <artifactId>spring-aware-beanNameAware</artifactId>
+
+</project>

spring-aware/spring-aware-beanNameAware/src/main/java/com/xcs/spring/service/MyAliPayService.java

@@ -1,7 +1,7 @@
-package com.xcs.spring.service;
+package com.xcs.spring.service;
-
+
-import org.springframework.stereotype.Service;
+import org.springframework.stereotype.Service;
-
+
-@Service
+@Service
-public class MyAliPayService extends MyBasePayService{
+public class MyAliPayService extends MyBasePayService{
-}
+}

spring-aware/spring-aware-beanNameAware/src/main/java/com/xcs/spring/service/MyBasePayService.java

@@ -1,25 +1,25 @@
-package com.xcs.spring.service;
+package com.xcs.spring.service;
-
+
-import org.springframework.beans.factory.BeanNameAware;
+import org.springframework.beans.factory.BeanNameAware;
-import org.springframework.beans.factory.DisposableBean;
+import org.springframework.beans.factory.DisposableBean;
-import org.springframework.beans.factory.InitializingBean;
+import org.springframework.beans.factory.InitializingBean;
-
+
-public abstract class MyBasePayService implements BeanNameAware, InitializingBean, DisposableBean {
+public abstract class MyBasePayService implements BeanNameAware, InitializingBean, DisposableBean {
-
+
-    private String beanName;
+    private String beanName;
-
+
-    @Override
+    @Override
-    public void setBeanName(String beanName) {
+    public void setBeanName(String beanName) {
-        this.beanName = beanName;
+        this.beanName = beanName;
-    }
+    }
-
+
-    @Override
+    @Override
-    public void afterPropertiesSet() throws Exception {
+    public void afterPropertiesSet() throws Exception {
-        System.out.println("Module " + beanName + " has been registered.");
+        System.out.println("Module " + beanName + " has been registered.");
-    }
+    }
-
+
-    @Override
+    @Override
-    public void destroy() throws Exception {
+    public void destroy() throws Exception {
-        System.out.println("Module " + beanName + " has been unregistered.");
+        System.out.println("Module " + beanName + " has been unregistered.");
-    }
+    }
-}
+}

spring-aware/spring-aware-beanNameAware/src/main/java/com/xcs/spring/service/MyWeChatPayService.java

@@ -1,7 +1,7 @@
-package com.xcs.spring.service;
+package com.xcs.spring.service;
-
+
-import org.springframework.stereotype.Service;
+import org.springframework.stereotype.Service;
-
+
-@Service
+@Service
-public class MyWeChatPayService extends MyBasePayService{
+public class MyWeChatPayService extends MyBasePayService{
-}
+}

spring-aware/spring-aware-embeddedValueResolverAware/README.md

@@ -1,474 +1,474 @@
-## EmbeddedValueResolverAware
+## EmbeddedValueResolverAware
-
+
-- [EmbeddedValueResolverAware](#embeddedvalueresolveraware)
+- [EmbeddedValueResolverAware](#embeddedvalueresolveraware)
-  - [一、接口描述](#一接口描述)
+  - [一、接口描述](#一接口描述)
-  - [二、接口源码](#二接口源码)
+  - [二、接口源码](#二接口源码)
-  - [三、主要功能](#三主要功能)
+  - [三、主要功能](#三主要功能)
-  - [四、最佳实践](#四最佳实践)
+  - [四、最佳实践](#四最佳实践)
-  - [五、时序图](#五时序图)
+  - [五、时序图](#五时序图)
-  - [六、源码分析](#六源码分析)
+  - [六、源码分析](#六源码分析)
-  - [七、注意事项](#七注意事项)
+  - [七、注意事项](#七注意事项)
-  - [八、总结](#八总结)
+  - [八、总结](#八总结)
-    - [8.1、最佳实践总结](#81最佳实践总结)
+    - [8.1、最佳实践总结](#81最佳实践总结)
-    - [8.2、源码分析总结](#82源码分析总结)
+    - [8.2、源码分析总结](#82源码分析总结)
-
+
-### 一、接口描述
+### 一、接口描述
-
+
-`EmbeddedValueResolverAware` 接口，主要用于提供一个字符串值解析器，这可以在 Bean 属性中解析占位符和表达式。如果我们熟悉 Spring 的 `${...}` 占位符和 `#{...}` 表达式，那么这个接口将帮助我们在自定义组件中解析这些值。
+`EmbeddedValueResolverAware` 接口，主要用于提供一个字符串值解析器，这可以在 Bean 属性中解析占位符和表达式。如果我们熟悉 Spring 的 `${...}` 占位符和 `#{...}` 表达式，那么这个接口将帮助我们在自定义组件中解析这些值。
-
+
-### 二、接口源码
+### 二、接口源码
-
+
-`EmbeddedValueResolverAware` 是 Spring 框架自 3.0.3 开始引入的一个核心接口。允许对象在初始化时得到一个 `StringValueResolver`，并使用它来解析嵌入的字符串值，如配置文件中的占位符或 SpEL 表达式。
+`EmbeddedValueResolverAware` 是 Spring 框架自 3.0.3 开始引入的一个核心接口。允许对象在初始化时得到一个 `StringValueResolver`，并使用它来解析嵌入的字符串值，如配置文件中的占位符或 SpEL 表达式。
-
+
-```java
+```java
-/**
+/**
- * 如果对象希望被通知一个 StringValueResolver，以解析嵌入的定义值，那么它应实现此接口。
+ * 如果对象希望被通知一个 StringValueResolver，以解析嵌入的定义值，那么它应实现此接口。
- *
+ *
- * 这提供了一个通过 ApplicationContextAware/BeanFactoryAware 接口
+ * 这提供了一个通过 ApplicationContextAware/BeanFactoryAware 接口
- * 依赖于完整的 ConfigurableBeanFactory 的替代方法。
+ * 依赖于完整的 ConfigurableBeanFactory 的替代方法。
- *
+ *
- * @author Juergen Hoeller
+ * @author Juergen Hoeller
- * @author Chris Beams
+ * @author Chris Beams
- * @since 3.0.3
+ * @since 3.0.3
- * @see org.springframework.beans.factory.config.ConfigurableBeanFactory#resolveEmbeddedValue(String)
+ * @see org.springframework.beans.factory.config.ConfigurableBeanFactory#resolveEmbeddedValue(String)
- * @see org.springframework.beans.factory.config.ConfigurableBeanFactory#getBeanExpressionResolver()
+ * @see org.springframework.beans.factory.config.ConfigurableBeanFactory#getBeanExpressionResolver()
- * @see org.springframework.beans.factory.config.EmbeddedValueResolver
+ * @see org.springframework.beans.factory.config.EmbeddedValueResolver
- */
+ */
-public interface EmbeddedValueResolverAware extends Aware {
+public interface EmbeddedValueResolverAware extends Aware {
-
+
-	/**
+	/**
-	 * 设置用于解析嵌入定义值的 StringValueResolver。
+	 * 设置用于解析嵌入定义值的 StringValueResolver。
-	 */
+	 */
-	void setEmbeddedValueResolver(StringValueResolver resolver);
+	void setEmbeddedValueResolver(StringValueResolver resolver);
-
+
-}
+}
-```
+```
-
+
-### 三、主要功能
+### 三、主要功能
-
+
-**解析嵌入的字符串值**： 当我们在 Bean 的属性或构造函数参数中有一个值，如 `${property.name}` 或 `#{some.expression}`，这需要被解析成实际的值时，`StringValueResolver` 可以帮助做这件事。
+**解析嵌入的字符串值**： 当我们在 Bean 的属性或构造函数参数中有一个值，如 `${property.name}` 或 `#{some.expression}`，这需要被解析成实际的值时，`StringValueResolver` 可以帮助做这件事。
-
+
-**避免对 `ConfigurableBeanFactory` 的直接依赖**： 通过使用 `EmbeddedValueResolverAware`，我们可以间接地得到这种解析功能，而不必直接依赖于整个 `ConfigurableBeanFactory`。这提供了一种更轻量级、更关注特定功能的方法来解析嵌入的值。
+**避免对 `ConfigurableBeanFactory` 的直接依赖**： 通过使用 `EmbeddedValueResolverAware`，我们可以间接地得到这种解析功能，而不必直接依赖于整个 `ConfigurableBeanFactory`。这提供了一种更轻量级、更关注特定功能的方法来解析嵌入的值。
-
+
-**自动注入 `StringValueResolver`**： 当我们的 Bean 实现了 `EmbeddedValueResolverAware` 接口，Spring 容器会在 Bean 初始化时自动调用 `setEmbeddedValueResolver` 方法，为其注入一个 `StringValueResolver` 实例。这样，Bean 可以在其生命周期中任何时候使用它来解析字符串值。
+**自动注入 `StringValueResolver`**： 当我们的 Bean 实现了 `EmbeddedValueResolverAware` 接口，Spring 容器会在 Bean 初始化时自动调用 `setEmbeddedValueResolver` 方法，为其注入一个 `StringValueResolver` 实例。这样，Bean 可以在其生命周期中任何时候使用它来解析字符串值。
-
+
-### 四、最佳实践
+### 四、最佳实践
-
+
-首先来看看启动类入口，上下文环境使用`AnnotationConfigApplicationContext`（此类是使用Java注解来配置Spring容器的方式），构造参数我们给定了一个`MyConfiguration`组件类。然后从Spring上下文中获取一个`MyEmbeddedValueResolverAware`类型的bean，最后调用`resolve`方法。
+首先来看看启动类入口，上下文环境使用`AnnotationConfigApplicationContext`（此类是使用Java注解来配置Spring容器的方式），构造参数我们给定了一个`MyConfiguration`组件类。然后从Spring上下文中获取一个`MyEmbeddedValueResolverAware`类型的bean，最后调用`resolve`方法。
-
+
-```java
+```java
-public class EmbeddedValueResolverAwareApplication {
+public class EmbeddedValueResolverAwareApplication {
-
+
-    public static void main(String[] args) {
+    public static void main(String[] args) {
-        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyConfiguration.class);
+        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyConfiguration.class);
-        MyEmbeddedValueResolverAware resolverAware = context.getBean(MyEmbeddedValueResolverAware.class);
+        MyEmbeddedValueResolverAware resolverAware = context.getBean(MyEmbeddedValueResolverAware.class);
-        resolverAware.resolve();
+        resolverAware.resolve();
-    }
+    }
-}
+}
-```
+```
-
+
-这里使用`@Bean`注解，定义了一个Bean，是为了确保 `MyEmbeddedValueResolverAware` 被 Spring 容器执行。
+这里使用`@Bean`注解，定义了一个Bean，是为了确保 `MyEmbeddedValueResolverAware` 被 Spring 容器执行。
-
+
-```java
+```java
-@Configuration
+@Configuration
-public class MyConfiguration {
+public class MyConfiguration {
-
+
-    @Bean
+    @Bean
-    public MyEmbeddedValueResolverAware myEmbeddedValueResolverAware(){
+    public MyEmbeddedValueResolverAware myEmbeddedValueResolverAware(){
-        return new MyEmbeddedValueResolverAware();
+        return new MyEmbeddedValueResolverAware();
-    }
+    }
-}
+}
-```
+```
-
+
-`MyEmbeddedValueResolverAware`类实现了`EmbeddedValueResolverAware`接口，当Spring容器初始化此类的Bean时，此方法将被调用，容器将传入一个`StringValueResolver`实例，然后通过`resolve()`方法，使用注入的`stringValueResolver`来解析包含占位符和SpEL表达式的字符串，并将解析后的字符串打印到控制台。
+`MyEmbeddedValueResolverAware`类实现了`EmbeddedValueResolverAware`接口，当Spring容器初始化此类的Bean时，此方法将被调用，容器将传入一个`StringValueResolver`实例，然后通过`resolve()`方法，使用注入的`stringValueResolver`来解析包含占位符和SpEL表达式的字符串，并将解析后的字符串打印到控制台。
-
+
-```java
+```java
-public class MyEmbeddedValueResolverAware implements EmbeddedValueResolverAware {
+public class MyEmbeddedValueResolverAware implements EmbeddedValueResolverAware {
-
+
-    private StringValueResolver stringValueResolver;
+    private StringValueResolver stringValueResolver;
-
+
-    @Override
+    @Override
-    public void setEmbeddedValueResolver(StringValueResolver resolver) {
+    public void setEmbeddedValueResolver(StringValueResolver resolver) {
-        this.stringValueResolver = resolver;
+        this.stringValueResolver = resolver;
-    }
+    }
-
+
-    public void resolve() {
+    public void resolve() {
-        String resolvedValue = stringValueResolver.resolveStringValue("Hello, ${user.name:xcs}! Today is #{T(java.time.LocalDate).now().toString()}");
+        String resolvedValue = stringValueResolver.resolveStringValue("Hello, ${user.name:xcs}! Today is #{T(java.time.LocalDate).now().toString()}");
-        System.out.println(resolvedValue);
+        System.out.println(resolvedValue);
-    }
+    }
-}
+}
-```
+```
-
+
-运行结果发现，结合 Spring 的 `Environment` 和 SpEL 功能来解析嵌入的字符串值，并得到了预期的运行结果。
+运行结果发现，结合 Spring 的 `Environment` 和 SpEL 功能来解析嵌入的字符串值，并得到了预期的运行结果。
-
+
-```java
+```java
-Hello, Lex! Today is 2023-10-03
+Hello, Lex! Today is 2023-10-03
-```
+```
-
+
-### 五、时序图
+### 五、时序图
-
+
-~~~mermaid
+~~~mermaid
-sequenceDiagram
+sequenceDiagram
-    Title: EnvironmentAware时序图
+    Title: EnvironmentAware时序图
-    participant EmbeddedValueResolverAwareApplication
+    participant EmbeddedValueResolverAwareApplication
-    participant AnnotationConfigApplicationContext
+    participant AnnotationConfigApplicationContext
-    participant AbstractApplicationContext
+    participant AbstractApplicationContext
-    participant DefaultListableBeanFactory
+    participant DefaultListableBeanFactory
-    participant AbstractBeanFactory
+    participant AbstractBeanFactory
-    participant DefaultSingletonBeanRegistry
+    participant DefaultSingletonBeanRegistry
-    participant AbstractAutowireCapableBeanFactory
+    participant AbstractAutowireCapableBeanFactory
-    participant ApplicationContextAwareProcessor
+    participant ApplicationContextAwareProcessor
-    participant MyEmbeddedValueResolverAware
+    participant MyEmbeddedValueResolverAware
-    
+    
-    EmbeddedValueResolverAwareApplication->>AnnotationConfigApplicationContext:AnnotationConfigApplicationContext(componentClasses)<br>创建上下文
+    EmbeddedValueResolverAwareApplication->>AnnotationConfigApplicationContext:AnnotationConfigApplicationContext(componentClasses)<br>创建上下文
-    AnnotationConfigApplicationContext->>AbstractApplicationContext:refresh()<br>刷新上下文
+    AnnotationConfigApplicationContext->>AbstractApplicationContext:refresh()<br>刷新上下文
-    AbstractApplicationContext->>AbstractApplicationContext:finishBeanFactoryInitialization(beanFactory)<br>初始化Bean工厂
+    AbstractApplicationContext->>AbstractApplicationContext:finishBeanFactoryInitialization(beanFactory)<br>初始化Bean工厂
-    AbstractApplicationContext->>DefaultListableBeanFactory:preInstantiateSingletons()<br>实例化单例
+    AbstractApplicationContext->>DefaultListableBeanFactory:preInstantiateSingletons()<br>实例化单例
-    DefaultListableBeanFactory->>AbstractBeanFactory:getBean(name)<br>获取Bean
+    DefaultListableBeanFactory->>AbstractBeanFactory:getBean(name)<br>获取Bean
-    AbstractBeanFactory->>AbstractBeanFactory:doGetBean(name,requiredType,args,typeCheckOnly)<br>执行获取Bean
+    AbstractBeanFactory->>AbstractBeanFactory:doGetBean(name,requiredType,args,typeCheckOnly)<br>执行获取Bean
-    AbstractBeanFactory->>DefaultSingletonBeanRegistry:getSingleton(beanName,singletonFactory)<br>获取单例Bean
+    AbstractBeanFactory->>DefaultSingletonBeanRegistry:getSingleton(beanName,singletonFactory)<br>获取单例Bean
-    DefaultSingletonBeanRegistry-->>AbstractBeanFactory:getObject()<br>获取Bean实例
+    DefaultSingletonBeanRegistry-->>AbstractBeanFactory:getObject()<br>获取Bean实例
-    AbstractBeanFactory->>AbstractAutowireCapableBeanFactory:createBean(beanName,mbd,args)<br>创建Bean
+    AbstractBeanFactory->>AbstractAutowireCapableBeanFactory:createBean(beanName,mbd,args)<br>创建Bean
-    AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:doCreateBean(beanName,mbd,args)<br>执行Bean创建
+    AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:doCreateBean(beanName,mbd,args)<br>执行Bean创建
-    AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:initializeBean(beanName,bean,mbd)<br>负责bean的初始化
+    AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:initializeBean(beanName,bean,mbd)<br>负责bean的初始化
-	AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:applyBeanPostProcessorsBeforeInitialization(existingBean, beanName)<br>调用前置处理器
+	AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:applyBeanPostProcessorsBeforeInitialization(existingBean, beanName)<br>调用前置处理器
-    AbstractAutowireCapableBeanFactory->>ApplicationContextAwareProcessor:postProcessBeforeInitialization(bean,beanName)<br>触发Aware处理
+    AbstractAutowireCapableBeanFactory->>ApplicationContextAwareProcessor:postProcessBeforeInitialization(bean,beanName)<br>触发Aware处理
-    ApplicationContextAwareProcessor->>ApplicationContextAwareProcessor:invokeAwareInterfaces(bean)<br>执行Aware回调
+    ApplicationContextAwareProcessor->>ApplicationContextAwareProcessor:invokeAwareInterfaces(bean)<br>执行Aware回调
-    ApplicationContextAwareProcessor->>MyEmbeddedValueResolverAware:setEmbeddedValueResolver(resolver)<br>设置StringValueResolver
+    ApplicationContextAwareProcessor->>MyEmbeddedValueResolverAware:setEmbeddedValueResolver(resolver)<br>设置StringValueResolver
-    AbstractAutowireCapableBeanFactory-->>AbstractBeanFactory:返回Bean对象
+    AbstractAutowireCapableBeanFactory-->>AbstractBeanFactory:返回Bean对象
-    AbstractBeanFactory-->>DefaultListableBeanFactory:返回Bean对象
+    AbstractBeanFactory-->>DefaultListableBeanFactory:返回Bean对象
-    AnnotationConfigApplicationContext-->>EmbeddedValueResolverAwareApplication:初始化完成
+    AnnotationConfigApplicationContext-->>EmbeddedValueResolverAwareApplication:初始化完成
-~~~
+~~~
-
+
-### 六、源码分析
+### 六、源码分析
-
+
-首先来看看启动类入口，上下文环境使用`AnnotationConfigApplicationContext`（此类是使用Java注解来配置Spring容器的方式），构造参数我们给定了一个`MyConfiguration`组件类。然后从Spring上下文中获取一个`MyEmbeddedValueResolverAware`类型的bean，最后调用`resolve`方法。
+首先来看看启动类入口，上下文环境使用`AnnotationConfigApplicationContext`（此类是使用Java注解来配置Spring容器的方式），构造参数我们给定了一个`MyConfiguration`组件类。然后从Spring上下文中获取一个`MyEmbeddedValueResolverAware`类型的bean，最后调用`resolve`方法。
-
+
-```java
+```java
-public class EmbeddedValueResolverAwareApplication {
+public class EmbeddedValueResolverAwareApplication {
-
+
-    public static void main(String[] args) {
+    public static void main(String[] args) {
-        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyConfiguration.class);
+        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyConfiguration.class);
-        MyEmbeddedValueResolverAware resolverAware = context.getBean(MyEmbeddedValueResolverAware.class);
+        MyEmbeddedValueResolverAware resolverAware = context.getBean(MyEmbeddedValueResolverAware.class);
-        resolverAware.resolve();
+        resolverAware.resolve();
-    }
+    }
-}
+}
-```
+```
-
+
-在`org.springframework.context.annotation.AnnotationConfigApplicationContext#AnnotationConfigApplicationContext`构造函数中，执行了三个步骤，我们重点关注`refresh()`方法
+在`org.springframework.context.annotation.AnnotationConfigApplicationContext#AnnotationConfigApplicationContext`构造函数中，执行了三个步骤，我们重点关注`refresh()`方法
-
+
-```java
+```java
-public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
+public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
-    this();
+    this();
-    register(componentClasses);
+    register(componentClasses);
-    refresh();
+    refresh();
-```
+```
-
+
-在`org.springframework.context.support.AbstractApplicationContext#refresh`方法中我们重点关注一下`finishBeanFactoryInitialization(beanFactory)`这方法会对实例化所有剩余非懒加载的单列Bean对象，其他方法不是本次源码阅读的重点暂时忽略。
+在`org.springframework.context.support.AbstractApplicationContext#refresh`方法中我们重点关注一下`finishBeanFactoryInitialization(beanFactory)`这方法会对实例化所有剩余非懒加载的单列Bean对象，其他方法不是本次源码阅读的重点暂时忽略。
-
+
-```java
+```java
-@Override
+@Override
-public void refresh() throws BeansException, IllegalStateException {
+public void refresh() throws BeansException, IllegalStateException {
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-    // Instantiate all remaining (non-lazy-init) singletons.
+    // Instantiate all remaining (non-lazy-init) singletons.
-    finishBeanFactoryInitialization(beanFactory);
+    finishBeanFactoryInitialization(beanFactory);
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-}
+}
-```
+```
-
+
-在`org.springframework.context.support.AbstractApplicationContext#finishBeanFactoryInitialization`方法中，会继续调用`DefaultListableBeanFactory`类中的`preInstantiateSingletons`方法来完成所有剩余非懒加载的单列Bean对象。
+在`org.springframework.context.support.AbstractApplicationContext#finishBeanFactoryInitialization`方法中，会继续调用`DefaultListableBeanFactory`类中的`preInstantiateSingletons`方法来完成所有剩余非懒加载的单列Bean对象。
-
+
-```java
+```java
-/**
+/**
- * 完成此工厂的bean初始化，实例化所有剩余的非延迟初始化单例bean。
+ * 完成此工厂的bean初始化，实例化所有剩余的非延迟初始化单例bean。
- * 
+ * 
- * @param beanFactory 要初始化的bean工厂
+ * @param beanFactory 要初始化的bean工厂
- */
+ */
-protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
+protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-    // 完成所有剩余非懒加载的单列Bean对象。
+    // 完成所有剩余非懒加载的单列Bean对象。
-    beanFactory.preInstantiateSingletons();
+    beanFactory.preInstantiateSingletons();
-}
+}
-```
+```
-
+
-在`org.springframework.beans.factory.support.DefaultListableBeanFactory#preInstantiateSingletons`方法中，主要的核心目的是预先实例化所有非懒加载的单例bean。在Spring的上下文初始化完成后，该方法会被触发，以确保所有单例bean都被正确地创建并初始化。其中`getBean(beanName)`是此方法的核心操作。对于容器中定义的每一个单例bean，它都会调用`getBean`方法，这将触发bean的实例化、初始化及其依赖的注入。如果bean之前没有被创建过，那么这个调用会导致其被实例化和初始化。
+在`org.springframework.beans.factory.support.DefaultListableBeanFactory#preInstantiateSingletons`方法中，主要的核心目的是预先实例化所有非懒加载的单例bean。在Spring的上下文初始化完成后，该方法会被触发，以确保所有单例bean都被正确地创建并初始化。其中`getBean(beanName)`是此方法的核心操作。对于容器中定义的每一个单例bean，它都会调用`getBean`方法，这将触发bean的实例化、初始化及其依赖的注入。如果bean之前没有被创建过，那么这个调用会导致其被实例化和初始化。
-
+
-```java
+```java
-public void preInstantiateSingletons() throws BeansException {
+public void preInstantiateSingletons() throws BeansException {
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-    // 循环遍历所有bean的名称
+    // 循环遍历所有bean的名称
-    for (String beanName : beanNames) {
+    for (String beanName : beanNames) {
-        getBean(beanName);
+        getBean(beanName);
-    }
+    }
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-}
+}
-```
+```
-
+
-在`org.springframework.beans.factory.support.AbstractBeanFactory#getBean()`方法中，又调用了`doGetBean`方法来实际执行创建Bean的过程，传递给它bean的名称和一些其他默认的参数值。此处，`doGetBean`负责大部分工作，如查找bean定义、创建bean（如果尚未创建）、处理依赖关系等。
+在`org.springframework.beans.factory.support.AbstractBeanFactory#getBean()`方法中，又调用了`doGetBean`方法来实际执行创建Bean的过程，传递给它bean的名称和一些其他默认的参数值。此处，`doGetBean`负责大部分工作，如查找bean定义、创建bean（如果尚未创建）、处理依赖关系等。
-
+
-```java
+```java
-@Override
+@Override
-public Object getBean(String name) throws BeansException {
+public Object getBean(String name) throws BeansException {
-    return doGetBean(name, null, null, false);
+    return doGetBean(name, null, null, false);
-}
+}
-```
+```
-
+
-在`org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean`方法中，首先检查所请求的bean是否是一个单例并且已经创建。如果尚未创建，它将创建一个新的实例。在这个过程中，它处理可能的异常情况，如循环引用，并确保返回的bean是正确的类型。这是Spring容器bean生命周期管理的核心部分。
+在`org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean`方法中，首先检查所请求的bean是否是一个单例并且已经创建。如果尚未创建，它将创建一个新的实例。在这个过程中，它处理可能的异常情况，如循环引用，并确保返回的bean是正确的类型。这是Spring容器bean生命周期管理的核心部分。
-
+
-```java
+```java
-protected <T> T doGetBean(
+protected <T> T doGetBean(
-        String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
+        String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
-        throws BeansException {
+        throws BeansException {
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-
+
-    // 开始创建bean实例
+    // 开始创建bean实例
-    if (mbd.isSingleton()) {
+    if (mbd.isSingleton()) {
-        // 如果bean是单例的，我们会尝试从单例缓存中获取它
+        // 如果bean是单例的，我们会尝试从单例缓存中获取它
-        // 如果不存在，则使用lambda创建一个新的实例
+        // 如果不存在，则使用lambda创建一个新的实例
-        sharedInstance = getSingleton(beanName, () -> {
+        sharedInstance = getSingleton(beanName, () -> {
-            try {
+            try {
-                // 尝试创建bean实例
+                // 尝试创建bean实例
-                return createBean(beanName, mbd, args);
+                return createBean(beanName, mbd, args);
-            }
+            }
-            catch (BeansException ex) {
+            catch (BeansException ex) {
-                // ... [代码部分省略以简化]
+                // ... [代码部分省略以简化]
-            }
+            }
-        });
+        });
-        // 对于某些bean（例如FactoryBeans），可能需要进一步处理以获取真正的bean实例
+        // 对于某些bean（例如FactoryBeans），可能需要进一步处理以获取真正的bean实例
-        beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
+        beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
-    }
+    }
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-
+
-    // 确保返回的bean实例与请求的类型匹配
+    // 确保返回的bean实例与请求的类型匹配
-    return adaptBeanInstance(name, beanInstance, requiredType);
+    return adaptBeanInstance(name, beanInstance, requiredType);
-}
+}
-```
+```
-
+
-在`org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton()`方法中，主要负责从单例缓存中获取一个已存在的bean实例，或者使用提供的`ObjectFactory`创建一个新的实例。这是确保bean在Spring容器中作为单例存在的关键部分。
+在`org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton()`方法中，主要负责从单例缓存中获取一个已存在的bean实例，或者使用提供的`ObjectFactory`创建一个新的实例。这是确保bean在Spring容器中作为单例存在的关键部分。
-
+
-```java
+```java
-public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
+public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
-    // 断言bean名称不能为空
+    // 断言bean名称不能为空
-    Assert.notNull(beanName, "Bean name must not be null");
+    Assert.notNull(beanName, "Bean name must not be null");
-
+
-    // 同步访问单例对象缓存，确保线程安全
+    // 同步访问单例对象缓存，确保线程安全
-    synchronized (this.singletonObjects) {
+    synchronized (this.singletonObjects) {
-        // 从缓存中获取单例对象
+        // 从缓存中获取单例对象
-        Object singletonObject = this.singletonObjects.get(beanName);
+        Object singletonObject = this.singletonObjects.get(beanName);
-
+
-        // 如果缓存中没有找到
+        // 如果缓存中没有找到
-        if (singletonObject == null) {
+        if (singletonObject == null) {
-            // ... [代码部分省略以简化]
+            // ... [代码部分省略以简化]
-
+
-            try {
+            try {
-                // 使用工厂创建新的单例实例
+                // 使用工厂创建新的单例实例
-                singletonObject = singletonFactory.getObject();
+                singletonObject = singletonFactory.getObject();
-                newSingleton = true;
+                newSingleton = true;
-            }
+            }
-            catch (IllegalStateException ex) {
+            catch (IllegalStateException ex) {
-                // ... [代码部分省略以简化]
+                // ... [代码部分省略以简化]
-            }
+            }
-            catch (BeanCreationException ex) {
+            catch (BeanCreationException ex) {
-                // ... [代码部分省略以简化]
+                // ... [代码部分省略以简化]
-            }
+            }
-            finally {
+            finally {
-                // ... [代码部分省略以简化]
+                // ... [代码部分省略以简化]
-            }
+            }
-
+
-            // ... [代码部分省略以简化]
+            // ... [代码部分省略以简化]
-        }
+        }
-
+
-        // 返回单例对象
+        // 返回单例对象
-        return singletonObject;
+        return singletonObject;
-    }
+    }
-}
+}
-```
+```
-
+
-在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBean()`方法中，主要的逻辑是调用 `doCreateBean`，这是真正进行 bean 实例化、属性填充和初始化的地方。这个方法会返回新创建的 bean 实例。
+在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBean()`方法中，主要的逻辑是调用 `doCreateBean`，这是真正进行 bean 实例化、属性填充和初始化的地方。这个方法会返回新创建的 bean 实例。
-
+
-```java
+```java
-@Override
+@Override
-protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
+protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
-    throws BeanCreationException {
+    throws BeanCreationException {
-    
+    
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-    
+    
-    try {
+    try {
-        // 正常的bean实例化、属性注入和初始化。
+        // 正常的bean实例化、属性注入和初始化。
-        // 这里是真正进行bean创建的部分。
+        // 这里是真正进行bean创建的部分。
-        Object beanInstance = doCreateBean(beanName, mbdToUse, args);
+        Object beanInstance = doCreateBean(beanName, mbdToUse, args);
-        // 记录bean成功创建的日志
+        // 记录bean成功创建的日志
-        if (logger.isTraceEnabled()) {
+        if (logger.isTraceEnabled()) {
-            logger.trace("Finished creating instance of bean '" + beanName + "'");
+            logger.trace("Finished creating instance of bean '" + beanName + "'");
-        }
+        }
-        return beanInstance;
+        return beanInstance;
-    }
+    }
-    catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
+    catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
-        // ... [代码部分省略以简化]
+        // ... [代码部分省略以简化]
-    }
+    }
-    catch (Throwable ex) {
+    catch (Throwable ex) {
-        // ... [代码部分省略以简化]
+        // ... [代码部分省略以简化]
-    }
+    }
-}
+}
-```
+```
-
+
-在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean`方法中，`initializeBean`方法是bean初始化，确保bean是完全配置和准备好的。
+在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean`方法中，`initializeBean`方法是bean初始化，确保bean是完全配置和准备好的。
-
+
-```java
+```java
-protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
+protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
-        throws BeanCreationException {
+        throws BeanCreationException {
-
+
-    // 声明一个对象，后续可能用于存放初始化后的bean或它的代理对象
+    // 声明一个对象，后续可能用于存放初始化后的bean或它的代理对象
-    Object exposedObject = bean;
+    Object exposedObject = bean;
-
+
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-    
+    
-    try {
+    try {
-        // ... [代码部分省略以简化]
+        // ... [代码部分省略以简化]
-        
+        
-        // bean初始化
+        // bean初始化
-        exposedObject = initializeBean(beanName, exposedObject, mbd);
+        exposedObject = initializeBean(beanName, exposedObject, mbd);
-    } 
+    } 
-    catch (Throwable ex) {
+    catch (Throwable ex) {
-        // ... [代码部分省略以简化]
+        // ... [代码部分省略以简化]
-    }
+    }
-
+
-    // 返回创建和初始化后的bean
+    // 返回创建和初始化后的bean
-    return exposedObject;
+    return exposedObject;
-}
+}
-```
+```
-
+
-在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#initializeBean`方法中，如果条件满足（即 bean 不是合成的），那么它会调用 `applyBeanPostProcessorsBeforeInitialization` 方法。这个方法是 Spring 生命周期中的一个关键点，它会遍历所有已注册的 `BeanPostProcessor` 实现，并调用它们的 `postProcessBeforeInitialization` 方法。这允许我们和内部处理器在 bean 初始化之前对其进行修改或执行其他操作。
+在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#initializeBean`方法中，如果条件满足（即 bean 不是合成的），那么它会调用 `applyBeanPostProcessorsBeforeInitialization` 方法。这个方法是 Spring 生命周期中的一个关键点，它会遍历所有已注册的 `BeanPostProcessor` 实现，并调用它们的 `postProcessBeforeInitialization` 方法。这允许我们和内部处理器在 bean 初始化之前对其进行修改或执行其他操作。
-
+
-```java
+```java
-protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
+protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
-
+
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-    
+    
-    Object wrappedBean = bean;
+    Object wrappedBean = bean;
-    if (mbd == null || !mbd.isSynthetic()) {
+    if (mbd == null || !mbd.isSynthetic()) {
-        wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
+        wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
-    }
+    }
-    
+    
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-
+
-    return wrappedBean;
+    return wrappedBean;
-}
+}
-```
+```
-
+
-在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsBeforeInitialization`方法中，遍历每一个 `BeanPostProcessor` 的 `postProcessBeforeInitialization` 方法都有机会对bean进行修改或增强
+在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsBeforeInitialization`方法中，遍历每一个 `BeanPostProcessor` 的 `postProcessBeforeInitialization` 方法都有机会对bean进行修改或增强
-
+
-```java
+```java
-@Override
+@Override
-public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
+public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
-    throws BeansException {
+    throws BeansException {
-
+
-    Object result = existingBean;
+    Object result = existingBean;
-    for (BeanPostProcessor processor : getBeanPostProcessors()) {
+    for (BeanPostProcessor processor : getBeanPostProcessors()) {
-        Object current = processor.postProcessBeforeInitialization(result, beanName);
+        Object current = processor.postProcessBeforeInitialization(result, beanName);
-        if (current == null) {
+        if (current == null) {
-            return result;
+            return result;
-        }
+        }
-        result = current;
+        result = current;
-    }
+    }
-    return result;
+    return result;
-}
+}
-```
+```
-
+
-在`org.springframework.context.support.ApplicationContextAwareProcessor#postProcessBeforeInitialization`方法中，在这个方法的实现特别关注那些实现了 "aware" 接口的 beans，并为它们提供所需的运行环境信息。
+在`org.springframework.context.support.ApplicationContextAwareProcessor#postProcessBeforeInitialization`方法中，在这个方法的实现特别关注那些实现了 "aware" 接口的 beans，并为它们提供所需的运行环境信息。
-
+
-```java
+```java
-@Override
+@Override
-@Nullable
+@Nullable
-public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
+public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
-    if (!(bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware ||
+    if (!(bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware ||
-          bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware ||
+          bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware ||
-          bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware ||
+          bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware ||
-          bean instanceof ApplicationStartupAware)) {
+          bean instanceof ApplicationStartupAware)) {
-        return bean;
+        return bean;
-    }
+    }
-
+
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-    
+    
-    invokeAwareInterfaces(bean);
+    invokeAwareInterfaces(bean);
-
+
-    return bean;
+    return bean;
-}
+}
-```
+```
-
+
-在`org.springframework.context.support.ApplicationContextAwareProcessor#invokeAwareInterfaces`方法中，用于处理实现了"Aware"接口的beans。这些接口使得beans能够被自动"感知"并获得对其运行环境或特定依赖的引用，而不需要显式地进行查找或注入。
+在`org.springframework.context.support.ApplicationContextAwareProcessor#invokeAwareInterfaces`方法中，用于处理实现了"Aware"接口的beans。这些接口使得beans能够被自动"感知"并获得对其运行环境或特定依赖的引用，而不需要显式地进行查找或注入。
-
+
-```java
+```java
-private void invokeAwareInterfaces(Object bean) {
+private void invokeAwareInterfaces(Object bean) {
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-	if (bean instanceof EmbeddedValueResolverAware) {
+	if (bean instanceof EmbeddedValueResolverAware) {
-        ((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver);
+        ((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver);
-    }
+    }
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-}
+}
-```
+```
-
+
-最后执行到我们自定义的逻辑中，`MyEmbeddedValueResolverAware`类实现了`EmbeddedValueResolverAware`接口，当Spring容器初始化此类的Bean时，此方法将被调用，容器将传入一个`StringValueResolver`实例，然后通过`resolve()`方法，使用注入的`stringValueResolver`来解析包含占位符和SpEL表达式的字符串，并将解析后的字符串打印到控制台。
+最后执行到我们自定义的逻辑中，`MyEmbeddedValueResolverAware`类实现了`EmbeddedValueResolverAware`接口，当Spring容器初始化此类的Bean时，此方法将被调用，容器将传入一个`StringValueResolver`实例，然后通过`resolve()`方法，使用注入的`stringValueResolver`来解析包含占位符和SpEL表达式的字符串，并将解析后的字符串打印到控制台。
-
+
-```java
+```java
-public class MyEmbeddedValueResolverAware implements EmbeddedValueResolverAware {
+public class MyEmbeddedValueResolverAware implements EmbeddedValueResolverAware {
-
+
-    private StringValueResolver stringValueResolver;
+    private StringValueResolver stringValueResolver;
-
+
-    @Override
+    @Override
-    public void setEmbeddedValueResolver(StringValueResolver resolver) {
+    public void setEmbeddedValueResolver(StringValueResolver resolver) {
-        this.stringValueResolver = resolver;
+        this.stringValueResolver = resolver;
-    }
+    }
-
+
-    public void resolve() {
+    public void resolve() {
-        String resolvedValue = stringValueResolver.resolveStringValue("Hello, ${user.name:xcs}! Today is #{T(java.time.LocalDate).now().toString()}");
+        String resolvedValue = stringValueResolver.resolveStringValue("Hello, ${user.name:xcs}! Today is #{T(java.time.LocalDate).now().toString()}");
-        System.out.println(resolvedValue);
+        System.out.println(resolvedValue);
-    }
+    }
-}
+}
-```
+```
-
+
-### 七、注意事项
+### 七、注意事项
-
+
-**正确的环境**： 确保你在 Spring 的环境中使用它，因为 `StringValueResolver` 需要 Spring 上下文来正确解析嵌入的值。
+**正确的环境**： 确保你在 Spring 的环境中使用它，因为 `StringValueResolver` 需要 Spring 上下文来正确解析嵌入的值。
-
+
-**非延迟依赖注入**： `setEmbeddedValueResolver` 方法在 Bean 初始化时调用。如果你太早地尝试使用 `StringValueResolver`（例如，在构造函数中），它可能还没有被注入。
+**非延迟依赖注入**： `setEmbeddedValueResolver` 方法在 Bean 初始化时调用。如果你太早地尝试使用 `StringValueResolver`（例如，在构造函数中），它可能还没有被注入。
-
+
-**默认值**： 当使用 `${user.name:xcs}` 语法时，如果 `user.name` 没有在环境中定义，它将使用 `xcs`。这可以避免因缺少配置而导致的错误。
+**默认值**： 当使用 `${user.name:xcs}` 语法时，如果 `user.name` 没有在环境中定义，它将使用 `xcs`。这可以避免因缺少配置而导致的错误。
-
+
-**明确解析的范围**： `EmbeddedValueResolverAware` 通常用于解析占位符和 SpEL 表达式。确保不将它与更复杂的 Bean 解析逻辑混淆。
+**明确解析的范围**： `EmbeddedValueResolverAware` 通常用于解析占位符和 SpEL 表达式。确保不将它与更复杂的 Bean 解析逻辑混淆。
-
+
-**错误处理**： 当解析一个字符串值失败时，Spring 通常会抛出一个异常。确保在代码中适当地处理这些异常。
+**错误处理**： 当解析一个字符串值失败时，Spring 通常会抛出一个异常。确保在代码中适当地处理这些异常。
-
+
-**与其他 Aware 接口的交互**： 如果你的 Bean 实现了多个 `Aware` 接口，需要确保你理解了每个接口的初始化时机和顺序，以及如何与其他 Aware 方法（如 `setBeanFactory` 或 `setApplicationContext`）交互。
+**与其他 Aware 接口的交互**： 如果你的 Bean 实现了多个 `Aware` 接口，需要确保你理解了每个接口的初始化时机和顺序，以及如何与其他 Aware 方法（如 `setBeanFactory` 或 `setApplicationContext`）交互。
-
+
-### 八、总结
+### 八、总结
-
+
-#### 8.1、最佳实践总结
+#### 8.1、最佳实践总结
-
+
-**启动类**：在 `EmbeddedValueResolverAwareApplication` 中，我们初始化了 Spring 的 `AnnotationConfigApplicationContext` 并加载了 `MyConfiguration` 作为配置类。接着，我们从上下文中取得 `MyEmbeddedValueResolverAware` 的 Bean，并调用了其 `resolve` 方法。
+**启动类**：在 `EmbeddedValueResolverAwareApplication` 中，我们初始化了 Spring 的 `AnnotationConfigApplicationContext` 并加载了 `MyConfiguration` 作为配置类。接着，我们从上下文中取得 `MyEmbeddedValueResolverAware` 的 Bean，并调用了其 `resolve` 方法。
-
+
-**配置与Bean声明**：在 `MyConfiguration` 配置类中，我们声明了 `MyEmbeddedValueResolverAware` 为一个 Bean，这确保了它会被 Spring 容器管理，并且会接收到 `StringValueResolver` 的实例注入。
+**配置与Bean声明**：在 `MyConfiguration` 配置类中，我们声明了 `MyEmbeddedValueResolverAware` 为一个 Bean，这确保了它会被 Spring 容器管理，并且会接收到 `StringValueResolver` 的实例注入。
-
+
-**嵌入值解析**：`MyEmbeddedValueResolverAware` 类实现了 `EmbeddedValueResolverAware` 接口，这意味着在该 Bean 被初始化时，Spring 会自动提供一个 `StringValueResolver` 实例。这个解析器之后被用于解析字符串 "Hello, ${user.name:xcs}! Today is #{T(java.time.LocalDate).now().toString()}"。
+**嵌入值解析**：`MyEmbeddedValueResolverAware` 类实现了 `EmbeddedValueResolverAware` 接口，这意味着在该 Bean 被初始化时，Spring 会自动提供一个 `StringValueResolver` 实例。这个解析器之后被用于解析字符串 "Hello, ${user.name:xcs}! Today is #{T(java.time.LocalDate).now().toString()}"。
-
+
-#### 8.2、源码分析总结
+#### 8.2、源码分析总结
-
+
-**应用启动**：在`EmbeddedValueResolverAwareApplication`类中，使用`AnnotationConfigApplicationContext`来启动Spring应用并加载`MyConfiguration`配置类。
+**应用启动**：在`EmbeddedValueResolverAwareApplication`类中，使用`AnnotationConfigApplicationContext`来启动Spring应用并加载`MyConfiguration`配置类。
-
+
-**容器初始化**：在构造函数`AnnotationConfigApplicationContext`中，`refresh()`方法被调用来初始化Spring容器。
+**容器初始化**：在构造函数`AnnotationConfigApplicationContext`中，`refresh()`方法被调用来初始化Spring容器。
-
+
-**实例化Beans**：在`AbstractApplicationContext`的`refresh()`方法中，`finishBeanFactoryInitialization`方法被调用，确保所有单例Bean被预先实例化。
+**实例化Beans**：在`AbstractApplicationContext`的`refresh()`方法中，`finishBeanFactoryInitialization`方法被调用，确保所有单例Bean被预先实例化。
-
+
-**Bean预实例化**：`DefaultListableBeanFactory`的`preInstantiateSingletons`方法确保所有非懒加载的单例Beans被实例化。核心操作是调用`getBean(beanName)`。
+**Bean预实例化**：`DefaultListableBeanFactory`的`preInstantiateSingletons`方法确保所有非懒加载的单例Beans被实例化。核心操作是调用`getBean(beanName)`。
-
+
-**获取Bean实例**：`AbstractBeanFactory`的`getBean`方法进一步调用`doGetBean`来真正实例化Bean，处理异常和依赖，并返回Bean实例。
+**获取Bean实例**：`AbstractBeanFactory`的`getBean`方法进一步调用`doGetBean`来真正实例化Bean，处理异常和依赖，并返回Bean实例。
-
+
-**Bean单例获取**：`DefaultSingletonBeanRegistry`的`getSingleton`方法确保Bean以单例形式存在，从缓存获取或使用提供的`ObjectFactory`创建新实例。
+**Bean单例获取**：`DefaultSingletonBeanRegistry`的`getSingleton`方法确保Bean以单例形式存在，从缓存获取或使用提供的`ObjectFactory`创建新实例。
-
+
-**创建Bean实例**：`AbstractAutowireCapableBeanFactory`的`createBean`方法调用`doCreateBean`进行Bean的实际实例化，并进行初始化，确保Bean完全配置并准备就绪。
+**创建Bean实例**：`AbstractAutowireCapableBeanFactory`的`createBean`方法调用`doCreateBean`进行Bean的实际实例化，并进行初始化，确保Bean完全配置并准备就绪。
-
+
-**Bean初始化**：`AbstractAutowireCapableBeanFactory`的`initializeBean`方法确保Bean被正确初始化，其中调用`applyBeanPostProcessorsBeforeInitialization`方法是Spring生命周期中的关键点，允许BeanPostProcessors在Bean初始化之前进行操作。
+**Bean初始化**：`AbstractAutowireCapableBeanFactory`的`initializeBean`方法确保Bean被正确初始化，其中调用`applyBeanPostProcessorsBeforeInitialization`方法是Spring生命周期中的关键点，允许BeanPostProcessors在Bean初始化之前进行操作。
-
+
-**处理Aware接口**：在Bean初始化过程中，`ApplicationContextAwareProcessor`确保实现了`Aware`接口的Beans被正确处理，这些Beans会自动"感知"并获得其运行环境或特定依赖的引用。
+**处理Aware接口**：在Bean初始化过程中，`ApplicationContextAwareProcessor`确保实现了`Aware`接口的Beans被正确处理，这些Beans会自动"感知"并获得其运行环境或特定依赖的引用。
-
+
 **值解析**：最后，我们的`MyEmbeddedValueResolverAware` Bean接收到了一个`StringValueResolver`实例。此时，当`resolve`方法被调用，它会使用这个解析器来解析嵌入的字符串值，并打印到控制台。

spring-aware/spring-aware-embeddedValueResolverAware/pom.xml

@@ -3,7 +3,7 @@
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <parent>
-        <artifactId>spring-reading</artifactId>
+        <artifactId>spring-aware</artifactId>
         <groupId>com.xcs.spring</groupId>
         <version>0.0.1-SNAPSHOT</version>
     </parent>

spring-aware/spring-aware-embeddedValueResolverAware/src/main/java/com/xcs/spring/config/MyEmbeddedValueResolverAware.java

@@ -1,19 +1,19 @@
-package com.xcs.spring.config;
+package com.xcs.spring.config;
-
+
-import org.springframework.context.EmbeddedValueResolverAware;
+import org.springframework.context.EmbeddedValueResolverAware;
-import org.springframework.util.StringValueResolver;
+import org.springframework.util.StringValueResolver;
-
+
-public class MyEmbeddedValueResolverAware implements EmbeddedValueResolverAware {
+public class MyEmbeddedValueResolverAware implements EmbeddedValueResolverAware {
-
+
-    private StringValueResolver stringValueResolver;
+    private StringValueResolver stringValueResolver;
-
+
-    @Override
+    @Override
-    public void setEmbeddedValueResolver(StringValueResolver resolver) {
+    public void setEmbeddedValueResolver(StringValueResolver resolver) {
-        this.stringValueResolver = resolver;
+        this.stringValueResolver = resolver;
-    }
+    }
-
+
-    public void resolve() {
+    public void resolve() {
-        String resolvedValue = stringValueResolver.resolveStringValue("Hello, ${user.name:xcs}! Today is #{T(java.time.LocalDate).now().toString()}");
+        String resolvedValue = stringValueResolver.resolveStringValue("Hello, ${user.name:xcs}! Today is #{T(java.time.LocalDate).now().toString()}");
-        System.out.println(resolvedValue);
+        System.out.println(resolvedValue);
-    }
+    }
-}
+}

spring-aware/spring-aware-environmentAware/README.md

@@ -1,464 +1,464 @@
-## EnvironmentAware
+## EnvironmentAware
-
+
-- [EnvironmentAware](#environmentaware)
+- [EnvironmentAware](#environmentaware)
-  - [一、接口描述](#一接口描述)
+  - [一、接口描述](#一接口描述)
-  - [二、接口源码](#二接口源码)
+  - [二、接口源码](#二接口源码)
-  - [三、主要功能](#三主要功能)
+  - [三、主要功能](#三主要功能)
-  - [四、最佳实践](#四最佳实践)
+  - [四、最佳实践](#四最佳实践)
-  - [五、时序图](#五时序图)
+  - [五、时序图](#五时序图)
-  - [六、源码分析](#六源码分析)
+  - [六、源码分析](#六源码分析)
-  - [七、注意事项](#七注意事项)
+  - [七、注意事项](#七注意事项)
-  - [八、总结](#八总结)
+  - [八、总结](#八总结)
-    - [8.1、最佳实践总结](#81最佳实践总结)
+    - [8.1、最佳实践总结](#81最佳实践总结)
-    - [8.2、源码分析总结](#82源码分析总结)
+    - [8.2、源码分析总结](#82源码分析总结)
-
+
-### 一、接口描述
+### 一、接口描述
-
+
-`EnvironmentAware` 接口，允许Beans访问`Environment`对象。这是一个回调接口，当实现该接口的Bean被Spring容器管理时，Spring容器会为该Bean设置`Environment`对象。
+`EnvironmentAware` 接口，允许Beans访问`Environment`对象。这是一个回调接口，当实现该接口的Bean被Spring容器管理时，Spring容器会为该Bean设置`Environment`对象。
-
+
-### 二、接口源码
+### 二、接口源码
-
+
-`EnvironmentAware` 是 Spring 框架自 3.1 开始引入的一个核心接口。主要目的是允许bean在运行时获取与其运行环境有关的信息。这包括环境属性、配置文件、激活的profile等。
+`EnvironmentAware` 是 Spring 框架自 3.1 开始引入的一个核心接口。主要目的是允许bean在运行时获取与其运行环境有关的信息。这包括环境属性、配置文件、激活的profile等。
-
+
-```java
+```java
-/**
+/**
- * 任何希望被通知其运行的Environment的bean应该实现的接口。
+ * 任何希望被通知其运行的Environment的bean应该实现的接口。
- * 
+ * 
- * @author Chris Beams
+ * @author Chris Beams
- * @since 3.1
+ * @since 3.1
- * @see org.springframework.core.env.EnvironmentCapable
+ * @see org.springframework.core.env.EnvironmentCapable
- */
+ */
-public interface EnvironmentAware extends Aware {
+public interface EnvironmentAware extends Aware {
-
+
-    /**
+    /**
-     * 设置此组件运行所在的Environment。
+     * 设置此组件运行所在的Environment。
-     */
+     */
-    void setEnvironment(Environment environment);
+    void setEnvironment(Environment environment);
-}
+}
-```
+```
-
+
-### 三、主要功能
+### 三、主要功能
-
+
-**访问环境属性**：通过实现 `EnvironmentAware`，beans 可以直接访问应用上下文的`Environment`对象。这意味着它们可以读取环境属性，这些属性可能来自多个来源，例如系统属性、JVM参数、操作系统环境变量、属性文件等。
+**访问环境属性**：通过实现 `EnvironmentAware`，beans 可以直接访问应用上下文的`Environment`对象。这意味着它们可以读取环境属性，这些属性可能来自多个来源，例如系统属性、JVM参数、操作系统环境变量、属性文件等。
-
+
-**识别运行时环境**：beans可以通过`Environment`对象来检查和确定当前激活的Spring profiles。这使得bean可以根据不同的运行环境（例如开发、测试、生产等）进行特定的操作或配置。
+**识别运行时环境**：beans可以通过`Environment`对象来检查和确定当前激活的Spring profiles。这使得bean可以根据不同的运行环境（例如开发、测试、生产等）进行特定的操作或配置。
-
+
-**自动回调**：当Spring容器识别到一个bean实现了`EnvironmentAware`接口时，容器会自动调用 `setEnvironment` 方法并传递当前的 `Environment` 对象。这意味着开发者不需要特意去手动设置或获取它。
+**自动回调**：当Spring容器识别到一个bean实现了`EnvironmentAware`接口时，容器会自动调用 `setEnvironment` 方法并传递当前的 `Environment` 对象。这意味着开发者不需要特意去手动设置或获取它。
-
+
-**框架级别的集成**：此接口提供了一个标准机制，允许框架级别的代码（如其他Spring组件和第三方库）访问和集成`Environment`对象，而不必依赖特定的注入策略或其他机制。
+**框架级别的集成**：此接口提供了一个标准机制，允许框架级别的代码（如其他Spring组件和第三方库）访问和集成`Environment`对象，而不必依赖特定的注入策略或其他机制。
-
+
-### 四、最佳实践
+### 四、最佳实践
-
+
-首先来看看启动类入口，上下文环境使用`AnnotationConfigApplicationContext`（此类是使用Java注解来配置Spring容器的方式），构造参数我们给定了一个`MyConfiguration`组件类。然后从Spring上下文中获取一个`MyEnvironmentAware`类型的bean，最后调用`getAppProperty`方法并打印。
+首先来看看启动类入口，上下文环境使用`AnnotationConfigApplicationContext`（此类是使用Java注解来配置Spring容器的方式），构造参数我们给定了一个`MyConfiguration`组件类。然后从Spring上下文中获取一个`MyEnvironmentAware`类型的bean，最后调用`getAppProperty`方法并打印。
-
+
-```java
+```java
-public class EnvironmentAwareApplication {
+public class EnvironmentAwareApplication {
-
+
-    public static void main(String[] args) {
+    public static void main(String[] args) {
-        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyConfiguration.class);
+        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyConfiguration.class);
-        MyEnvironmentAware environmentAware = context.getBean(MyEnvironmentAware.class);
+        MyEnvironmentAware environmentAware = context.getBean(MyEnvironmentAware.class);
-        System.out.println("AppProperty = " + environmentAware.getAppProperty());
+        System.out.println("AppProperty = " + environmentAware.getAppProperty());
-    }
+    }
-}
+}
-```
+```
-
+
-这里使用`@Bean`注解，定义了以个Bean，是为了确保 `MyEnvironmentAware` 被 Spring 容器执行，另外使用`@PropertySource`注解从类路径下的`application.properties`文件中加载属性。这意味着我们可以在这个文件中定义属性，然后在应用中使用`Environment`对象来访问它们。
+这里使用`@Bean`注解，定义了以个Bean，是为了确保 `MyEnvironmentAware` 被 Spring 容器执行，另外使用`@PropertySource`注解从类路径下的`application.properties`文件中加载属性。这意味着我们可以在这个文件中定义属性，然后在应用中使用`Environment`对象来访问它们。
-
+
-```java
+```java
-@Configuration
+@Configuration
-@PropertySource("classpath:application.properties")
+@PropertySource("classpath:application.properties")
-public class MyConfiguration {
+public class MyConfiguration {
-
+
-    @Bean
+    @Bean
-    public MyEnvironmentAware myEnvironmentAware(){
+    public MyEnvironmentAware myEnvironmentAware(){
-        return new MyEnvironmentAware();
+        return new MyEnvironmentAware();
-    }
+    }
-
+
-}
+}
-```
+```
-
+
-`MyEnvironmentAware`类实现了`EnvironmentAware`接口，并重写了`setEnvironment`方法，以便在Spring容器初始化它时获取`Environment`对象。之后，我们可以使用`getPropertyValue`方法来查询`application.properties`中的任何属性。
+`MyEnvironmentAware`类实现了`EnvironmentAware`接口，并重写了`setEnvironment`方法，以便在Spring容器初始化它时获取`Environment`对象。之后，我们可以使用`getPropertyValue`方法来查询`application.properties`中的任何属性。
-
+
-```java
+```java
-public class MyEnvironmentAware implements EnvironmentAware {
+public class MyEnvironmentAware implements EnvironmentAware {
-
+
-    private String appProperty;
+    private String appProperty;
-
+
-    @Override
+    @Override
-    public void setEnvironment(Environment environment) {
+    public void setEnvironment(Environment environment) {
-        this.appProperty = environment.getProperty("app.xcs.property");
+        this.appProperty = environment.getProperty("app.xcs.property");
-    }
+    }
-
+
-    public String getAppProperty() {
+    public String getAppProperty() {
-        return appProperty;
+        return appProperty;
-    }
+    }
-}
+}
-```
+```
-
+
-运行结果发现，这个输出证明了`EnvironmentAware`接口及其与`application.properties`文件的整合成功工作，我们已经成功地使用Spring环境获取了配置属性。
+运行结果发现，这个输出证明了`EnvironmentAware`接口及其与`application.properties`文件的整合成功工作，我们已经成功地使用Spring环境获取了配置属性。
-
+
-```java
+```java
-AppProperty = Hello from EnvironmentAware!
+AppProperty = Hello from EnvironmentAware!
-```
+```
-
+
-### 五、时序图
+### 五、时序图
-
+
-~~~mermaid
+~~~mermaid
-sequenceDiagram
+sequenceDiagram
-    Title: EnvironmentAware时序图
+    Title: EnvironmentAware时序图
-    participant EnvironmentAwareApplication
+    participant EnvironmentAwareApplication
-    participant AnnotationConfigApplicationContext
+    participant AnnotationConfigApplicationContext
-    participant AbstractApplicationContext
+    participant AbstractApplicationContext
-    participant DefaultListableBeanFactory
+    participant DefaultListableBeanFactory
-    participant AbstractBeanFactory
+    participant AbstractBeanFactory
-    participant DefaultSingletonBeanRegistry
+    participant DefaultSingletonBeanRegistry
-    participant AbstractAutowireCapableBeanFactory
+    participant AbstractAutowireCapableBeanFactory
-    participant ApplicationContextAwareProcessor
+    participant ApplicationContextAwareProcessor
-    participant MyEnvironmentAware
+    participant MyEnvironmentAware
-    
+    
-    EnvironmentAwareApplication->>AnnotationConfigApplicationContext:AnnotationConfigApplicationContext(componentClasses)<br>创建上下文
+    EnvironmentAwareApplication->>AnnotationConfigApplicationContext:AnnotationConfigApplicationContext(componentClasses)<br>创建上下文
-    AnnotationConfigApplicationContext->>AbstractApplicationContext:refresh()<br>刷新上下文
+    AnnotationConfigApplicationContext->>AbstractApplicationContext:refresh()<br>刷新上下文
-    AbstractApplicationContext->>AbstractApplicationContext:finishBeanFactoryInitialization(beanFactory)<br>初始化Bean工厂
+    AbstractApplicationContext->>AbstractApplicationContext:finishBeanFactoryInitialization(beanFactory)<br>初始化Bean工厂
-    AbstractApplicationContext->>DefaultListableBeanFactory:preInstantiateSingletons()<br>实例化单例
+    AbstractApplicationContext->>DefaultListableBeanFactory:preInstantiateSingletons()<br>实例化单例
-    DefaultListableBeanFactory->>AbstractBeanFactory:getBean(name)<br>获取Bean
+    DefaultListableBeanFactory->>AbstractBeanFactory:getBean(name)<br>获取Bean
-    AbstractBeanFactory->>AbstractBeanFactory:doGetBean(name,requiredType,args,typeCheckOnly)<br>执行获取Bean
+    AbstractBeanFactory->>AbstractBeanFactory:doGetBean(name,requiredType,args,typeCheckOnly)<br>执行获取Bean
-    AbstractBeanFactory->>DefaultSingletonBeanRegistry:getSingleton(beanName,singletonFactory)<br>获取单例Bean
+    AbstractBeanFactory->>DefaultSingletonBeanRegistry:getSingleton(beanName,singletonFactory)<br>获取单例Bean
-    DefaultSingletonBeanRegistry-->>AbstractBeanFactory:getObject()<br>获取Bean实例
+    DefaultSingletonBeanRegistry-->>AbstractBeanFactory:getObject()<br>获取Bean实例
-    AbstractBeanFactory->>AbstractAutowireCapableBeanFactory:createBean(beanName,mbd,args)<br>创建Bean
+    AbstractBeanFactory->>AbstractAutowireCapableBeanFactory:createBean(beanName,mbd,args)<br>创建Bean
-    AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:doCreateBean(beanName,mbd,args)<br>执行Bean创建
+    AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:doCreateBean(beanName,mbd,args)<br>执行Bean创建
-    AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:initializeBean(beanName,bean,mbd)<br>负责bean的初始化
+    AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:initializeBean(beanName,bean,mbd)<br>负责bean的初始化
-	AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:applyBeanPostProcessorsBeforeInitialization(existingBean, beanName)<br>调用前置处理器
+	AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:applyBeanPostProcessorsBeforeInitialization(existingBean, beanName)<br>调用前置处理器
-    AbstractAutowireCapableBeanFactory->>ApplicationContextAwareProcessor:postProcessBeforeInitialization(bean,beanName)<br>触发Aware处理
+    AbstractAutowireCapableBeanFactory->>ApplicationContextAwareProcessor:postProcessBeforeInitialization(bean,beanName)<br>触发Aware处理
-    ApplicationContextAwareProcessor->>ApplicationContextAwareProcessor:invokeAwareInterfaces(bean)<br>执行Aware回调
+    ApplicationContextAwareProcessor->>ApplicationContextAwareProcessor:invokeAwareInterfaces(bean)<br>执行Aware回调
-    ApplicationContextAwareProcessor->>MyEnvironmentAware:setEnvironment(environment)<br>设置运行环境
+    ApplicationContextAwareProcessor->>MyEnvironmentAware:setEnvironment(environment)<br>设置运行环境
-    AbstractAutowireCapableBeanFactory-->>AbstractBeanFactory:返回Bean对象
+    AbstractAutowireCapableBeanFactory-->>AbstractBeanFactory:返回Bean对象
-    AbstractBeanFactory-->>DefaultListableBeanFactory:返回Bean对象
+    AbstractBeanFactory-->>DefaultListableBeanFactory:返回Bean对象
-    AnnotationConfigApplicationContext-->>EnvironmentAwareApplication:初始化完成
+    AnnotationConfigApplicationContext-->>EnvironmentAwareApplication:初始化完成
-~~~
+~~~
-
+
-### 六、源码分析
+### 六、源码分析
-
+
-首先来看看启动类入口，上下文环境使用`AnnotationConfigApplicationContext`（此类是使用Java注解来配置Spring容器的方式），构造参数我们给定了一个`MyConfiguration`组件类。然后从Spring上下文中获取一个`MyEnvironmentAware`类型的bean，最后调用`getAppProperty`方法并打印。
+首先来看看启动类入口，上下文环境使用`AnnotationConfigApplicationContext`（此类是使用Java注解来配置Spring容器的方式），构造参数我们给定了一个`MyConfiguration`组件类。然后从Spring上下文中获取一个`MyEnvironmentAware`类型的bean，最后调用`getAppProperty`方法并打印。
-
+
-```java
+```java
-public class EnvironmentAwareApplication {
+public class EnvironmentAwareApplication {
-
+
-    public static void main(String[] args) {
+    public static void main(String[] args) {
-        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyConfiguration.class);
+        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyConfiguration.class);
-        MyEnvironmentAware environmentAware = context.getBean(MyEnvironmentAware.class);
+        MyEnvironmentAware environmentAware = context.getBean(MyEnvironmentAware.class);
-        System.out.println("AppProperty = " + environmentAware.getAppProperty());
+        System.out.println("AppProperty = " + environmentAware.getAppProperty());
-    }
+    }
-}
+}
-```
+```
-
+
-在`org.springframework.context.annotation.AnnotationConfigApplicationContext#AnnotationConfigApplicationContext`构造函数中，执行了三个步骤，我们重点关注`refresh()`方法
+在`org.springframework.context.annotation.AnnotationConfigApplicationContext#AnnotationConfigApplicationContext`构造函数中，执行了三个步骤，我们重点关注`refresh()`方法
-
+
-```java
+```java
-public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
+public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
-    this();
+    this();
-    register(componentClasses);
+    register(componentClasses);
-    refresh();
+    refresh();
-```
+```
-
+
-在`org.springframework.context.support.AbstractApplicationContext#refresh`方法中我们重点关注一下`finishBeanFactoryInitialization(beanFactory)`这方法会对实例化所有剩余非懒加载的单列Bean对象，其他方法不是本次源码阅读的重点暂时忽略。
+在`org.springframework.context.support.AbstractApplicationContext#refresh`方法中我们重点关注一下`finishBeanFactoryInitialization(beanFactory)`这方法会对实例化所有剩余非懒加载的单列Bean对象，其他方法不是本次源码阅读的重点暂时忽略。
-
+
-```java
+```java
-@Override
+@Override
-public void refresh() throws BeansException, IllegalStateException {
+public void refresh() throws BeansException, IllegalStateException {
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-    // Instantiate all remaining (non-lazy-init) singletons.
+    // Instantiate all remaining (non-lazy-init) singletons.
-    finishBeanFactoryInitialization(beanFactory);
+    finishBeanFactoryInitialization(beanFactory);
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-}
+}
-```
+```
-
+
-在`org.springframework.context.support.AbstractApplicationContext#finishBeanFactoryInitialization`方法中，会继续调用`DefaultListableBeanFactory`类中的`preInstantiateSingletons`方法来完成所有剩余非懒加载的单列Bean对象。
+在`org.springframework.context.support.AbstractApplicationContext#finishBeanFactoryInitialization`方法中，会继续调用`DefaultListableBeanFactory`类中的`preInstantiateSingletons`方法来完成所有剩余非懒加载的单列Bean对象。
-
+
-```java
+```java
-/**
+/**
- * 完成此工厂的bean初始化，实例化所有剩余的非延迟初始化单例bean。
+ * 完成此工厂的bean初始化，实例化所有剩余的非延迟初始化单例bean。
- * 
+ * 
- * @param beanFactory 要初始化的bean工厂
+ * @param beanFactory 要初始化的bean工厂
- */
+ */
-protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
+protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-    // 完成所有剩余非懒加载的单列Bean对象。
+    // 完成所有剩余非懒加载的单列Bean对象。
-    beanFactory.preInstantiateSingletons();
+    beanFactory.preInstantiateSingletons();
-}
+}
-```
+```
-
+
-在`org.springframework.beans.factory.support.DefaultListableBeanFactory#preInstantiateSingletons`方法中，主要的核心目的是预先实例化所有非懒加载的单例bean。在Spring的上下文初始化完成后，该方法会被触发，以确保所有单例bean都被正确地创建并初始化。其中`getBean(beanName)`是此方法的核心操作。对于容器中定义的每一个单例bean，它都会调用`getBean`方法，这将触发bean的实例化、初始化及其依赖的注入。如果bean之前没有被创建过，那么这个调用会导致其被实例化和初始化。
+在`org.springframework.beans.factory.support.DefaultListableBeanFactory#preInstantiateSingletons`方法中，主要的核心目的是预先实例化所有非懒加载的单例bean。在Spring的上下文初始化完成后，该方法会被触发，以确保所有单例bean都被正确地创建并初始化。其中`getBean(beanName)`是此方法的核心操作。对于容器中定义的每一个单例bean，它都会调用`getBean`方法，这将触发bean的实例化、初始化及其依赖的注入。如果bean之前没有被创建过，那么这个调用会导致其被实例化和初始化。
-
+
-```java
+```java
-public void preInstantiateSingletons() throws BeansException {
+public void preInstantiateSingletons() throws BeansException {
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-    // 循环遍历所有bean的名称
+    // 循环遍历所有bean的名称
-    for (String beanName : beanNames) {
+    for (String beanName : beanNames) {
-        getBean(beanName);
+        getBean(beanName);
-    }
+    }
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-}
+}
-```
+```
-
+
-在`org.springframework.beans.factory.support.AbstractBeanFactory#getBean()`方法中，又调用了`doGetBean`方法来实际执行创建Bean的过程，传递给它bean的名称和一些其他默认的参数值。此处，`doGetBean`负责大部分工作，如查找bean定义、创建bean（如果尚未创建）、处理依赖关系等。
+在`org.springframework.beans.factory.support.AbstractBeanFactory#getBean()`方法中，又调用了`doGetBean`方法来实际执行创建Bean的过程，传递给它bean的名称和一些其他默认的参数值。此处，`doGetBean`负责大部分工作，如查找bean定义、创建bean（如果尚未创建）、处理依赖关系等。
-
+
-```java
+```java
-@Override
+@Override
-public Object getBean(String name) throws BeansException {
+public Object getBean(String name) throws BeansException {
-    return doGetBean(name, null, null, false);
+    return doGetBean(name, null, null, false);
-}
+}
-```
+```
-
+
-在`org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean`方法中，首先检查所请求的bean是否是一个单例并且已经创建。如果尚未创建，它将创建一个新的实例。在这个过程中，它处理可能的异常情况，如循环引用，并确保返回的bean是正确的类型。这是Spring容器bean生命周期管理的核心部分。
+在`org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean`方法中，首先检查所请求的bean是否是一个单例并且已经创建。如果尚未创建，它将创建一个新的实例。在这个过程中，它处理可能的异常情况，如循环引用，并确保返回的bean是正确的类型。这是Spring容器bean生命周期管理的核心部分。
-
+
-```java
+```java
-protected <T> T doGetBean(
+protected <T> T doGetBean(
-        String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
+        String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
-        throws BeansException {
+        throws BeansException {
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-
+
-    // 开始创建bean实例
+    // 开始创建bean实例
-    if (mbd.isSingleton()) {
+    if (mbd.isSingleton()) {
-        // 如果bean是单例的，我们会尝试从单例缓存中获取它
+        // 如果bean是单例的，我们会尝试从单例缓存中获取它
-        // 如果不存在，则使用lambda创建一个新的实例
+        // 如果不存在，则使用lambda创建一个新的实例
-        sharedInstance = getSingleton(beanName, () -> {
+        sharedInstance = getSingleton(beanName, () -> {
-            try {
+            try {
-                // 尝试创建bean实例
+                // 尝试创建bean实例
-                return createBean(beanName, mbd, args);
+                return createBean(beanName, mbd, args);
-            }
+            }
-            catch (BeansException ex) {
+            catch (BeansException ex) {
-                // ... [代码部分省略以简化]
+                // ... [代码部分省略以简化]
-            }
+            }
-        });
+        });
-        // 对于某些bean（例如FactoryBeans），可能需要进一步处理以获取真正的bean实例
+        // 对于某些bean（例如FactoryBeans），可能需要进一步处理以获取真正的bean实例
-        beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
+        beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
-    }
+    }
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-
+
-    // 确保返回的bean实例与请求的类型匹配
+    // 确保返回的bean实例与请求的类型匹配
-    return adaptBeanInstance(name, beanInstance, requiredType);
+    return adaptBeanInstance(name, beanInstance, requiredType);
-}
+}
-```
+```
-
+
-在`org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton()`方法中，主要负责从单例缓存中获取一个已存在的bean实例，或者使用提供的`ObjectFactory`创建一个新的实例。这是确保bean在Spring容器中作为单例存在的关键部分。
+在`org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton()`方法中，主要负责从单例缓存中获取一个已存在的bean实例，或者使用提供的`ObjectFactory`创建一个新的实例。这是确保bean在Spring容器中作为单例存在的关键部分。
-
+
-```java
+```java
-public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
+public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
-    // 断言bean名称不能为空
+    // 断言bean名称不能为空
-    Assert.notNull(beanName, "Bean name must not be null");
+    Assert.notNull(beanName, "Bean name must not be null");
-
+
-    // 同步访问单例对象缓存，确保线程安全
+    // 同步访问单例对象缓存，确保线程安全
-    synchronized (this.singletonObjects) {
+    synchronized (this.singletonObjects) {
-        // 从缓存中获取单例对象
+        // 从缓存中获取单例对象
-        Object singletonObject = this.singletonObjects.get(beanName);
+        Object singletonObject = this.singletonObjects.get(beanName);
-
+
-        // 如果缓存中没有找到
+        // 如果缓存中没有找到
-        if (singletonObject == null) {
+        if (singletonObject == null) {
-            // ... [代码部分省略以简化]
+            // ... [代码部分省略以简化]
-
+
-            try {
+            try {
-                // 使用工厂创建新的单例实例
+                // 使用工厂创建新的单例实例
-                singletonObject = singletonFactory.getObject();
+                singletonObject = singletonFactory.getObject();
-                newSingleton = true;
+                newSingleton = true;
-            }
+            }
-            catch (IllegalStateException ex) {
+            catch (IllegalStateException ex) {
-                // ... [代码部分省略以简化]
+                // ... [代码部分省略以简化]
-            }
+            }
-            catch (BeanCreationException ex) {
+            catch (BeanCreationException ex) {
-                // ... [代码部分省略以简化]
+                // ... [代码部分省略以简化]
-            }
+            }
-            finally {
+            finally {
-                // ... [代码部分省略以简化]
+                // ... [代码部分省略以简化]
-            }
+            }
-
+
-            // ... [代码部分省略以简化]
+            // ... [代码部分省略以简化]
-        }
+        }
-
+
-        // 返回单例对象
+        // 返回单例对象
-        return singletonObject;
+        return singletonObject;
-    }
+    }
-}
+}
-```
+```
-
+
-在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBean()`方法中，主要的逻辑是调用 `doCreateBean`，这是真正进行 bean 实例化、属性填充和初始化的地方。这个方法会返回新创建的 bean 实例。
+在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBean()`方法中，主要的逻辑是调用 `doCreateBean`，这是真正进行 bean 实例化、属性填充和初始化的地方。这个方法会返回新创建的 bean 实例。
-
+
-```java
+```java
-@Override
+@Override
-protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
+protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
-    throws BeanCreationException {
+    throws BeanCreationException {
-    
+    
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-    
+    
-    try {
+    try {
-        // 正常的bean实例化、属性注入和初始化。
+        // 正常的bean实例化、属性注入和初始化。
-        // 这里是真正进行bean创建的部分。
+        // 这里是真正进行bean创建的部分。
-        Object beanInstance = doCreateBean(beanName, mbdToUse, args);
+        Object beanInstance = doCreateBean(beanName, mbdToUse, args);
-        // 记录bean成功创建的日志
+        // 记录bean成功创建的日志
-        if (logger.isTraceEnabled()) {
+        if (logger.isTraceEnabled()) {
-            logger.trace("Finished creating instance of bean '" + beanName + "'");
+            logger.trace("Finished creating instance of bean '" + beanName + "'");
-        }
+        }
-        return beanInstance;
+        return beanInstance;
-    }
+    }
-    catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
+    catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
-        // ... [代码部分省略以简化]
+        // ... [代码部分省略以简化]
-    }
+    }
-    catch (Throwable ex) {
+    catch (Throwable ex) {
-        // ... [代码部分省略以简化]
+        // ... [代码部分省略以简化]
-    }
+    }
-}
+}
-```
+```
-
+
-在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean`方法中，`initializeBean`方法是bean初始化，确保bean是完全配置和准备好的。
+在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean`方法中，`initializeBean`方法是bean初始化，确保bean是完全配置和准备好的。
-
+
-```java
+```java
-protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
+protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
-        throws BeanCreationException {
+        throws BeanCreationException {
-
+
-    // 声明一个对象，后续可能用于存放初始化后的bean或它的代理对象
+    // 声明一个对象，后续可能用于存放初始化后的bean或它的代理对象
-    Object exposedObject = bean;
+    Object exposedObject = bean;
-
+
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-    
+    
-    try {
+    try {
-        // ... [代码部分省略以简化]
+        // ... [代码部分省略以简化]
-        
+        
-        // bean初始化
+        // bean初始化
-        exposedObject = initializeBean(beanName, exposedObject, mbd);
+        exposedObject = initializeBean(beanName, exposedObject, mbd);
-    } 
+    } 
-    catch (Throwable ex) {
+    catch (Throwable ex) {
-        // ... [代码部分省略以简化]
+        // ... [代码部分省略以简化]
-    }
+    }
-
+
-    // 返回创建和初始化后的bean
+    // 返回创建和初始化后的bean
-    return exposedObject;
+    return exposedObject;
-}
+}
-```
+```
-
+
-在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#initializeBean`方法中，如果条件满足（即 bean 不是合成的），那么它会调用 `applyBeanPostProcessorsBeforeInitialization` 方法。这个方法是 Spring 生命周期中的一个关键点，它会遍历所有已注册的 `BeanPostProcessor` 实现，并调用它们的 `postProcessBeforeInitialization` 方法。这允许我们和内部处理器在 bean 初始化之前对其进行修改或执行其他操作。
+在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#initializeBean`方法中，如果条件满足（即 bean 不是合成的），那么它会调用 `applyBeanPostProcessorsBeforeInitialization` 方法。这个方法是 Spring 生命周期中的一个关键点，它会遍历所有已注册的 `BeanPostProcessor` 实现，并调用它们的 `postProcessBeforeInitialization` 方法。这允许我们和内部处理器在 bean 初始化之前对其进行修改或执行其他操作。
-
+
-```java
+```java
-protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
+protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
-
+
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-    
+    
-    Object wrappedBean = bean;
+    Object wrappedBean = bean;
-    if (mbd == null || !mbd.isSynthetic()) {
+    if (mbd == null || !mbd.isSynthetic()) {
-        wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
+        wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
-    }
+    }
-    
+    
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-
+
-    return wrappedBean;
+    return wrappedBean;
-}
+}
-```
+```
-
+
-在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsBeforeInitialization`方法中，遍历每一个 `BeanPostProcessor` 的 `postProcessBeforeInitialization` 方法都有机会对bean进行修改或增强
+在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsBeforeInitialization`方法中，遍历每一个 `BeanPostProcessor` 的 `postProcessBeforeInitialization` 方法都有机会对bean进行修改或增强
-
+
-```java
+```java
-@Override
+@Override
-public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
+public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
-    throws BeansException {
+    throws BeansException {
-
+
-    Object result = existingBean;
+    Object result = existingBean;
-    for (BeanPostProcessor processor : getBeanPostProcessors()) {
+    for (BeanPostProcessor processor : getBeanPostProcessors()) {
-        Object current = processor.postProcessBeforeInitialization(result, beanName);
+        Object current = processor.postProcessBeforeInitialization(result, beanName);
-        if (current == null) {
+        if (current == null) {
-            return result;
+            return result;
-        }
+        }
-        result = current;
+        result = current;
-    }
+    }
-    return result;
+    return result;
-}
+}
-```
+```
-
+
-在`org.springframework.context.support.ApplicationContextAwareProcessor#postProcessBeforeInitialization`方法中，在这个方法的实现特别关注那些实现了 "aware" 接口的 beans，并为它们提供所需的运行环境信息。
+在`org.springframework.context.support.ApplicationContextAwareProcessor#postProcessBeforeInitialization`方法中，在这个方法的实现特别关注那些实现了 "aware" 接口的 beans，并为它们提供所需的运行环境信息。
-
+
-```java
+```java
-@Override
+@Override
-@Nullable
+@Nullable
-public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
+public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
-    if (!(bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware ||
+    if (!(bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware ||
-          bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware ||
+          bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware ||
-          bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware ||
+          bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware ||
-          bean instanceof ApplicationStartupAware)) {
+          bean instanceof ApplicationStartupAware)) {
-        return bean;
+        return bean;
-    }
+    }
-
+
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-    
+    
-    invokeAwareInterfaces(bean);
+    invokeAwareInterfaces(bean);
-
+
-    return bean;
+    return bean;
-}
+}
-```
+```
-
+
-在`org.springframework.context.support.ApplicationContextAwareProcessor#invokeAwareInterfaces`方法中，用于处理实现了"Aware"接口的beans。这些接口使得beans能够被自动"感知"并获得对其运行环境或特定依赖的引用，而不需要显式地进行查找或注入。
+在`org.springframework.context.support.ApplicationContextAwareProcessor#invokeAwareInterfaces`方法中，用于处理实现了"Aware"接口的beans。这些接口使得beans能够被自动"感知"并获得对其运行环境或特定依赖的引用，而不需要显式地进行查找或注入。
-
+
-```java
+```java
-private void invokeAwareInterfaces(Object bean) {
+private void invokeAwareInterfaces(Object bean) {
-	if (bean instanceof EnvironmentAware) {
+	if (bean instanceof EnvironmentAware) {
-        ((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
+        ((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
-    }
+    }
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-}
+}
-```
+```
-
+
-最后执行到我们自定义的逻辑中，`MyEnvironmentAware`类实现了`EnvironmentAware`接口，并重写了`setEnvironment`方法，以便在Spring容器初始化它时获取`Environment`对象。之后，我们可以使用`getPropertyValue`方法来查询`application.properties`中的任何属性。
+最后执行到我们自定义的逻辑中，`MyEnvironmentAware`类实现了`EnvironmentAware`接口，并重写了`setEnvironment`方法，以便在Spring容器初始化它时获取`Environment`对象。之后，我们可以使用`getPropertyValue`方法来查询`application.properties`中的任何属性。
-
+
-```java
+```java
-public class MyEnvironmentAware implements EnvironmentAware {
+public class MyEnvironmentAware implements EnvironmentAware {
-
+
-    private String appProperty;
+    private String appProperty;
-
+
-    @Override
+    @Override
-    public void setEnvironment(Environment environment) {
+    public void setEnvironment(Environment environment) {
-        this.appProperty = environment.getProperty("app.xcs.property");
+        this.appProperty = environment.getProperty("app.xcs.property");
-    }
+    }
-
+
-    public String getAppProperty() {
+    public String getAppProperty() {
-        return appProperty;
+        return appProperty;
-    }
+    }
-}
+}
-```
+```
-
+
-### 七、注意事项
+### 七、注意事项
-
+
-**不要过度使用**：虽然`EnvironmentAware`为Bean提供了一个直接访问`Environment`的方法，但这并不意味着所有的Bean都应该使用它。在可能的情况下，首先考虑使用Spring的属性注入功能，例如`@Value`。
+**不要过度使用**：虽然`EnvironmentAware`为Bean提供了一个直接访问`Environment`的方法，但这并不意味着所有的Bean都应该使用它。在可能的情况下，首先考虑使用Spring的属性注入功能，例如`@Value`。
-
+
-**避免使用硬编码的属性键**：当从`Environment`对象中获取属性时，尽量避免在代码中硬编码属性键。最好是将这些键作为常量或在外部配置中定义。
+**避免使用硬编码的属性键**：当从`Environment`对象中获取属性时，尽量避免在代码中硬编码属性键。最好是将这些键作为常量或在外部配置中定义。
-
+
-**处理不存在的属性**：当使用`Environment`获取属性时，如果该属性不存在，`Environment`可能会返回`null`。确保在代码中正确处理这种情况，或使用`Environment`提供的默认值方法。
+**处理不存在的属性**：当使用`Environment`获取属性时，如果该属性不存在，`Environment`可能会返回`null`。确保在代码中正确处理这种情况，或使用`Environment`提供的默认值方法。
-
+
-**记住激活的配置文件**：`Environment`允许我们查询当前激活的配置文件(profiles)。确保我们知道哪些profiles是激活的，尤其是在使用特定于profile的属性时。
+**记住激活的配置文件**：`Environment`允许我们查询当前激活的配置文件(profiles)。确保我们知道哪些profiles是激活的，尤其是在使用特定于profile的属性时。
-
+
-**了解Environment的层次结构**：`Environment`对象可能会从多个来源获取属性（例如系统属性、环境变量、配置文件等）。了解这些来源的优先级和加载顺序，以便正确地理解在存在冲突时哪个属性值会被使用。
+**了解Environment的层次结构**：`Environment`对象可能会从多个来源获取属性（例如系统属性、环境变量、配置文件等）。了解这些来源的优先级和加载顺序，以便正确地理解在存在冲突时哪个属性值会被使用。
-
+
-### 八、总结
+### 八、总结
-
+
-#### 8.1、最佳实践总结
+#### 8.1、最佳实践总结
-
+
-**启动过程**：通过`EnvironmentAwareApplication`作为主入口，我们使用了`AnnotationConfigApplicationContext`来启动Spring上下文，并加载了`MyConfiguration`作为配置类。
+**启动过程**：通过`EnvironmentAwareApplication`作为主入口，我们使用了`AnnotationConfigApplicationContext`来启动Spring上下文，并加载了`MyConfiguration`作为配置类。
-
+
-**加载属性**：在`MyConfiguration`类中，我们使用了`@PropertySource`注解指定了从类路径下的`application.properties`文件加载属性到Spring的环境中。
+**加载属性**：在`MyConfiguration`类中，我们使用了`@PropertySource`注解指定了从类路径下的`application.properties`文件加载属性到Spring的环境中。
-
+
-**注册Bean**：在配置类`MyConfiguration`中，我们定义了一个bean `MyEnvironmentAware`。这保证了当Spring容器启动时，`MyEnvironmentAware`对象会被创建并由Spring管理。
+**注册Bean**：在配置类`MyConfiguration`中，我们定义了一个bean `MyEnvironmentAware`。这保证了当Spring容器启动时，`MyEnvironmentAware`对象会被创建并由Spring管理。
-
+
-**访问环境属性**：`MyEnvironmentAware`类实现了`EnvironmentAware`接口，这使得当Spring容器初始化该bean时，它会自动调用`setEnvironment`方法，注入当前的`Environment`对象。我们使用这个方法来读取`app.xcs.property`属性，并将其值存储在`appProperty`私有变量中。
+**访问环境属性**：`MyEnvironmentAware`类实现了`EnvironmentAware`接口，这使得当Spring容器初始化该bean时，它会自动调用`setEnvironment`方法，注入当前的`Environment`对象。我们使用这个方法来读取`app.xcs.property`属性，并将其值存储在`appProperty`私有变量中。
-
+
-**显示属性**：最后，在`EnvironmentAwareApplication`主程序中，我们从Spring上下文中获取了`MyEnvironmentAware` bean，并调用了`getAppProperty`方法来获取属性值，然后将其打印到控制台。
+**显示属性**：最后，在`EnvironmentAwareApplication`主程序中，我们从Spring上下文中获取了`MyEnvironmentAware` bean，并调用了`getAppProperty`方法来获取属性值，然后将其打印到控制台。
-
+
-**输出**：结果显示为“AppProperty = Hello from EnvironmentAware!”，这证明了`EnvironmentAware`接口和`application.properties`文件成功地结合起来，并且我们已经成功地使用Spring环境获取了配置属性。
+**输出**：结果显示为“AppProperty = Hello from EnvironmentAware!”，这证明了`EnvironmentAware`接口和`application.properties`文件成功地结合起来，并且我们已经成功地使用Spring环境获取了配置属性。
-
+
-#### 8.2、源码分析总结
+#### 8.2、源码分析总结
-
+
-**应用启动**： 通过`EnvironmentAwareApplication`作为入口，使用`AnnotationConfigApplicationContext`来初始化Spring的上下文，并加载`MyConfiguration`作为配置类。
+**应用启动**： 通过`EnvironmentAwareApplication`作为入口，使用`AnnotationConfigApplicationContext`来初始化Spring的上下文，并加载`MyConfiguration`作为配置类。
-
+
-**属性加载**： 在`MyConfiguration`类中，利用`@PropertySource`注解，指定从`application.properties`文件加载属性到Spring环境中。
+**属性加载**： 在`MyConfiguration`类中，利用`@PropertySource`注解，指定从`application.properties`文件加载属性到Spring环境中。
-
+
-**Bean注册与初始化**： 在上下文的`refresh()`方法中，调用`finishBeanFactoryInitialization()`确保所有非懒加载的单例bean都被实例化。这个过程在`preInstantiateSingletons()`中通过循环调用`getBean()`完成，该方法将触发bean的创建、初始化及其依赖的注入。
+**Bean注册与初始化**： 在上下文的`refresh()`方法中，调用`finishBeanFactoryInitialization()`确保所有非懒加载的单例bean都被实例化。这个过程在`preInstantiateSingletons()`中通过循环调用`getBean()`完成，该方法将触发bean的创建、初始化及其依赖的注入。
-
+
-**Bean后处理与"感知"**： 在bean的初始化过程中，`ApplicationContextAwareProcessor`负责检查并调用那些实现了Aware接口的bean的特定方法。对于实现了`EnvironmentAware`接口的beans，它会调用`setEnvironment()`方法并传入当前的`Environment`对象。
+**Bean后处理与"感知"**： 在bean的初始化过程中，`ApplicationContextAwareProcessor`负责检查并调用那些实现了Aware接口的bean的特定方法。对于实现了`EnvironmentAware`接口的beans，它会调用`setEnvironment()`方法并传入当前的`Environment`对象。
-
+
-**自定义Bean的处理**： `MyEnvironmentAware`在其`setEnvironment()`方法中，从传入的`Environment`对象中获取了`app.xcs.property`属性，并存储到了它的私有变量`appProperty`中。
+**自定义Bean的处理**： `MyEnvironmentAware`在其`setEnvironment()`方法中，从传入的`Environment`对象中获取了`app.xcs.property`属性，并存储到了它的私有变量`appProperty`中。
-
+
 **应用结果输出**： 在`EnvironmentAwareApplication`的主方法中，从Spring上下文获取了`MyEnvironmentAware` bean并调用其`getAppProperty()`方法，然后将获得的属性值输出到控制台。

spring-aware/spring-aware-environmentAware/pom.xml

@@ -3,7 +3,7 @@
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <parent>
-        <artifactId>spring-reading</artifactId>
+        <artifactId>spring-aware</artifactId>
         <groupId>com.xcs.spring</groupId>
         <version>0.0.1-SNAPSHOT</version>
     </parent>

spring-aware/spring-aware-environmentAware/src/main/java/com/xcs/spring/config/MyEnvironmentAware.java

@@ -1,18 +1,18 @@
-package com.xcs.spring.config;
+package com.xcs.spring.config;
-
+
-import org.springframework.context.EnvironmentAware;
+import org.springframework.context.EnvironmentAware;
-import org.springframework.core.env.Environment;
+import org.springframework.core.env.Environment;
-
+
-public class MyEnvironmentAware implements EnvironmentAware {
+public class MyEnvironmentAware implements EnvironmentAware {
-
+
-    private String appProperty;
+    private String appProperty;
-
+
-    @Override
+    @Override
-    public void setEnvironment(Environment environment) {
+    public void setEnvironment(Environment environment) {
-        this.appProperty = environment.getProperty("app.xcs.property");
+        this.appProperty = environment.getProperty("app.xcs.property");
-    }
+    }
-
+
-    public String getAppProperty() {
+    public String getAppProperty() {
-        return appProperty;
+        return appProperty;
-    }
+    }
-}
+}

spring-aware/spring-aware-importAware/README.md

@@ -1,493 +1,493 @@
-## ImportAware
+## ImportAware
-
+
-- [ImportAware](#importaware)
+- [ImportAware](#importaware)
-  - [一、接口描述](#一接口描述)
+  - [一、接口描述](#一接口描述)
-  - [二、接口源码](#二接口源码)
+  - [二、接口源码](#二接口源码)
-  - [三、主要功能](#三主要功能)
+  - [三、主要功能](#三主要功能)
-  - [四、最佳实践](#四最佳实践)
+  - [四、最佳实践](#四最佳实践)
-  - [五、时序图](#五时序图)
+  - [五、时序图](#五时序图)
-  - [六、源码分析](#六源码分析)
+  - [六、源码分析](#六源码分析)
-  - [七、注意事项](#七注意事项)
+  - [七、注意事项](#七注意事项)
-  - [八、总结](#八总结)
+  - [八、总结](#八总结)
-    - [8.1、最佳实践总结](#81最佳实践总结)
+    - [8.1、最佳实践总结](#81最佳实践总结)
-    - [8.2、源码分析总结](#82源码分析总结)
+    - [8.2、源码分析总结](#82源码分析总结)
-
+
-### 一、接口描述
+### 一、接口描述
-
+
-`ImportAware` 接口，提供被导入类的访问功能。当一个类实现了 `ImportAware` 接口，并且被通过 @Import 注解导入到其他配置类中，该类可以获得对导入它的 `AnnotationMetadata` 的访问权。
+`ImportAware` 接口，提供被导入类的访问功能。当一个类实现了 `ImportAware` 接口，并且被通过 @Import 注解导入到其他配置类中，该类可以获得对导入它的 `AnnotationMetadata` 的访问权。
-
+
-### 二、接口源码
+### 二、接口源码
-
+
-`ApplicationStartupAware` 是 Spring 框架自 3.1 开始引入的一个核心接口。实现`ImportAware`接口的对象会在Spring容器中被自动注入一个`AnnotationMetadata`实例。
+`ApplicationStartupAware` 是 Spring 框架自 3.1 开始引入的一个核心接口。实现`ImportAware`接口的对象会在Spring容器中被自动注入一个`AnnotationMetadata`实例。
-
+
-```java
+```java
-/**
+/**
- * 任何希望被注入其导入它的Configuration类的AnnotationMetadata的Configuration类都应实现此接口。
+ * 任何希望被注入其导入它的Configuration类的AnnotationMetadata的Configuration类都应实现此接口。
- * 与使用Import作为元注解的注解结合使用时特别有用。
+ * 与使用Import作为元注解的注解结合使用时特别有用。
- * 
+ * 
- * @author Chris Beams
+ * @author Chris Beams
- * @since 3.1
+ * @since 3.1
- */
+ */
-public interface ImportAware extends Aware {
+public interface ImportAware extends Aware {
-
+
-	/**
+	/**
-	 * 设置导入的@Configuration类的注解元数据。
+	 * 设置导入的@Configuration类的注解元数据。
-	 */
+	 */
-	void setImportMetadata(AnnotationMetadata importMetadata);
+	void setImportMetadata(AnnotationMetadata importMetadata);
-
+
-}
+}
-```
+```
-
+
-### 三、主要功能
+### 三、主要功能
-
+
-**访问导入类的注解元数据**：当一个类实现了 `ImportAware` 接口，并且它是通过 `@Import` 或其他特定方式被导入的，Spring 容器会自动调用它的 `setImportMetadata` 方法，并传入与导入该类的注解相关的 `AnnotationMetadata`。
+**访问导入类的注解元数据**：当一个类实现了 `ImportAware` 接口，并且它是通过 `@Import` 或其他特定方式被导入的，Spring 容器会自动调用它的 `setImportMetadata` 方法，并传入与导入该类的注解相关的 `AnnotationMetadata`。
-
+
-**条件性的行为**：通过访问导入类的注解元数据，可以实现基于特定条件的行为。例如，根据导入类上的注解属性，决定是否注册某个 bean，或者为 bean 设置特定的属性值。
+**条件性的行为**：通过访问导入类的注解元数据，可以实现基于特定条件的行为。例如，根据导入类上的注解属性，决定是否注册某个 bean，或者为 bean 设置特定的属性值。
-
+
-**框架和库的开发**：`ImportAware` 在 Spring 框架内部和某些第三方库中被用于执行特定的初始化和配置任务。例如，某些特性的自动配置可能会根据导入它们的配置类上的注解属性进行调整。
+**框架和库的开发**：`ImportAware` 在 Spring 框架内部和某些第三方库中被用于执行特定的初始化和配置任务。例如，某些特性的自动配置可能会根据导入它们的配置类上的注解属性进行调整。
-
+
-**增强诊断和调试信息**：可以基于导入类的元数据为我们提供更多的上下文信息，这在诊断复杂的配置问题时可能会很有用。
+**增强诊断和调试信息**：可以基于导入类的元数据为我们提供更多的上下文信息，这在诊断复杂的配置问题时可能会很有用。
-
+
-### 四、最佳实践
+### 四、最佳实践
-
+
-首先来看看启动类入口，上下文环境使用`AnnotationConfigApplicationContext`（此类是使用Java注解来配置Spring容器的方式），构造参数我们给定了一个`MyConfiguration`组件类。然后从Spring上下文中获取一个`String`类型的bean并打印。
+首先来看看启动类入口，上下文环境使用`AnnotationConfigApplicationContext`（此类是使用Java注解来配置Spring容器的方式），构造参数我们给定了一个`MyConfiguration`组件类。然后从Spring上下文中获取一个`String`类型的bean并打印。
-
+
-```java
+```java
-public class ImportAwareApplication {
+public class ImportAwareApplication {
-
+
-    public static void main(String[] args) {
+    public static void main(String[] args) {
-        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyConfiguration.class);
+        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyConfiguration.class);
-        String customBean  = context.getBean(String.class);
+        String customBean  = context.getBean(String.class);
-        System.out.println(customBean);
+        System.out.println(customBean);
-    }
+    }
-}
+}
-```
+```
-
+
- `MyConfiguration` 是一个 Spring 配置类，然后通过这个类启用了通过 `@EnableXcs` 注解提供`ImportAware`功能。
+ `MyConfiguration` 是一个 Spring 配置类，然后通过这个类启用了通过 `@EnableXcs` 注解提供`ImportAware`功能。
-
+
-```java
+```java
-@Configuration
+@Configuration
-@EnableXcs
+@EnableXcs
-public class MyConfiguration {
+public class MyConfiguration {
-
+
-}
+}
-```
+```
-
+
-`EnableXcs`是一个注解类，`@Import(MyImportAware.class)`会对 Spring 上下文进行某种配置或修改
+`EnableXcs`是一个注解类，`@Import(MyImportAware.class)`会对 Spring 上下文进行某种配置或修改
-
+
-```java
+```java
-@Retention(RetentionPolicy.RUNTIME)
+@Retention(RetentionPolicy.RUNTIME)
-@Target(ElementType.TYPE)
+@Target(ElementType.TYPE)
-@Documented
+@Documented
-@Import(MyImportAware.class)
+@Import(MyImportAware.class)
-public @interface EnableXcs {
+public @interface EnableXcs {
-    
+    
-}
+}
-```
+```
-
+
-由于 `MyImportAware` 实现了 `ImportAware`，它会检查导入它的配置类上是否存在 `@EnableXcs` 注解。如果存在，则继续处理并注册 `customBean` 这个 String 类型的 bean 到 Spring 上下文中。如果不存在 `@EnableXcs` 注解，则抛出异常。
+由于 `MyImportAware` 实现了 `ImportAware`，它会检查导入它的配置类上是否存在 `@EnableXcs` 注解。如果存在，则继续处理并注册 `customBean` 这个 String 类型的 bean 到 Spring 上下文中。如果不存在 `@EnableXcs` 注解，则抛出异常。
-
+
-```java
+```java
-public class MyImportAware implements ImportAware {
+public class MyImportAware implements ImportAware {
-
+
-    private AnnotationAttributes enableXcs;
+    private AnnotationAttributes enableXcs;
-
+
-    @Override
+    @Override
-    public void setImportMetadata(AnnotationMetadata importMetadata) {
+    public void setImportMetadata(AnnotationMetadata importMetadata) {
-        this.enableXcs = AnnotationAttributes.fromMap(
+        this.enableXcs = AnnotationAttributes.fromMap(
-                importMetadata.getAnnotationAttributes(EnableXcs.class.getName(), false));
+                importMetadata.getAnnotationAttributes(EnableXcs.class.getName(), false));
-        if (this.enableXcs == null) {
+        if (this.enableXcs == null) {
-            throw new IllegalArgumentException(
+            throw new IllegalArgumentException(
-                    "@EnableXcs is not present on importing class " + importMetadata.getClassName());
+                    "@EnableXcs is not present on importing class " + importMetadata.getClassName());
-        }
+        }
-    }
+    }
-
+
-    @Bean
+    @Bean
-    public String customBean() {
+    public String customBean() {
-        return "This is a custom bean!";
+        return "This is a custom bean!";
-    }
+    }
-}
+}
-```
+```
-
+
-运行结果发现，当我们在 Spring 上下文中使用 `@EnableXcs` 注解并运行程序时，`MyImportAware` 类会被导入并处理，最后在 Spring 容器中注册一个 String 类型的 bean，其值为 "This is a custom bean!"。
+运行结果发现，当我们在 Spring 上下文中使用 `@EnableXcs` 注解并运行程序时，`MyImportAware` 类会被导入并处理，最后在 Spring 容器中注册一个 String 类型的 bean，其值为 "This is a custom bean!"。
-
+
-```java
+```java
-This is a custom bean!
+This is a custom bean!
-```
+```
-
+
-当我们不通过`@EnableXcs` 注解方式去导入`MyImportAware`类，而是直接在MyConfiguration类中导入`@Import(MyImportAware.class)`来看看另外一种情况。
+当我们不通过`@EnableXcs` 注解方式去导入`MyImportAware`类，而是直接在MyConfiguration类中导入`@Import(MyImportAware.class)`来看看另外一种情况。
-
+
-```java
+```java
-@Configuration
+@Configuration
-@Import(MyImportAware.class)
+@Import(MyImportAware.class)
-public class MyConfiguration {
+public class MyConfiguration {
-
+
-}
+}
-```
+```
-
+
-运行结果发现，当我们直接使用`@Import(MyImportAware.class)`导入`MyImportAware`类而不使用`@EnableXcs`注解时，由于`MyConfiguration`上没有`@EnableXcs`注解，所以`enableXcs`的值为null，由于此时`enableXcs`是null，`MyImportAware`抛出了一个`IllegalArgumentException`异常。
+运行结果发现，当我们直接使用`@Import(MyImportAware.class)`导入`MyImportAware`类而不使用`@EnableXcs`注解时，由于`MyConfiguration`上没有`@EnableXcs`注解，所以`enableXcs`的值为null，由于此时`enableXcs`是null，`MyImportAware`抛出了一个`IllegalArgumentException`异常。
-
+
-```java
+```java
-Caused by: java.lang.IllegalArgumentException: @EnableXcs is not present on importing class com.xcs.spring.config.MyConfiguration
+Caused by: java.lang.IllegalArgumentException: @EnableXcs is not present on importing class com.xcs.spring.config.MyConfiguration
-	at com.xcs.spring.config.MyImportAware.setImportMetadata(MyImportAware.java:19)
+	at com.xcs.spring.config.MyImportAware.setImportMetadata(MyImportAware.java:19)
-	at org.springframework.context.annotation.ConfigurationClassPostProcessor$ImportAwareBeanPostProcessor.postProcessBeforeInitialization(ConfigurationClassPostProcessor.java:484)
+	at org.springframework.context.annotation.ConfigurationClassPostProcessor$ImportAwareBeanPostProcessor.postProcessBeforeInitialization(ConfigurationClassPostProcessor.java:484)
-	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.applyBeanPostProcessorsBeforeInitialization(AbstractAutowireCapableBeanFactory.java:440)
+	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.applyBeanPostProcessorsBeforeInitialization(AbstractAutowireCapableBeanFactory.java:440)
-	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.initializeBean(AbstractAutowireCapableBeanFactory.java:1796)
+	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.initializeBean(AbstractAutowireCapableBeanFactory.java:1796)
-	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:620)
+	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:620)
-	... 10 more
+	... 10 more
-```
+```
-
+
-
+
-
+
-### 五、时序图
+### 五、时序图
-
+
-~~~mermaid
+~~~mermaid
-sequenceDiagram
+sequenceDiagram
-    Title: ImportAware时序图
+    Title: ImportAware时序图
-    participant ImportAwareApplication
+    participant ImportAwareApplication
-    participant AnnotationConfigApplicationContext
+    participant AnnotationConfigApplicationContext
-    participant AbstractApplicationContext
+    participant AbstractApplicationContext
-    participant DefaultListableBeanFactory
+    participant DefaultListableBeanFactory
-    participant AbstractBeanFactory
+    participant AbstractBeanFactory
-    participant DefaultSingletonBeanRegistry
+    participant DefaultSingletonBeanRegistry
-    participant AbstractAutowireCapableBeanFactory
+    participant AbstractAutowireCapableBeanFactory
-    participant ImportAwareBeanPostProcessor
+    participant ImportAwareBeanPostProcessor
-    participant MyImportAware
+    participant MyImportAware
-    
+    
-    ImportAwareApplication->>AnnotationConfigApplicationContext:AnnotationConfigApplicationContext(componentClasses)
+    ImportAwareApplication->>AnnotationConfigApplicationContext:AnnotationConfigApplicationContext(componentClasses)
-    AnnotationConfigApplicationContext->>AbstractApplicationContext:refresh()
+    AnnotationConfigApplicationContext->>AbstractApplicationContext:refresh()
-    AbstractApplicationContext->>AbstractApplicationContext:finishBeanFactoryInitialization(beanFactory)
+    AbstractApplicationContext->>AbstractApplicationContext:finishBeanFactoryInitialization(beanFactory)
-    AbstractApplicationContext->>DefaultListableBeanFactory:preInstantiateSingletons()
+    AbstractApplicationContext->>DefaultListableBeanFactory:preInstantiateSingletons()
-    DefaultListableBeanFactory->>AbstractBeanFactory:getBean(name)
+    DefaultListableBeanFactory->>AbstractBeanFactory:getBean(name)
-    AbstractBeanFactory->>AbstractBeanFactory:doGetBean(name,requiredType,args,typeCheckOnly)
+    AbstractBeanFactory->>AbstractBeanFactory:doGetBean(name,requiredType,args,typeCheckOnly)
-    AbstractBeanFactory->>DefaultSingletonBeanRegistry:getSingleton(beanName,singletonFactory)
+    AbstractBeanFactory->>DefaultSingletonBeanRegistry:getSingleton(beanName,singletonFactory)
-    DefaultSingletonBeanRegistry-->>AbstractBeanFactory:getObject()
+    DefaultSingletonBeanRegistry-->>AbstractBeanFactory:getObject()
-    AbstractBeanFactory->>AbstractAutowireCapableBeanFactory:createBean(beanName,mbd,args)
+    AbstractBeanFactory->>AbstractAutowireCapableBeanFactory:createBean(beanName,mbd,args)
-    AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:doCreateBean(beanName,mbd,args)
+    AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:doCreateBean(beanName,mbd,args)
-    AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:initializeBean(beanName,bean,mbd)
+    AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:initializeBean(beanName,bean,mbd)
-    AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:applyBeanPostProcessorsBeforeInitialization(existingBean,beanName)
+    AbstractAutowireCapableBeanFactory->>AbstractAutowireCapableBeanFactory:applyBeanPostProcessorsBeforeInitialization(existingBean,beanName)
-    AbstractAutowireCapableBeanFactory->>ImportAwareBeanPostProcessor: postProcessBeforeInitialization(bean,beanName)
+    AbstractAutowireCapableBeanFactory->>ImportAwareBeanPostProcessor: postProcessBeforeInitialization(bean,beanName)
-    ImportAwareBeanPostProcessor->>MyImportAware:setImportMetadata(importMetadata)设置importMetadata
+    ImportAwareBeanPostProcessor->>MyImportAware:setImportMetadata(importMetadata)设置importMetadata
-    ImportAwareBeanPostProcessor-->>AbstractAutowireCapableBeanFactory: 返回Bean对象
+    ImportAwareBeanPostProcessor-->>AbstractAutowireCapableBeanFactory: 返回Bean对象
-	AbstractAutowireCapableBeanFactory-->>AbstractBeanFactory:返回Bean对象
+	AbstractAutowireCapableBeanFactory-->>AbstractBeanFactory:返回Bean对象
-	AbstractBeanFactory-->>DefaultListableBeanFactory:返回Bean对象
+	AbstractBeanFactory-->>DefaultListableBeanFactory:返回Bean对象
-	AnnotationConfigApplicationContext->>ImportAwareApplication: 初始化完成
+	AnnotationConfigApplicationContext->>ImportAwareApplication: 初始化完成
-~~~
+~~~
-
+
-### 六、源码分析
+### 六、源码分析
-
+
-首先来看看启动类入口，上下文环境使用`AnnotationConfigApplicationContext`（此类是使用Java注解来配置Spring容器的方式），构造参数我们给定了一个`MyConfiguration`组件类。然后从Spring上下文中获取一个`String`类型的bean并打印。
+首先来看看启动类入口，上下文环境使用`AnnotationConfigApplicationContext`（此类是使用Java注解来配置Spring容器的方式），构造参数我们给定了一个`MyConfiguration`组件类。然后从Spring上下文中获取一个`String`类型的bean并打印。
-
+
-```java
+```java
-public class ImportAwareApplication {
+public class ImportAwareApplication {
-
+
-    public static void main(String[] args) {
+    public static void main(String[] args) {
-        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyConfiguration.class);
+        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyConfiguration.class);
-        String customBean  = context.getBean(String.class);
+        String customBean  = context.getBean(String.class);
-        System.out.println(customBean);
+        System.out.println(customBean);
-    }
+    }
-}
+}
-```
+```
-
+
-在`org.springframework.context.annotation.AnnotationConfigApplicationContext#AnnotationConfigApplicationContext`构造函数中，执行了三个步骤，我们重点关注`refresh()`方法。
+在`org.springframework.context.annotation.AnnotationConfigApplicationContext#AnnotationConfigApplicationContext`构造函数中，执行了三个步骤，我们重点关注`refresh()`方法。
-
+
-```java
+```java
-public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
+public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
-    this();
+    this();
-    register(componentClasses);
+    register(componentClasses);
-    refresh();
+    refresh();
-}
+}
-```
+```
-
+
-在`org.springframework.context.support.AbstractApplicationContext#refresh`方法中，我们重点关注一下`finishBeanFactoryInitialization(beanFactory)`这方法会对实例化所有剩余非懒加载的单列Bean对象，其他方法不是本次源码阅读的重点暂时忽略。
+在`org.springframework.context.support.AbstractApplicationContext#refresh`方法中，我们重点关注一下`finishBeanFactoryInitialization(beanFactory)`这方法会对实例化所有剩余非懒加载的单列Bean对象，其他方法不是本次源码阅读的重点暂时忽略。
-
+
-```java
+```java
-@Override
+@Override
-public void refresh() throws BeansException, IllegalStateException {
+public void refresh() throws BeansException, IllegalStateException {
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-    // Instantiate all remaining (non-lazy-init) singletons.
+    // Instantiate all remaining (non-lazy-init) singletons.
-    finishBeanFactoryInitialization(beanFactory);
+    finishBeanFactoryInitialization(beanFactory);
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-}
+}
-```
+```
-
+
-在`org.springframework.context.support.AbstractApplicationContext#finishBeanFactoryInitialization`方法中，会继续调用`DefaultListableBeanFactory`类中的`preInstantiateSingletons`方法来完成所有剩余非懒加载的单列Bean对象。
+在`org.springframework.context.support.AbstractApplicationContext#finishBeanFactoryInitialization`方法中，会继续调用`DefaultListableBeanFactory`类中的`preInstantiateSingletons`方法来完成所有剩余非懒加载的单列Bean对象。
-
+
-```java
+```java
-/**
+/**
- * 完成此工厂的bean初始化，实例化所有剩余的非延迟初始化单例bean。
+ * 完成此工厂的bean初始化，实例化所有剩余的非延迟初始化单例bean。
- * 
+ * 
- * @param beanFactory 要初始化的bean工厂
+ * @param beanFactory 要初始化的bean工厂
- */
+ */
-protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
+protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-    // 完成所有剩余非懒加载的单列Bean对象。
+    // 完成所有剩余非懒加载的单列Bean对象。
-    beanFactory.preInstantiateSingletons();
+    beanFactory.preInstantiateSingletons();
-}
+}
-```
+```
-
+
-在`org.springframework.beans.factory.support.DefaultListableBeanFactory#preInstantiateSingletons`方法中，主要的核心目的是预先实例化所有非懒加载的单例bean。在Spring的上下文初始化完成后，该方法会被触发，以确保所有单例bean都被正确地创建并初始化。其中`getBean(beanName)`是此方法的核心操作。对于容器中定义的每一个单例bean，它都会调用`getBean`方法，这将触发bean的实例化、初始化及其依赖的注入。如果bean之前没有被创建过，那么这个调用会导致其被实例化和初始化。
+在`org.springframework.beans.factory.support.DefaultListableBeanFactory#preInstantiateSingletons`方法中，主要的核心目的是预先实例化所有非懒加载的单例bean。在Spring的上下文初始化完成后，该方法会被触发，以确保所有单例bean都被正确地创建并初始化。其中`getBean(beanName)`是此方法的核心操作。对于容器中定义的每一个单例bean，它都会调用`getBean`方法，这将触发bean的实例化、初始化及其依赖的注入。如果bean之前没有被创建过，那么这个调用会导致其被实例化和初始化。
-
+
-```java
+```java
-public void preInstantiateSingletons() throws BeansException {
+public void preInstantiateSingletons() throws BeansException {
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-    // 循环遍历所有bean的名称
+    // 循环遍历所有bean的名称
-    for (String beanName : beanNames) {
+    for (String beanName : beanNames) {
-        getBean(beanName);
+        getBean(beanName);
-    }
+    }
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-}
+}
-```
+```
-
+
-在`org.springframework.beans.factory.support.AbstractBeanFactory#getBean()`方法中，又调用了`doGetBean`方法来实际执行创建Bean的过程，传递给它bean的名称和一些其他默认的参数值。此处，`doGetBean`负责大部分工作，如查找bean定义、创建bean（如果尚未创建）、处理依赖关系等。
+在`org.springframework.beans.factory.support.AbstractBeanFactory#getBean()`方法中，又调用了`doGetBean`方法来实际执行创建Bean的过程，传递给它bean的名称和一些其他默认的参数值。此处，`doGetBean`负责大部分工作，如查找bean定义、创建bean（如果尚未创建）、处理依赖关系等。
-
+
-```java
+```java
-@Override
+@Override
-public Object getBean(String name) throws BeansException {
+public Object getBean(String name) throws BeansException {
-    return doGetBean(name, null, null, false);
+    return doGetBean(name, null, null, false);
-}
+}
-```
+```
-
+
-在`org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean`方法中，首先检查所请求的bean是否是一个单例并且已经创建。如果尚未创建，它将创建一个新的实例。在这个过程中，它处理可能的异常情况，如循环引用，并确保返回的bean是正确的类型。这是Spring容器bean生命周期管理的核心部分。
+在`org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean`方法中，首先检查所请求的bean是否是一个单例并且已经创建。如果尚未创建，它将创建一个新的实例。在这个过程中，它处理可能的异常情况，如循环引用，并确保返回的bean是正确的类型。这是Spring容器bean生命周期管理的核心部分。
-
+
-```java
+```java
-protected <T> T doGetBean(
+protected <T> T doGetBean(
-        String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
+        String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
-        throws BeansException {
+        throws BeansException {
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-
+
-    // 开始创建bean实例
+    // 开始创建bean实例
-    if (mbd.isSingleton()) {
+    if (mbd.isSingleton()) {
-        // 如果bean是单例的，我们会尝试从单例缓存中获取它
+        // 如果bean是单例的，我们会尝试从单例缓存中获取它
-        // 如果不存在，则使用lambda创建一个新的实例
+        // 如果不存在，则使用lambda创建一个新的实例
-        sharedInstance = getSingleton(beanName, () -> {
+        sharedInstance = getSingleton(beanName, () -> {
-            try {
+            try {
-                // 尝试创建bean实例
+                // 尝试创建bean实例
-                return createBean(beanName, mbd, args);
+                return createBean(beanName, mbd, args);
-            }
+            }
-            catch (BeansException ex) {
+            catch (BeansException ex) {
-                // ... [代码部分省略以简化]
+                // ... [代码部分省略以简化]
-            }
+            }
-        });
+        });
-        // 对于某些bean（例如FactoryBeans），可能需要进一步处理以获取真正的bean实例
+        // 对于某些bean（例如FactoryBeans），可能需要进一步处理以获取真正的bean实例
-        beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
+        beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
-    }
+    }
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-
+
-    // 确保返回的bean实例与请求的类型匹配
+    // 确保返回的bean实例与请求的类型匹配
-    return adaptBeanInstance(name, beanInstance, requiredType);
+    return adaptBeanInstance(name, beanInstance, requiredType);
-}
+}
-```
+```
-
+
-在`org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton()`方法中，主要负责从单例缓存中获取一个已存在的bean实例，或者使用提供的`ObjectFactory`创建一个新的实例。这是确保bean在Spring容器中作为单例存在的关键部分。
+在`org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton()`方法中，主要负责从单例缓存中获取一个已存在的bean实例，或者使用提供的`ObjectFactory`创建一个新的实例。这是确保bean在Spring容器中作为单例存在的关键部分。
-
+
-```java
+```java
-public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
+public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
-    // 断言bean名称不能为空
+    // 断言bean名称不能为空
-    Assert.notNull(beanName, "Bean name must not be null");
+    Assert.notNull(beanName, "Bean name must not be null");
-
+
-    // 同步访问单例对象缓存，确保线程安全
+    // 同步访问单例对象缓存，确保线程安全
-    synchronized (this.singletonObjects) {
+    synchronized (this.singletonObjects) {
-        // 从缓存中获取单例对象
+        // 从缓存中获取单例对象
-        Object singletonObject = this.singletonObjects.get(beanName);
+        Object singletonObject = this.singletonObjects.get(beanName);
-
+
-        // 如果缓存中没有找到
+        // 如果缓存中没有找到
-        if (singletonObject == null) {
+        if (singletonObject == null) {
-            // ... [代码部分省略以简化]
+            // ... [代码部分省略以简化]
-
+
-            try {
+            try {
-                // 使用工厂创建新的单例实例
+                // 使用工厂创建新的单例实例
-                singletonObject = singletonFactory.getObject();
+                singletonObject = singletonFactory.getObject();
-                newSingleton = true;
+                newSingleton = true;
-            }
+            }
-            catch (IllegalStateException ex) {
+            catch (IllegalStateException ex) {
-                // ... [代码部分省略以简化]
+                // ... [代码部分省略以简化]
-            }
+            }
-            catch (BeanCreationException ex) {
+            catch (BeanCreationException ex) {
-                // ... [代码部分省略以简化]
+                // ... [代码部分省略以简化]
-            }
+            }
-            finally {
+            finally {
-                // ... [代码部分省略以简化]
+                // ... [代码部分省略以简化]
-            }
+            }
-
+
-			// ... [代码部分省略以简化]
+			// ... [代码部分省略以简化]
-        }
+        }
-
+
-        // 返回单例对象
+        // 返回单例对象
-        return singletonObject;
+        return singletonObject;
-    }
+    }
-}
+}
-```
+```
-
+
-在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBean()`方法中，主要的逻辑是调用 `doCreateBean`，这是真正进行 bean 实例化、属性填充和初始化的地方。这个方法会返回新创建的 bean 实例。
+在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBean()`方法中，主要的逻辑是调用 `doCreateBean`，这是真正进行 bean 实例化、属性填充和初始化的地方。这个方法会返回新创建的 bean 实例。
-
+
-```java
+```java
-@Override
+@Override
-protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
+protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
-    throws BeanCreationException {
+    throws BeanCreationException {
-    
+    
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-    
+    
-    try {
+    try {
-        // 正常的bean实例化、属性注入和初始化。
+        // 正常的bean实例化、属性注入和初始化。
-        // 这里是真正进行bean创建的部分。
+        // 这里是真正进行bean创建的部分。
-        Object beanInstance = doCreateBean(beanName, mbdToUse, args);
+        Object beanInstance = doCreateBean(beanName, mbdToUse, args);
-        // 记录bean成功创建的日志
+        // 记录bean成功创建的日志
-        if (logger.isTraceEnabled()) {
+        if (logger.isTraceEnabled()) {
-            logger.trace("Finished creating instance of bean '" + beanName + "'");
+            logger.trace("Finished creating instance of bean '" + beanName + "'");
-        }
+        }
-        return beanInstance;
+        return beanInstance;
-    }
+    }
-    catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
+    catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
-        // ... [代码部分省略以简化]
+        // ... [代码部分省略以简化]
-    }
+    }
-    catch (Throwable ex) {
+    catch (Throwable ex) {
-        // ... [代码部分省略以简化]
+        // ... [代码部分省略以简化]
-    }
+    }
-}
+}
-```
+```
-
+
-在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean`方法中，主要负责bean初始化。
+在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean`方法中，主要负责bean初始化。
-
+
-```java
+```java
-protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
+protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
-        throws BeanCreationException {
+        throws BeanCreationException {
-
+
-    // 声明一个对象，后续可能用于存放初始化后的bean或它的代理对象
+    // 声明一个对象，后续可能用于存放初始化后的bean或它的代理对象
-    Object exposedObject = bean;
+    Object exposedObject = bean;
-
+
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-    
+    
-    try {
+    try {
-        // ... [代码部分省略以简化]
+        // ... [代码部分省略以简化]
-        
+        
-        // bean初始化
+        // bean初始化
-        exposedObject = initializeBean(beanName, exposedObject, mbd);
+        exposedObject = initializeBean(beanName, exposedObject, mbd);
-    } 
+    } 
-    catch (Throwable ex) {
+    catch (Throwable ex) {
-        // ... [代码部分省略以简化]
+        // ... [代码部分省略以简化]
-    }
+    }
-
+
-    // 返回创建和初始化后的bean
+    // 返回创建和初始化后的bean
-    return exposedObject;
+    return exposedObject;
-}
+}
-```
+```
-
+
-在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#initializeBean()`方法中，核心逻辑是对`BeanPostProcessors`接口中的`postProcessBeforeInitialization`进行回调。
+在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#initializeBean()`方法中，核心逻辑是对`BeanPostProcessors`接口中的`postProcessBeforeInitialization`进行回调。
-
+
-```java
+```java
-protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
+protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
-
+
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-    
+    
-    Object wrappedBean = bean;
+    Object wrappedBean = bean;
-    if (mbd == null || !mbd.isSynthetic()) {
+    if (mbd == null || !mbd.isSynthetic()) {
-        wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
+        wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
-    }
+    }
-    
+    
-    // ... [代码部分省略以简化]
+    // ... [代码部分省略以简化]
-
+
-    return wrappedBean;
+    return wrappedBean;
-}
+}
-```
+```
-
+
-在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsBeforeInitialization`方法中，遍历每一个 `BeanPostProcessor` 的 `postProcessBeforeInitialization` 方法都有机会对bean进行修改或增强。
+在`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsBeforeInitialization`方法中，遍历每一个 `BeanPostProcessor` 的 `postProcessBeforeInitialization` 方法都有机会对bean进行修改或增强。
-
+
-```java
+```java
-@Override
+@Override
-public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
+public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
-    throws BeansException {
+    throws BeansException {
-
+
-    Object result = existingBean;
+    Object result = existingBean;
-    for (BeanPostProcessor processor : getBeanPostProcessors()) {
+    for (BeanPostProcessor processor : getBeanPostProcessors()) {
-        Object current = processor.postProcessBeforeInitialization(result, beanName);
+        Object current = processor.postProcessBeforeInitialization(result, beanName);
-        if (current == null) {
+        if (current == null) {
-            return result;
+            return result;
-        }
+        }
-        result = current;
+        result = current;
-    }
+    }
-    return result;
+    return result;
-}
+}
-```
+```
-
+
-在`org.springframework.context.annotation.ConfigurationClassPostProcessor.ImportAwareBeanPostProcessor#postProcessBeforeInitialization`方法中，主要作用是为实现了 `ImportAware` 接口的 beans 设置导入它们的类的 `AnnotationMetadata`。这样，任何实现了 `ImportAware` 接口的 bean 都可以知道它是由哪个类导入的，以及这个导入类上的所有注解信息。
+在`org.springframework.context.annotation.ConfigurationClassPostProcessor.ImportAwareBeanPostProcessor#postProcessBeforeInitialization`方法中，主要作用是为实现了 `ImportAware` 接口的 beans 设置导入它们的类的 `AnnotationMetadata`。这样，任何实现了 `ImportAware` 接口的 bean 都可以知道它是由哪个类导入的，以及这个导入类上的所有注解信息。
-
+
-```java
+```java
-@Override
+@Override
-public Object postProcessBeforeInitialization(Object bean, String beanName) {
+public Object postProcessBeforeInitialization(Object bean, String beanName) {
-    if (bean instanceof ImportAware) {
+    if (bean instanceof ImportAware) {
-        ImportRegistry ir = this.beanFactory.getBean(IMPORT_REGISTRY_BEAN_NAME, ImportRegistry.class);
+        ImportRegistry ir = this.beanFactory.getBean(IMPORT_REGISTRY_BEAN_NAME, ImportRegistry.class);
-        AnnotationMetadata importingClass = ir.getImportingClassFor(ClassUtils.getUserClass(bean).getName());
+        AnnotationMetadata importingClass = ir.getImportingClassFor(ClassUtils.getUserClass(bean).getName());
-        if (importingClass != null) {
+        if (importingClass != null) {
-            ((ImportAware) bean).setImportMetadata(importingClass);
+            ((ImportAware) bean).setImportMetadata(importingClass);
-        }
+        }
-    }
+    }
-    return bean;
+    return bean;
-}
+}
-```
+```
-
+
-最后执行到我们自定义的逻辑中，由于 `MyImportAware` 实现了 `ImportAware`，它会检查导入它的配置类上是否存在 `@EnableXcs` 注解。如果存在，则继续处理并注册 `customBean` 这个 String 类型的 bean 到 Spring 上下文中。如果不存在 `@EnableXcs` 注解，则抛出异常。
+最后执行到我们自定义的逻辑中，由于 `MyImportAware` 实现了 `ImportAware`，它会检查导入它的配置类上是否存在 `@EnableXcs` 注解。如果存在，则继续处理并注册 `customBean` 这个 String 类型的 bean 到 Spring 上下文中。如果不存在 `@EnableXcs` 注解，则抛出异常。
-
+
-```java
+```java
-public class MyImportAware implements ImportAware {
+public class MyImportAware implements ImportAware {
-
+
-    private AnnotationAttributes enableXcs;
+    private AnnotationAttributes enableXcs;
-
+
-    @Override
+    @Override
-    public void setImportMetadata(AnnotationMetadata importMetadata) {
+    public void setImportMetadata(AnnotationMetadata importMetadata) {
-        this.enableXcs = AnnotationAttributes.fromMap(
+        this.enableXcs = AnnotationAttributes.fromMap(
-                importMetadata.getAnnotationAttributes(EnableXcs.class.getName(), false));
+                importMetadata.getAnnotationAttributes(EnableXcs.class.getName(), false));
-        if (this.enableXcs == null) {
+        if (this.enableXcs == null) {
-            throw new IllegalArgumentException(
+            throw new IllegalArgumentException(
-                    "@EnableXcs is not present on importing class " + importMetadata.getClassName());
+                    "@EnableXcs is not present on importing class " + importMetadata.getClassName());
-        }
+        }
-    }
+    }
-
+
-    @Bean
+    @Bean
-    public String customBean() {
+    public String customBean() {
-        return "This is a custom bean!";
+        return "This is a custom bean!";
-    }
+    }
-}
+}
-```
+```
-
+
-### 七、注意事项
+### 七、注意事项
-
+
-**明确需求**：在决定实现 `ImportAware` 之前，请确保您确实需要知道是哪个类导入了您的组件，并且需要访问其注解元数据。避免不必要的复杂性。
+**明确需求**：在决定实现 `ImportAware` 之前，请确保您确实需要知道是哪个类导入了您的组件，并且需要访问其注解元数据。避免不必要的复杂性。
-
+
-**正确的上下文**：`ImportAware` 只对通过 `@Import` 导入的类有意义。对于其他方式注册的 beans（例如，通过 component scanning 或 XML 配置），`setImportMetadata` 方法可能不会被调用。
+**正确的上下文**：`ImportAware` 只对通过 `@Import` 导入的类有意义。对于其他方式注册的 beans（例如，通过 component scanning 或 XML 配置），`setImportMetadata` 方法可能不会被调用。
-
+
-**小心处理元数据**：当访问 `AnnotationMetadata` 时，确保处理不存在的注解或属性的情况，以避免空指针异常。
+**小心处理元数据**：当访问 `AnnotationMetadata` 时，确保处理不存在的注解或属性的情况，以避免空指针异常。
-
+
-**注意与其他 `BeanPostProcessor` 的交互**：`ImportAware` 的功能部分是通过 `BeanPostProcessor` 机制实现的。如果您在应用中使用其他 `BeanPostProcessor`，请确保您了解它们之间的交互和执行顺序。
+**注意与其他 `BeanPostProcessor` 的交互**：`ImportAware` 的功能部分是通过 `BeanPostProcessor` 机制实现的。如果您在应用中使用其他 `BeanPostProcessor`，请确保您了解它们之间的交互和执行顺序。
-
+
-**不要过度使用**：虽然 `ImportAware` 可以带来一些灵活性，但不应在不需要的地方使用它。过度使用可能会导致配置变得复杂且难以追踪。
+**不要过度使用**：虽然 `ImportAware` 可以带来一些灵活性，但不应在不需要的地方使用它。过度使用可能会导致配置变得复杂且难以追踪。
-
+
-### 八、总结
+### 八、总结
-
+
-#### 8.1、最佳实践总结
+#### 8.1、最佳实践总结
-
+
-**初始化与运行**：使用 `AnnotationConfigApplicationContext` 初始化了一个 Spring 上下文，加载了 `MyConfiguration` 配置类，并从上下文中获取了一个类型为 `String` 的 bean。
+**初始化与运行**：使用 `AnnotationConfigApplicationContext` 初始化了一个 Spring 上下文，加载了 `MyConfiguration` 配置类，并从上下文中获取了一个类型为 `String` 的 bean。
-
+
-**`@EnableXcs` 注解的作用**：`@EnableXcs` 是一个自定义注解，其主要作用是通过 `@Import` 注解导入 `MyImportAware` 类，从而启动 `ImportAware` 功能。
+**`@EnableXcs` 注解的作用**：`@EnableXcs` 是一个自定义注解，其主要作用是通过 `@Import` 注解导入 `MyImportAware` 类，从而启动 `ImportAware` 功能。
-
+
-**`MyImportAware` 类与 `ImportAware`**：`MyImportAware` 实现了 `ImportAware` 接口，允许它获取关于导入它的类的注解信息。在 `setImportMetadata` 方法中，`MyImportAware` 会检查导入它的类是否有 `@EnableXcs` 注解。如果存在 `@EnableXcs` 注解，它会继续并注册一个 `String` 类型的 bean，值为 "This is a custom bean!"。如果不存在，它会抛出异常，提示 `@EnableXcs` 注解不存在于导入它的类上。
+**`MyImportAware` 类与 `ImportAware`**：`MyImportAware` 实现了 `ImportAware` 接口，允许它获取关于导入它的类的注解信息。在 `setImportMetadata` 方法中，`MyImportAware` 会检查导入它的类是否有 `@EnableXcs` 注解。如果存在 `@EnableXcs` 注解，它会继续并注册一个 `String` 类型的 bean，值为 "This is a custom bean!"。如果不存在，它会抛出异常，提示 `@EnableXcs` 注解不存在于导入它的类上。
-
+
-**正常使用**：当 `MyConfiguration` 使用 `@EnableXcs` 注解时，程序可以正常运行，从上下文中获取到的 String 类型的 bean 值为 "This is a custom bean!"。
+**正常使用**：当 `MyConfiguration` 使用 `@EnableXcs` 注解时，程序可以正常运行，从上下文中获取到的 String 类型的 bean 值为 "This is a custom bean!"。
-
+
-**异常情况**：但如果 `MyConfiguration` 直接使用 `@Import(MyImportAware.class)` 导入 `MyImportAware` 类，而不使用 `@EnableXcs` 注解，会导致 `MyImportAware` 在查找 `@EnableXcs` 注解时发现它不存在，从而抛出异常。
+**异常情况**：但如果 `MyConfiguration` 直接使用 `@Import(MyImportAware.class)` 导入 `MyImportAware` 类，而不使用 `@EnableXcs` 注解，会导致 `MyImportAware` 在查找 `@EnableXcs` 注解时发现它不存在，从而抛出异常。
-
+
-#### 8.2、源码分析总结
+#### 8.2、源码分析总结
-
+
-**应用程序启动**： 使用 `AnnotationConfigApplicationContext` 初始化 Spring 上下文，加载 `MyConfiguration` 配置类。程序试图从 Spring 上下文中获取一个类型为 `String` 的 bean。
+**应用程序启动**： 使用 `AnnotationConfigApplicationContext` 初始化 Spring 上下文，加载 `MyConfiguration` 配置类。程序试图从 Spring 上下文中获取一个类型为 `String` 的 bean。
-
+
-**上下文刷新**： 在构造 `AnnotationConfigApplicationContext` 时，会调用 `refresh()` 方法，这是 Spring 上下文的初始化和刷新过程的入口点。
+**上下文刷新**： 在构造 `AnnotationConfigApplicationContext` 时，会调用 `refresh()` 方法，这是 Spring 上下文的初始化和刷新过程的入口点。
-
+
-**实例化Beans**： 执行 `finishBeanFactoryInitialization`，该方法负责预实例化上下文中的所有非懒加载单例bean。对于每个bean，它都会调用 `getBean` 方法。
+**实例化Beans**： 执行 `finishBeanFactoryInitialization`，该方法负责预实例化上下文中的所有非懒加载单例bean。对于每个bean，它都会调用 `getBean` 方法。
-
+
-**处理 `ImportAware` Beans**： 如果bean实现了 `ImportAware` 接口，`postProcessBeforeInitialization` 方法会为该 bean 设置导入它的类的注解元数据。在我们的例子中，`MyImportAware` 就是这样一个bean。
+**处理 `ImportAware` Beans**： 如果bean实现了 `ImportAware` 接口，`postProcessBeforeInitialization` 方法会为该 bean 设置导入它的类的注解元数据。在我们的例子中，`MyImportAware` 就是这样一个bean。
-
+
-**检查 `@EnableXcs`**： 在 `MyImportAware` 的 `setImportMetadata` 方法中，它会检查导入它的类是否有 `@EnableXcs` 注解。如果存在该注解，则继续处理；如果不存在，则抛出异常。
+**检查 `@EnableXcs`**： 在 `MyImportAware` 的 `setImportMetadata` 方法中，它会检查导入它的类是否有 `@EnableXcs` 注解。如果存在该注解，则继续处理；如果不存在，则抛出异常。
-
+
-**Bean创建**： 如果导入类上存在 `@EnableXcs` 注解，`MyImportAware` 继续并定义了一个 `String` 类型的 bean。这就是我们从上下文中检索并在控制台上打印的bean。
+**Bean创建**： 如果导入类上存在 `@EnableXcs` 注解，`MyImportAware` 继续并定义了一个 `String` 类型的 bean。这就是我们从上下文中检索并在控制台上打印的bean。
-
+
 **异常处理**： 如果直接使用 `@Import` 导入 `MyImportAware` 而不使用 `@EnableXcs` 注解，会发生异常，因为 `MyImportAware` 期望导入它的类上有 `@EnableXcs` 注解。

spring-aware/spring-aware-importAware/pom.xml

@@ -3,7 +3,7 @@
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <parent>
-        <artifactId>spring-reading</artifactId>
+        <artifactId>spring-aware</artifactId>
         <groupId>com.xcs.spring</groupId>
         <version>0.0.1-SNAPSHOT</version>
     </parent>

spring-aware/spring-aware-importAware/src/main/java/com/xcs/spring/ImportAwareApplication.java

@@ -1,13 +1,13 @@
-package com.xcs.spring;
+package com.xcs.spring;
-
+
-import com.xcs.spring.config.MyConfiguration;
+import com.xcs.spring.config.MyConfiguration;
-import org.springframework.context.annotation.AnnotationConfigApplicationContext;
+import org.springframework.context.annotation.AnnotationConfigApplicationContext;
-
+
-public class ImportAwareApplication {
+public class ImportAwareApplication {
-
+
-    public static void main(String[] args) {
+    public static void main(String[] args) {
-        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyConfiguration.class);
+        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyConfiguration.class);
-        String customBean  = context.getBean(String.class);
+        String customBean  = context.getBean(String.class);
-        System.out.println(customBean);
+        System.out.println(customBean);
-    }
+    }
-}
+}

spring-aware/spring-aware-importAware/src/main/java/com/xcs/spring/annotation/EnableXcs.java

@@ -1,13 +1,13 @@
-package com.xcs.spring.annotation;
+package com.xcs.spring.annotation;
-
+
-import com.xcs.spring.config.MyImportAware;
+import com.xcs.spring.config.MyImportAware;
-import org.springframework.context.annotation.Import;
+import org.springframework.context.annotation.Import;
-
+
-import java.lang.annotation.*;
+import java.lang.annotation.*;
-
+
-@Retention(RetentionPolicy.RUNTIME)
+@Retention(RetentionPolicy.RUNTIME)
-@Target(ElementType.TYPE)
+@Target(ElementType.TYPE)
-@Documented
+@Documented
-@Import(MyImportAware.class)
+@Import(MyImportAware.class)
-public @interface EnableXcs {
+public @interface EnableXcs {
-}
+}

spring-aware/spring-aware-importAware/src/main/java/com/xcs/spring/config/MyConfiguration.java

@@ -1,10 +1,10 @@
-package com.xcs.spring.config;
+package com.xcs.spring.config;
-
+
-import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Configuration;
-import org.springframework.context.annotation.Import;
+import org.springframework.context.annotation.Import;
-
+
-@Configuration
+@Configuration
-@Import(MyImportAware.class)
+@Import(MyImportAware.class)
-public class MyConfiguration {
+public class MyConfiguration {
-
+
-}
+}

spring-aware/spring-aware-importAware/src/main/java/com/xcs/spring/config/MyImportAware.java

@@ -1,27 +1,27 @@
-package com.xcs.spring.config;
+package com.xcs.spring.config;
-
+
-import com.xcs.spring.annotation.EnableXcs;
+import com.xcs.spring.annotation.EnableXcs;
-import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.ImportAware;
+import org.springframework.context.annotation.ImportAware;
-import org.springframework.core.annotation.AnnotationAttributes;
+import org.springframework.core.annotation.AnnotationAttributes;
-import org.springframework.core.type.AnnotationMetadata;
+import org.springframework.core.type.AnnotationMetadata;
-
+
-public class MyImportAware implements ImportAware {
+public class MyImportAware implements ImportAware {
-
+
-    private AnnotationAttributes enableXcs;
+    private AnnotationAttributes enableXcs;
-
+
-    @Override
+    @Override
-    public void setImportMetadata(AnnotationMetadata importMetadata) {
+    public void setImportMetadata(AnnotationMetadata importMetadata) {
-        this.enableXcs = AnnotationAttributes.fromMap(
+        this.enableXcs = AnnotationAttributes.fromMap(
-                importMetadata.getAnnotationAttributes(EnableXcs.class.getName(), false));
+                importMetadata.getAnnotationAttributes(EnableXcs.class.getName(), false));
-        if (this.enableXcs == null) {
+        if (this.enableXcs == null) {
-            throw new IllegalArgumentException(
+            throw new IllegalArgumentException(
-                    "@EnableXcs is not present on importing class " + importMetadata.getClassName());
+                    "@EnableXcs is not present on importing class " + importMetadata.getClassName());
-        }
+        }
-    }
+    }
-
+
-    @Bean
+    @Bean
-    public String customBean() {
+    public String customBean() {
-        return "This is a custom bean!";
+        return "This is a custom bean!";
-    }
+    }
-}
+}