淺析Spring獲取Bean的九種方法詳解

2023-01-20 14:02:05

前言
Spring的IoC容器
BeanFactory與ApplicationContext的區別
通過BeanFactory獲取
通過BeanFactoryAware獲取
啟動獲取ApplicationContext
通過繼承ApplicationObjectSupport
通過繼承WebApplicationObjectSupport
通過WebApplicationContextUtils
通過ApplicationContextAware
通過ContextLoader
通過BeanFactoryPostProcessor
小結

前言

隨著SpringBoot的普及，Spring的使用也越來越廣，在某些場景下，我們無法通過註解或設定的形式直接獲取到某個Bean。比如，在某一些工具類、設計模式實現中需要使用到Spring容器管理的Bean，此時就需要直接獲取到對應的Bean。

本文為大家整理彙總了常見的獲取Bean的方式，並提供一些優劣分析，方便大家在使用到時有更好的選擇。同時，也會為大家適當的普及和拓展一些相關知識。

Spring的IoC容器

在Spring中，Bean的範例化、定位、設定應用程式中的物件及建立物件間的依賴關係，都是在IoC容器中進行的。因此，要在Spring中獲取Bean，本質上就是從IoC容器當中獲取Bean。

在Spring中，BeanFactory是IoC容器的實際代表者，該介面提供了IoC容器最基本功能。同時，Spring還提供了另外一種型別的容器：ApplicationContext容器。

ApplicationContext容器包括BeanFactory容器的所有功能（BeanFactory的子介面），提供了更多面嚮應用的功能，它提供了國際化支援和框架事件體系，更易於建立實際應用。

一般情況，我們稱BeanFactory為IoC容器，稱ApplicationContext為應用上下文。但有時為了方便，也將ApplicationContext稱為Spring容器。

通常不建議使用BeanFactory，但BeanFactory 仍然可以用於輕量級的應用程式，如移動裝置或基於applet的應用程式，其中它的資料量和速度是顯著。

BeanFactory與ApplicationContext的區別

BeanFactory是Spring框架的基礎設施，面向Spring本身。ApplicationContext則面向使用Spring框架的開發者，幾乎所有的應用場合都可以直接使用ApplicationContext，而非底層的BeanFactory。

另外，ApplicationContext的初始化和BeanFactory有一個重大的區別：

BeanFactory在初始化容器時，並未範例化Bean，直到第一次存取某個Bean時才範例目標Bean。這樣，我們就不能發現一些存在的Spring的設定問題。如果Bean的某一個屬性沒有注入，BeanFacotry載入後，直至第一次使用呼叫getBean方法才會丟擲異常。

而ApplicationContext則在初始化應用上下文時就範例化所有單範例的Bean，相對應的，ApplicationContext的初始化時間會比BeanFactory長一些。

瞭解了上述的基本理論知識之後，我們就可以嘗試從IoC容器當中獲取Bean物件了。

通過BeanFactory獲取

通過BeanFactory來獲取Bean。基於xml組態檔的時代，可以通過如下方式獲得BeanFactory，再通過BeanFactory來獲得對應的Bean。

BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));
UserInfo userInfo = (UserInfo) beanFactory.getBean("userInfo");

有一定程式設計年齡的程式設計師，應該對此還有一些印象。這種寫法估計也只會出現在古老的專案當中。鑑於xml形式組態檔已經被基於註解形式所替代，同時XmlBeanFactory也被標註為廢棄。此種方式不推薦使用。

其實，不推薦的理由還有一個，在上面已經提到，儘量不要使用BeanFactory，而應該使用ApplicationContext。

通過BeanFactoryAware獲取

在上面的方式中，XmlBeanFactory已經被廢棄，但可以通過其他方式來獲得BeanFactory，然後再從BeanFactory中獲得指定的Bean。獲取BeanFactory範例最簡單的方式就是實現BeanFactoryAware介面。

BeanFactoryAware介面原始碼：

public interface BeanFactoryAware extends Aware {
  /**
   * 初始化回撥方法，Spring會自動將BeanFactory注入進去，接收之後即可使用BeanFactory
   */
  void setBeanFactory(BeanFactory beanFactory) throws BeansException;
}

BeanFactoryAware屬於org.springframework.beans.factory.Aware根標記介面，使用setter注入來在應用程式上下文啟動期間獲取物件。Aware介面是回撥，監聽器和觀察者設計模式的混合，它表示Bean有資格通過回撥方式被Spring容器通知。

這裡提供一個完整的工具類：

