SpringBoot Aware使用及原理解析

前言

Aware接口

在Spring中存在一个Aware接口，实现该接口可以让我们的Bean获取到Spring容器中特定的资源，但该接口只是个标记接口，不存在任何方法，因此我们还需要继承Aware来做特定资源获取的实现。

Spring中有不少继承于Aware的接口的实现，比如当前Bean想要获取环境变量时，可以实现EnvironmentAware接口，想要获取应用上下文则可以实现ApplicationContextAware接口。

常用的Aware实现

接口	作用
BeanClassLoaderAware	获得类加载器
BeanNameAware	获取容器中Bean名称
BeanFactoryAware	获取bean创建工厂
EnvironmentAware	获得环境变量
ResourceLoaderAware	获取资源加载器
ApplicationEventPublisherAware	获取应用事件发布器
MessageSourceAware	获取文本信息
ApplicationContextAware	获取当前应用上下文

Aware示例

以下做一个代码示例，实现EnvironmentAware接口，获取到Environment并尝试获取并输出自定义的属性。除了Aware外，还涉及到之前提到的CommandLineRunner 和Property，可以点击回顾。

创建一个AwareCommandLineRunner，实现EnvironmentAware接口，并尝试获取并输出redis-host属性

package geek.springboot.application.runner;

import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.CommandLineRunner;
import org.springframework.context.EnvironmentAware;
import org.springframework.core.env.Environment;
import org.springframework.stereotype.Component;

@Slf4j
@Component
public class AwareCommandLineRunner implements CommandLineRunner, EnvironmentAware {

    @Override
    public void run(String... args) throws Exception {
        log.info("AwareCommandLineRunner running...");
    }

    @Override
    public void setEnvironment(Environment environment) {
        String redisHost = environment.getProperty("redis-host");
        log.info("redis-host is {}", redisHost);
    }

}

SpringApplication启动代码如下

package geek.springboot.application;

import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import java.util.Properties;

@Slf4j
@SpringBootApplication
public class Application {

    public static void main(String[] args) {

        SpringApplication application = new SpringApplication(Application.class);
        // 添加redis-host配置  
        Properties properties = new Properties();
        properties.setProperty("redis-host", "127.0.0.1");
        application.setDefaultProperties(properties);

        application.run(args);

    }

}

启动输出 2023-08-27 19:01:15.198 INFO 56188 --- [ main] g.s.a.runner.AwareCommandLineRunner : redis-host is 127.0.0.1

自定义Aware

新建一个RedisConfig配置类

package geek.springboot.application.configuration;

import lombok.Data;
import org.springframework.stereotype.Component;


@Data
@Component
public class RedisConfig {

    private String ip = "127.0.0.1";

    private Integer port = 6379;


    @Override
    public String toString() {
        return "RedisConfig{" +
                "ip='" + ip + ''' +
                ", port=" + port +
                '}';
    }

}

创建一个RedisAware接口，Bean实现该接口即可获取RedisConfig

package geek.springboot.application.aware;

import geek.springboot.application.configuration.RedisConfig;
import org.springframework.beans.factory.Aware;


/**
 * 自定义Aware
 *
 * @author Bruse
 */
public interface RedisAware extends Aware {

    void setRedisConfig(RedisConfig config);

}

创建一个RedisAwareProcessor，实现BeanPostProcessor接口，由它具体负责将RedisConfig注入实现了RedisAware接口的Bean。 为什么要实现BeanPostProcessor后边的原理分析会提及。

package geek.springboot.application.aware;

import geek.springboot.application.configuration.RedisConfig;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.context.ApplicationContext;
import org.springframework.stereotype.Component;

/**
 * 自定义RedisAwareProcessor
 *
 * @author Bruse
 */
@Component
public class RedisAwareProcessor implements BeanPostProcessor {

    @Autowired
    private ApplicationContext context;

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        // 判断当前Bean是否实现RedisAware
        if (bean instanceof RedisAware) {
            // 强转,调用setRedisConfig方法注入RedisConfig
            ((RedisAware) bean).setRedisConfig(context.getBean(RedisConfig.class));
        }
        return bean;
    }
}

AwareCommandLineRunner实现RedisAware接口

package geek.springboot.application.runner;

import geek.springboot.application.aware.RedisAware;
import geek.springboot.application.configuration.RedisConfig;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.CommandLineRunner;
import org.springframework.context.EnvironmentAware;
import org.springframework.core.env.Environment;
import org.springframework.stereotype.Component;

@Slf4j
@Component
public class AwareCommandLineRunner implements CommandLineRunner, EnvironmentAware, RedisAware {

    @Override
    public void run(String... args) throws Exception {
        log.info("AwareCommandLineRunner running...");
    }

    @Override
    public void setEnvironment(Environment environment) {
        String redisHost = environment.getProperty("redis-host");
        log.info("redis-host is {}", redisHost);
    }

    @Override
    public void setRedisConfig(RedisConfig config) {
        log.info("redis config: {}", config.toString());
    }

}

启动SpringApplication，输出如下

2023-08-27 19:08:36.641 INFO 79920 --- [ main] g.s.a.runner.AwareCommandLineRunner : redis config: RedisConfig{ip='127.0.0.1', port=6379}

Aware原理

在AwareCommandLineRunner的setEnvironment方法打上断点，根据调用栈可以看到是在ApplicationContextAwareProcessor的invokeAwareInterfaces()方法中调用setEnvironment()方法进Environment注入的

接着再往上查找，可以看到invokeAwareInterfaces()方法又是在postProcessBeforeInitialization()中调用的

而ApplicationContextAwareProcessor正好实现了BeanPostProcessor接口。这也就是为什么上边自定义Aware实现时，需要创建一个RedisAwareProcessor并实现BeanPostProcessor的原因

再往上查看调用栈的话，可以理清完整的从上到下Aware调用链路

1. 调用AbstractAutowireCapableBeanFactory的doCreateBean()方法
2. 调用AbstractAutowireCapableBeanFactory的initializeBean()方法
3. 调用AbstractAutowireCapableBeanFactory的applyBeanPostProcessorsBeforeInitialization()方法
4. 调用ApplicationContextAwareProcessor的postProcessBeforeInitialization()方法
5. 调用ApplicationContextAwareProcessor的invokeAwareInterfaces()方法
6. 调用Aware接口实现的方法

doCreateBean其实涉及到SpringBoot中Bea初始化的内容，可以看这一篇SpringBoot Bean实例化流程解析

结尾

本文章源自《Learn SpringBoot》专栏，感兴趣的话还请关注点赞收藏.

上一篇文章：《SpringBoot Bean实例化流程解析》