0
点赞
收藏
分享

微信扫一扫

Spring揭秘:Aware接口应用场景及实现原理!

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

内容概要

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

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

核心概念

它能解决什么问题?

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

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

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

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

它有哪些子类拓展?

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

  1. BeanNameAware: 实现此接口的bean可以获得其在Spring容器中的名称,当bean被创建并添加到容器中时,Spring会调用setBeanName(String name)方法。
  2. BeanFactoryAware: 实现此接口的bean可以获得对其所在的BeanFactory的引用,这允许bean直接访问容器以查找或操作其他bean,通过setBeanFactory(BeanFactory beanFactory)方法注入。
  3. ApplicationContextAware: 与BeanFactoryAware类似,但是提供对更高级的ApplicationContext的访问,实现此接口的bean可以通过setApplicationContext(ApplicationContext context)方法获得ApplicationContext的引用。
  4. MessageSourceAware: 实现此接口的bean可以获得对MessageSource的引用,这允许bean进行国际化消息的处理,通过setMessageSource(MessageSource messageSource)方法注入。
  5. ApplicationEventPublisherAware: 实现此接口的bean可以获得一个ApplicationEventPublisher的引用,用于发布应用事件,Spring会在适当时刻调用setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher)方法。
  6. ResourceLoaderAware: 实现此接口的bean可以获得对ResourceLoader的引用,这使得bean可以加载资源,如配置文件等,通过setResourceLoader(ResourceLoader resourceLoader)方法注入。
  7. EnvironmentAware: 实现此接口的bean可以获得对当前应用环境的Environment对象的引用。这允许bean查询配置的属性、配置文件等,通过setEnvironment(Environment environment)方法注入。
  8. EmbeddedValueResolverAware: 实现此接口的bean可以获得对字符串值解析器的引用,该解析器能够处理占位符(如${...}),通过setEmbeddedValueResolver(StringValueResolver resolver)方法注入。
  9. 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,类中通过@AutowiredMyResourceLoaderAwareComponent注入进来,如下:

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!

举报

相关推荐

0 条评论