当前位置：首页 > news >正文

Spring揭秘：Aware接口应用场景及实现原理！

news 2026/2/7 12:02:50

Spring揭秘：Aware接口应用场景及实现原理！ - 程序员古德

内容概要

Aware接口赋予了Bean更多自感知的能力，通过实现不同的Aware接口，Bean可以轻松地获取到Spring容器中的其他资源引用，像ApplicationContext、BeanFactory等。

这样不仅增强了Bean的功能，还提高了代码的可维护性和扩展性，从而让Spring的IoC容器变得更加强大和灵活。

核心概念

它能解决什么问题？

在Spring中，Aware接口是一种标记接口，它本身并没有定义任何方法，但是Spring提供了一系列以Aware命名的接口，如BeanNameAware、BeanFactoryAware、ApplicationContextAware等。

这些接口定义了一些回调方法，通过这些回调方法，Spring容器在初始化Bean时会将容器中的一些资源、状态、环境信息注入到Bean中，使Bean能够感知到这些信息并据此进行相应的操作。

Aware接口主要用来解决以下技术问题：

依赖注入：Spring的核心功能之一就是依赖注入（DI），但有时候标准的依赖注入方式可能无法满足某些特定的需求。例如，当需要访问当前Bean的名称、BeanFactory或ApplicationContext等信息，通过实现相应的Aware接口，可以让Spring容器在初始化Bean时自动将这些信息注入到Bean中。
环境感知：有时候，Bean的行为可能需要根据其所处的环境进行调整，例如，在不同的ApplicationContext中，Bean可能需要进行不同的配置或初始化操作，通过实现ApplicationContextAware接口，Bean可以访问到当前的ApplicationContext，并据此进行环境感知的操作。
资源访问：除了基本的依赖注入和环境感知外，Aware接口还可以用于访问Spring容器中的其他资源。例如，通过实现ResourceLoaderAware接口，Bean可以获得一个ResourceLoader的引用，用于加载类路径下的资源文件。

它有哪些子类拓展？

以下是Aware接口的一些常见的子类实现，如下：

BeanNameAware: 实现此接口的bean可以获得其在Spring容器中的名称，当bean被创建并添加到容器中时，Spring会调用setBeanName(String name)方法。
BeanFactoryAware: 实现此接口的bean可以获得对其所在的BeanFactory的引用，这允许bean直接访问容器以查找或操作其他bean，通过setBeanFactory(BeanFactory beanFactory)方法注入。
ApplicationContextAware: 与BeanFactoryAware类似，但是提供对更高级的ApplicationContext的访问，实现此接口的bean可以通过setApplicationContext(ApplicationContext context)方法获得ApplicationContext的引用。
MessageSourceAware: 实现此接口的bean可以获得对MessageSource的引用，这允许bean进行国际化消息的处理，通过setMessageSource(MessageSource messageSource)方法注入。
ApplicationEventPublisherAware: 实现此接口的bean可以获得一个ApplicationEventPublisher的引用，用于发布应用事件，Spring会在适当时刻调用setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher)方法。
ResourceLoaderAware: 实现此接口的bean可以获得对ResourceLoader的引用，这使得bean可以加载资源，如配置文件等，通过setResourceLoader(ResourceLoader resourceLoader)方法注入。
EnvironmentAware: 实现此接口的bean可以获得对当前应用环境的Environment对象的引用。这允许bean查询配置的属性、配置文件等，通过setEnvironment(Environment environment)方法注入。
EmbeddedValueResolverAware: 实现此接口的bean可以获得对字符串值解析器的引用，该解析器能够处理占位符（如${...}），通过setEmbeddedValueResolver(StringValueResolver resolver)方法注入。
SchedulingConfigurerAware (不直接属于Aware接口系列, 但类似): 允许配置计划任务，在Spring Boot应用中，可以通过实现SchedulingConfigurer接口和覆盖configureTasks(ScheduledTaskRegistrar taskRegistrar)方法来定义计划任务。

代码案例

下面列举举个常见的Aware子类实现案例。

BeanFactoryAware接口

BeanFactoryAware接口允许一个bean在初始化时获得对BeanFactory的引用，这通常用于需要以编程方式访问其他bean或执行与容器相关的操作的场景。下面是一个简单的例子，演示了BeanFactoryAware接口使用，如下代码：

先创建一个实现了BeanFactoryAware接口的类：

import org.springframework.beans.BeansException;  
import org.springframework.beans.factory.BeanFactory;  
import org.springframework.beans.factory.BeanFactoryAware;  
import org.springframework.stereotype.Component;  @Component  
public class MyBeanFactoryAwareBean implements BeanFactoryAware {  private BeanFactory beanFactory;  // 实现BeanFactoryAware接口的回调方法  @Override  public void setBeanFactory(BeanFactory beanFactory) throws BeansException {  this.beanFactory = beanFactory;  }  // 一个简单的方法，用于从BeanFactory中获取bean  public Object getBean(String beanName) {  return beanFactory.getBean(beanName);  }  
}

