拉勾筆記02(2)Spring IOC和AOP源碼篇
目錄
本篇文章是基於拉勾高薪課程學習筆記，基礎是在Spring源碼編譯執行，jdk源碼編譯教程請自行搜索
1、IoC容器初始化流程
1.1、容器繼承體系
ApplicationContext是容器的高級接口，BeanFactory是頂級容器，規范/定義容器的基礎行為
Spring應用上下文，稱之為IoC容器，是一組組件和過程的集合，包括BeanFactory、單例池、BeanPostProcessor等之間的協作流程
首先看下BeanFactory的繼承結構體系圖，ApplicationContext除了繼承BeanFactory，還繼承了MessageSource、ResourceLoader等接口
上圖是ApplicationContext繼承的ListableBeanFactory接口的方法列表，確實有好多方法是頂級接口BeanFactory中所沒有的
1.2、關鍵方法refresh()
通過參照Bean生命周期Debug可知，無論是Bean構造器、Bean后置處理器或者Bean工廠后置處理器初始化，都會調用refresh方法
廢話少說，直接上源碼
@Override
public void refresh() throws BeansException, IllegalStateException {
// 對象鎖加鎖
synchronized (this.startupShutdownMonitor) {
/*
Prepare this context for refreshing.
刷新前的預處理
表示在真正做refresh操作之前需要准備做的事情：
設置Spring容器的啟動時間，
開啟活躍狀態，撤銷關閉狀態
驗證環境信息里一些必須存在的屬性等
*/
prepareRefresh();
/*
Tell the subclass to refresh the internal bean factory.
獲取BeanFactory；默認實現是DefaultListableBeanFactory
加載BeanDefition 並注冊到 BeanDefitionRegistry
*/
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
/*
Prepare the bean factory for use in this context.
BeanFactory的預准備工作（BeanFactory進行一些設置，比如context的類加載器等）
*/
prepareBeanFactory(beanFactory);
try {
/*
Allows post-processing of the bean factory in context subclasses.
BeanFactory准備工作完成后進行的后置處理工作
*/
postProcessBeanFactory(beanFactory);
/*
Invoke factory processors registered as beans in the context.
實例化實現了BeanFactoryPostProcessor接口的Bean，並調用接口方法
*/
invokeBeanFactoryPostProcessors(beanFactory);
/*
Register bean processors that intercept bean creation.
注冊BeanPostProcessor（Bean的后置處理器），在創建bean的前后等執行
*/
registerBeanPostProcessors(beanFactory);
/*
Initialize message source for this context.
初始化MessageSource組件（做國際化功能；消息綁定，消息解析）；
*/
initMessageSource();
/*
Initialize event multicaster for this context.
初始化事件派發器
*/
initApplicationEventMulticaster();
/*
Initialize other special beans in specific context subclasses.
子類重寫這個方法，在容器刷新的時候可以自定義邏輯；如創建Tomcat，Jetty等WEB服務器
*/
onRefresh();
/*
Check for listener beans and register them.
注冊應用的監聽器。就是注冊實現了ApplicationListener接口的監聽器bean
*/
registerListeners();
/*
Instantiate all remaining (non-lazy-init) singletons.
初始化所有剩下的非懶加載的單例bean
初始化創建非懶加載方式的單例Bean實例（未設置屬性）
填充屬性
初始化方法調用（比如調用afterPropertiesSet方法、init-method方法）
調用BeanPostProcessor（后置處理器）對實例bean進行后置處理
*/
finishBeanFactoryInitialization(beanFactory);
/*
Last step: publish corresponding event.
完成context的刷新。主要是調用LifecycleProcessor的onRefresh()方法，並且發布事件（ContextRefreshedEvent）
*/
finishRefresh();
}
catch (BeansException ex) {
if (logger.isWarnEnabled()) {
logger.warn("Exception encountered during context initialization - " +
"cancelling refresh attempt: " + ex);
}
// Destroy already created singletons to avoid dangling resources.
destroyBeans();
// Reset 'active' flag.
cancelRefresh(ex);
// Propagate exception to caller.
throw ex;
}
finally {
// Reset common introspection caches in Spring's core, since we
// might not ever need metadata for singleton beans anymore...
resetCommonCaches();
}
}
}
首先通過find usage反調來查看第一行synchronized對象鎖都被哪些方法調用
由圖可知，該鎖的作用，就是在refresh和close方法不能同時運行，避免沖突
因為refresh方法中調用的方法過多，我下面就挑重要的方法展開，如果需要可以自行查看源碼
/*
Tell the subclass to refresh the internal bean factory.
獲取BeanFactory；默認實現是DefaultListableBeanFactory
加載BeanDefition 並注冊到 BeanDefitionRegistry
*/
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
1.3、BeanFactory獲取子流程
調用棧如下：
refresh——obtainFreshBeanFactory——refreshBeanFactory
@Override
protected final void refreshBeanFactory() throws BeansException {
// 判斷是否已有bean factory
if (hasBeanFactory()) {
// 銷毀 beans
destroyBeans();
// 關閉 bean factory
closeBeanFactory();
}
try {
// 實例化 DefaultListableBeanFactory
DefaultListableBeanFactory beanFactory = createBeanFactory();
// 設置序列化id
beanFactory.setSerializationId(getId());
// 自定義bean工廠的一些屬性（是否覆蓋、是否允許循環依賴）
customizeBeanFactory(beanFactory);
// 加載應用中的BeanDefinitions
loadBeanDefinitions(beanFactory);
synchronized (this.beanFactoryMonitor) {
// 賦值當前bean facotry
this.beanFactory = beanFactory;
}
}
catch (IOException ex) {
throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
}
}
時序圖如下：
1.4、BeanDefinition加載注冊子流程
調用棧如下：
obtainFreshBeanFactory——refreshBeanFactory——loadBeanDefinitions
@Override
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
// 給指定的beanFactory創建一個XmlBeanDefinitionReader讀取器對象，用於讀取解析xml對象
XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
// 給XmlBeanDefinitionReader對象設置一些context上下文中的環境屬性
beanDefinitionReader.setEnvironment(this.getEnvironment());
beanDefinitionReader.setResourceLoader(this);
beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
// 提供給子類實現提供一些自定義的初始化策略
initBeanDefinitionReader(beanDefinitionReader);
// 真正的去加載BeanDefinitions
loadBeanDefinitions(beanDefinitionReader);
}
protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
// 從Resource資源對象加載BeanDefinitions
Resource[] configResources = getConfigResources();
if (configResources != null) {
reader.loadBeanDefinitions(configResources);
}
// 從xml配置文件加載BeanDefinition對象
String[] configLocations = getConfigLocations();
if (configLocations != null) {
reader.loadBeanDefinitions(configLocations);
}
}
1.5、Bean對象創建流程
@Override
public void preInstantiateSingletons() throws BeansException {
if (logger.isTraceEnabled()) {
logger.trace("Pre-instantiating singletons in " + this);
}
// Iterate over a copy to allow for init methods which in turn register new bean definitions.
// While this may not be part of the regular factory bootstrap, it does otherwise work fine.
// 所有bean的名字
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
// Trigger initialization of all non-lazy singleton beans...
// 觸發所有非延遲加載單例bean的初始化，主要步驟為getBean
for (String beanName : beanNames) {
// 合並父BeanDefinition對象
// map.get(beanName)
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
if (isFactoryBean(beanName)) {
Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
// 如果是FactoryBean則加&
if (bean instanceof FactoryBean) {
final FactoryBean<?> factory = (FactoryBean<?>) bean;
boolean isEagerInit;
if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
((SmartFactoryBean<?>) factory)::isEagerInit,
getAccessControlContext());
}
else {
isEagerInit = (factory instanceof SmartFactoryBean &&
((SmartFactoryBean<?>) factory).isEagerInit());
}
if (isEagerInit) {
getBean(beanName);
}
}
}
else {
// 實例化當前bean
getBean(beanName);
}
}
}
...
}
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
// 解析beanName 如果以&開頭去掉&開頭，如果是別名獲取到真正的名字
final String beanName = transformedBeanName(name);
Object bean;
// 單純理解嘗試從緩存中獲取 bean
Object sharedInstance = getSingleton(beanName);
// 如果已經存在則返回
if (sharedInstance != null && args == null) {
if (logger.isTraceEnabled()) {
if (isSingletonCurrentlyInCreation(beanName)) {
logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
"' that is not fully initialized yet - a consequence of a circular reference");
}
else {
logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
}
}
// 針對 FactoryBean 的處理
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else {
// 如果是prototype類型且開啟允許循環依賴，則拋出異常
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
// Check if bean definition exists in this factory.
// 檢查父工廠中是否存在該對象
BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
// Not found -> check parent.
String nameToLookup = originalBeanName(name);
if (parentBeanFactory instanceof AbstractBeanFactory) {
return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
nameToLookup, requiredType, args, typeCheckOnly);
}
else if (args != null) {
// Delegation to parent with explicit args.
return (T) parentBeanFactory.getBean(nameToLookup, args);
}
else if (requiredType != null) {
// No args -> delegate to standard getBean method.
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
else {
return (T) parentBeanFactory.getBean(nameToLookup);
}
}
if (!typeCheckOnly) {
markBeanAsCreated(beanName);
}
try {
// 合並父子bean 屬性
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
checkMergedBeanDefinition(mbd, beanName, args);
// Guarantee initialization of beans that the current bean depends on.
// 處理dependsOn配置
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
for (String dep : dependsOn) {
if (isDependent(beanName, dep)) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
}
registerDependentBean(dep, beanName);
try {
getBean(dep);
}
catch (NoSuchBeanDefinitionException ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
}
}
}
// 創建單例bean
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, () -> {
try {
// 創建 bean
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
// Explicitly remove instance from singleton cache: It might have been put there
// eagerly by the creation process, to allow for circular reference resolution.
// Also remove any beans that received a temporary reference to the bean.
destroySingleton(beanName);
throw ex;
}
});
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
}
1.6、lazy-init延遲加載
1.7、Spring IoC循環依賴
是什么
循環依賴指的是循環引用，也就是兩個或兩個以上的Bean互相持有對方，形成閉環，如下圖
原理
為了解決循環依賴問題，Spring是以三級緩存的機制來處理的，其實官方文檔並沒有三級緩存這樣的定義，在Spring中僅僅是三個Map。其中一級緩存singletonObjects就是咱們熟知的單例池，二級緩存singleFactories是映射創建Bean的原始工廠，三級緩存earlySingletonObjects是映射Bean的早期引用。
<!--循環依賴問題-->
<bean id="aBean" class="com.lagou.edu.aBean">
<property name="bBean" ref="bBean"/>
</bean>
<bean id="bBean" class="com.lagou.edu.bBean">
<property name="aBean" ref="aBean"/>
</bean>
上例就是一個簡單的循環依賴，A依賴於B，B依賴於A。Spring的解決方式如下
- A在對象實例化后放入三級緩存（提前暴露）
- B在創建的過程中發現依賴於A，那么先去一級緩存中查找，沒有再去二級，還沒有再去三級。
- 在三級緩存中查找到后會升級到二級緩存。
- 此時B創建完成，則將成型的B放入一級緩存中。
- 這時候A在創建的過程中會使用一級緩存中的B完成創建
三級緩存的源碼過於復雜，這里只放一個時序圖
