什么是BeanFactory？

提到Spring，總是讓人第一時間想起IOC容器，而IOC容器的頂層核心介面就是我們的BeanFactory，如果能夠理解BeanFactory的體系結構想必能讓我們對Spring整體脈絡有更加清晰的認知，所以，本文的探究方向主要為以下幾點：

BeanFactory的體系結構是怎樣的？
Bean的元資訊從何而來？
BeanFactory生產Bean的程序是怎樣的？

BeanFactory的體系結構

我們先來看看有哪些子類實作了它吧

在這里插入圖片描述
其中ApplicationContext這一塊已在上篇文章有詳細說明，而DefaultListableBeanFactory這個底層實作類便理所當然的成為了我們此次探究的出發點，為了讓我們有個更好的觀感，以下是純粹的BeanFactoryUML圖：

在這里插入圖片描述
我們可以看到DefaultListableBeanFactory實作的介面有：

SingletonBeanRegistry: 定義了對單例快取池相關的操作，如將bean注冊到單例快取池中
ConfigurableBeanFactory: 可配置的BeanFactory，定義了各種各樣的配置能力，如bean的作用域，bean的classLoader,添加bean的后置處理器，設定bean的創建狀態，銷毀bean等等
AutowireCapableBeanFactory: 能進行自動裝配的BeanFactory,這可能是我們最為熟悉的BeanFactory，定義了自動裝配的型別(byName/byType)，createBean, autowireBean, 自動裝配屬性, populateBean, initializeBean, 對于與bean生命周期相關的方法都將在這里體現
ListableBeanFactory: 對BeanFactory的增強，定義了一系列根據beanType獲取bean或者beanName的方法
ConfigurableListableBeanFactory: 對ConfigurableBeanFactory的增強，定義了忽略bean的型別、快取bean定義、預實體化單例bean等方法
BeanDefinitionRegistry: bean定義注冊器，定義了與bean定義相關的方法

如果說以上的介面體現了DefaultListableBeanFactory具備的功能，那么它所繼承的一系列類就是這些功能的實作：

DefaultSingletonBeanRegistry: 單例bean注冊器，定義了三級快取，其實就是三個Map屬性
FactoryBeanRegistrySupport: 提供對FactoryBean的支持
AbstractBeanFactory: 實作了一系列操作IOC容器的功能，但最終的createBean依舊交由子類AbstractAutowireCapableBeanFactory完成
AbstractAutowireCapableBeanFactory: 實作了創建bean的功能，所有與創建bean的相關的功能都在這里
DefaultListableBeanFactory: 在以上父類的功能基礎上實作了ConfigurableBeanFactory和BeanDefinitionRegistry介面，定義了一些存放Bean定義相關資訊的Map

看到這里，想必對DefaultListableBeanFactory已經有一個大致的了解了，那么問題來啦，我們應該怎么從容器中獲取一個bean呢？是不是只要通過BeanDefinitionRegistry注冊一個bean定義，再通過AutowireCapableBeanFactory去createBean就完成了呢？就像下面這樣：

DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
RootBeanDefinition beanDefinition = new RootBeanDefinition(Wheel.class);
beanFactory.registerBeanDefinition("wheel",beanDefinition);
beanFactory.getBean("wheel", Wheel.class);

`Bean`的元資訊從何而來？

我們現在已經知道DefaultListableBeanFactory的大致功能了，我們發現當我們想要創建一個Bean的時候，總是離不開一個名詞：Bean定義，那么這個Bean定義究竟是什么呢？

BeanDefinition其實是一個介面，并不是一個具體的類，我們也可以看一下它的UML圖：

