亚洲视频二区_亚洲欧洲日本天天堂在线观看_日韩一区二区在线观看_中文字幕不卡一区

Spring 有一個特點，就是創建出來的 Bean 對容器是無感的，一個 Bean 是怎么樣被容器從一個 Class 整成一個 Bean 的，對于 Bean 本身來說是不知道的，當然也不需要知道，也就是 Bean 對容器的存在是無感的。

但是有時候我們可能會遇到一些場景，這些場景讓我們去感知容器的存在，松哥舉幾個例子：

1. Spring 容器提供的功能不止 IoC、AOP 這些，常見的 I18N 也是 Spring 的能力之一，如果我們想要在自己的 Bean 中去使用 I18N，那就得去找 Spring，這樣就感知到了 Spring 容器的存在了。
2. Spring 提供了資源加載器，如果我們想要使用這個資源加載器去加載配置，那就得去找 Spring 要，這樣就感知到了 Spring 容器的存在了。
3. 想根據 beanName 去 Spring 容器中查找 Bean，那不用多說，肯定得知道 Spring 容器的存在。
4. ...

也就是說，雖然 Spring 中的 Bean 可以不用去感知 Spring 容器的存在，但是在實際開發中，我們往往還是需要 Spring 容器提供的各種能力，這樣就迫使我們的 Bean 不得不去感知到 Spring 容器的存在。

那么 Spring 中的 Bean 如何感知到 Spring 容器的存在呢？

1. Aware

Aware 本身就有感知的意思。

Spring Aware 是 Spring 框架中的一個特性，它允許我們的應用程序或組件與 Spring 容器進行交互。當一個類實現了 Spring Aware 接口并注冊到 Spring 容器中時，該類就能夠感知到 Spring 容器的存在，并且可以獲取容器的一些資源或進行一些特定的操作。

Spring Aware 接口包括了多個子接口，每個子接口對應于不同的 Spring 容器資源或功能。

Aware 的實現有很多，大的方向來說主要有如下一些：

圖片

每一個 Aware 的作用如下：

• ApplicationEventPublisherAware：實現該接口的對象可以獲取事件發布的能力。
• ServletContextAware：實現該接口的對象可以獲取到 ServletContext 對象。
• MessageSourceAware：實現該接口的對象可以獲取到 MessageSource 對象，MessageSource 支持多消息源，主要用于主要用于國際化。
• ResourceLoaderAware：實現該接口的對象可以獲取到一個 ResourceLoader，Spring ResourceLoader 則為我們提供了一個統一的 getResource() 方法來通過資源路徑檢索外部資源，例如文本文件、XML 文件、屬性文件或圖像文件等。
• ApplicationStartupAware：實現該接口的對象可以獲取到一個 ApplicationStartup 對象，這個比較新，是 Spring 5.3 中新推出的，通過 ApplicationStartup 可以標記應用程序啟動期間的步驟，并收集有關執行上下文或其處理時間的數據。
• NotificationPublisherAware：實現該接的對象可以獲取到一個 NotificationPublisher 對象，通過該對象可以實現通知的發送。
• EnvironmentAware：實現該接口的對象可以獲取到一個 Environment 對象，通過 Environment 可以獲取到容器的環境信息。
• BeanFactoryAware：實現該接口的對象可以獲取到一個 BeanFactory 對象，通過 BeanFactory 可以完成 Bean 的查詢等操作。
• ImportAware：實現該接口的對象可以獲取到一個 AnnotationMetadata 對象，ImportAware 接口是需要和 @Import 注解一起使用的。在 @Import 作為元注解使用時，通過 @Import 導入的配置類如果實現了 ImportAware 接口就可以獲取到導入該配置類接口的數據配置。
• EmbeddedValueResolverAware：實現該接口的對象可以獲取到一個 StringValueResolver 對象，通過 StringValueResolver 對象，可以讀取到 Spring 容器中的 properties 配置的值（YAML 配置也可以）。
• ServletConfigAware：實現該接口的對象可以獲取到一個 ServletConfig 對象，不過這個似乎沒什么用，我們很少自己去配置 ServletConfig。
• LoadTimeWeaverAware：實現該接口的對象可以獲取到一個 LoadTimeWeaver 對象，通過該對象可以獲取加載 Spring Bean 時織入的第三方模塊，如 AspectJ 等。
• BeanClassLoaderAware：實現該接口的對象可以獲取到一個 ClassLoader 對象，ClassLoader 能干嘛不需要我多說了吧。
• BeanNameAware：實現該接口的對象可以獲取到一個當前 Bean 的名稱。
• ApplicationContextAware：實現該接口的對象可以獲取到一個 ApplicationContext 對象，通過 ApplicationContext 可以獲取容器中的 Bean、環境等信息。

通過實現這些接口，我們可以在應用程序中獲取 Spring 容器提供的各種資源，并與容器進行交互，以實現更靈活和可擴展的功能。

2. 實踐

舉兩個例子小伙伴們來感受下 Aware 的具體用法。

2.1 案例

例如我想在 Bean 中感知到當前 Bean 的名字，那么我們可以按照如下方式來使用：

