Spring启动过程源码分析基本概念

2021年11月20日 阅读数:2
这篇文章主要向大家介绍Spring启动过程源码分析基本概念,主要内容包括基础应用、实用技巧、原理机制等方面,希望对大家有所帮助。

Spring启动过程源码分析基本概念

本文是经过AnnotationConfigApplicationContext读取配置类来一步一步去了解Spring的启动过程。spring

在看源码以前,咱们要知道某些类的做用,这样更方便后续的了解。ide

一、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 一、经过class获取 二、经过类的全限定类名获取
//beanDefinition.setBeanClass(Testt.class);
beanDefinition.setBeanClassName("com.beans.Testt");
//将beanDefinition注册到BeanFactory中
DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
factory.registerBeanDefinition("BEAN",beanDefinition);
//获取Bean
factory.getBean("BEAN");

 

还能够直接使用RootBeanDefinition来获取BeanDefinitionui

//生成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。this

假设咱们有一个实体类Testtlua

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属性赋值spa

//生成一个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还能够prototype

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");
        }
    }

 

二、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的名字

三、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);

 

 

四、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

 

五、ConditionEvaluator

ConditionEvaluator是一个Spring中的内部类,他提供了@Condition注解的断定条件做用,具体能够看它的shouldSkip方法。

 

六、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的名字。