Spring5深度原始碼分析(三)之AnnotationConfigApplicationContext啟動原理分析
阿新 • • 發佈：2019-07-04
程式碼地址：https://github.com/showkawa/spring-annotation/tree/master/src/main/java/com/brian
AnnotationConfigApplicationContext啟動原理分析主要分析下面三點
1.@Qualifier與@Primary註解的使用
2.BeanFactory與ApplicationContext區別
3.AnnotationConfigApplicationContext啟動原理分析
1.@Qualifier與@Primary註解的使用
下面是 @Qualifier 和 @Primary註解的官方解釋
@Qualifier
This annotation may be used on a field or parameter as a qualifier for candidate beans when autowiring. It may also be used to annotate other custom annotations that can then in turn be used as qualifiers.這個註釋可用於作為預備bean的欄位或引數，也可以用在其他的自定義註釋下 @Qualifier(“XXX”) Spring的Bean注入配置註解，該註解指定注入的Bean的名稱，Spring框架使用byName方式尋找合格的bean，這樣就消除了byType方式產生的歧義。
qualifer字面意思合格者，一般情況下：程式碼裡面需要注入其他依賴，一般用@Reource（ 預設按名稱裝配，當找不到與名稱匹配的bean才會按型別裝配和@Autowired（預設按型別裝配，如果我們想使用按名稱裝配，可以結合@Qualifier註解一起使用）
@Primary
Indicates that a bean should be given preference when multiple candidates are qualified to autowire a single-valued dependency. If exactly one ‘primary’ bean exists among the candidates, it will be the autowired value. This annotation is semantically equivalent to the {@code} element’s {@code primary} attribute 不難看出如果用primary註解其中一個bean就要優先於其他的Bean，當然這個對於這種三方jar包最好不要新增的，誰知道它會不會後期又出什麼么蛾子，只能改自己的程式碼了最後的方案是改成@qualifiel（“getMetricRegistry”），選取了其中一個bean注入
primary字面意思最主要者，如果是有配置過多資料來源，那一定會熟悉這個註解
1.1 @Qualifier的使用
我們這裡定義一個BookService介面
public interface BookService {
void printBook();
}
兩個實現類BookServiceImpl和OtherBookServiceImpl實現BookService介面的printBook()方法
@Service
public class BookServiceImpl implements BookService {
@Override
public void printBook() {
System.out.println("---BookServiceImpl---: spring5原始碼分析");
}
}
@Service
public class OtherBookServiceImpl implements BookService {
@Override
public void printBook() {
System.out.println("---OtherBookServiceImpl---: 天道酬勤，一步一個坑");
}
}
我們在BookController注入BooKService
@Controller
public class BookController {
@Autowiredprivate BookService bookService;
private void printBook() {
bookService.printBook();
}
}
附上配置類MainConfig
@Configuration //告訴spring這是一個配置類
/*
* @ComponentScan
* value:只當於掃描的的包
* excludeFilters = 指定掃描的時候按照什麼規則排除哪些元件
* includeFilters = 指定掃描的時候只需要包含哪些元件
* Filter.ANNOTATION:按照註解
* Filter.ASSIGNABLE_TYPE: 按照給定的型別
* */
//@ComponentScans(value = {
// @ComponentScan(value = "com.brian",includeFilters = {
// @ComponentScan.Filter(type = FilterType.ANNOTATION,classes = {Controller.class}),
// @ComponentScan.Filter(type=FilterType.ASSIGNABLE_TYPE,classes = {BookService.class}),
// @ComponentScan.Filter(type = FilterType.CUSTOM,classes = {BrianTypeFilter.class})
// },useDefaultFilters = false)
//})
@ComponentScan({"com.brian.service", "com.brian.controller"})
//@Import({Brian.class,Alan.class})
@Import({BrianSelector.class})
public class MainConfig {
@Bean("person") //給容器中註冊一個Bean;型別為返回值的型別；id預設是方法名作為id
public Person person(){
return new Person("Alan",18);
}
/*
* @Conditional() 按照條件註冊
*
* */
@Conditional({BrianCondition.class})
@Bean("person01")
public Person person01() {
return new Person("Brian",17);
}
@Conditional({BrianCondition.class})
@Bean("person02")
public Person person02() {
return new Person("wenTao",19);
}
/*
*
*給容器中註冊元件
* 1，包掃描+ 元件標註註解（@Controller/@Service/@Repository/@Component）[自己寫的方法]
* 2， @Bean [匯入的第三方包裡面的元件]
* 3，@Import [快速的給容器匯入一個元件]
* 1.@Import(要匯入的元件class)
* 2.ImportSelector：返回需要匯入的元件的全類名陣列
* 3.ImportBeanDefinitionRegistrar: 手動註冊bean到容器
* 4. 使用Spring提供的FactoryBean
* */
@Bean
public BrianBeanFactory brianBeanFactory() {
return new BrianBeanFactory();
}
}
在測試類MainTest類中測試該printBook()方法
public class MainTest {
public static void main(String[] args) {
ApplicationContext mainConfig =
new AnnotationConfigApplicationContext(MainConfig.class);
System.out.println("MainConfig容器建立成功");
BookController bookController = mainConfig.getBean(BookController.class);
try {
Method printBook = bookController.getClass().getDeclaredMethod("printBook");
printBook.setAccessible(true);
printBook.invoke(bookController);
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
// Alan alan1 = acac.getBean(Alan.class);
// System.out.println("--ALAN--:" + alan1);
// Alan alan2 = acac.getBean(Alan.class);
//System.out.println("比較兩個Alan例項: " + (alan1 == alan2));
// Person person1 = (Person) acac.getBean("person01");
// System.out.println("---main---test---person1---: " + person1.toString());
// Person person2 = (Person) acac.getBean("person02");
// System.out.println("---main---test---person2---: " + person2.toString());
// MathCalculator mathCalculator = (MathCalculator) acac.getBean("mathCalculator");
// System.out.println("----get--mathCalculator---: " + mathCalculator);
// BrianBeanFactory beanFactory = acac.getBean(BrianBeanFactory.class);
// WenTao wentao = null;
// try {
// wentao = beanFactory.getObject();
// } catch (Exception e) {
// e.printStackTrace();
// }
// System.out.println("----get--WenTao---: " + wentao);
//關閉ioc容器
((AnnotationConfigApplicationContext) mainConfig).close();
}
}
看到有報錯No qualifying bean of type 'com.brian.service.BookService' available: expected single matching bean but found 2: bookServiceImpl,otherBookServiceImpl，就是因為預設按型別裝配
OK,此時我在BookController注入BookSevice的時候加上@Qualifier指定beanName,再次測試
@Controller
public class BookController {
@Autowired
@Qualifier("bookServiceImpl")
private BookService bookService;
private void printBook() {
bookService.printBook();
}
}
1.2 @Primary的使用
繼續返回到上面的報錯時候的場景，因為此時BookService有兩個實現類，此時我在OtherBookServiceImpl類上加上@Primary註解，再次測試
@Service
@Primary
public class OtherBookServiceImpl implements BookService {
@Override
public void printBook() {
System.out.println("---OtherBookServiceImpl---: 天道酬勤，一步一個坑");
}
}
這裡順便總結下常用的註解：
@Configuration把一個類作為一個IoC容器，它的某個方法頭上如果註冊了@Bean，就會作為這個Spring容器中的Bean。
@Scope註解 作用域
@Lazy(true) 表示延遲初始化
@Service用於標註業務層元件、
@Controller用於標註控制層元件
@Repository用於標註資料訪問元件，即DAO元件。
@Component泛指元件，當元件不好歸類的時候，我們可以使用這個註解進行標註。
@Scope用於指定scope作用域的（用在類上）
@PostConstruct用於指定初始化方法（用在方法上）
@PreDestory用於指定銷燬方法（用在方法上）
@Resource 預設按名稱裝配，當找不到與名稱匹配的bean才會按型別裝配。
@DependsOn：定義Bean初始化及銷燬時的順序
@Primary：自動裝配時當出現多個Bean候選者時，被註解為@Primary的Bean將作為首選者，否則將丟擲異常
@Autowired 預設按型別裝配，如果我們想使用按名稱裝配，可以結合@Qualifier註解一起使用
@Autowired @Qualifier("OtherBookServiceImpl") 存在多個例項配合使用
2.BeanFactory與ApplicationContext區別
之前的原始碼分析有見過BeanFactory和FactoryBean介面的區別，FactoryBean是建立bean物件，而BeanFactory是獲取物件。但ApplicationContext也可以獲取物件，我上面的測試類getBean()方法就是的。同樣都可以獲取bean物件BeanFactory與ApplicationContext有什麼區別？
1. BeanFactory負責讀取bean配置文件，管理bean的載入，例項化，維護bean之間的依賴關係，負責bean的宣告週期。
2. ApplicationContext除了提供上述BeanFactory所能提供的功能之外，還提供了更完整的框架功能： a. 國際化支援 b. 資源訪問：Resource rs = ctx. getResource(“classpath:config.properties”), “file:E:/config.properties” c. 事件傳遞：通過實現ApplicationContextAware介面 3. 常用的獲取ApplicationContext的方法：
AnnotationConfigApplicationContext 從@Configuration配置類建立容器 FileSystemXmlApplicationContext：從【檔案系統】 或者 【classpath的xml配置檔案】 建立，引數為配置檔名或檔名陣列 ClassPathXmlApplicationContext：從【classpath的xml配置檔案】建立，可以從【jar包】中讀取配置檔案 WebApplicationContextUtils：從web應用的根目錄讀取配置檔案，需要先在web.xml中配置，可以配置監聽器或者servlet來實現
Spring的IoC容器就是一個實現了BeanFactory介面的可例項化類。事實上， Spring提供了兩種不同的容器：一種是最基本的BeanFactory，另一種是擴充套件的ApplicationContext。
BeanFactory 僅提供了最基本的依賴注入支援，而 ApplicationContext 則擴充套件了BeanFactory ,提供了更多的額外功能。 ApplicationContext的初始化和BeanFactory有一個重大的區別:BeanFactory在初始化容器時 並未例項化Bean, 直到第一次訪問 某個Bean時才例項目標Bean;而ApplicationContext則在初始化應用上下文時就例項化所有的單例項的Bean。 因此ApplicationContext的初始化時間會比BeanFactory稍長一些.
3.AnnotationConfigApplicationContext啟動原理分析
從AnnotationConfigApplicationContext的類圖中可以看出：
AnnotationConfigApplicationContext繼承GenericApplicationContext這個通用應用上下文，GenericApplicationContext內部定義了一個DefaultListableBeanFactory例項，
GenericApplicationContext實現了BeanDefinitionRegistry介面，所以可以通過AnnotationConfigApplicationContext例項註冊beanDefinition，然後呼叫refresh()方法來初始化上下文。
AnnotationConfigApplicationContext繼承AbstractApplicationContext，AbstractApplicationContext提供了ApplicationContext的抽象實現。
我這邊就從MainTest這個測試類開始AnnotationConfigApplicationContext啟動原理分析：
MainTest測試類：
public class MainTest {
public static void main(String[] args) {
// 1.讀取配置類建立IOC容器
ApplicationContext mainConfig =
new AnnotationConfigApplicationContext(MainConfig.class);
System.out.println("MainConfig容器建立成功");
BookController bookController = mainConfig.getBean(BookController.class);
try {
Method printBook = bookController.getClass().getDeclaredMethod("printBook");
printBook.setAccessible(true);
printBook.invoke(bookController);
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}//關閉ioc容器
((AnnotationConfigApplicationContext) mainConfig).close();
}
}
AnnotationConfigApplicationContext點進去，我這邊後面的原始碼都會附帶官方註釋的翻譯
/**
*建立一個新的AnnotationConfigApplicationContext，派生bean定義
*來自給定的帶註釋的類並自動重新整理上下文。
* @param annotatedClasses一個或多個帶註釋的類，
*例如 {@link Configuration @Configuration}類
*/
public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
//1. 初始化bean讀取器和掃描器;
/** 呼叫父類GenericApplicationContext無參建構函式，初始化一個BeanFactory: this.beanFactory = new DefaultListableBeanFactory()*/
this();
// 2.註冊bean配置類
register(annotatedClasses);
// 3.重新整理上下文
refresh();
}
現在我們點進去this()這個方法；
/**
*建立一個需要填充的新AnnotationConfigApplicationContext
*通過{@link #register}呼叫，然後手動{@linkplain #refresh重新整理}。
*/
public AnnotationConfigApplicationContext() {
//在IOC容器中初始化註解bean讀取器AnnotatedBeanDefinitionReader
this.reader = new AnnotatedBeanDefinitionReader(this);
//在IOC容器中初始化按類路徑掃描註解bean的掃描器
this.scanner = new ClassPathBeanDefinitionScanner(this);
}
this()方法在呼叫自身的無參構造方法時會先走父類GenericApplicationContext的無參構造方法
/**
*建立一個新的GenericApplicationContext。
* @see #registerBeanDefinition
* @see #refresh
*/
public GenericApplicationContext() {
//初始化一個BeanFactory
this.beanFactory = new DefaultListableBeanFactory();
}
現在我們再點進去看下register(annotatedClasses)這個方法,直接呼叫AnnotatedBeanDefinitionReader的register方法
/**
*註冊一個或多個要處理的註釋類。
* <p>對{@code register}的呼叫是冪等的; 新增相同的
*註釋類不止一次沒有額外的效果。
* @param annotatedClasses一個或多個帶註釋的類，
*例如 {@link Configuration @Configuration}類
*/
public void register(Class<?>... annotatedClasses) {
for (Class<?> annotatedClass : annotatedClasses) {
registerBean(annotatedClass);
}
}
/**
*從給定的bean類註冊bean，從中派生元資料
*類宣告的註釋。
* @param annotatedClass bean的類
*/
public void registerBean(Class<?> annotatedClass) {
doRegisterBean(annotatedClass, null, null, null);
}
/**
*從給定的bean類註冊bean，從中派生元資料
*類宣告的註釋。
* @param annotatedClass bean的類
* @param instanceSupplier用於建立bean例項的回撥
*（可能是{@code null}）
* @param命名bean的顯式名稱
* @param限定符特定限定符註釋要考慮，如果有的話，
*除了bean類級別的限定符
* @param definition定製一個或多個用於自定義的回撥
*工廠的{@link BeanDefinition}，例如 設定lazy-init或主標誌
* @since 5.0
*/
<T> void doRegisterBean(Class<T> annotatedClass, @Nullable Supplier<T> instanceSupplier, @Nullable String name,
@Nullable Class<? extends Annotation>[] qualifiers, BeanDefinitionCustomizer... definitionCustomizers) {
/** 將Bean配置類資訊轉成容器中AnnotatedGenericBeanDefinition資料結構,
* AnnotatedGenericBeanDefinition繼承自BeanDefinition作用是定義一個bean的資料結構，
* 下面的getMetadata可以獲取到該bean上的註解資訊 */
AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass);
//@Conditional裝配條件判斷是否需要跳過註冊
if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
return;
}
//設定回撥 @param instanceSupplier 用於建立bean例項的回撥
abd.setInstanceSupplier(instanceSupplier);
//解析bean作用域(單例或者原型)，如果有@Scope註解，則解析@Scope，沒有則預設為singleton
ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
//作用域寫回BeanDefinition資料結構, abd中缺損的情況下為空，將預設值singleton重新賦值到abd
abd.setScope(scopeMetadata.getScopeName());
//生成bean配置類beanName
String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));
//通用註解解析到abd結構中，主要是處理Lazy, primary DependsOn, Role ,Description這五個註解
AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
// @Qualifier特殊限定符處理，@param qualifiers 除了bean類級別的限定符之外，要考慮的限定符特定限定符註釋（如果有）
if (qualifiers != null) {
for (Class<? extends Annotation> qualifier : qualifiers) {
if (Primary.class == qualifier) {
// 如果配置@Primary註解，則設定當前Bean為自動裝配autowire時首選bean
abd.setPrimary(true);
}
else if (Lazy.class == qualifier) {
//設定當前bean為延遲載入
abd.setLazyInit(true);
}
else {
//其他註解，則新增到abd結構中
abd.addQualifier(new AutowireCandidateQualifier(qualifier));
}
}
}
/**自定義bean註冊，通常用在applicationContext建立後，手動向容器中一lambda表示式的方式註冊bean,
* 比如：applicationContext.registerBean(BookService.class, () -> new BookService()); */
for (BeanDefinitionCustomizer customizer : definitionCustomizers) {
//自定義bean新增到BeanDefinition
customizer.customize(abd);
}
//根據beanName和bean定義資訊封裝一個beanhold,heanhold其實就是一個 beanname和BeanDefinition的對映
BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
//建立代理物件
definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
/** BeanDefinitionReaderUtils.registerBeanDefinition 內部通過
* DefaultListableBeanFactory.registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
* 按名稱將bean定義資訊註冊到容器中，實際上DefaultListableBeanFactory內部維護一個Map<String, BeanDefinition>型別變數beanDefinitionMap，
* 用於儲存注bean定義資訊（beanname 和 beandefine對映）*/
BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
}
register方法重點完成了bean配置類本身的解析和註冊，處理過程可以分為以下幾個步驟：
1.根據bean配置類，使用BeanDefinition解析Bean的定義資訊，主要是一些註解資訊
2.Bean作用域的處理，沒有@Scope註解預設解析成單例
3.藉助AnnotationConfigUtils工具類解析通用註解
4.將bean定義資訊已beanname，beandifine鍵值對的形式註冊到ioc容器中
然後我們繼續點進去refresh()方法
refresh方法在AbstractApplicationContext容器中實現，refresh()方法的作用載入或者重新整理當前的配置資訊，如果已經存在spring容器，則先銷燬之前的容器，重新建立spring容器，載入bean定義，完成容器初始化工作，所以可以看出AnnotationConfigApplicationContext容器是通過呼叫其父類AbstractApplicationContext的refresh()函式啟動整個IoC容器完成對Bean定義的載入。
AbstractApplicationContext類的refresh()方法原始碼如下:
@Override
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
//1.重新整理前的預處理
prepareRefresh();
//2.獲取重新整理後的內部Bean工廠
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
//3.BeanFactory的預準備工作
prepareBeanFactory(beanFactory);
try {
// BeanFactory準備工作完成後，可以做一些後置處理工作
// 4.空方法，用於在容器的子類中擴充套件
postProcessBeanFactory(beanFactory);
// 5. 執行BeanFactoryPostProcessor的方法，BeanFactory的後置處理器，在BeanFactory標準初始化之後執行的
invokeBeanFactoryPostProcessors(beanFactory);
// 6. 註冊BeanPostProcessor（Bean的後置處理器）,用於攔截bean建立過程，實現對bean的增強
registerBeanPostProcessors(beanFactory);
// 7. 初始化MessageSource元件（做國際化功能；訊息繫結，訊息解析）
initMessageSource();
// 8. 初始化事件派發器
initApplicationEventMulticaster();
// 9.空方法，可以用於子類實現在容器重新整理時自定義邏輯
onRefresh();
// 10. 註冊事件監聽器，將所有專案裡面的ApplicationListener註冊到容器中來
registerListeners();
// 11. 初始化所有剩下的單例項bean,單例bean在初始化容器時建立，原型bean在獲取時（getbean）時建立
finishBeanFactoryInitialization(beanFactory);
// 12. 完成BeanFactory的初始化建立工作，IOC容器就建立完成；
finishRefresh();
}
catch (BeansException ex) {
if (logger.isWarnEnabled()) {
logger.warn("Exception encountered during context initialization - " +
"cancelling refresh attempt: " + ex);
}
//銷燬已經建立的單例，以避免掛起資源。
destroyBeans();
//重置“活動”標誌。
cancelRefresh(ex);
//向呼叫者傳播異常。
throw ex;
}
finally {
//在Spring的core中重置常見的內省快取，因為我們可能不再需要單例bean的元資料了...
resetCommonCaches();
}
}
}
接下來我們要分析refresh()裡面的這些方法
3.1 prepareRefresh ()重新整理預處理方法:
/**
*準備此上下文以進行重新整理，設定其啟動日期和
*活動標誌以及執行屬性源的任何初始化。
*/
protected void prepareRefresh() {
//設定容器啟動時間
this.startupDate = System.currentTimeMillis();
//啟動標識
this.closed.set(false);
this.active.set(true);
if (logger.isDebugEnabled()) {
if (logger.isTraceEnabled()) {
logger.trace("Refreshing " + this);
}
else {
logger.debug("Refreshing " + getDisplayName());
}
}
//空方法，用於子容器自定義個性化的屬性設定方法
initPropertySources();
//檢驗屬性的合法等
getEnvironment().validateRequiredProperties();
//儲存預重新整理應用程式監聽器…
if (this.earlyApplicationListeners == null) {
this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);
}
else {
//將本地應用程式偵聽器重置為預重新整理狀態。
this.applicationListeners.clear();
this.applicationListeners.addAll(this.earlyApplicationListeners);
}
//儲存容器中的一些早期的事件
this.earlyApplicationEvents = new LinkedHashSet<>();
}
3.2 obtainFreshBeanFactory()方法
該方法獲取重新整理後的內部Bean工廠，obtainFreshBeanFactory方法為內部bean工廠重新生成id，並返回bean工廠
/**
*告訴子類重新整理內部bean工廠。
* @return新鮮的BeanFactory例項
* @see #refreshBeanFactory（）
* @see #getBeanFactory（）
*/
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
/**
*為beanfactory生成唯一序列化id，beanfactory已經在GenericApplicationContext建構函式中初始化了，
*refreshBeanFactory的邏輯在AbstractApplicationContext的實現類GenericApplicationContext中
*/
refreshBeanFactory();
//獲取beanfactory return getBeanFactory(); }
GenericApplicationContext類的refreshBeanFactory()方法
//---------------------------------------------------------------------
實現AbstractApplicationContext的模板方法
//---------------------------------------------------------------------
/ * *
*什麼都不做:我們只有一個內部BeanFactory，並且依賴於呼叫者
*通過我們的公共方法(或BeanFactory的)註冊bean。
* @see # registerBeanDefinition
* /
@Override
protected final void refreshBeanFactory() throws IllegalStateException {
if (!this.refreshed.compareAndSet(false, true)) {
throw new IllegalStateException(
"GenericApplicationContext does not support multiple refresh attempts: just call 'refresh' once");
}
//生成一個序列化id
this.beanFactory.setSerializationId(getId());
}
這裡使用AbstractApplicationContext.refreshBeanFactory()如果是註解的方式實現，則並沒有解析專案包下的註解，而是通過在refresh()方法中執行ConfigurationClassPostProcessor後置處理器完成對bean的載入.
3.3 prepareBeanFactory(beanFactory)方法
prepareBeanFactory主要完成beanFactory的一些屬性設定，BeanFactory的預準備工作
/**
*配置工廠的標準上下文特徵，
*例如上下文的ClassLoader和後置處理器。
* @param beanFactory要配置的BeanFactory
*/
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
//告訴內部bean工廠使用上下文的類載入器等等。
//設定類載入器
beanFactory.setBeanClassLoader(getClassLoader());
//bean表示式解析器
beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
//使用上下文回撥配置bean工廠。
//新增一個BeanPostProcessor實現ApplicationContextAwareProcessor
beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
//設定忽略的自動裝配介面，表示這些介面的實現類不允許通過介面自動注入
beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
//註冊可以自動裝配的元件，就是可以在任何元件中允許自動注入的元件
beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
beanFactory.registerResolvableDependency(ResourceLoader.class, this);
beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
beanFactory.registerResolvableDependency(ApplicationContext.class, this);
//將早期後置處理器註冊為application監聽器，用於檢測內部bean。
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
//新增編譯時的AspectJ
if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
//為匹配的型別設定一個臨時類載入器。
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
// 給beanfactory容器中註冊元件ConfigurableEnvironment、systemProperties、systemEnvironment
if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
}
if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
}
if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
}
}
3.4 invokeBeanFactoryPostProcessors(beanFactory)方法
invokeBeanFactoryPostProcessors 執行bean工廠後置處理器
/**
*例項化並呼叫所有已註冊的BeanFactoryPostProcessor beans，
*如果給定則遵守顯示的順序。
* <p>必須在單例例項化之前呼叫。
*/
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
}
invokeBeanFactoryPostProcessors方法內部執行實現了BeanFactoryPostProcessor、BeanDefinitionRegistryPostProcessor這兩個介面的Processor，先獲取所有BeanDefinitionRegistryPostProcessor的實現，按優先順序執行（是否實現PriorityOrdered優先順序介面，是否實現Ordered順序介面）；再以相同的策略執行所有BeanFactoryPostProcessor的實現。
PostProcessorRegistrationDelegate. invokeBeanFactoryPostProcessors實現:
public static void invokeBeanFactoryPostProcessors(
ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
//如果有的話，首先呼叫BeanDefinitionRegistryPostProcessors。
Set<String> processedBeans = new HashSet<>();
if (beanFactory instanceof BeanDefinitionRegistry) {
BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
BeanDefinitionRegistryPostProcessor registryProcessor =
(BeanDefinitionRegistryPostProcessor) postProcessor;
registryProcessor.postProcessBeanDefinitionRegistry(registry);
registryProcessors.add(registryProcessor);
}
else {
regularPostProcessors.add(postProcessor);
}
}
//不要在這裡初始化FactoryBeans：我們需要保留所有常規bean
//未初始化的，讓bean工廠的後置處理程式負責於它們!
List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
//首先，呼叫實現PriorityOrated介面的BeanDefinitionRegistryPostProcessors類的方法。
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
}
}
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
currentRegistryProcessors.clear();
//接下來，呼叫實現Ordered介面的BeanDefinitionRegistryPostProcessors類的方法。
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
}
}
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
currentRegistryProcessors.clear();
//最後，呼叫所有其他BeanDefinitionRegistryPostProcessors，直到沒有其他的後置處理器出現。
boolean reiterate = true;
while (reiterate) {
reiterate = false;
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
if (!processedBeans.contains(ppName)) {
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
reiterate = true;
}
}
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
currentRegistryProcessors.clear();
}
//現在，呼叫到目前為止處理完所有處理器的postProcessBeanFactory回撥。
invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
}
else {
//呼叫在上下文例項中註冊的工廠處理器。
invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
}
//不要在這裡初始化FactoryBeans:我們需要保留所有常規bean
//未初始化，以讓bean工廠的後值處理器負責於它們!
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
List<String> orderedPostProcessorNames = new ArrayList<>();
List<String> nonOrderedPostProcessorNames = new ArrayList<>();
for (String ppName : postProcessorNames) {
if (processedBeans.contains(ppName)) {
//跳過-已經在上面的第一階段處理
}
else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
}
else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
}
else {
nonOrderedPostProcessorNames.add(ppName);
}
}
//首先，呼叫實現PriorityOrated介面的BeanFactoryPostProcessors類。
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
//接下來，呼叫實現Ordered介面的BeanFactoryPostProcessors類方法。
List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>();
for (String postProcessorName : orderedPostProcessorNames) {
orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
sortPostProcessors(orderedPostProcessors, beanFactory);
invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
//最後，呼叫所有其他BeanFactoryPostProcessors，直到沒有其他的後置處理器出現。
List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
for (String postProcessorName : nonOrderedPostProcessorNames) {
nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
//清除快取的合併bean定義，因為後置處理器可能修改了原始元資料，例如替換了值中的佔位符……
beanFactory.clearMetadataCache();
}
這裡面在處理BeanDefinitionRegistryPostProcessors時有一個非常重要的過程，AnnotationConfigApplicationContext建構函式在初始化reader時為內部beanFactory容器初始化了一個id為org.springframework.context.annotation.internalConfigurationAnnotationProcessor的元件，這是一個ConfigurationClassPostProcessor元件，用來處理新增@Configuration註解的類，並將Bean定義註冊到BeanFactory中。
3.5 invokeBeanFactoryPostProcessors(beanFactory)方法
註冊後置處理器的大致邏輯是：
1.獲取所有的 BeanPostProcessor
2.根據處理器實現的介面區分出4中型別：
2.1.實現PriorityOrdered介面的處理器
2.2.實現Ordered介面的處理器，
2.3.實現MergedBeanDefinitionPostProcessor介面的處理器，
2.4.普通後置處理器
3.按這個4中型別依次註冊到容器中
4.註冊一個特殊的後置處理器ApplicationListenerDetector，ApplicationListenerDetector本身也實現了MergedBeanDefinitionPostProcessor介面
/ * *
*例項化並註冊所有BeanPostProcessor bean，如果給定則遵循顯式順序。
* <p>必須在應用程式bean的任何例項化之前呼叫。
* /
protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
}
public static void registerBeanPostProcessors(
ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
//註冊BeanPostProcessorChecker，當bean在BeanPostProcessor例項化過程中被建立時，即當一個bean沒有資格被所有BeanPostProcessor處理時，它記錄一條資訊到日誌。
int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
//按優先順序分類
List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
List<String> orderedPostProcessorNames = new ArrayList<>();
List<String> nonOrderedPostProcessorNames = new ArrayList<>();
for (String ppName : postProcessorNames) {
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
priorityOrderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
}
else {
nonOrderedPostProcessorNames.add(ppName);
}
}
//首先，呼叫實現PriorityOrated介面的BeanPostProcessors類。
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
//接下來，呼叫實現Ordered介面的BeanPostProcessors類方法。
List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>();
for (String ppName : orderedPostProcessorNames) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
orderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
sortPostProcessors(orderedPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, orderedPostProcessors);
//現在，註冊所有常規的BeanPostProcessors。
List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
for (String ppName : nonOrderedPostProcessorNames) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
nonOrderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
//最後，呼叫所有其他BeanPostProcessors，直到沒有其他的後置處理器出現。
sortPostProcessors(internalPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, internalPostProcessors);
//註冊ApplicationListenerDetector，用於Bean建立完時檢查是否是ApplicationListener
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}
3.6 initMessageSource()方法
初始化MessageSource元件（做國際化功能；訊息繫結，訊息解析）
/ * *
初始化MessageSource。
*如果在此上下文中沒有定義，則使用父類的。
* /
protected void initMessageSource() {
//獲取beanFactory
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
//讓MessageSource知道父類的MessageSource。
if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;
if (hms.getParentMessageSource() == null) {
//如果沒有註冊父類的MessageSource，則只將父類的上下文設定為父類的MessageSource。
hms.setParentMessageSource(getInternalParentMessageSource());
}
}
if (logger.isTraceEnabled()) {
logger.trace("Using MessageSource [" + this.messageSource + "]");
}
}
else {
//使用空的MessageSource來接受getMessage呼叫。
DelegatingMessageSource dms = new DelegatingMessageSource();
dms.setParentMessageSource(getInternalParentMessageSource());
this.messageSource = dms;
beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
if (logger.isTraceEnabled()) {
logger.trace("No '" + MESSAGE_SOURCE_BEAN_NAME + "' bean, using [" + this.messageSource + "]");
}
}
}
3.7 initApplicationEventMulticaster()方法
初始化事件派發器
/ * *
初始化ApplicationEventMulticaster。
如果上下文中沒有定義，則使用SimpleApplicationEventMulticaster。
* @see org.springframework.context.event.SimpleApplicationEventMulticaster
* /
protected void initApplicationEventMulticaster() {
//獲取BeanFactory
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
//如果有配置beanName為applicationEventMulticaster的事件派發器，則將其賦給容器中的applicationEventMulticaster物件
if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
this.applicationEventMulticaster =
beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
if (logger.isTraceEnabled()) {
logger.trace("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
}
}
else {
//不存在，則建立一個SimpleApplicationEventMulticaster事件派發器，並註冊到beanfactory中
this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
if (logger.isTraceEnabled()) {
logger.trace("No '" + APPLICATION_EVENT_MULTICASTER_BEAN_NAME + "' bean, using " +
"[" + this.applicationEventMulticaster.getClass().getSimpleName() + "]");
}
}
}
3.8 registerListeners()方法
registerListeners方法主要實現將事件監聽器新增到IOC容器中的事件派發器中，並在最後做了一個事件釋出的邏輯(如果之前的步驟有產生事件，則將earlyApplicationEvents中儲存的事件逐一發布)
/ * *
新增實現ApplicationListener作為偵聽器的bean。
*不影響其他偵聽器，可以在不新增bean的情況下新增。
* /
protected void registerListeners() {
//首先註冊靜態指定的監聽器。
for (ApplicationListener<?> listener : getApplicationListeners()) {
getApplicationEventMulticaster().addApplicationListener(listener);
}
//不要在這裡初始化factorybean:我們需要不初始化所有常規bean，以便讓後置處理器處理它們
String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
for (String listenerBeanName : listenerBeanNames) {
getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
}
//釋出早期的application事件…
Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
this.earlyApplicationEvents = null;
if (earlyEventsToProcess != null) {
for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
getApplicationEventMulticaster().multicastEvent(earlyEvent);
}
}
}
3.9 finishBeanFactoryInitialization(beanFactory)方法
初始化所有剩下的單例項bean,單例bean在初始化容器時建立，原型bean在獲取時（getbean）時建立
/ * *
*完成這個上下文的bean工廠的初始化，
初始化所有剩餘的單例bean。
* /
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
//初始化此上下文的轉換服務。
if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
beanFactory.setConversionService(
beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
}
//如果之前沒有註冊bean後置處理器(例如PropertyPlaceholderConfigurer bean)，則註冊一個預設的嵌入式值解析器:此時，主要用於在註釋屬性值中進行解析。
if (!beanFactory.hasEmbeddedValueResolver()) {
beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
}
//提前初始化LoadTimeWeaverAware beans，以便儘早註冊它們的轉換器。
String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
for (String weaverAwareName : weaverAwareNames) {
getBean(weaverAwareName);
}
//停止使用臨時類載入器進行型別匹配。
beanFactory.setTempClassLoader(null);
//允許快取所有bean定義元資料，不需要進一步更改。
beanFactory.freezeConfiguration();
//例項化所有剩餘的(非懶載入初始化)單例。
beanFactory.preInstantiateSingletons();
}
DefaultListableBeanFactory. preInstantiateSingletons()方法的實現：
@Override
public void preInstantiateSingletons() throws BeansException {
if (logger.isTraceEnabled()) {
logger.trace("Pre-instantiating singletons in " + this);
}
//容器中所有bean名稱
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
for (String beanName : beanNames) {
//獲取Bean的定義資訊；RootBeanDefinition
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
//非抽象，單例，非延遲載入
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
//是否是FactoryBean
if (isFactoryBean(beanName)) {
// 通過"&beanName"獲取工廠Bean例項
Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
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 {
//不是FactoryBean,則利用getBean(beanName)例項化bean
getBean(beanName);
}
}
}
for (String beanName : beanNames) {
Object singletonInstance = getSingleton(beanName);
if (singletonInstance instanceof SmartInitializingSingleton) {
final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
smartSingleton.afterSingletonsInstantiated();
return null;
}, getAccessControlContext());
}
else {
smartSingleton.afterSingletonsInstantiated();
}
}
}
}
3.10 finishRefresh()方法
完成BeanFactory的初始化建立工作，程式碼走到這一步IOC容器就建立完成
/ * *
*呼叫LifecycleProcessor，完成此上下文的重新整理
方法併發布
* {@link org.springframework.context.event.ContextRefreshedEvent}。
* /
protected void finishRefresh() {
//清除上下文級的資源快取(例如來自掃描的ASM元資料)。
clearResourceCaches();
//初始化和生命週期有關的後置處理器LifecycleProcessor，預設DefaultLifecycleProcessor
initLifecycleProcessor();
// 回撥生命週期處理器
getLifecycleProcessor().onRefresh();
//釋出容器重新整理完成事件：ContextRefreshedEvent
publishEvent(new ContextRefreshedEvent(this));
LiveBeansView.registerApplicationContext(this);
}
以上基本分析了AnnotationConfigApplicationContext容器的初始化過程， Spring容器在啟動過程中，會先儲存所有註冊進來的Bean的定義資訊；Spring容器根據條件建立Bean例項，區分單例，還是原型，後置處理器等（後置處理器會在容器建立過程中通過getBean建立，並執行相應的邏輯）；Spring容器在建立bean例項後，會使用多種後置處理器來增加bean的功能，比如處理自動注入，AOP，非同步，這種後置處理器機制也豐富了bean的功能。
我這邊在AnnotationConfigApplicationContext啟動原理分析的程式碼走讀部分有參考部落格： https://www.cnblogs.com/ashleyboy/p/9662119.html ，不過有些類的方法會有點不一樣，因為我這邊時基於Spring5.X的版本分析
&n