Spring啟動(dòng)過程源碼分析及簡(jiǎn)介

更新時(shí)間：2021年10月20日 14:08:46 作者：薩科拉

本文是通過AnnotationConfigApplicationContext讀取配置類來(lái)一步一步去了解Spring的啟動(dòng)過程。本文重點(diǎn)給大家介紹Spring啟動(dòng)過程源碼分析及基本概念，感興趣的朋友一起看看吧

1、BeanDefinition

BeanDefinition就是Bean的定義，它是用來(lái)描述Bean的，里面存放著關(guān)于Bean的一系列信息，比如Bean的作用域，Bean所對(duì)應(yīng)的Class，是否懶加載等等，BeanDfinition與Bean的關(guān)系可以看作是類和class的關(guān)系，那么有人說，有class對(duì)象就好啦，但是Class不能完完全全的抽象出Bean，比如說，Bean的注入模型，是否懶加載，是否是工廠bean等等，這些是class無(wú)法去抽象出來(lái)的，所以需要BeanDefinition來(lái)描述Bean，在Spring中，我們可以通過<Bean><Bean/>、@Component、BeanDefinition來(lái)定義Bean

//定義一個(gè)BeanDefinition
AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();
//設(shè)置當(dāng)前bean的class 1、通過class獲取 2、通過類的全限定類名獲取
//beanDefinition.setBeanClass(Testt.class);
beanDefinition.setBeanClassName("com.beans.Testt");
//將beanDefinition注冊(cè)到BeanFactory中
DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
factory.registerBeanDefinition("BEAN",beanDefinition);
//獲取Bean
factory.getBean("BEAN");

還可以直接使用RootBeanDefinition來(lái)獲取BeanDefinition

//生成BeanDefinition
RootBeanDefinition rootBeanDefinition = new RootBeanDefinition(Testt.class);
DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
//將BeanDefinition注冊(cè)到工廠中
factory.registerBeanDefinition("tt",rootBeanDefinition);
Object tt = factory.getBean("tt");
System.out.println(tt);

通過上述三種方式我們就可以定義一個(gè)Bean。

假設(shè)我們有一個(gè)實(shí)體類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來(lái)給name屬性賦值

//生成一個(gè)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);
//通過實(shí)例獲取name的值
String name1 = tt.getName();
System.out.println(name1); //123
System.out.println(name);//123

BeanDefinition還可以

beanDefinition.setScope("prototype"); // 設(shè)置作用域
beanDefinition.setInitMethodName("init"); // 設(shè)置初始化方法
beanDefinition.setAutowireMode(0); // 設(shè)置自動(dòng)裝配模型 0默認(rèn)裝配模式不自動(dòng)注入，1 ByName 2 ByType 3 構(gòu)造器注入 
......

BeanDefinition還有很多功能，在這里就不一一去說明了，感興趣的讀者可以通過查看beanDefinition的接口和實(shí)現(xiàn)類對(duì)其一一了解。

無(wú)論通過哪種方式來(lái)定義Bean，都會(huì)被解析為BeanDefinition對(duì)象，總之，Bean與BeanDefinition之間的關(guān)系你是可以看作是類和class的關(guān)系，這樣就很容易去理解它了。

這里有一個(gè)mergedBeanDefinitions，我們來(lái)說一下它是做什么的，mergedBeanDefinitions是存儲(chǔ)合并后的BeanDefinition的ConcurrentHashMap,Spring會(huì)對(duì)BeanDefinition進(jìn)行合并，基于合并后的BeanDefinition去創(chuàng)建Bean

private final Map<String, RootBeanDefinition> mergedBeanDefinitions = new ConcurrentHashMap<>(256);

那么，什么時(shí)候beanDefinition會(huì)進(jìn)行合并呢？我們舉出下列的一個(gè)例子，來(lái)帶大家一探究竟

首先寫一個(gè)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設(shè)置為prototype，而children并沒有去設(shè)置他的scope屬性，默認(rèn)就是單例的，我們通過下面方式去調(diào)試，看看mergedBeanDefinitions中到底存的是什么

public class mainT {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext classPathXmlApplicationContext =
                                                        new ClassPathXmlApplicationContext("Spring.xml");
        classPathXmlApplicationContext.getBean("children");
    }
}

我們通過在getBean上打上斷點(diǎn)，進(jìn)行調(diào)試后，我們可以看到FactoryBean中的mergedBeanDefinitions存的參數(shù)如下圖所示