@Component
public class BeanFactoryHelper implements BeanFactoryAware {
  private static BeanFactory beanFactory;
  /**
   * 重寫 BeanFactoryAware 介面的方法
   * @param beanFactory ：引數賦值給本地屬性之後即可使用 BeanFactory
   * @throws BeansException BeansException
   */
  @Override
  public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
    BeanFactoryHelper.beanFactory = beanFactory;
  }
  /**
   * 根據名稱獲取容器中的物件範例
   * @param beanName ：注入的範例必須已經存在容器中，否則拋異常：NoSuchBeanDefinitionException
   * @return Object
   */
  public static Object getBean(String beanName) {
    return beanFactory.getBean(beanName);
  }
  /**
   * 根據 class 獲取容器中的物件範例
   * @param requiredType ：被注入的必須已經存在容器中，否則拋異常：NoSuchBeanDefinitionException
   * @param <T> Class
   * @return 物件
   */
  public static <T> T getBean(Class<T> requiredType) {
    return beanFactory.getBean(requiredType);
  }
  /**
   * 判斷 spring 容器中是否包含指定名稱的物件
   * @param beanName bean名稱
   * @return 是否存在
   */
  public static boolean containsBean(String beanName) {
    return beanFactory.containsBean(beanName);
  }
  //其它需求皆可參考 BeanFactory 介面和它的實現類
}

在上述工具類中，便是基於BeanFactoryAware的特性，獲得了BeanFactory，然後再通過BeanFactory來獲得指定的Bean。

該方案滿足了獲取Bean的基本需求，但同時具有使用BeanFactory的缺點。根據前文介紹的BeanFactory特性，可酌情使用。

上面提供了兩種基於BeanFactory容器獲得Bean的方式，下面則通過ApplicationContext來獲取容器中的Bean，不同的是獲取ApplicationContext的方式的區別。

啟動獲取ApplicationContext

在專案啟動時先獲取ApplicationContext物件，然後將其儲存在一個地方，以便後續用到時進行使用。

這裡提供兩種場景的獲取：

基於xml設定bean的形式，適用於比較古老的專案，已經很少使用了；

基於SpringBoot啟動時獲取ApplicationContext物件；

基於xml的形式實現：

// 其中applicationContext.xml 為設定容器的xml，不過現在一般很少使用了
ApplicationContext ac = new FileSystemXmlApplicationContext("applicationContext.xml");

這裡等於直接初始化容器，並且獲得容器的參照。這種方式適用於採用Spring框架的獨立應用程式，需要程式通過組態檔手工初始化Spring的情況。目前大多數Spring專案已經不再採用xml設定，很少使用了。

基於SpringBoot啟動實現：

@SpringBootApplication
public class ExampleApplication {
    public static void main(String[] args) {
        // 啟動時，儲存上下文，並儲存為靜態
        ConfigurableApplicationContext ac = SpringApplication.run(ExampleApplication.class, args);
        SpringContextUtil.setAc(ac);
    }
}

對應的SpringContextUtil類如下：

public class SpringContextUtil1 {
    private static ApplicationContext ac;
    public static <T>  T getBean(String beanName, Class<T> clazz) {
        T bean = ac.getBean(beanName, clazz);
        return bean;
    }
    public static void setAc(ApplicationContext applicationContext){
        ac = applicationContext;
    }
}

兩種方式都是在啟動Spring專案時，直接獲取到ApplicationContext的參照，然後將其儲存到工具類當中。在使用時，則從工具類中獲取ApplicationContext容器，進而從中獲得Bean物件。

通過繼承ApplicationObjectSupport

此種方式依舊是先獲得ApplicationContext容器，然後從中獲取Bean物件，只不過是基於繼承ApplicationObjectSupport類實現的。

具體實現程式碼：

@Component
public class SpringContextUtil extends ApplicationObjectSupport {
  public <T> T getBean(Class<T> clazz) {
    ApplicationContext ac = getApplicationContext();
    if(ac == null){
      return null;
    }
    return ac.getBean(clazz);
  }
}

注意，這裡的SpringContextUtil類需要範例化。

通過繼承WebApplicationObjectSupport

WebApplicationObjectSupport是ApplicationObjectSupport的一個實現類，提供了Web相關的支援。實現原理與ApplicationObjectSupport一樣。

具體實現程式碼如下：

@Component
public class SpringContextUtil extends WebApplicationObjectSupport {
  public <T> T getBean(Class<T> clazz) {
    ApplicationContext ac = getApplicationContext();
    if(ac == null){
      return null;
    }
    return ac.getBean(clazz);
  }
}

