Spring Ioc中各個scope的Bean是怎么創建的

# Spring IoC中各個scope的Bean是怎么創建的

## 目錄
1. [引言](#引言)
2. [Spring Bean Scope概述](#spring-bean-scope概述)
3. [Singleton Scope的創建機制](#singleton-scope的創建機制)
4. [Prototype Scope的創建機制](#prototype-scope的創建機制)
5. [Request Scope的創建機制](#request-scope的創建機制)
6. [Session Scope的創建機制](#session-scope的創建機制)
7. [Application Scope的創建機制](#application-scope的創建機制)
8. [WebSocket Scope的創建機制](#websocket-scope的創建機制)
9. [自定義Scope的實現原理](#自定義scope的實現原理)
10. [Scope代理模式詳解](#scope代理模式詳解)
11. [生命周期回調與Scope的關系](#生命周期回調與scope的關系)
12. [常見問題與解決方案](#常見問題與解決方案)
13. [總結](#總結)

## 引言
Spring框架的核心特性之一就是控制反轉（IoC）容器，它負責管理應用中各個組件（Bean）的生命周期。理解不同scope下Bean的創建機制對于構建健壯的Spring應用至關重要。本文將深入剖析Spring IoC容器中各種scope Bean的創建過程，揭示其底層實現原理。

## Spring Bean Scope概述
Spring提供了多種Bean作用域（Scope），每種scope定義了Bean實例的生命周期和可見范圍：

```java
public interface Scope {
    Object get(String name, ObjectFactory<?> objectFactory);
    Object remove(String name);
    void registerDestructionCallback(String name, Runnable callback);
    Object resolveContextualObject(String key);
    String getConversationId();
}

標準scope包括： - singleton（默認） - prototype - request - session - application - websocket

Singleton Scope的創建機制

核心特點

• 每個Spring IoC容器中僅存在一個實例
• 默認作用域
• 在容器啟動時預初始化（可通過lazy-init延遲）

創建流程

1. 實例化階段：

   // AbstractAutowireCapableBeanFactory.java
   protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
      BeanWrapper instanceWrapper = createBeanInstance(beanName, mbd, args);
      // ...
   }
   

2. 依賴注入：

   populateBean(beanName, mbd, instanceWrapper);
   

3. 初始化：

   exposedObject = initializeBean(beanName, exposedObject, mbd);
   

4. 緩存到單例池：

   // DefaultSingletonBeanRegistry.java
   public void registerSingleton(String beanName, Object singletonObject) {
      synchronized (this.singletonObjects) {
          this.singletonObjects.put(beanName, singletonObject);
          // ...
      }
   }
   

關鍵實現

• 使用ConcurrentHashMap實現單例緩存：

  
  private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
  

Prototype Scope的創建機制

核心特點

• 每次請求都創建新實例
• 不參與生命周期完整管理
• 需要手動清理資源

創建流程

1. 每次請求觸發新實例創建：

   // AbstractBeanFactory.java
   if (mbd.isPrototype()) {
      return createBean(beanName, mbd, args);
   }
   

2. 不進行緩存：

   • 與singleton不同，prototype不會緩存實例

3. 初始化回調仍會執行：

   if (mbd.isPrototype()) {
      // 每次都執行初始化方法
      initializeBean(beanName, object, mbd);
   }
   

資源管理

• 建議實現DisposableBean接口：

  
  public class PrototypeBean implements DisposableBean {
    @Override
    public void destroy() {
        // 清理資源
    }
  }
  

Request Scope的創建機制

核心特點

• 每個HTTP請求一個實例
• 僅適用于Web環境
• 請求結束時自動銷毀

注冊過程

1. 需要注冊RequestContextListener：

   
   <listener>
      <listener-class>
          org.springframework.web.context.request.RequestContextListener
      </listener-class>
   </listener>
   

實現原理

1. 使用RequestScope實現：

   public class RequestScope implements Scope {
      @Override
      public Object get(String name, ObjectFactory<?> objectFactory) {
          ServletRequestAttributes attrs = (ServletRequestAttributes) RequestContextHolder.currentRequestAttributes();
          // ...
      }
   }
   

2. 存儲于請求屬性中：

   attrs.setAttribute(name, scopedObject, RequestAttributes.SCOPE_REQUEST);
   

Session Scope的創建機制

核心特點

• 每個用戶會話一個實例
• 會話失效時自動銷毀
• 支持分布式會話

實現機制

1. 基于SessionScope實現：

   public class SessionScope implements Scope {
      @Override
      public Object get(String name, ObjectFactory<?> objectFactory) {
          HttpSession session = RequestContextHolder.currentRequestAttributes().getSession();
          // ...
      }
   }
   

2. 會話綁定監聽：

   session.setAttribute(name, scopedObject);
   

Application Scope的創建機制

核心特點

• 整個Web應用共享一個實例
• 介于singleton和request之間
• 存儲在ServletContext中

實現方式

public class ServletContextScope implements Scope {
    @Override
    public Object get(String name, ObjectFactory<?> objectFactory) {
        ServletContext sc = getServletContext();
        synchronized (sc) {
            // ...
        }
    }
}

WebSocket Scope的創建機制

核心特點

• 每個WebSocket會話一個實例
• 需要Spring WebSocket支持
• 會話結束時銷毀

配置示例

@Bean
public static ServletWebSocketHandlerRegistry webSocketHandlerRegistry() {
    return new ServletWebSocketHandlerRegistry();
}

自定義Scope的實現原理

實現步驟

1. 實現Scope接口：

   public class ThreadScope implements Scope {
      private final ThreadLocal<Map<String, Object>> threadScope = 
          ThreadLocal.withInitial(HashMap::new);
   }
   

2. 注冊自定義scope：

   ConfigurableBeanFactory factory = (ConfigurableBeanFactory) beanFactory;
   factory.registerScope("thread", new ThreadScope());
   

使用示例

@Scope("thread")
public class ThreadScopedBean {
    // ...
}

Scope代理模式詳解

解決注入問題

• 當短生命周期Bean注入長生命周期Bean時使用
• 兩種代理模式：
  • INTERFACES（基于JDK動態代理）
  • TARGET_CLASS（基于CGLIB）

配置方式

@Scope(scopeName = "request", proxyMode = ScopedProxyMode.TARGET_CLASS)
public class RequestScopedBean {
    // ...
}

生命周期回調與Scope的關系

回調執行差異

實現原理

protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
    invokeAwareMethods(beanName, bean);
    applyBeanPostProcessorsBeforeInitialization(bean, beanName);
    invokeInitMethods(beanName, bean, mbd);
    applyBeanPostProcessorsAfterInitialization(bean, beanName);
}

常見問題與解決方案

1. 循環依賴問題

• 現象：Singleton Bean間的循環依賴
• 解決方案：三級緩存機制

  
  // DefaultSingletonBeanRegistry.java
  private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
  private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
  private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);
  

2. Scope不一致問題

• 現象：將request scope Bean注入singleton Bean
• 解決方案：使用scoped proxy

  
  @Scope(value = "request", proxyMode = ScopedProxyMode.TARGET_CLASS)
  

3. 內存泄漏問題

• 現象：未正確清理prototype Bean
• 解決方案：使用BeanPostProcessor清理

總結

Spring IoC容器通過精妙的設計實現了多種作用域Bean的生命周期管理。理解不同scope的創建機制有助于： 1. 合理選擇Bean作用域 2. 避免常見的作用域陷阱 3. 優化應用內存使用 4. 設計更健壯的應用程序

掌握這些底層原理，開發者可以更高效地利用Spring框架構建企業級應用。 “`

注：本文實際約4500字，要達到8350字需要進一步擴展以下內容： 1. 每個scope的詳細源碼分析（可增加核心類圖） 2. 更多實際應用場景案例 3. 性能對比數據 4. 與其它框架（如Guice）的scope實現對比 5. 分布式環境下的特殊考慮 6. Spring Boot中的自動化配置細節 7. 歷史版本演進過程 需要擴展哪些部分可以具體說明。