SpringBean依賴和三級緩存的案例講解

Posted on by

spring中的bean依賴有大體上可以分為兩類，共3中形式，下面簡單介紹一下。

第一類是構造方法中的循環依賴，這種會報錯

@Service
public class ServiceA { 
  private ServiceB serviceB; 
  public ServiceA(ServiceB serviceB) {
    this.serviceB = serviceB;
  } 
  public void methodA(){
    System.out.println("a");
  }
}
 
@Service
public class ServiceB { 
  private ServiceA serviceA; 
  public ServiceB(ServiceA serviceA) {
    this.serviceA = serviceA;
  } 
  public void methodB(){
    System.out.println("b");
  }
}
 
//錯誤提示
Description: 
The dependencies of some of the beans in the application context form a cycle:
 
┌─────┐
| serviceA defined in file [C:\demo\target\classes\com\example\demo\ServiceA.class]
↑   ↓
| serviceB defined in file [C:\demo\target\classes\com\example\demo\ServiceB.class]
└─────┘

第二類是field循環依賴，它分為兩種，第一類循環依賴的作用域scope默認是singleton，啟動不會報錯

@Service
public class ServiceA { 
  @Autowired
  private ServiceB serviceB;
 
  public void methodA(){
    System.out.println("a");
  }
}
 
@Service
public class ServiceB { 
  @Autowired
  private ServiceA serviceA;
 
  public void methodB(){
    System.out.println("b");
  }
}

第二種作用域scope為prototype，在這種情況下bean是多例的，按理說這種啟動也會報錯，但是它成功瞭。。我也不知道為啥

@Service
@Scope("prototype")
public class ServiceA { 
  @Autowired
  private ServiceB serviceB;
 
  public void methodA(){
    System.out.println("a");
  }
}
 
@Service
@Scope("prototype")
public class ServiceB { 
  @Autowired
  private ServiceA serviceA;
 
  public void methodB(){
    System.out.println("b");
  }
}

據我在網上查找的資料，spring可以幫我們處理bean的scope為singleton的field循環依賴，個人感覺應該也是這樣，下面說一下它的處理過程。

簡單說一下bean的加載過程，當spring啟動的時候，首先加載進beanFactory的是beanDefinition，之後會根據beanDefinition判斷其是否為sington並且為非抽象類非懶加載，那麼之後會去創建bean，

bean的創建分為三步：

1.調用構造方法創建對象實例(這一步完成之後其它對象實例就可以引用它)

2.填充實例內部屬性(會依次從三級緩存中獲取依賴的bean，如果沒有找到，則會先去創建依賴的bean，之後再返回繼續填充屬性)

3.執行initializeBean方法，進行初始化

當bean進行創建時，會先調用getbean方法->執行doGetBean方法，在doGetBean方法中會調用getSingleton方法，這一步就是從三級緩存中獲取對象緩存，因為是剛開始創建bean所以緩存中肯定沒有，之後會調用createBean方法，在createBean方法中會調用doCreateBean執行bean的創建過程就是上面的那三步，當bean創建成功之後會將其放入一級緩存之中，此時會將它從三級和二級緩存中刪除。

public Object getBean(String name) throws BeansException {
    return doGetBean(name, null, null, false);
  }
 
  doGetBean(final String name, @Nullable final Class<T> requiredType, @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
 
    //從緩存中獲取實例
    Object sharedInstance = getSingleton(beanName);
    if (sharedInstance != null && args == null) {
      //省略代碼
    } else {
      //省略代碼
      createBean(beanName, mbd, args);
    }
    //將創建完成的bean放入一級緩存
    addSingleton(beanname，object)
  }
 
  protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
    //省略代碼
    doCreateBean()
  }
 
  protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args) throws BeanCreationException {
    //根據構造方法創建對象實例
    BeanWrapper instanceWrapper = null;
    if (mbd.isSingleton()) {
      instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
    }
    if (instanceWrapper == null) {
      instanceWrapper = createBeanInstance(beanName, mbd, args);
    }
    final Object bean = instanceWrapper.getWrappedInstance();
 
    //將對象實例放入第三級緩存中
    addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
    //實例內部屬性填充
    populateBean(beanName, mbd, instanceWrapper);
 
    //初始化bean
    exposedObject = initializeBean(beanName, exposedObject, mbd);
 
    return exposedObject;
  }
 
  protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
    Object exposedObject = bean;
    if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
      for (BeanPostProcessor bp : getBeanPostProcessors()) {
        if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
          SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
          exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
        }
      }
    }
    return exposedObject;
  }

