Spring啟動過程源碼分析及簡介
本文是通過AnnotationConfigApplicationContext讀取配置類來一步一步去瞭解Spring的啟動過程。
在看源碼之前，我們要知道某些類的作用，這樣更方便後續的瞭解。
1、BeanDefinition
BeanDefinition就是Bean的定義，它是用來描述Bean的，裡面存放著關於Bean的一系列信息，比如Bean的作用域，Bean所對應的Class，是否懶加載等等，BeanDfinition與Bean的關系可以看作是類和class的關系，那麼有人說，有class對象就好啦，但是Class不能完完全全的抽象出Bean，比如說，Bean的註入模型，是否懶加載，是否是工廠bean等等，這些是class無法去抽象出來的，所以需要BeanDefinition來描述Bean，在Spring中，我們可以通過<Bean><Bean/>、@Component、BeanDefinition來定義Bean
//定義一個BeanDefinition
AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();
//設置當前bean的class 1、通過class獲取 2、通過類的全限定類名獲取
//beanDefinition.setBeanClass(Testt.class);
beanDefinition.setBeanClassName("com.beans.Testt");
//將beanDefinition註冊到BeanFactory中
DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
factory.registerBeanDefinition("BEAN",beanDefinition);
//獲取Bean
factory.getBean("BEAN");
還可以直接使用RootBeanDefinition來獲取BeanDefinition
//生成BeanDefinition
RootBeanDefinition rootBeanDefinition = new RootBeanDefinition(Testt.class);
DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
//將BeanDefinition註冊到工廠中
factory.registerBeanDefinition("tt",rootBeanDefinition);
Object tt = factory.getBean("tt");
System.out.println(tt);
通過上述三種方式我們就可以定義一個Bean。
假設我們有一個實體類Testt
public class Testt {
public String name;
public void sayHello(){
System.out.println("Hello World!");
}
public void setName(String name){
this.name = name;
}
public String getName(){
return name;
}
}
我們還可以通過beanDefinition來給name屬性賦值
//生成一個BeanDefinition
RootBeanDefinition rootBeanDefinition = new RootBeanDefinition(Testt.class);
//賦值屬性name為123
rootBeanDefinition.getPropertyValues().addPropertyValue("name","123");
//獲取name的值
Object name = rootBeanDefinition.getPropertyValues().getPropertyValue("name").getValue();
DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
factory.registerBeanDefinition("tt",rootBeanDefinition);
Testt tt = (Testt) factory.getBean("tt");
System.out.println(tt);
//通過實例獲取name的值
String name1 = tt.getName();
System.out.println(name1); //123
System.out.println(name);//123
BeanDefinition還可以
beanDefinition.setScope("prototype"); // 設置作用域
beanDefinition.setInitMethodName("init"); // 設置初始化方法
beanDefinition.setAutowireMode(0); // 設置自動裝配模型 0默認裝配模式不自動註入，1 ByName 2 ByType 3 構造器註入
......
BeanDefinition還有很多功能，在這裡就不一一去說明瞭，感興趣的讀者可以通過查看beanDefinition的接口和實現類對其一一瞭解。
無論通過哪種方式來定義Bean，都會被解析為BeanDefinition對象，總之，Bean與BeanDefinition之間的關系你是可以看作是類和class的關系，這樣就很容易去理解它瞭。
這裡有一個mergedBeanDefinitions，我們來說一下它是做什麼的，mergedBeanDefinitions是存儲合並後的BeanDefinition的ConcurrentHashMap,Spring會對BeanDefinition進行合並，基於合並後的BeanDefinition去創建Bean
private final Map<String, RootBeanDefinition> mergedBeanDefinitions = new ConcurrentHashMap<>(256);
那麼，什麼時候beanDefinition會進行合並呢？我們舉出下列的一個例子，來帶大傢一探究竟
首先寫一個Spring.xml，我們通過xml文件去聲明bean
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="parent" scope="prototype"/>
<bean id="children" parent="parent"/>
</beans>
這裡，我們指將parent的scope設置為prototype，而children並沒有去設置他的scope屬性，默認就是單例的，我們通過下面方式去調試，看看mergedBeanDefinitions中到底存的是什麼
public class mainT {
public static void main(String[] args) {
ClassPathXmlApplicationContext classPathXmlApplicationContext =
new ClassPathXmlApplicationContext("Spring.xml");
classPathXmlApplicationContext.getBean("children");
}
}
我們通過在getBean上打上斷點，進行調試後，我們可以看到FactoryBean中的mergedBeanDefinitions存的參數如下圖所示
children的scope屬性也成為瞭prototype，這就是合並後的BeanDefinition。其實就相當於子類繼承父類的時候包含父類的屬性
這裡還要記錄一下RootBeanDefinition和GenericBeanDefinition的顯在區別
可以發現GenericBeanDefinition的SetParentName是正常的，可以添加
public void setParentName(@Nullable String parentName) {
this.parentName = parentName;
}
而RootBeanDefinition是會報錯的，也會直接返回null
@Override
public String getParentName() {
return null;
}
@Override
public void setParentName(@Nullable String parentName) {
if (parentName != null) {
throw new IllegalArgumentException("Root bean cannot be changed into a child bean with parent reference");
}
}
2、beanFactory
從名字來看，這是一個工廠類，它負責生產和管理bean，在Spring中，BeanFactory是IOC容器的核心接口，他有很多職責和功能，它的核心實現類是DefaultListableBeanefauFactory類。下圖是DefaultListableBeanefauFactory類的UML圖。
DefaultListableBeanefauFactory實現瞭很多接口，也說明瞭DefaultListableBeanefauFactory類繼承瞭很多功能
我們可以通過beanfactory做很多事，例如：
AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();
beanDefinition.setBeanClass(Testt.class);
DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
//註冊BeanDefinition
factory.registerBeanDefinition("Testt",beanDefinition);
//註冊別名
factory.registerAlias("Testt","T");
//獲取bean
Object alias = factory.getBean("T");
System.out.println(alias);//com.beans.Testt@6b1274d2
//通過類型獲取Bean
String[] beanNamesForType = factory.getBeanNamesForType(Testt.class);
System.out.println(beanNamesForType[0]);//Testt
//獲取BeanDefinition
BeanDefinition testt = factory.getBeanDefinition("Testt");
System.out.println(testt);
//Generic bean: class [com.beans.Testt]; scope=; abstract=false; lazyInit=null; autowireMode=0; //dependencyCheck=0; autowireCandidate=true; primary=false; factoryBeanName=null; factoryMethodName=null; //initMethodName=null; destroyMethodName=null
//獲取BeanDefinition個數
int beanDefinitionCount = factory.getBeanDefinitionCount();
System.out.println(beanDefinitionCount);
//獲取Bean的提供者
ObjectProvider<Testt> beanProvider = factory.getBeanProvider(Testt.class); System.out.println(beanProvider);
//org.springframework.beans.factory.support.DefaultListableBeanFactory$1@6a472554
等等。
ApplicationContext繼承BeanFactory接口，它是Spring的一種更更高級的容器，提供瞭更多有用的功能，我們可以看到ApplicationContext的實現類GenericApplicationContext中有一個屬性
private final DefaultListableBeanFactory beanFactory;
那麼他既然已經繼承瞭BeanFactory接口，為什麼又要增加一個DefaultListableBeanFactory屬性呢，可以從上面看到DefaultListableBeanFactory實現瞭很多接口，擁有很多功能，這麼做的目的就是，使GenericApplicationContext通過DefaultListableBeanFactory間接擁有瞭DefaultListableBeanFactory繼承的那些功能，而無需在去繼承或者實現。o
這裡要說明一下別名和beanName的存儲，也是通過map去存儲的，{aliasname:beanname}，key為別名，value為bean的名字
3、BeanDefinitionReader
可以直接把某個類轉換為BeanDefinition，並且會解析該類上的註解，
它能解析的註解是：@Conditional，@Scope、@Lazy、@Primary、@DependsOn、@Role、@Description
DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
AnnotatedBeanDefinitionReader Reader = new AnnotatedBeanDefinitionReader(factory);
/**
* 也可以使用registerBean(Testt.class) 或者 registerBean(Testt.class,"指定Bean名字")
**/
Reader.register(Testt.class);
Object testt = factory.getBean("testt");
System.out.println(testt);
4、ClassPathBeanDefinitionScanner
這個並不是BeanDefinitionReader，但是它的作用和BeanDefinitionReader類似，它可以進行掃描，掃描某個包路徑，對掃描到的類進行解析，比如，掃描到的類上如果存在@Component註解，那麼就會把這個類解析為一個BeanDefinition
DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
ClassPathBeanDefinitionScanner classPathBeanDefinitionScanner = new ClassPathBeanDefinitionScanner(factory);
//得到該包下類的個數
// int scan = classPathBeanDefinitionScanner.scan("com.beans");
// System.out.println(scan);//6
//掃描沒有加@Componment註解的類，並註冊到容器中，未通過註解或其他方式定義Bean的類也不會添加到容器中
//classPathBeanDefinitionScanner.addExcludeFilter(new AnnotationTypeFilter(Component.class));
//掃描加瞭@Componment註解的類，並註冊到容器中
classPathBeanDefinitionScanner.addIncludeFilter(new AnnotationTypeFilter(Component.class));
//獲取bean
Object bean = factory.getBean(BeanTest.class);
System.out.println(bean);//com.beans.BeanTest@5ccddd20
5、ConditionEvaluator
ConditionEvaluator是一個Spring中的內部類，他提供瞭@Condition註解的判定條件作用，具體可以看它的shouldSkip方法。
6、Aware
Aware翻譯過來是感知的意思，他的用意是用來讓用戶感知到一些信息，比如說BeanNameAware
@Component
public class User implements BeanNameAware {
private String awareName;
@Override
public void setBeanName(String name) {
this.awareName = name;
}
public String getAwareName(){
return awareName;
}
}
我們寫一個User類來實現BeanNameAware，重寫它的方法setBeanName，並將其賦值給我們的awareName
@ComponentScan("com.beans")
public class mainT {
public static void main(String[] args) {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(mainT.class);
User bean = context.getBean(User.class);
System.out.println(bean.getAwareName());
}
}
結果顯示，得到的bean的名字。
到此這篇關於Spring啟動過程源碼分析基本概念的文章就介紹到這瞭,更多相關Spring啟動過程內容請搜索WalkonNet以前的文章或繼續瀏覽下面的相關文章希望大傢以後多多支持WalkonNet！
推薦閱讀：
- Spring源碼解析容器初始化構造方法
- 手把手帶你實現一個萌芽版的Spring容器
- 關於Spring Bean實例過程中使用反射和遞歸處理的Bean屬性填充問題
- 深入瞭解Spring控制反轉IOC原理
- spring Bean創建的完整過程記錄