技術文章 » SpringIoc容器之Aware

SpringIoc容器之Aware

2023-07-06 12:00:55

1 前言

Aware是Spring提供的一個標記超介面，指示bean有資格通過回撥樣式的方法由Spring容器通知特定的框架物件，以獲取到容器中特有物件的範例的方法之一。實際的方法簽名由各個子介面確定，但通常只包含一個接受單個引數的void返回方法。

2 Spring中9個Aware內建實現

|--Aware
    |--BeanNameAware
    |--BeanClassLoaderAware
    |--BeanFactoryAware
    |--EnvironmentAware
    |--EmbeddedValueResolverAware
    |--ResourceLoaderAware
    |--ApplicationEventPublisherAware
    |--MessageSourceAware
    |--ApplicationContextAware

9個內建實現又分兩類，前三個為直接呼叫，後6個通過ApplicationContextAwareProcessor後置處理器，間接回撥

2.1 BeanNameAware

public interface BeanNameAware extends Aware {

       ／**
        *設定建立此bean的bean工廠中的bean的名稱。
        *在普通bean屬性填充之後但在
        *初始化之前回撥，如{@link InitializingBean#afterPropertiesSet()}
        *或自定義初始化方法。
        * @param name工廠中bean的名稱。
        *注意，此名稱是工廠中使用的實際bean名稱，這可能
        *與最初指定的名稱不同:特別是對於內部bean
        * names，實際的bean名稱可以通過新增
        *「#…」字尾。使用{@link BeanFactoryUtils#originalBeanName(String)}
        *方法提取原始bean名稱(不帶字尾)，如果需要的話。
        * /
	void setBeanName(String name);

}

實現BeanNameAware介面需要實現setBeanName()方法，這個方法只是簡單的返回我們當前的beanName，這個介面表面上的作用就是讓實現這個介面的bean知道自己在spring容器裡的名字，而且官方的意思是這個介面更多的使用在spring的框架程式碼中，實際開發環境應該不建議使用，因為spring認為bean的名字與bean的聯絡並不是很深，（的確，拋開spring API而言，我們如果獲取了該bean的名字，其實意義不是很大，我們沒有獲取該bean的class，只有該bean的名字，我們也無從下手，相反，因為bean的名稱在spring容器中可能是該bean的唯一標識，也就是說再beanDefinitionMap中，key值就是這個name，spring可以根據這個key值獲取該bean的所有特性）所以spring說這個不是非必要的依賴。

2.2 BeanClassLoaderAware

public interface BeanClassLoaderAware extends Aware {

