Spring 提供了一系列 Aware 接口，允许 Bean 在容器中获取对特定基础设施组件的引用。

1. 速览

Aware 接口	对应功能组件	组件功能说明	组件核心能力	典型使用场景	使用频率
ApplicationEventPublisherAware	ApplicationEventPublisher	应用事件发布器，支持观察者模式	- 发布应用事件（publishEvent()） - 支持同步/异步事件处理 - 与监听器自动集成	- 业务解耦（如订单创建后发通知） - 异步处理触发 - 跨模块通信 - 审计日志记录	特别常用
ApplicationContextAware	ApplicationContext	Spring 应用上下文，提供对容器的完整访问	- 获取任意 Bean（getBean()） - 发布事件（publishEvent()） - 获取环境信息（getEnvironment()） - 检查 Bean 状态（containsBean()） - 获取资源（getResource()）	- 动态获取服务 Bean - 实现插件化架构 - 框架级通用组件开发 - 运行时 Bean 管理	常用
EnvironmentAware	Environment	应用运行环境抽象，管理配置属性和 Profile	- 读取配置属性（getProperty()） - Profile 条件判断（acceptsProfiles()） - 获取活跃 Profile（getActiveProfiles()） - 属性源管理	- 多环境配置管理（dev/test/prod） - 条件化配置加载 - 动态特性开关 - 外部化配置读取	常用
MessageSourceAware	MessageSource	国际化消息源，支持多语言消息管理	- 获取本地化消息（getMessage()） - 支持消息参数替换 - 多语言资源文件管理 - 默认消息回退	- 国际化 Web 应用 - 多语言错误提示 - 本地化内容展示 - 用户界面国际化	按需使用
ResourceLoaderAware	ResourceLoader	资源加载器，统一访问各类资源	- 加载 Classpath 资源（classpath:） - 加载文件系统资源（file:） - 加载 URL 资源（http:） - 支持通配符路径	- 加载配置模板文件 - 读取静态资源 - 动态脚本加载 - 文件批量处理	较少使用
BeanNameAware	String（Bean 名称）	当前 Bean 在容器中的标识名称	- 提供 Bean 的注册名称 - 支持自省和调试	- 日志记录中标识具体 Bean - 动态配置查找（按名称） - 调试和监控工具集成	较少使用
BeanFactoryAware	BeanFactory	Spring 底层 Bean 工厂，负责 Bean 的创建和管理	- 获取 Bean 实例（getBean()） - 检查 Bean 定义（containsBeanDefinition()） - 获取 Bean 类型（getType()） - 检查单例状态（isSingleton()）	- 自定义 Bean 生命周期控制 - 高级容器扩展 - 框架底层开发 - 动态代理实现	不常用
ServletContextAware	ServletContext	Servlet 容器上下文，Web 应用全局共享空间	- 获取 Web 应用路径（getContextPath()） - 存储全局属性（setAttribute()） - 获取初始化参数 - 访问真实文件路径（getRealPath()）	- Web 应用初始化 - 全局数据共享 - 文件上传路径获取 - 第三方库集成	Web项目常用
ServletConfigAware	ServletConfig	Servlet 配置信息，特定 Servlet 的初始化参数	- 获取 Servlet 初始化参数（getInitParameter()） - 获取 Servlet 名称 - 访问 ServletContext	- 传统 Web.xml 配置读取 - Servlet 特定配置处理 - 遗留系统集成	很少使用

2. 主要 Aware 接口介绍

2.1 ApplicationEventPublisherAware

功能：获取 ApplicationEventPublisher 引用
使用场景：专门用于发布应用事件

@Component
public class EventPublisherService implements ApplicationEventPublisherAware {
    private ApplicationEventPublisher eventPublisher;
    
    @Override
    public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
        this.eventPublisher = applicationEventPublisher;
    }
    
    public void publishCustomEvent(String message) {
        //事件发布 → 事件监听器自动调用
        eventPublisher.publishEvent(new CustomEvent(message));
        //自动触发所有 @EventListener 标注的方法
    }
}

// 自定义事件
public class CustomEvent extends ApplicationEvent {
    private String message;
    
    public CustomEvent(String message) {
        super(message);
        this.message = message;
    }
    
    public String getMessage() { return message; }
}

