这篇文章主要讲解了“Spring aware接口的作用是什么”，文中的讲解内容简单清晰，易于学习与理解，下面请大家跟着小编的思路慢慢深入，一起来研究和学习“Spring aware接口的作用是什么”吧！
通过aware接口可以获取Spring容器相关信息，但这样会与Spring容器耦合。
执行顺序从上到下。
| 类名 | 作用 |
|---|---|
| BeanNameAware | 获得容器中bean名称 |
| BeanClassLoaderAware | 获得类加载器 |
| BeanFactoryAware | 获得bean创建工厂 |
| EnvironmentAware | 获得环境变量 |
| EmbeddedValueResolverAware | 获取spring容器加载的properties文件属性值 |
| ResourceLoaderAware | 获得资源加载器 |
| ApplicationEventPublisherAware | 获得应用事件发布器 |
| MessageSourceAware | 获得文本信息 |
| ApplicationContextAware | 获得当前应用上下文 |
/**
* 获取spring注入对象方法
*/
@Component("springUtil")
public final class SpringUtil implements ApplicationContextAware {
/**
* 应用上下文
*/
private static ApplicationContext applicationContext;
/**
* public方法可能被调用，导致线程不安全。这样写也是为了通过sonar检测
* @param applicationContext 通过aware设置上下文
*/
@Override
public void setApplicationContext(@NonNull ApplicationContext applicationContext) {
synchronized (SpringUtil.class) {
if (null == SpringUtil.applicationContext) {
SpringUtil.applicationContext = applicationContext;
}
}
}
/**
* 获取注入对象
*
* @param name 对象名称
* @return 指定注入对象
*/
public static Object getBean(String name) {
return getApplicationContext().getBean(name);
}
private static ApplicationContext getApplicationContext() {
return applicationContext;
}
/**
* 获取注入对象
*
* @param clazz 对象类型
* @param <T> 泛型
* @return 指定注入对象
*/
public static <T> T getBean(Class<T> clazz) {
return getApplicationContext().getBean(clazz);
}
/**
* 获取注入对象
*
* @param name 对象名称
* @param clazz 对象类型
* @param <T> 泛型
* @return 指定注入对象
*/
public static <T> T getBean(String name, Class<T> clazz) {
return getApplicationContext().getBean(name, clazz);
}
}先定义一个继承Aware的接口，然后注册一个实现BeanPostProcessor接口的Bean，在postProcessBeforeInitialization中处理Aware接口的逻辑。
举一个例子。获取调用自定义Aware接口方法的时间。
public interface TimeAware extends Aware {
void setTriggerTime(Date date);
}@Component
public class AwarePostProcessor implements BeanPostProcessor {
private final ConfigurableApplicationContext applicationContext;
/**
* 可写可不写，这个构造是为了获取applicationContext
*/
public AwarePostProcessor(ConfigurableApplicationContext applicationContext) {
this.applicationContext = applicationContext;
}
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
if (bean instanceof Aware) {
if (bean instanceof TimeAware) {
// 实现自定义Aware接口的逻辑，设置调用的时间
((TimeAware)bean).setTriggerTime(new Date());
}
}
return bean;
}
}@Import(AwarePostProcessor.class)
public class Test implements TimeAware {
Date date;
@Override
public void setTriggerTime(Date date) {
this.date = date;
}
public static void main(String[] args) {
ApplicationContext context = new AnnotationConfigApplicationContext(Test.class);
Test bean = context.getBean(Test.class);
System.out.println(bean.date);
}
}结果：
Bean实例化->填充属性->初始化，在初始化阶段将实现aware接口的Bean的方法执行。
1.先执行实现了下面三个aware接口的方法
BeanNameAware
BeanClassLoaderAware
BeanFactoryAware
2.调用初始化方法
3.执行实现剩下aware接口的方法
AbstractAutowireCapableBeanFactory#initializeBean
protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
invokeAwareMethods(beanName, bean);
return null;
}, getAccessControlContext());
}
else {
/**
* 调用Bean实现的Aware接口的方法，主要包括下面三个接口
* BeanNameAware ----> setBeanName()
* BeanClassLoaderAware ----> setBeanClassLoader()
* BeanFactoryAware ----> setBeanFactory()
*/
invokeAwareMethods(beanName, bean);
}
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
/** 调用Bean对象的postProcessBeforeInitialization方法，此处会执行标注@PostConstruct注解的方法 */
// 此处会调用ApplicationContextAwareProcessor执行其他的aware方法.
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
try {
/**
* 执行Bean的初始化方法:
*
* 1.先判断Bean是否实现了InitializingBean接口，如果实现了InitializingBean接口，则调用Bean对象的afterPropertiesSet方法；
* 2.然后判断Bean是否有指定init-method方法，如果指定了init-method方法，则调用bean对象的init-method指定的方法.
*/
invokeInitMethods(beanName, wrappedBean, mbd);
}
catch (Throwable ex) {
throw new BeanCreationException(
(mbd != null ? mbd.getResourceDescription() : null),
beanName, "Invocation of init method failed", ex);
}
if (mbd == null || !mbd.isSynthetic()) {
/**
* 调用Bean对象的postProcessAfterInitialization方法
*
* 如果需要创建代理，在该步骤中执行postProcessAfterInitialization方法的时候会去创建代理
* 调用AbstractAutoProxyCreator类的postProcessAfterInitialization方法，然后调用wrapIfNecessary方法去创建代理.
*
*
* 另外还有一些Aware接口，也会在该步骤中执行，例如：ApplicationContextAwareProcessor后置处理器，对应的setApplicationContext方法会被执行.
*/
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}调用initializeBean =>invokeAwareMethods方法将前三个aware方法调用
AbstractAutowireCapableBeanFactory#invokeAwareMethods
private void invokeAwareMethods(String beanName, Object bean) {
if (bean instanceof Aware) {
if (bean instanceof BeanNameAware) {
((BeanNameAware) bean).setBeanName(beanName);
}
if (bean instanceof BeanClassLoaderAware) {
ClassLoader bcl = getBeanClassLoader();
if (bcl != null) {
((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
}
}
if (bean instanceof BeanFactoryAware) {
((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
}
}
}调用initializeBean =>applyBeanPostProcessorsBeforeInitialization=>BeanPostProcessor.postProcessBeforeInitialization
进入ApplicationContextAwareProcessor#postProcessBeforeInitialization=>invokeAwareInterfaces
private void invokeAwareInterfaces(Object bean) {
if (bean instanceof EnvironmentAware) {
((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
}
if (bean instanceof EmbeddedValueResolverAware) {
((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver);
}
if (bean instanceof ResourceLoaderAware) {
((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);
}
if (bean instanceof ApplicationEventPublisherAware) {
((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);
}
if (bean instanceof MessageSourceAware) {
((MessageSourceAware) bean).setMessageSource(this.applicationContext);
}
if (bean instanceof ApplicationContextAware) {
((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
}
}因此可以自定义aware接口，并且注册一个实现BeanPostProcessor的postProcessBeforeInitialization方法的Bean，处理调用aware方法时的处理逻辑。
感谢各位的阅读，以上就是“Spring aware接口的作用是什么”的内容了，经过本文的学习后，相信大家对Spring aware接口的作用是什么这一问题有了更深刻的体会，具体使用情况还需要大家实践验证。这里是亿速云，小编将为大家推送更多相关知识点的文章，欢迎关注！
免责声明：本站发布的内容（图片、视频和文字）以原创、转载和分享为主，文章观点不代表本网站立场，如果涉及侵权请联系站长邮箱：is@yisu.com进行举报，并提供相关证据，一经查实，将立刻删除涉嫌侵权内容。