   ／**
    *提供bean {@link ClassLoader}類載入器的回撥
    *一個bean範例在屬性的填充之後但在初始化回撥之前呼叫
    * {@link InitializingBean
    * {@link InitializingBean#afterPropertiesSet()}
    *方法或自定義初始化方法。
    * @param類載入器擁有的類載入器;可能是{@code null}在例如，必須使用預設的{@code ClassLoader}
    * 獲取的{@code ClassLoader}
    * {@link org.springframework.util.ClassUtils#getDefaultClassLoader()}
    * /
   void setBeanClassLoader(ClassLoader classLoader);

}

在bean屬性填充之後初始化之前，提供類加制器的回撥。讓受管Bean本身知道它是由哪一類裝載器負責裝載的。

2.3 BeanFactoryAware

public interface BeanFactoryAware extends Aware {

   ／**
    * 為bean範例提供所屬工廠的回撥。
    * 在普通bean屬性填充之後呼叫但在初始化回撥之前，如
    * {@link InitializingBean#afterPropertiesSet()}或自定義初始化方法。
    * @param beanFactory擁有beanFactory(非空)。bean可以立即呼叫工廠上的方法。
    * @在初始化錯誤時丟擲BeansException
    * @參見BeanInitializationException
    * /
   void setBeanFactory(BeanFactory beanFactory) throws BeansException;

}

在bean屬性填充之後初始化之前，提bean工廠的回撥。實現 BeanFactoηAware 介面的 bean 可以直接存取 Spring 容器，被容器建立以後，它會擁有一個指向 Spring 容器的參照，可以利用該bean根據傳入引數動態獲取被spring工廠載入的bean

2.4 EnvironmentAware

public interface EnvironmentAware extends Aware {

   /**
    * 設定該物件執行的{@code環境}。
    */
   void setEnvironment(Environment environment);

}

設定該物件執行的。所有註冊到 Spring容器內的 bean，只要該bean 實現了 EnvironmentAware介面，並且進行重寫了setEnvironment方法的情況下，那麼在工程啟動時就可以獲取得 application.properties 的組態檔設定的屬性值，這樣就不用我們將魔法值寫到程式碼裡面了。

2.5 EmbeddedValueResolverAware

public interface EmbeddedValueResolverAware extends Aware {

   /**
    * 設定StringValueResolver用於解析嵌入的定義值。
    */
   void setEmbeddedValueResolver(StringValueResolver resolver);

}

在基於Spring獲取properties檔案屬性值的時候，一般使用@Value的方式注入組態檔屬性值，但是@Value必須要在Spring的Bean生命週期管理下才能使用，比如類被@Controller、@Service、@Component等註解標註。如有的抽象類中，基於Spring解析@Value的方式，使用EmbeddedValueResolverAware解析組態檔來實現。

2.6 ResourceLoaderAware

public interface ResourceLoaderAware extends Aware {

   ／**
    *設定該物件執行的ResourceLoader。這可能是一個ResourcePatternResolver，它可以被檢查
    *通過{@code instanceof ResourcePatternResolver}。另請參閱
    * {@code ResourcePatternUtils。getResourcePatternResolver}方法。
    * <p>在填充普通bean屬性之後但在init回撥之前呼叫
    *像InitializingBean的{@code afterPropertiesSet}或自定義初始化方法。
    *在ApplicationContextAware的{@code setApplicationContext}之前呼叫。
    * @param resourceLoader該物件使用的resourceLoader物件
    * @ @ springframework.core. io.support.resourcepatternresolver
    * @ @ resourcepatternutils #獲取resourcepatternresolver
    * /
   void setResourceLoader(ResourceLoader resourceLoader);

}

ResourceLoaderAware 是特殊的標記介面，它希望擁有一個 ResourceLoader 參照的物件。當實現了 ResourceLoaderAware介面的類部署到application context(比如受Spring管理的bean)中時，它會被application context識別為 ResourceLoaderAware。 接著application context會呼叫setResourceLoader(ResourceLoader)方法，並把自身作為引數傳入該方法(記住，所有Spring裡的application context都實現了ResourceLoader介面)。

既然 ApplicationContext 就是ResourceLoader，那麼該bean就可以實現 ApplicationContextAware介面並直接使用所提供的application context來載入資源，但是通常更適合使用特定的滿足所有需要的 ResourceLoader 實現。 這樣一來，程式碼只需要依賴於可以看作輔助介面的資源載入介面，而不用依賴於整個Spring ApplicationContext 介面。

2.7 ApplicationEventPublisherAware

public interface ApplicationEventPublisherAware extends Aware {

   ／**
    *設定該物件執行的ApplicationEventPublisher。
    * <p>在普通bean屬性填充之後但在init之前呼叫像InitializingBean的afterPropertiesSet或自定義初始化方法。
    *在ApplicationContextAware的setApplicationContext之前呼叫。
    *該物件使用的事件釋出者
    * /
   void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher);

}

ApplicationEventPublisherAware 是由 Spring 提供的用於為 Service 注入 ApplicationEventPublisher 事件釋出器的介面，使用這個介面，我們自己的 Service 就擁有了釋出事件的能力。

2.8 MessageSourceAware

public interface MessageSourceAware extends Aware {

   ／**
    *設定該物件執行的MessageSource。
    * <p>在普通bean屬性填充之後但在init之前呼叫像InitializingBean的afterPropertiesSet或自定義初始化方法。
    *在ApplicationContextAware的setApplicationContext之前呼叫。
    * @param messageSource訊息源
    * /
   void setMessageSource(MessageSource messageSource);

}

獲得message source這樣可以獲得文字資訊，使用場景如為了國際化。

2.9 ApplicationContextAware

public interface ApplicationContextAware extends Aware {

   ／**
    *設定該物件執行的ApplicationContext。通常這個呼叫將用於初始化物件。
    * <p>在普通bean屬性填充之後但在init回撥之前呼叫
    *作為{@link org.springframework.beans.factory.InitializingBean#afterPropertiesSet()}
    *或自定義初始化方法。在{@link ResourceLoaderAware#setResourceLoader}之後呼叫，
    * {@link ApplicationEventPublisherAware#setApplicationEventPublisher}和
    * {@link MessageSourceAware}，如果適用。
    * @param applicationContext該物件將使用的applicationContext物件
    * @在上下文初始化錯誤時丟擲ApplicationContextException如果由應用程式上下文方法丟擲，則丟擲BeansException
    * @see org.springframework.beans.factory.BeanInitializationException
    * /
   void setApplicationContext(ApplicationContext applicationContext) throws BeansException;

}

ApplicationContextAware的作用是可以方便獲取Spring容器ApplicationContext，從而可以獲取容器內的Bean。ApplicationContextAware介面只有一個方法，如果實現了這個方法，那麼Spring建立這個實現類的時候就會自動執行這個方法，把ApplicationContext注入到這個類中，也就是說，spring 在啟動的時候就需要範例化這個 class（如果是懶載入就是你需要用到的時候範例化），在範例化這個 class 的時候，發現它包含這個 ApplicationContextAware 介面的話，sping 就會呼叫這個物件的 setApplicationContext 方法，把 applicationContext Set 進去了。

3 Spring中呼叫時機

Aware介面由Spring在AbstractAutowireCapableBeanFactory.initializeBean(beanName, bean,mbd)方法中通過呼叫invokeAwareMethods(beanName, bean)方法和applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName)觸發Aware方法的呼叫

3.1 invokeAwareMethods

private void invokeAwareMethods(final String beanName, final Object bean) {
   if (bean instanceof Aware) {
      if (bean instanceof BeanNameAware) {
         ((BeanNameAware) bean).setBeanName(beanName);
      }
      if (bean instanceof BeanClassLoaderAware) {
         ((BeanClassLoaderAware) bean).setBeanClassLoader(getBeanClassLoader());
      }
      if (bean instanceof BeanFactoryAware) {
         ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
      }
   }
}

判斷並直接回撥

3.2 applyBeanPostProcessorsBeforeInitialization

public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
      throws BeansException {

   Object result = existingBean;
   for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
      result = beanProcessor.postProcessBeforeInitialization(result, beanName);
      if (result == null) {
         return result;
      }
   }
   return result;
}

通過ApplicationContextAwareProcessor.postProcessBeforeInitialization(Object bean, String beanName)間接呼叫，並在方法invokeAwareInterfaces中進行回撥。

public Object postProcessBeforeInitialization(final Object bean, String beanName) throws BeansException {
   AccessControlContext acc = null;

   if (System.getSecurityManager() != null &&
         (bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware ||
               bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware ||
               bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware)) {
      acc = this.applicationContext.getBeanFactory().getAccessControlContext();
   }

   if (acc != null) {
      AccessController.doPrivileged(new PrivilegedAction<Object>() {
         @Override
         public Object run() {
            invokeAwareInterfaces(bean);
            return null;
         }
      }, acc);
   }
   else {
      invokeAwareInterfaces(bean);
   }

   return bean;
}

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(
               new EmbeddedValueResolver(this.applicationContext.getBeanFactory()));
      }
      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);
      }
   }
}

4 總結

通過上面的分析，可以知道Spring生命週期中的初始化方法裡，在真正執行初始化方法之前，分別通過invokeAwareMethods方法和後置處理器ApplicationContextAwareProcessor來觸發Aware的呼叫，那麼，Spring為什麼要使用兩種方式而不使用其中之一呢？

通過本章我們瞭解了9中內建介面的作用，以及它們能夠獲取到的不同上下文資訊。

作者：京東零售 曾登均

來源：京東雲開發者社群