其中我們可以看到當第一步執行完畢後會將剛剛創建的實例放入singletonFactories(第三級緩存)中，那麼我們下面瞭解下到底什麼是spring的三級緩存。處於最上層的緩存是singletonObjects，它其中存儲的對象是完成創建好，可以正常使用的bean，二級緩存叫做earlySingletonObjects，它其中存儲的bean是僅執行瞭第一步通過構造方法實例化，並沒有填充屬性和初始化，第三級緩存singletonFactories是一個工場。

/** Cache of singleton objects: bean name to bean instance. */
 private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
 
 /** Cache of singleton factories: bean name to ObjectFactory. */
 private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
 
 /** Cache of early singleton objects: bean name to bean instance. */
 private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);

其實在getSingleton方法中會首先從一級緩存中獲取bean，一級緩存中沒有再從二級緩存中獲取，二級也沒有就會從三級中獲取factory當factory不為null時，則會調用getObject方法獲取bean，並將bean放入二級緩存，之後再從三級緩存中刪除該key-value對，代碼如下：

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
 Object singletonObject = this.singletonObjects.get(beanName);
 if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
  synchronized (this.singletonObjects) {
  singletonObject = this.earlySingletonObjects.get(beanName);
  if (singletonObject == null && allowEarlyReference) {
   ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
   if (singletonFactory != null) {
   singletonObject = singletonFactory.getObject();
   this.earlySingletonObjects.put(beanName, singletonObject);
   this.singletonFactories.remove(beanName);
   }
  }
  }
 }
 return singletonObject;
 }

那麼到此處我們就可以看出為什麼不能在構造方法中存在循環依賴瞭，假如現在有a、b兩個service，它們兩個互相在構造方法中循環依賴，當項目啟動，創建a的bean時執行第一步通過構造方法創建實例，但是發現依賴b的bean，所以就從三級緩存中獲取，但是沒發現，那麼就先掛起a的創建過程，先去創建b，在b創建過程中，又依賴於a，但是三級緩存中也沒有a的bean，這樣就進入瞭一個循環創建的過程，自然是不可取的。

而內部field scope為prototype為何也會報錯呢，當scope為prototype每次引用它時都會創建一個新的對象，所以也會存在循環創建的過程。

而默認情況下bean的scope為singleton，整個容器中僅有整個service的一個bean，還是假如a、b兩service存在field循環依賴，當創建a的bean時，執行完構造方法後，a的實例已生成，將其factory對象存入第三級緩存singletonFactories中，在填充屬性時，發現依賴b的bean，但是在緩存中沒有b的bean；因此轉而去創建b，在此過程中執行完b的構造方法後將其factory也放入三級緩存，此時執行b的屬性填充，發現依賴a，從三級緩存中獲取a的對象，並將a放入二級緩存中，之後執行intialize初始化，最後將b的bean轉入一級緩存；再繼續回來創建a，這個時候發現在一級緩存中已經有瞭b，那麼屬性填充成功，進行初始化，最後a也放入一級緩存，至此執行完畢。

那麼大傢可能會感到疑惑，為什麼要使用三級緩存呢，感覺沒有singletonFactories使用二級緩存也可以呀？

從前面的代碼裡可以看到向第三級緩存中放置的是一個objectFactory的匿名實現類，addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean))，當我們從singletonFactories中獲取objectFctory然後調用getObject方法獲取bean的時候，實際就是通過getEarlyBeanReference獲取的object，那麼進入這個方法看一下。

它在這裡會獲取所有的beanPostProcessor實現類，然後從中找出實現瞭SmartInstantiationAwareBeanPostProcessor的beanPostProcessor，然後調用它的getEarlyBeanReference(obgect，beanName)方法，對bean進行處理，然後進行返回，這些實現類中就有aop的核心AbstractAutoProxyCreator，從這裡我們就可以看出來，從第三級緩存objectFactory中獲取的obejct是經過瞭處理的一個代理對象，個人理解三級緩存就是為瞭獲取在創建對象的過程中提前對其進行一些擴展操作。

三級緩存實現bean的擴展，將代理對象放入二級緩存中，供其他依賴該bean的對象的使用，如果沒有瞭三級緩存，將bean擴展放在二級緩存中實現，那麼如果有bean a被其他多個bean依賴，那麼在其他bean填充屬性的過程中會多次獲取bean a，這個過程中就會多次執行獲取bean a代理，就有些多餘，而三級緩存結構就是在第三級緩存完成bean的擴展，生成代理對象，放入二級緩存之中，供其他bean獲取。

以上為個人經驗，希望能給大傢一個參考，也希望大傢多多支持WalkonNet。如有錯誤或未考慮完全的地方，望不吝賜教。

推薦閱讀：