然后，创建一个简单的bean，后面将通过MyBeanFactoryAwareBean来获取它：

import org.springframework.stereotype.Component;  @Component  
public class MySimpleBean {  public String sayHello() {  return "Hello from MySimpleBean!";  }  
}

接下来，创建一个配置类来启动Spring应用：

import org.springframework.context.annotation.ComponentScan;  
import org.springframework.context.annotation.Configuration;  @Configuration  
@ComponentScan(basePackages = "com.example") // 假设上面的类在com.example包下  
public class AppConfig {  // 这里不需要额外的bean定义，因为@Component注解已经足够  
}

最后，编写一个客户端类来运行应用并测试MyBeanFactoryAwareBean：

import org.springframework.context.ApplicationContext;  
import org.springframework.context.annotation.AnnotationConfigApplicationContext;  public class ClientApp {  public static void main(String[] args) {  // 创建一个Spring应用上下文  ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);  // 获取MyBeanFactoryAwareBean的实例  MyBeanFactoryAwareBean beanFactoryAwareBean = context.getBean(MyBeanFactoryAwareBean.class);  // 使用MyBeanFactoryAwareBean来获取MySimpleBean的实例  MySimpleBean simpleBean = (MySimpleBean) beanFactoryAwareBean.getBean("mySimpleBean");  // 调用MySimpleBean的方法并打印结果  System.out.println(simpleBean.sayHello());  // 关闭应用上下文  ((AnnotationConfigApplicationContext) context).close();  }  
}

ApplicationContextAware接口

ApplicationContextAware接口允许一个bean在初始化时获得对ApplicationContext的引用，通常用于需要以编程方式访问其他bean或执行与Spring应用上下文相关的操作的场景。

如下代码，演示了如何实现ApplicationContextAware接口，并在客户端代码中调用该bean。

首先，创建一个实现了ApplicationContextAware接口的类：

import org.springframework.beans.BeansException;  
import org.springframework.context.ApplicationContext;  
import org.springframework.context.ApplicationContextAware;  
import org.springframework.stereotype.Component;  @Component  
public class MyApplicationContextAwareBean implements ApplicationContextAware {  private ApplicationContext applicationContext;  // 实现ApplicationContextAware接口的回调方法  @Override  public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {  this.applicationContext = applicationContext;  }  // 一个简单的方法，用于从ApplicationContext中获取bean  public Object getBean(String beanName) {  return applicationContext.getBean(beanName);  }  
}

然后，创建一个简单的bean，稍后将通过MyApplicationContextAwareBean来获取它：

import org.springframework.stereotype.Component;  @Component  
public class MySimpleBean {  public String sayHello() {  return "Hello from MySimpleBean!";  }  
}

接下来，创建一个配置类来启动Spring应用：

import org.springframework.context.annotation.ComponentScan;  
import org.springframework.context.annotation.Configuration;  @Configuration  
@ComponentScan(basePackages = "com.example") // 假设上面的类在com.example包下  
public class AppConfig {  // 这里不需要额外的bean定义，因为@Component注解已经足够  
}

最后，编写一个客户端类来运行应用并测试MyApplicationContextAwareBean：

import org.springframework.context.ApplicationContext;  
import org.springframework.context.annotation.AnnotationConfigApplicationContext;  public class ClientApp {  public static void main(String[] args) {  // 创建一个Spring应用上下文  ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);  // 获取MyApplicationContextAwareBean的实例  MyApplicationContextAwareBean contextAwareBean = context.getBean(MyApplicationContextAwareBean.class);  // 使用MyApplicationContextAwareBean来获取MySimpleBean的实例  MySimpleBean simpleBean = (MySimpleBean) contextAwareBean.getBean("mySimpleBean");  // 调用MySimpleBean的方法并打印结果  System.out.println(simpleBean.sayHello());  // 关闭应用上下文（尽管在这个例子中不是必须的，因为main方法结束后JVM会退出）  ((AnnotationConfigApplicationContext) context).close();  }  
}

EnvironmentAware接口

EnvironmentAware接口允许bean在其初始化之后访问到Environment属性。

Environment表示当前应用环境，它封装了应用程序环境的配置属性，例如系统属性、环境变量以及应用上下文中的属性。

如下代码，演示了如何实现Environment接口。

创建一个类MyEnvironmentAwareBean实现EnvironmentAware接口：

import org.springframework.beans.BeansException;  
import org.springframework.beans.factory.BeanNameAware;  
import org.springframework.beans.factory.config.ConfigurableBeanFactory;  
import org.springframework.beans.factory.EnvironmentAware;  
import org.springframework.context.EnvironmentAwareBean;  
import org.springframework.core.env.Environment;  public class MyEnvironmentAwareBean implements EnvironmentAware {  private Environment environment;  // 实现 EnvironmentAware 接口的 setEnvironment 方法  @Override  public void setEnvironment(Environment environment) throws BeansException {  this.environment = environment;  }  // 一个简单的方法，用于输出某个属性的值  public void printProperty(String propertyName) {  String propertyValue = environment.getProperty(propertyName);  System.out.println("Property '" + propertyName + "' = " + propertyValue);  }  
}

上面的代码中MyEnvironmentAwareBean类实现了EnvironmentAware接口，并通过setEnvironment方法接收Environment对象。

接下来，配置Spring上下文，注册MyEnvironmentAwareBean bean，并通过一个客户端类调用它：

import org.springframework.context.annotation.AnnotationConfigApplicationContext;  
import org.springframework.context.annotation.Bean;  
import org.springframework.context.annotation.Configuration;  @Configuration  
public class AppConfig {  // 声明 MyEnvironmentAwareBean 为一个 bean  @Bean  public MyEnvironmentAwareBean myEnvironmentAwareBean() {  return new MyEnvironmentAwareBean();  }  
}  public class ClientApp {  public static void main(String[] args) {  // 创建 AnnotationConfigApplicationContext 上下文  AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);  // 从上下文中获取 MyEnvironmentAwareBean 实例  MyEnvironmentAwareBean myBean = context.getBean(MyEnvironmentAwareBean.class);  // 调用 printProperty 方法，打印系统属性 java.version  myBean.printProperty("java.version");  // 关闭上下文  context.close();  }  
}

ResourceLoaderAware接口

如下代码，演示了如何实现Environment接口：

创建一个类MyResourceLoaderAwareComponent实现ResourceLoaderAware接口，并实现setResourceLoader方法

import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.context.ResourceLoaderAware;  
import org.springframework.core.io.Resource;  
import org.springframework.core.io.ResourceLoader;  
import org.springframework.stereotype.Component;  import java.io.IOException;  
import java.io.InputStream;  
import java.nio.charset.StandardCharsets;  
import java.util.Scanner;  // 声明这是一个Spring组件  
@Component  
public class MyResourceLoaderAwareComponent implements ResourceLoaderAware {  private ResourceLoader resourceLoader;  // 实现了ResourceLoaderAware接口的setResourceLoader方法  @Override  public void setResourceLoader(ResourceLoader resourceLoader) {  this.resourceLoader = resourceLoader;  }  // 使用ResourceLoader加载资源并返回资源内容  public String loadResourceContent(String location) {  Resource resource = resourceLoader.getResource(location);  try (InputStream inputStream = resource.getInputStream();  Scanner scanner = new Scanner(inputStream, StandardCharsets.UTF_8.name())) {  StringBuilder content = new StringBuilder();  while (scanner.hasNextLine()) {  content.append(scanner.nextLine()).append("\n");  }  return content.toString();  } catch (IOException e) {  throw new RuntimeException("Failed to load resource: " + location, e);  }  }  
}

创建换一个client类MyResourceLoaderAwareClient，类中通过@Autowired将MyResourceLoaderAwareComponent注入进来，如下：

import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.stereotype.Component;  @Component  
public class MyResourceLoaderAwareClient {  private final MyResourceLoaderAwareComponent myResourceLoaderAwareComponent;  @Autowired  public MyResourceLoaderAwareClient(MyResourceLoaderAwareComponent myResourceLoaderAwareComponent) {  this.myResourceLoaderAwareComponent = myResourceLoaderAwareComponent;  }  // 客户端方法，用于调用加载资源的方法并打印结果  public void printResourceContent(String location) {  String content = myResourceLoaderAwareComponent.loadResourceContent(location);  System.out.println("Resource content from location: " + location);  System.out.println(content);  }  
}

Spring揭秘：Aware接口应用场景及实现原理！ - 程序员古德

最后，Aware子类比较多，这里就不一一通过代码举例了，但是只需要记住，在Spring中提供的Aware接口都是为了能够让开发者轻松地获取到Spring容器中的其他资源的引用。

关注我，每天学习互联网编程技术 - 程序员古德

END!
END!
END!

往期回顾

精品文章

Spring揭秘：@import注解应用场景及实现原理！

Java并发基础：原子类之AtomicMarkableReference全面解析！

Java并发基础：concurrent Flow API全面解析

Java并发基础：CopyOnWriteArraySet全面解析

Java并发基础：ConcurrentSkipListMap全面解析