// 事件监听器
@Component
public class CustomEventListener {
    @EventListener
    public void handleCustomEvent(CustomEvent event) {
        System.out.println("Received event: " + event.getMessage());
    }
}

2.2 ApplicationContextAware

功能：获取 ApplicationContext 引用
使用场景：需要访问完整的应用上下文，如发布事件、获取其他 Bean 等

@Component
public class MyService implements ApplicationContextAware {
    private ApplicationContext applicationContext;
    
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) {
        this.applicationContext = applicationContext;
    }
    
    public void doSomething() {
        // 发布事件
        applicationContext.publishEvent(new CustomEvent("Hello"));
        
        // 获取其他Bean
        OtherService otherService = applicationContext.getBean(OtherService.class);
    }
}

ApplicationContext vs BeanFactory

• ApplicationContext：高级容器接口，包含 BeanFactory 所有功能 + 事件发布、国际化、资源访问等企业级特性
• BeanFactory：基础容器接口，专注于 Bean 的生命周期管理

2.3 EnvironmentAware

功能：获取 Environment 引用
使用场景：访问配置属性、Profile 信息等

@Component
public class ConfigService implements EnvironmentAware {
    private Environment environment;
    
    @Override
    public void setEnvironment(Environment environment) {
        this.environment = environment;
    }
    
    public void printConfig() {
        // 获取配置属性
        String dbUrl = environment.getProperty("database.url");
        String username = environment.getProperty("database.username");
        
        // 检查激活的Profile
        String[] activeProfiles = environment.getActiveProfiles();
        boolean isProd = environment.acceptsProfiles("prod");
        
        System.out.println("DB URL: " + dbUrl);
        System.out.println("Active profiles: " + Arrays.toString(activeProfiles));
    }
}

Environment 的层次结构：

Environment
├── PropertySources（多个属性源）
│   ├── System Properties
│   ├── System Environment Variables  
│   ├── application.properties
│   └── application-{profile}.properties
└── Profiles（激活的环境配置）

2.4 MessageSourceAware

功能：获取 MessageSource 引用
使用场景：国际化消息处理

@Component
public class MessageService implements MessageSourceAware {
    private MessageSource messageSource;
    
    @Override
    public void setMessageSource(MessageSource messageSource) {
        this.messageSource = messageSource;
    }
    
    public void printLocalizedMessage(Locale locale) {
        // 获取国际化消息
        String greeting = messageSource.getMessage("greeting", null, locale);
        String welcome = messageSource.getMessage("welcome.message", 
            new Object[]{"John"}, "Default Message", locale);
        
        System.out.println(greeting);
        System.out.println(welcome);
    }
}

2.5 ResourceLoaderAware

功能：获取 ResourceLoader 引用
使用场景：加载资源文件（classpath、文件系统等）

@Component
public class FileService implements ResourceLoaderAware {
    private ResourceLoader resourceLoader;
    
    @Override
    public void setResourceLoader(ResourceLoader resourceLoader) {
        this.resourceLoader = resourceLoader;
    }
    
    public void loadConfigFile() throws IOException {
        // 加载classpath资源
        Resource configResource = resourceLoader.getResource("classpath:application.properties");
        
        // 加载文件系统资源
        Resource fileResource = resourceLoader.getResource("file:/path/to/config.txt");
        
        try (InputStream inputStream = configResource.getInputStream()) {
            Properties props = new Properties();
            props.load(inputStream);
            // 处理配置
        }
    }
}

ResourceLoader 支持的协议：

• classpath: - 类路径资源
• file: - 文件系统资源
• http: - HTTP URL 资源
• ftp: - FTP 资源（较少用）

2.6 BeanNameAware

功能：获取当前 Bean 的名称
使用场景：需要知道自己的 Bean 名称，用于日志记录或调试

@Component("userService")
public class UserService implements BeanNameAware {
    private String beanName;
    
    @Override
    public void setBeanName(String name) {
        this.beanName = name;
    }
    
    public void logBeanInfo() {
        System.out.println("I am bean: " + beanName);
        // 输出: I am bean: userService
    }
}

2.7 BeanFactoryAware

功能：获取 BeanFactory 引用
使用场景：需要访问底层 Bean 工厂，通常在高级场景中使用