@Service
public class UserService implements BeanNameAware {
    private String beanName;
    @Override
    public void setBeanName(String name) {
        this.beanName = name;
    }

    @Override
    public String toString() {
        return "UserService{" +
                "beanName='" + beanName + ''' +
                '}';
    }
}

讓當前 bean 實現 BeanNameAware 接口，并重寫 setBeanName 方法，這個方法會在 Spring 容器初始化 Bean 的時候自動被調用，我們就可以據此獲取到 bean 的名稱了。

再比如我想做一個工具 Bean，用來查找其他 Bean，那么我可以使用如下方式：

@Component
public class BeanUtils implements BeanFactoryAware {
    private static BeanFactory beanFactory;
    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        this.beanFactory = beanFactory;
    }

    public static  <T> T getBean(Class<T> clazz) {
        return (T) beanFactory.getBean(clazz);
    }
}

讓當前 Bean 實現 BeanFactoryAware 接口并重寫 setBeanFactory 方法，在系統初始化當前 Bean 的時候，會自動調用 setBeanFactory 方法，進而將 beanFactory 變量傳進來。

2.2 原理

當 Spring 容器創建一個 Bean 的時候，大致的流程是創建實例對象 -> 屬性填充 -> Bean 初始化。

最后這個 Bean 的初始化，就是調用 init 方法、afterPropertiesSet 方法以及 BeanPostProcessor 中的方法的，如下：

protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
 invokeAwareMethods(beanName, bean);
 Object wrappedBean = bean;
 if (mbd == null || !mbd.isSynthetic()) {
  wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
 }
 try {
  invokeInitMethods(beanName, wrappedBean, mbd);
 }
 catch (Throwable ex) {
  throw new BeanCreationException(
    (mbd != null ? mbd.getResourceDescription() : null), beanName, ex.getMessage(), ex);
 }
 if (mbd == null || !mbd.isSynthetic()) {
  wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
 }
 return wrappedBean;
}

在這個方法一進來，首先有一個 invokeAwareMethods，這個就是用來觸發 Aware 的，來看下：

private void invokeAwareMethods(String beanName, Object bean) {
 if (bean instanceof Aware) {
  if (bean instanceof BeanNameAware beanNameAware) {
   beanNameAware.setBeanName(beanName);
  }
  if (bean instanceof BeanClassLoaderAware beanClassLoaderAware) {
   ClassLoader bcl = getBeanClassLoader();
   if (bcl != null) {
    beanClassLoaderAware.setBeanClassLoader(bcl);
   }
  }
  if (bean instanceof BeanFactoryAware beanFactoryAware) {
   beanFactoryAware.setBeanFactory(AbstractAutowireCapableBeanFactory.this);
  }
 }
}

小伙伴們可以看到，BeanNameAware、BeanClassLoaderAware 以及 BeanFactoryAware 這三種類型的 Aware 是在這里觸發的。

每種 Aware 因為功能不同，因此作用的時機也不同。

invokeAwareMethods 方法執行完畢之后，接下來是執行 applyBeanPostProcessorsBeforeInitialization 方法，這個我們之前分析過，這個方法最終會觸發 BeanPostProcessor#postProcessBeforeInitialization 方法的執行，而 BeanPostProcessor 有一個子類專門處理 Aware 的，就是 ApplicationContextAwareProcessor：

@Override
@Nullable
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
 if (!(bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware ||
   bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware ||
   bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware ||
   bean instanceof ApplicationStartupAware)) {
  return bean;
 }
 invokeAwareInterfaces(bean);
 return bean;
}
private void invokeAwareInterfaces(Object bean) {
 if (bean instanceof Aware) {
  if (bean instanceof EnvironmentAware environmentAware) {
   environmentAware.setEnvironment(this.applicationContext.getEnvironment());
  }
  if (bean instanceof EmbeddedValueResolverAware embeddedValueResolverAware) {
   embeddedValueResolverAware.setEmbeddedValueResolver(this.embeddedValueResolver);
  }
  if (bean instanceof ResourceLoaderAware resourceLoaderAware) {
   resourceLoaderAware.setResourceLoader(this.applicationContext);
  }
  if (bean instanceof ApplicationEventPublisherAware applicationEventPublisherAware) {
   applicationEventPublisherAware.setApplicationEventPublisher(this.applicationContext);
  }
  if (bean instanceof MessageSourceAware messageSourceAware) {
   messageSourceAware.setMessageSource(this.applicationContext);
  }
  if (bean instanceof ApplicationStartupAware applicationStartupAware) {
   applicationStartupAware.setApplicationStartup(this.applicationContext.getApplicationStartup());
  }
  if (bean instanceof ApplicationContextAware applicationContextAware) {
   applicationContextAware.setApplicationContext(this.applicationContext);
  }
 }
}

大家看下，這七種類型的 Aware 是在這里被觸發的。

另外像 ImportAware 是在 ImportAwareBeanPostProcessor#postProcessBeforeInitialization 方法中處理的；LoadTimeWeaverAware 是在 、LoadTimeWeaverAwareProcessor#postProcessBeforeInitialization 方法中處理的。

基本上，大部分的 Aware 接口都是在 BeanPostProcessor 中處理的。