children的scope屬性也成為了prototype，這就是合并后的BeanDefinition。其實(shí)就相當(dāng)于子類繼承父類的時(shí)候包含父類的屬性

這里還要記錄一下RootBeanDefinition和GenericBeanDefinition的顯在區(qū)別

可以發(fā)現(xiàn)GenericBeanDefinition的SetParentName是正常的，可以添加

public void setParentName(@Nullable String parentName) {
        this.parentName = parentName;
    }

而RootBeanDefinition是會(huì)報(bào)錯(cuò)的，也會(huì)直接返回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

從名字來(lái)看，這是一個(gè)工廠類，它負(fù)責(zé)生產(chǎn)和管理bean，在Spring中，BeanFactory是IOC容器的核心接口，他有很多職責(zé)和功能，它的核心實(shí)現(xiàn)類是DefaultListableBeanefauFactory類。下圖是DefaultListableBeanefauFactory類的UML圖。

DefaultListableBeanefauFactory實(shí)現(xiàn)了很多接口，也說明了DefaultListableBeanefauFactory類繼承了很多功能

我們可以通過beanfactory做很多事，例如：

AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();
beanDefinition.setBeanClass(Testt.class);
DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
//注冊(cè)BeanDefinition
factory.registerBeanDefinition("Testt",beanDefinition);
//注冊(cè)別名
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個(gè)數(shù)
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的一種更更高級(jí)的容器，提供了更多有用的功能，我們可以看到ApplicationContext的實(shí)現(xiàn)類GenericApplicationContext中有一個(gè)屬性

private final DefaultListableBeanFactory beanFactory;

那么他既然已經(jīng)繼承了BeanFactory接口，為什么又要增加一個(gè)DefaultListableBeanFactory屬性呢，可以從上面看到DefaultListableBeanFactory實(shí)現(xiàn)了很多接口，擁有很多功能，這么做的目的就是，使GenericApplicationContext通過DefaultListableBeanFactory間接擁有了DefaultListableBeanFactory繼承的那些功能，而無(wú)需在去繼承或者實(shí)現(xiàn)。o

這里要說明一下別名和beanName的存儲(chǔ)，也是通過map去存儲(chǔ)的，{aliasname:beanname}，key為別名，value為bean的名字

3、BeanDefinitionReader

可以直接把某個(gè)類轉(zhuǎn)換為BeanDefinition，并且會(huì)解析該類上的注解，

它能解析的注解是：@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

這個(gè)并不是BeanDefinitionReader，但是它的作用和BeanDefinitionReader類似，它可以進(jìn)行掃描，掃描某個(gè)包路徑，對(duì)掃描到的類進(jìn)行解析，比如，掃描到的類上如果存在@Component注解，那么就會(huì)把這個(gè)類解析為一個(gè)BeanDefinition

DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
ClassPathBeanDefinitionScanner classPathBeanDefinitionScanner = new ClassPathBeanDefinitionScanner(factory);
//得到該包下類的個(gè)數(shù)
//        int scan = classPathBeanDefinitionScanner.scan("com.beans");
//        System.out.println(scan);//6
//掃描沒有加@Componment注解的類，并注冊(cè)到容器中，未通過注解或其他方式定義Bean的類也不會(huì)添加到容器中
//classPathBeanDefinitionScanner.addExcludeFilter(new AnnotationTypeFilter(Component.class));
//掃描加了@Componment注解的類，并注冊(cè)到容器中
classPathBeanDefinitionScanner.addIncludeFilter(new AnnotationTypeFilter(Component.class));
//獲取bean
Object bean = factory.getBean(BeanTest.class);
System.out.println(bean);//com.beans.BeanTest@5ccddd20

5、ConditionEvaluator

ConditionEvaluator是一個(gè)Spring中的內(nèi)部類，他提供了@Condition注解的判定條件作用，具體可以看它的shouldSkip方法。

6、Aware

Aware翻譯過來(lái)是感知的意思，他的用意是用來(lái)讓用戶感知到一些信息，比如說BeanNameAware

@Component
public class User implements BeanNameAware {
    private String awareName;
    @Override
    public void setBeanName(String name) {
        this.awareName = name;
    }
    public String getAwareName(){
        return awareName;
    }
}

我們寫一個(gè)User類來(lái)實(shí)現(xiàn)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());
    }
}