@Component
public class BeanFactoryService implements BeanFactoryAware {
    private BeanFactory beanFactory;
    
    @Override
    public void setBeanFactory(BeanFactory beanFactory) {
        this.beanFactory = beanFactory;
    }
    
    public void getBeanInfo() {
        // 检查Bean是否存在
        boolean exists = beanFactory.containsBean("myService");
        
        // 获取Bean类型
        Class<?> beanType = beanFactory.getType("myService");
        
        // 获取Bean（较少使用，通常用@Autowired）
        MyService service = beanFactory.getBean(MyService.class);
    }
}

2.8 ServletContextAware（Web 应用）

功能：获取 ServletContext 引用
使用场景：Web 应用中访问 Servlet 上下文

@Component
public class WebConfigService implements ServletContextAware {
    private ServletContext servletContext;
    
    @Override
    public void setServletContext(ServletContext servletContext) {
        this.servletContext = servletContext;
    }
    
    public void getWebInfo() {
        String contextPath = servletContext.getContextPath();
        String realPath = servletContext.getRealPath("/");
        int majorVersion = servletContext.getMajorVersion();
        
        System.out.println("Context Path: " + contextPath);
        System.out.println("Real Path: " + realPath);
    }
}

2.9 ServletConfigAware（Web 应用）

功能：获取 ServletConfig 引用
使用场景：访问 Servlet 配置信息

@Component
public class ServletConfigService implements ServletConfigAware {
    private ServletConfig servletConfig;
    
    @Override
    public void setServletConfig(ServletConfig servletConfig) {
        this.servletConfig = servletConfig;
    }
    
    public void getServletInitParams() {
        String paramValue = servletConfig.getInitParameter("configParam");
        ServletContext context = servletConfig.getServletContext();
        
        System.out.println("Init Param: " + paramValue);
    }
}

3. 使用建议

3.1 优先使用依赖注入替代Aware接口

在 Spring Boot 应用中，90% 以上的 Aware 接口使用场景都可以通过标准的 @Autowired 注入来替代，这样代码更加清晰、测试更加容易，且与 Spring 框架的耦合度更低。

// ✅ 推荐：使用构造函数注入或字段注入
@Service
public class BetterService {
    private final ApplicationEventPublisher eventPublisher;
    private final Environment environment;
    
    public BetterService(ApplicationEventPublisher eventPublisher, 
                        Environment environment) {
        this.eventPublisher = eventPublisher;
        this.environment = environment;
    }
}
// 或
@Service
public class BetterService {
    @Autowired
    private final ApplicationEventPublisher eventPublisher;
    @Autowired
    private final Environment environment;
}

// ❌ 不推荐：过度使用 Aware 接口
@Service
public class LegacyService implements ApplicationEventPublisherAware, EnvironmentAware {
    // 实现方法...
}

Aware 接口	推荐的现代替代方式
ApplicationContextAware	直接注入 ApplicationContext 或具体需要的组件
ApplicationEventPublisherAware	@Autowired ApplicationEventPublisher
EnvironmentAware	@Value("${property}") 或 @ConfigurationProperties
ResourceLoaderAware	@Autowired ResourceLoader 或直接注入 Resource
MessageSourceAware	@Autowired MessageSource
ServletContextAware	在 Controller 中直接注入 ServletContext
其他 Aware 接口	优先考虑标准依赖注入或注解驱动方式

3.2 Aware 接口的适用场景

• 框架开发：编写通用组件时
• 遗留代码集成：无法修改构造函数的场景
• 特殊需求：确实需要动态获取上下文信息

3.2.1 Aware 接口执行顺序

Aware 接口的回调方法在以下生命周期阶段执行：

1. Bean 实例化后
2. 属性填充后（@Autowired 处理前）
3. InitializingBean.afterPropertiesSet() 和 @PostConstruct 之前

3.2.2 使用Aware 接口注意事项

• Aware 接口会使代码与 Spring 耦合
• 在单元测试中可能需要模拟这些依赖
• 过度使用会降低代码的可测试性和可维护性

合理使用这些 Aware 接口，可以在需要时访问 Spring 容器的各种基础设施组件，但应谨慎权衡是否真的需要它们，如果可以请优先考虑标准的依赖注入方式。