【Spring】关于Spring中aware相关接口的作用

Aware 接口的回调方法是在 Bean 实例化之后调用的。具体来说，这些回调方法是在依赖注入完成后，但在 Bean 完全初始化之前调用的。这是 Spring 容器管理 Bean 生命周期的一部分

完成了属性赋值之后，Spring会执行一些回调，包括： 1. BeanNameAware：回传beanName给bean对象。 2. BeanClassLoaderAware：回传classLoader给bean对象。 3. BeanFactoryAware：回传beanFactory

1、BeanNameAware：

• 回调目的：告诉 Bean 它自己的名字。
• 大白话解释：Spring 会调用 setBeanName(String name) 方法，把 Bean 的名字告诉给 Bean 本身。这样，Bean 就知道它在 Spring 容器中的名字是什么。
• 应用场景：如果你的 Bean 需要知道自己在 Spring 容器中的名字，可以实现 BeanNameAware 接口。

2、BeanClassLoaderAware：

• 回调目的：告诉 Bean 它的类加载器。
• 大白话解释：Spring 会调用 setBeanClassLoader(ClassLoader classLoader) 方法，把类加载器告诉给 Bean 本身。这样，Bean 就可以使用这个类加载器来加载类。
• 应用场景：如果你的 Bean 需要动态加载类，可以实现 BeanClassLoaderAware 接口。

3、BeanFactoryAware：

• 回调目的：告诉 Bean 它所在的 BeanFactory。
• 大白话解释：Spring 会调用 setBeanFactory(BeanFactory beanFactory) 方法，把 BeanFactory 的引用告诉给 Bean 本身。这样，Bean 就可以访问和操作整个 Spring 容器。
• 应用场景：如果你的 Bean 需要访问 Spring 容器中的其他 Bean，或者需要执行一些与容器相关的操作，可以实现 BeanFactoryAware 接口。

当然Spring中还有很多其它功能的aware接口或者自定义aware接口

具体示例

1. 定义 MyBean 类
首先，定义一个 MyBean 类，实现 BeanNameAware、BeanClassLoaderAware 和 BeanFactoryAware 接口：

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.BeanClassLoaderAware;public class MyBean implements BeanNameAware, BeanClassLoaderAware, BeanFactoryAware {private String beanName;private ClassLoader classLoader;private BeanFactory beanFactory;@Overridepublic void setBeanName(String name) {this.beanName = name;System.out.println("Bean name is: " + name);}@Overridepublic void setBeanClassLoader(ClassLoader classLoader) {this.classLoader = classLoader;System.out.println("Class loader is: " + classLoader);}@Overridepublic void setBeanFactory(BeanFactory beanFactory) throws BeansException {this.beanFactory = beanFactory;System.out.println("BeanFactory is: " + beanFactory);}public void doSomething() {System.out.println("Doing something...");// 你可以在这里使用 beanName、classLoader 和 beanFactory}
}

2. 定义配置类
接下来，定义一个配置类，使用 @Configuration 和 @Bean 注解来配置 MyBean：

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;@Configuration
public class AppConfig {@Beanpublic MyBean myBean() {return new MyBean();}
}

3. 启动 Spring 应用

最后，编写一个主类来启动 Spring 应用，并获取 MyBean 实例

import org.springframework.context.annotation.AnnotationConfigApplicationContext;public class Main {public static void main(String[] args) {// 创建 Spring 应用上下文AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);// 获取 MyBean 实例MyBean myBean = context.getBean(MyBean.class);// 调用 MyBean 的方法myBean.doSomething();// 关闭上下文context.close();}
}

运行结果
当你运行 Main 类时，你会看到类似以下的输出

解释
1、MyBean 类：

• 实现了 BeanNameAware、BeanClassLoaderAware 和 BeanFactoryAware 接口。
• 重写了 setBeanName、setBeanClassLoader 和 setBeanFactory 方法，在这些方法中打印相关信息。

2、AppConfig 类：

• 使用 @Configuration 注解标记为配置类。
• 使用 @Bean 注解定义 MyBean 的 Bean。

3、Main 类：

• 使用 AnnotationConfigApplicationContext 创建 Spring 应用上下文，并传入配置类 AppConfig。
• 从上下文中获取 MyBean 实例，并调用其 doSomething 方法。
• 最后关闭上下文。

通过这种方式，你可以使用纯 Java 配置来实现 BeanNameAware、BeanClassLoaderAware 和 BeanFactoryAware 回调

当然还有更多的

ApplicationContextAwareProcessor会在初始化前这个步骤中进行其他Aware的回调：

• i. EnvironmentAware：回传环境变量
• ii. EmbeddedValueResolverAware：回传占位符解析器
• iii. ResourceLoaderAware：回传资源加载器
• iv. ApplicationEventPublisherAware：回传事件发布器
• v. MessageSourceAware：回传国际化资源
• vi. ApplicationStartupAware：回传应用其他监听对象，可忽略
• vii. ApplicationContextAware：回传Spring容器ApplicationContext