spring中的 Aware 接口

Aware 接口

• Aware 是个接口。xxxAware 都是实现了Aware接口。
• Aware 的含义是感知。当 bean 比如 xxxAware 实现了对应的 Aware 接口的时候， BeanFactory 就会在产生这个 bean 的时候根据对应的 Aware 接口，给 bean 注入相应的属性，这样 bean 就能够获取外界资源的引用了。
• 在 spring 中，这些实现 Aware 接口的xxxAware类是如何实现感应并设置xxx属性的值呢？
  • 答案是：在spring容器中，工厂类创建实例后使用instanceof判断实例是否属于 xxxAware 接口的实例，如果是的话，那么 spring 容器类就会调用实例的 setXxx() 方法给实例的 xxx 属性设置值。
    • ApplicationContextAwareProcessor 类 implements BeanPostProcessor 接口
    • ApplicationContextAwareProcessor 类中的 invokeAwareInterfaces 方法进行了 instanceof 逻辑判断

    • private void invokeAwareInterfaces(Object bean) {
      		if (bean instanceof Aware) {
      			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 接口的 bean 在被初始化后，可以从 spring 容器中取得一些相对应的资源。
    • 1、比如实现 ApplicationContextAware 接口的 bean，在 bean 被初始化后，将会被注入 ApplicationContext 实例
      • 下面是代码实例：

      • 
        /**
         * Aware是个接口
         * Aware的本意是感知
         * @Description:
         * @date 2021/7/18 13:42
         */
        public class SpringContextUtil implements ApplicationContextAware {
        
            private ApplicationContext applicationContext;
        
            /**
             * <T> T表示返回值是一个泛型，传递啥，就返回啥类型的数据，
             * 而单独的T就是表示限制你传递的参数类型，
             *
             * 这个<T> T 表示的是返回值T是泛型，T是一个占位符，用来告诉编译器，
             * 这个东西先给我留着，等我编译的时候，告诉你。
             *
             * 返回值，直接写T表示限制参数的类型，这种方法一般多用于共同操作一个类对象，
             * 然后获取里面的集合信息啥的。
             * @param tClass
             * @param <T>
             * @return
             */
            public <T> T  getBean(Class<T> tClass){
                return applicationContext.getBean(tClass);
            }
        
            // spring容器类就会调用实例的setApplicationContext()方法给实例的applicationContext属性设置值。
            public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
                this.applicationContext = applicationContext;
        
            }
        }

      • 从 spring 2.5 之后可以用使用 @Autowired 注解自动注入 Application 对象了。
    •  2、比如实现 BeanFactoryAware 接口的 bean，在 bean 被初始化后，将会被注入 BeanFactory 实例

      • public interface BeanFactoryAware extends Aware {
        
        	/**
        	 * Callback that supplies the owning factory to a bean instance.
        	 * <p>Invoked after the population of normal bean properties
        	 * but before an initialization callback such as
        	 * {@link InitializingBean#afterPropertiesSet()} or a custom init-method.
        	 * @param beanFactory owning BeanFactory (never {@code null}).
        	 * The bean can immediately call methods on the factory.
        	 * @throws BeansException in case of initialization errors
        	 * @see BeanInitializationException
        	 */
        	void setBeanFactory(BeanFactory beanFactory) throws BeansException;
        
        }