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启动过程内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！