浅析对Spring aware接口理解

 更新时间:2022年08月29日 16:59:16   作者:dreambyday  
通过aware接口可以获取Spring容器相关信息,但这样会与Spring容器耦合,这篇文章主要介绍了Spring aware接口理解,需要的朋友可以参考下

1. aware接口的作用

通过aware接口可以获取Spring容器相关信息,但这样会与Spring容器耦合。

2. 常用aware接口及作用

执行顺序从上到下。

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

3. 使用样例:ApplicationContextAware 在Bean中获取上下文

/**
 * 获取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);
    }
}

4. 自定义aware的方式

先定义一个继承Aware的接口,然后注册一个实现BeanPostProcessor接口的Bean,在postProcessBeforeInitialization中处理Aware接口的逻辑。

举一个例子。获取调用自定义Aware接口方法的时间。

4.1 定义继承Aware的接口

public interface TimeAware extends Aware {
    void setTriggerTime(Date date);
}

4.2 注册实现BeanPostProcessor接口的Bean

@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;
    }
}

4.3 实现TimeAware接口,并测试

@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);
    }
}

结果:

在这里插入图片描述

5. 源码处理方式

  • Bean实例化->填充属性->初始化,在初始化阶段将实现aware接口的Bean的方法执行。

1.先执行实现了下面三个aware接口的方法

  • BeanNameAware
  • BeanClassLoaderAware
  • BeanFactoryAware

2.调用初始化方法

3.执行实现剩下aware接口的方法

5.1 初始化阶段的源码逻辑

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;
	}

5.2 实现前三个aware接口的处理

调用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);
			}
		}
	}

5.3 剩余实现aware接口的Bean的处理

调用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方法时的处理逻辑。

相关文章

  • Java8中的forEach使用及说明

    Java8中的forEach使用及说明

    这篇文章主要介绍了Java8中的forEach使用及说明,具有很好的参考价值,希望对大家有所帮助。如有错误或未考虑完全的地方,望不吝赐教
    2023-07-07
  • java实现简单的小超市程序

    java实现简单的小超市程序

    这篇文章主要为大家详细介绍了java实现简单的小超市程序,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
    2021-02-02
  • OpenTelemetry Java SDK 高级用法解析

    OpenTelemetry Java SDK 高级用法解析

    这篇文章主要介绍了OpenTelemetry Java SDK 的高级用法示例解析,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪
    2023-02-02
  • java虚拟机深入学习之内存管理机制

    java虚拟机深入学习之内存管理机制

    java虚拟机在程序运行时将内存划分为多个区域,每个区域作用,生命周期各不相同,下面这篇文章主要给大家介绍了关于java虚拟机深入学习之内存管理机制的相关资料,文中通过示例代码介绍的非常详细,需要的朋友可以参考下
    2018-11-11
  • 接口签名怎么用Java实现

    接口签名怎么用Java实现

    今天带大家学习java的相关知识,文章围绕怎么用Java实现接口签名展开,文中有非常详细的代码示例及介绍,需要的朋友可以参考下
    2021-06-06
  • Spring Boot 使用 Swagger 构建 RestAPI 接口文档

    Spring Boot 使用 Swagger 构建 RestAPI 接口文档

    这篇文章主要介绍了Spring Boot 使用 Swagger 构建 RestAPI 接口文档,帮助大家更好的理解和使用Spring Boot框架,感兴趣的朋友可以了解下
    2020-10-10
  • Java Socket实现多线程通信功能示例

    Java Socket实现多线程通信功能示例

    这篇文章主要介绍了Java Socket实现多线程通信功能,结合具体实例形式较为详细的分析了java多线程通信的原理及客户端、服务器端相应实现技巧,需要的朋友可以参考下
    2017-06-06
  • DolphinScheduler容错Master源码分析

    DolphinScheduler容错Master源码分析

    这篇文章主要为大家介绍了DolphinScheduler容错Master源码分析,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪
    2023-02-02
  • Spring  ApplicationContextAware 接口的作用及使用方式

    Spring  ApplicationContextAware 接口的作用及使用方式

    Spring提供了许多回调接口,用于Bean生命周期中执行特定的操作,通过实现ApplicationContextAware接口,Spring提供了一种便捷的方式让 Bean获取对Spring容器的引用,本文介绍ApplicationContextAware接口的作用、使用方式,以及在实际应用中的常见场景,感兴趣的朋友一起看看吧
    2024-01-01
  • 详谈hibernate,jpa与spring data jpa三者之间的关系

    详谈hibernate,jpa与spring data jpa三者之间的关系

    这篇文章主要介绍了hibernate,jpa与spring data jpa三者之间的关系,具有很好的参考价值,希望对大家有所帮助。如有错误或未考虑完全的地方,望不吝赐教
    2021-11-11

最新评论