[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳

在這里插入圖片描述
可以發現這里使用了模板方法的設計模式擴展了許多的子類，其中我們最常用的為RootBeanDefinition，它主要包含的屬性如下：

我們向容器中注冊的Bean定義的資訊大概就是如此，當BeanFactory生產Bean時，便可以通過beanClass清楚的知道Bean的類是什么，作用域是怎樣，是否懶加載，init方法是什么等等等等

咦，如果一個最簡單的bean，好像可以直接通過反射就搞定了耶~

具體結構已經清楚了，那我們來看一下注冊程序吧

先從Demo看起

public static void main(String[] args) {
    //創建一個DefaultListableBeanFactory實體
    DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
    //創建一個BeanDefinition
    RootBeanDefinition beanDefinition = new RootBeanDefinition(Wheel.class);
    //將BeanDefinition注冊到容器中
    beanFactory.registerBeanDefinition("wheel",beanDefinition);
}

public static class Wheel {
}

創建BeanDefinition

public RootBeanDefinition(@Nullable Class<?> beanClass) {
    //初始化父類
    super();
    //將beanClass賦值給this.BeanClass
    setBeanClass(beanClass);
}

初始化父類

//將其中一部分屬性賦予默認值
autowireCandidate = true;
primary = false;

protected AbstractBeanDefinition() {
    this(null, null);
}
protected AbstractBeanDefinition(@Nullable ConstructorArgumentValues cargs, @Nullable MutablePropertyValues pvs) {
    this.constructorArgumentValues = cargs;
    this.propertyValues = pvs;
}

將BeanDefinition注冊到容器中

//除去校驗邏輯，注冊時只做了這兩步操作
this.beanDefinitionMap.put(beanName, beanDefinition);
this.beanDefinitionNames.add(beanName);

看到這里，大家伙可能會充滿疑問？what? 就這樣？沒有填充屬性的步驟嗎？嘿嘿，BeanFactory是一個純粹的工廠，只負責生產Bean，是沒有裝配（設計）BeanDefinition的功能的，專業的事還是交給專業的人做，設計的事情還是交由ApplicationContext完成的，

那在ApplicationContext中是怎么完成一個BeanDefinition的呢？還記得預啟動將配置類注冊到容器中時有這樣一段代碼嗎？以下代碼為AnnotatedBeanDefinitionReader#doRegisterBean中的摘要部分：

<T> void doRegisterBean(Class<T> annotatedClass, @Nullable Supplier<T> instanceSupplier, @Nullable String name,
                        @Nullable Class<? extends Annotation>[] qualifiers, BeanDefinitionCustomizer... definitionCustomizers) {
	//.......代碼
    //處理普通的bean定義注解，@Lazy @Primary @DependsOn @Role @Description
    AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
    //......代碼
   
}

而非配置的Bean是通過在預啟動時注冊的配置類后置處理器ConfigurationClassPostProcessor#processConfigBeanDefinitions中完成的，以下代碼為ClassPathBeanDefinitionScanner#doScan中的摘要部分，詳細呼叫鏈將在后面的文章進行說明

//傳入我們配置類的包路徑
protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
		Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();
		for (String basePackage : basePackages) {
            //尋找到所有標識了@Component注解的BeanDefinition
			Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
			for (BeanDefinition candidate : candidates) {
				//....省略代碼
				if (candidate instanceof AbstractBeanDefinition) {
                    //處理BeanDefinition
					postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
				}
				if (candidate instanceof AnnotatedBeanDefinition) {
 //處理普通的bean定義注解，@Lazy @Primary @DependsOn @Role @Description
                    AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
				}
                //...省略代碼
                //將BeanDefinition注冊到容器中
                registerBeanDefinition(definitionHolder, this.registry);
            }
	}

處理BeanDefinition

protected void postProcessBeanDefinition(AbstractBeanDefinition beanDefinition, String beanName) {
	//設定默認值
    beanDefinition.applyDefaults(this.beanDefinitionDefaults);
    //這里默認為空
    if (this.autowireCandidatePatterns != null) {
        beanDefinition.setAutowireCandidate(PatternMatchUtils.simpleMatch(this.autowireCandidatePatterns, beanName));
    }
}

設定默認值

public void applyDefaults(BeanDefinitionDefaults defaults) {
    //默認為null
    Boolean lazyInit = defaults.getLazyInit();
    if (lazyInit != null) {
        setLazyInit(lazyInit);
    }
    //默認為0
    setAutowireMode(defaults.getAutowireMode());
    //默認為0
    setDependencyCheck(defaults.getDependencyCheck());
    //默認為null
    setInitMethodName(defaults.getInitMethodName());
    setEnforceInitMethod(false);
    //默認為null
    setDestroyMethodName(defaults.getDestroyMethodName());
    setEnforceDestroyMethod(false);
}

處理普通的bean定義注解

public static void processCommonDefinitionAnnotations(AnnotatedBeanDefinition abd) {
    processCommonDefinitionAnnotations(abd, abd.getMetadata());
}

static void processCommonDefinitionAnnotations(AnnotatedBeanDefinition abd, AnnotatedTypeMetadata metadata) {
    	//從元資料中取出該注解的屬性串列，不為空說明有標識該注解
		AnnotationAttributes lazy = attributesFor(metadata, Lazy.class);
		if (lazy != null) {
			abd.setLazyInit(lazy.getBoolean("value"));
		}
		else if (abd.getMetadata() != metadata) {
			lazy = attributesFor(abd.getMetadata(), Lazy.class);
			if (lazy != null) {
				abd.setLazyInit(lazy.getBoolean("value"));
			}
		}
		//判斷元資料中是否有該注解
		if (metadata.isAnnotated(Primary.class.getName())) {
			abd.setPrimary(true);
		}
		AnnotationAttributes dependsOn = attributesFor(metadata, DependsOn.class);
		if (dependsOn != null) {
			abd.setDependsOn(dependsOn.getStringArray("value"));
		}
		AnnotationAttributes role = attributesFor(metadata, Role.class);
		if (role != null) {
			abd.setRole(role.getNumber("value").intValue());
		}
		AnnotationAttributes description = attributesFor(metadata, Description.class);
		if (description != null) {
			abd.setDescription(description.getString("value"));
		}
	}

attributesFor(metadata, Lazy.class)

static AnnotationAttributes attributesFor(AnnotatedTypeMetadata metadata, Class<?> annotationClass) {
    return attributesFor(metadata, annotationClass.getName());
}
static AnnotationAttributes attributesFor(AnnotatedTypeMetadata metadata, String annotationClassName) {
    //metadata為beanClass的注解元資料，存放了該類所配置的所有注解
    //annotationClassName為需要尋找的注解名稱
    return AnnotationAttributes.fromMap(metadata.getAnnotationAttributes(annotationClassName, false));
}
default Map<String, Object> getAnnotationAttributes(String annotationName,
                                                    boolean classValuesAsString) {
    //遍歷元資料中的所有注解
    MergedAnnotation<Annotation> annotation = getAnnotations().get(annotationName,
                                                                   null, MergedAnnotationSelectors.firstDirectlyDeclared());
    //不存在則回傳null,否則回傳一個map
    if (!annotation.isPresent()) {
        return null;
    }
    return annotation.asAnnotationAttributes(Adapt.values(classValuesAsString, true));
}

以上為掃描@Component注解類進行決議元資料填充屬性的邏輯，在配置類中以@Bean方式注冊的BeanDefinition填充屬性程序在ConfigurationClassBeanDefinitionReader.loadBeanDefinitions(configClasses)

`BeanFactory`生產`Bean`的程序是怎樣的？

現在，我們已經知道了一個BeanDefinition的具體結構以及是如何產生并注冊到BeanFactory的，那么BeanFactory又是如何使用它生產Bean的呢？以下附上createBean的粗略流程圖，具體細節將放在IOC容器啟動流程中詳細說明

在這里插入圖片描述

那么關于BeanFactory的相關內容就到這里了，希望大家有所識訓，下篇將正式進入Spring IOC容器的啟動流程！

準備花個30天時間，系統的來整理一下我對spring原始碼的認識：

Spring 原始碼系列

Spring原始碼分析之 IOC 容器預啟動流程(已完結)
Spring原始碼分析之BeanFactory體系結構(已完結)
Spring原始碼分析之BeanFactoryPostProcessor呼叫程序(已完結)
Spring原始碼分析之Bean的創建程序
Spring原始碼分析之什么是回圈依賴及解決方案
Spring原始碼分析之AOP從決議到呼叫
Spring原始碼分析之事務管理(上)，事物管理是spring作為容器的一個特點，總結一下他的基本實作與原理吧
Spring原始碼分析之事務管理(下) ，關于他的底層事物隔離與事物傳播原理，重點分析一下

Spring Mvc 原始碼系列

SpringMvc體系結構
SpringMvc原始碼分析之Handler決議程序
SpringMvc原始碼分析之請求鏈程序

Mybatis 原始碼系列

暫定

追更，可掃下面的二維碼，分享純粹為了樂趣，也有一種成就感吧，筆者這篇文章先就到這
在這里插入圖片描述

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/166485.html

標籤：其他

上一篇：Spring的BeanFactory是什么？

下一篇：Java中實作介面與繼承的區別

Spring的BeanFactory是什么？