對照基於ApplicationObjectSupport的實現，除了繼承物件不同外，沒有其他區別，都是基於getApplicationContext方法來獲取。

通過WebApplicationContextUtils

Spring提供了工具類WebApplicationContextUtils，通過該類可獲取WebApplicationContext物件。

具體實現程式碼如下：

public class SpringContextUtil2 {
  public static <T> T getBean(ServletContext request, String name, Class<T> clazz){
    WebApplicationContext webApplicationContext = WebApplicationContextUtils.getRequiredWebApplicationContext(request);
    // 或者
    WebApplicationContext webApplicationContext1 = WebApplicationContextUtils.getWebApplicationContext(request);
//        webApplicationContext1.getBean(name, clazz)
    T bean = webApplicationContext.getBean(name, clazz);
    return bean;
  }
}

這個方法很常見於SpringMVC構建的Web專案中，適用於Web專案的B/S結構。

通過ApplicationContextAware

通過實現ApplicationContextAware介面，在Spring容器啟動時將ApplicationContext注入進去，從而獲取ApplicationContext物件，這種方法也是常見的獲取Bean的一種方式，推薦使用。

具體實現程式碼如下：

@Component
public class SpringContextUtil3 implements ApplicationContextAware {
  private static ApplicationContext ac;
  @Override
  public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
    ac = applicationContext;
  }
  public static <T> T getBean(Class<T> clazz) {
    T bean = ac.getBean(clazz);
    return bean;
  }
}

這種方式與前面通過BeanFactoryAware獲得BeanFactory的思路一致。

通過ContextLoader

使用ContextLoader提供的getCurrentWebApplicationContext方法，也是常用的獲取WebApplicationContext的一種方法。

具體實現程式碼如下：

WebApplicationContext wac = ContextLoader.getCurrentWebApplicationContext();
wac.getBean(beanID);

該方法常見於SpringMVC實現的Web專案中。該方式是一種不依賴於Servlet，不需要注入的方式。但是需要注意一點，在伺服器啟動時和Spring容器初始化時，不能通過該方法獲取Spring容器。

通過BeanFactoryPostProcessor

Spring工具類，方便在非Spring管理環境中獲取Bean。

@Component
public final class SpringUtils implements BeanFactoryPostProcessor{
    /** Spring應用上下文環境 */
    private static ConfigurableListableBeanFactory beanFactory;
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException{
        SpringUtilsS.beanFactory = beanFactory;
    }
    /**
     * 獲取物件
     *
     * @param name
     * @return Object 一個以所給名字註冊的bean的範例
     * @throws BeansException
     *
     */
    @SuppressWarnings("unchecked")
    public static <T> T getBean(String name) throws BeansException{
        return (T) beanFactory.getBean(name);
    }
    /**
     * 獲取型別為requiredType的物件
     *
     * @param clz
     * @return
     * @throws BeansException
     *
     */
    public static <T> T getBean(Class<T> clz) throws BeansException{
        T result = (T) beanFactory.getBean(clz);
        return result;
    }
    /**
     * 如果BeanFactory包含一個與所給名稱匹配的bean定義，則返回true
     *
     * @param name
     * @return boolean
     */
    public static boolean containsBean(String name){
        return beanFactory.containsBean(name);
    }
    /**
     * 判斷以給定名字註冊的bean定義是一個singleton還是一個prototype。 如果與給定名字相應的bean定義沒有被找到，將會丟擲一個異常（NoSuchBeanDefinitionException）
     *
     * @param name
     * @return boolean
     * @throws NoSuchBeanDefinitionException
     *
     */
    public static boolean isSingleton(String name) throws NoSuchBeanDefinitionException{
        return beanFactory.isSingleton(name);
    }
    /**
     * @param name
     * @return Class 註冊物件的型別
     * @throws NoSuchBeanDefinitionException
     *
     */
    public static Class<?> getType(String name) throws NoSuchBeanDefinitionException{
        return beanFactory.getType(name);
    }
    /**
     * 如果給定的bean名字在bean定義中有別名，則返回這些別名
     *
     * @param name
     * @return
     * @throws NoSuchBeanDefinitionException
     *
     */
    public static String[] getAliases(String name) throws NoSuchBeanDefinitionException{
        return beanFactory.getAliases(name);
    }
    /**
     * 獲取aop代理物件
     * 
     * @param invoker
     * @return
     */
    @SuppressWarnings("unchecked")
    public static <T> T getAopProxy(T invoker){
        return (T) AopContext.currentProxy();
    }
}

其中ConfigurableListableBeanFactory介面，也屬於BeanFactory的子介面。