Spring扩展接口Aware家族 spring的扩展机制

在Spring中，相信大家都见过以Aware结尾的接口，aware：英文意思是有感知的。就是让bean在创建的过程中，能感知到容器的变化。最常见的就是ApplicationContextAware接口，这个接口一般在项目中怎么使用呢？接下来就来说一说。

大家在使用Spring开发的时候，可能会遇到这样一个问题。就是想要在普通类中获取spring的bean，该怎么做呢？

我们常见的方法就是定义一个类，实现ApplicationContextAware接口，然后在类里面定义一个static ApplicationContext applicationContext 对象作为成员变量，在重写setApplicationContext(ApplicationContext applicationContext)方法时，将这里的applicationContext赋值给类中的成员变量applicationContext对象，然后在定义另一个static方法，在其中通过applicationContext.getBean(String beanName)来获取bean对象，这样就可以在普通类中调用这个static方法来获取bean了。具体代码如下：

@Component
public class SpringContextHolder implements ApplicationContextAware {

    private static ApplicationContext applicationContext;

    /**
     * 实现ApplicationContextAware接口的context注入函数, 将其存入静态变量
     * 在项目启动的时候执行
     * @param applicationContext
     * @throws BeansException
     */
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        SpringContextHolder.applicationContext = applicationContext;
    }

    public static ApplicationContext getApplicationContext(){
        return applicationContext;
    }

    /**
     * 根据name获取bean
     * @param beanName
     * @param <T>
     * @return
     */
    public static <T> T getBean(String beanName){
        return (T) getApplicationContext().getBean(beanName);
    }

    /**
     * 根据class获取Bean
     * @param clazz
     * @param <T>
     * @return
     */
    public static <T> T getBean(Class<T> clazz){
        return getApplicationContext().getBean(clazz);
    }

    /**
     * 根据name,以及Clazz返回指定的Bean
     * @param beanName
     * @param clazz
     * @param <T>
     * @return
     */
    public static <T> T getBean(String beanName,Class<T> clazz){
        return getApplicationContext().getBean(beanName,clazz);
    }
}

源码分析

你可能很疑惑为什么这样就能在实现类中获取到Spring的容器ApplicationContext对象呢？这里我们来看下源码，入口同样也是refresh()方法，接着finishBeanFactoryInitialization(beanFactory);然后是getBean()，继续调用doCreateBean()，在AbstractAutowireCapableBeanFactory类的doCreateBean()方法里：

调用了initializeBean()方法，我们可以看到在initializeBean()里先后调用了invokeAwareMethods(beanName, bean);和applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);方法

在invokeAwareMethods调用了多个Aware实现类的set()方法：

接着又调用了ApplicationContextAwareProcessor类中的invokeAwareInterfaces()方法：

在其中又调用了多个Aware实现类的set()方法，其中就包括我们前面讲的ApplicationContextAware的实现类，就是在这里将容器applicationContext对象设置到我们自定义的类中的，这样就可以让我们的bean在生成的时候能感知到容器的变化。

对于其他Aware接口的实现类也是如此，都是在这里进行赋值传递。

注：这些Aware接口的操作是发生在bean初始化之前的。即在bean调用afterPropertiesSet()方法和init-method方法之前。

Aware接口家族

BeanNameAware：设置bean的名称

BeanClassLoaderAware：设置bean的类加载器

BeanFactoryAware：设置beanFactory容器

EnvironmentAware：设置Environment对象，可以用来获取环境变量和配置文件属性

EmbeddedValueResolverAware：设置StringValueResolver对象，可以用来获取配置文件属性

ResourceLoaderAware：设置ResourceLoader对象，可以用来读取各种不同形式的资源文件，如classpath、jar、file等等

ApplicationEventPublisherAware：设置ApplicationEventPublisher对象，可以发送事件通知

MessageSourceAware：设置MessageSource对象，可以用来进行国际化的实现

ApplicationContextAware：设置ApplicationContext容器，可以用来获取bean对象

针对以上的几个Aware接口，我们看一下几个示例：

/**
 * 凡注册到Spring容器内的bean，实现了EnvironmentAware接口重写setEnvironment方法后，
 * 在工程启动时可以获得application.properties的配置文件配置的属性值。
 * Note:@Controller @Service 等被Spring管理的类都支持
 */
//@Configuration注解在SpringBoot里面相当于Spring的XML文件里的beans标签一样，
// 而@Bean注解相当于XML文件里的bean标签，代表该类会被加载到Spring的IOC容器内
@Configuration
public class MyEnvironmentAware implements EnvironmentAware {

    private Environment environment;

    @Override
    public void setEnvironment(Environment environment) {
        this.environment = environment;
    }

    @Bean
    public CustomService customService(){
        String uploadPath = environment.getProperty("file.uploadPath");
        System.out.println("uploadPath============"+uploadPath);
        //通过 environment 获取到系统属性
        String java_home = environment.getProperty("JAVA_HOME");
        System.out.println("java_home================"+java_home);
        //获取到前缀是spring.redis.的属性列表值
        RelaxedPropertyResolver relaxedPropertyResolver = new RelaxedPropertyResolver(environment,"spring.redis.");
        System.out.println("spring.redis.host=========="+relaxedPropertyResolver.getProperty("host"));
        System.out.println("spring.redis.timeout=========="+relaxedPropertyResolver.getProperty("timeout"));

        return new CustomService();
    }
}

/**
 * 注意该类必须在ioc容器中使用，否则EmbeddedValueResolverAware不会注入进来
 * EmbeddedValueResolverAware只能读取配置文件的属性值
 */
@Component
public class PropertiesUtil implements EmbeddedValueResolverAware {

    private StringValueResolver resolver;

    @Override
    public void setEmbeddedValueResolver(StringValueResolver resolver) {
        this.resolver = resolver;
    }

    public String getPropertiesValue(String key) {
        //StringValueResolver还可以解析spel表达式
        return resolver.resolveStringValue("${"+key+"}");
    }
}

@Component
public class MyMessageSourceAware implements MessageSourceAware {

    private MessageSource messageSource;

    @Override
    public void setMessageSource(MessageSource messageSource) {
        this.messageSource = messageSource;
    }


    public void printMessage(){
        String name = messageSource.getMessage("user.name",null, Locale.US);
        System.out.println("user name (English) : " + name);

        String namechinese = messageSource.getMessage("user.name",
                null,
                Locale.SIMPLIFIED_CHINESE);

        System.out.println("user name (Chinese) : " + namechinese);
    }
}