当前位置： 移动技术网 > IT编程>开发语言>Java > 深入springboot原理——一步步分析springboot启动机制（starter机制）

深入springboot原理——一步步分析springboot启动机制（starter机制）

2019年01月29日  | 移动技术网IT编程  | 我要评论

前言

使用过springboot的同学应该已经知道，springboot通过默认配置了很多框架的使用方式帮我们大大简化了项目初始搭建以及开发过程。本文的目的就是一步步分析springboot的启动过程，分析springboot是如何帮我们简化这个过程的。

springboot帮我们做了什么

通常搭建一个基于spring的web应用，我们需要做以下工作：

1、pom文件中引入相关jar包，包括spring、springmvc、redis、mybaits、log4j、mysql-connector-java 等等相关jar ...

2、配置web.xml，listener配置、filter配置、servlet配置、log4j配置、error配置 ...

3、配置数据库连接、配置spring事务

4、配置视图解析器

5、开启注解、自动扫描功能

6、配置完成后部署tomcat、启动调试

......

搭个初始项目不一会就一个小时甚至半天过去了。而用springboot后，一切都变得很简便快速。下来我们来一步步分析springboot的起步依赖与自动配置这两个核心原理。

起步依赖

在springboot中我们只需要引入下面简单的几步就可以完成一个ssm后台项目的初始搭建。

1、引入jar

<parent>
    <groupid>org.springframework.boot</groupid>
    <artifactid>spring-boot-starter-parent</artifactid>
    <version>2.0.4.release</version>
    <relativepath/> <!-- lookup parent from repository -->
</parent>
<!--mybatis 开发包-->
<dependency>
    <groupid>org.mybatis.spring.boot</groupid>
    <artifactid>mybatis-spring-boot-starter</artifactid>
    <version>1.3.2</version>
</dependency>
<!--springboot web模块支持-->
<dependency>
    <groupid>org.springframework.boot</groupid>
    <artifactid>spring-boot-starter-web</artifactid>
</dependency>
<dependency>
    <groupid>mysql</groupid>
    <artifactid>mysql-connector-java</artifactid>
    <scope>runtime</scope>
</dependency>
<!--druid 的数据源-->
<dependency>
    <groupid>com.alibaba</groupid>
    <artifactid>druid</artifactid>
    <version>1.0.31</version>
</dependency>

spring-boot-starter-web包自动帮我们引入了web模块开发需要的相关jar包，

mybatis-spring-boot-starter帮我们引入了dao开发相关的jar包。

spring-boot-starter-xxx是官方提供的starter，xxx-spring-boot-starter是第三方提供的starter。

如下截图：

可以看出在这个mybatis-spring-boot-starter 中，并没有任何源码，只有一个pom文件，它的作用就是帮我们引入了相关jar包。

2、配置数据源

spring:
  datasource:
     url: jdbc:mysql://127.0.0.1:3306/mybatis_test
     username: root
     password: root
     driver-class-name: com.mysql.jdbc.driver
     type: com.alibaba.druid.pool.druiddatasource
     dbcp2:
       min-idle: 5
       initial-size: 5
       max-total: 5
       max-wait-millis: 200

 stater机制帮我们完成了项目起步所需要的的相关jar包。那问题又来了，传统的spring应用中不是要在application.xml中配置很多bean的吗，比如datasource的配置，transactionmanager的配置 ... springboot是如何帮我们完成这些bean的配置的？下面我们来分析这个过程

自动配置

基于java代码的bean配置

以mybatis为例，在上面的截图中，我们发下mybatis-spring-boot-starter这个包帮我们引入了mybatis-spring-boot-autoconfigure这个包，如下图：

里面有mybatisautoconfiguration这个类，打开这个类看看有什么东西。

熟悉@configuration&、@bean这两个bean的同学或许已经知道了。这两个注解一起使用就可以创建一个基于java代码的配置类，可以用来替代相应的xml配置文件。

@configuration注解的类可以看作是能生产让spring ioc容器管理的bean实例的工厂。

@bean注解告诉spring，一个带有@bean的注解方法将返回一个对象，该对象应该被注册到spring容器中。

 传统的基于xml的bean配置方法如下：

<beans>  
    <bean id = "car" class="com.test.car">  
        <property name="wheel" ref = "wheel"></property>  
    </bean>  
    <bean id = "wheel" class="com.test.wheel"></bean>  
</beans>

相当于用基于java代码的配置方式：

@configuration  
public class conf {  
    @bean  
    public car car() {  
        car car = new car();  
        car.setwheel(wheel());  
        return car;  
    }  
    @bean   
    public wheel wheel() {  
        return new wheel();  
    }  
}

所以上面的mybatisautoconfiguration这个类，自动帮我们生成了sqlsessionfactory这些mybatis的重要实例并交给spring容器管理，从而完成bean的自动注册。

自动配置条件依赖

从mybatisautoconfiguration这个类中使用的注解可以看出，要完成自动配置是有依赖条件的。

@configuration
@conditionalonclass({sqlsessionfactory.class, sqlsessionfactorybean.class})
@conditionalonbean({datasource.class})
@enableconfigurationproperties({mybatisproperties.class})
@autoconfigureafter({datasourceautoconfiguration.class})
public class mybatisautoconfiguration {
//....
}

这些是springboot特有的，常见的条件依赖注解有：

@conditionalonbean，仅在当前上下文中存在某个bean时，才会实例化这个bean。

@conditionalonclass，某个class位于类路径上，才会实例化这个bean。

@conditionalonexpression，当表达式为true的时候，才会实例化这个bean。

@conditionalonmissingbean，仅在当前上下文中不存在某个bean时，才会实例化这个bean。

@conditionalonmissingclass，某个class在类路径上不存在的时候，才会实例化这个bean。

@conditionalonnotwebapplication，不是web应用时才会实例化这个bean。

@autoconfigureafter，在某个bean完成自动配置后实例化这个bean。

@autoconfigurebefore，在某个bean完成自动配置前实例化这个bean。

所以要完成mybatis的自动配置，需要在类路径中存在sqlsessionfactory.class、sqlsessionfactorybean.class这两个类，需要存在datasource这个bean且这个bean完成自动注册。

进入datasourceautoconfiguration这个类，可以看到这个类属于这个包：

org.springframework.boot.autoconfigure.jdbc

这个包又属于spring-boot-autoconfigure-2.0.4.release.jar这个包，自动配置这个包帮们引入了jdbc、kafka、logging、mail、mongo等包。很多包需要我们引入相应jar后自动配置才生效。

bean参数获取

到此我们已经知道了bean的配置过程，但是还没有看到springboot是如何读取yml或者properites配置文件的的属性来创建数据源的？

在datasourceautoconfiguration类里面，我们注意到使用了enableconfigurationproperties这个注解。

@configuration
@conditionalonclass({datasource.class, embeddeddatabasetype.class})
@enableconfigurationproperties({datasourceproperties.class})
@import({datasourcepoolmetadataprovidersconfiguration.class, datasourceinitializationconfiguration.class})
public class datasourceautoconfiguration {
...
}

datasourceproperties中封装了数据源的各个属性，且使用了注解configurationproperties指定了配置文件的前缀。

@configurationproperties(
    prefix = "spring.datasource"
)
public class datasourceproperties implements beanclassloaderaware, initializingbean {
    private classloader classloader;
    private string name;
    private boolean generateuniquename;
    private class<? extends datasource> type;
    private string driverclassname;
    private string url;
    private string username;
    private string password;
    private string jndiname;
    ...
}

@enableconfigurationproperties与@configurationproperties这两个注解有什么用呢？我们先看一个例子：

@component
@configurationproperties(prefix="spring.datasource")
public class propertiesbean {
    private string url;
    private string username;
    private string password;
    //省略getter、setter...
    @override
    public string tostring() {
        return "propertiesbean{" +
                "url='" + url + '\'' +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}
@springbootapplication
@mapperscan("com.itpsc.mapper*")
@enableconfigurationproperties
public class springbootmybatisdemoapplication {
    public static void main(string[] args) {
        //springapplication.run(springbootmybatisdemoapplication.class, args);
        configurableapplicationcontext context = springapplication.run(springbootmybatisdemoapplication.class, args);
         //获取yml配置转换后的bean
        system.out.println("----------------------"+context.getbean(propertiesbean.class));
        context.close();
    }
}

运行结果：

 

从运行结果可以看出@configurationproperties与@enableconfigurationpropertie的作用就是：

@configurationproperties注解的作用是把yml或者properties配置文件转化为bean。

@enableconfigurationproperties注解的作用是使@configurationproperties注解生效。如果只配置@configurationproperties注解，在spring容器中是获取不到yml或者properties配置文件转化的bean的。

 

通过这种方式，把yml或者properties配置参数转化为bean，这些bean又是如何被发现与加载的？

bean发现

springboot默认扫描启动类所在的包下的主类与子类的所有组件，但并没有包括依赖包的中的类，那么依赖包中的bean是如何被发现和加载的？

 

我们通常在启动类中加@springbootapplication这个注解，点进去看

@target({elementtype.type})
@retention(retentionpolicy.runtime)
@documented
@inherited
@springbootconfiguration
@enableautoconfiguration
@componentscan(
    excludefilters = {@filter(
    type = filtertype.custom,
    classes = {typeexcludefilter.class}
), @filter(
    type = filtertype.custom,
    classes = {autoconfigurationexcludefilter.class}
)}
)
public @interface springbootapplication {
...
}

实际上重要的只有三个annotation：

@configuration（@springbootconfiguration里面还是应用了@configuration）

@enableautoconfiguration

@componentscan

 

@configuration的作用上面我们已经知道了，被注解的类将成为一个bean配置类。

@componentscan的作用就是自动扫描并加载符合条件的组件，比如@component和@repository等，最终将这些bean定义加载到spring容器中。

@enableautoconfiguration 这个注解的功能很重要，借助@import的支持，收集和注册依赖包中相关的bean定义。

 

@target({elementtype.type})
@retention(retentionpolicy.runtime)
@documented
@inherited
@autoconfigurationpackage
@import({autoconfigurationimportselector.class})
public @interface enableautoconfiguration {
    string enabled_override_property = "spring.boot.enableautoconfiguration";

    class<?>[] exclude() default {};

    string[] excludename() default {};
}

如上源码，@enableautoconfiguration注解引入了@autoconfigurationpackage和@import这两个注解。@autoconfigurationpackage的作用就是自动配置的包，@import导入需要自动配置的组件。

 

进入@autoconfigurationpackage，发现也是引入了@import注解

@target({elementtype.type})
@retention(retentionpolicy.runtime)
@documented
@inherited
@import({registrar.class})
public @interface autoconfigurationpackage {
}
static class registrar implements importbeandefinitionregistrar, determinableimports {
        registrar() {
        }

        public void registerbeandefinitions(annotationmetadata metadata, beandefinitionregistry registry) {
            autoconfigurationpackages.register(registry, new string[]{(new autoconfigurationpackages.packageimport(metadata)).getpackagename()});
        }

        public set<object> determineimports(annotationmetadata metadata) {
            return collections.singleton(new autoconfigurationpackages.packageimport(metadata));
        }
    }

new autoconfigurationpackages.packageimport(metadata)).getpackagename()

new autoconfigurationpackages.packageimport(metadata)

这两句代码的作用就是加载启动类所在的包下的主类与子类的所有组件注册到spring容器，这就是前文所说的springboot默认扫描启动类所在的包下的主类与子类的所有组件。

 

那问题又来了，要搜集并注册到spring容器的那些beans来自哪里？

进入 autoconfigurationimportselector类，

public class autoconfigurationimportselector implements deferredimportselector, beanclassloaderaware, resourceloaderaware, beanfactoryaware, environmentaware, ordered {
private static final string[] no_imports = new string[0];
...
    public string[] selectimports(annotationmetadata annotationmetadata) {
        if(!this.isenabled(annotationmetadata)) {
            return no_imports;
        } else {
            autoconfigurationmetadata autoconfigurationmetadata = autoconfigurationmetadataloader.loadmetadata(this.beanclassloader);
            annotationattributes attributes = this.getattributes(annotationmetadata);
            list configurations = this.getcandidateconfigurations(annotationmetadata, attributes);
            configurations = this.removeduplicates(configurations);
            set exclusions = this.getexclusions(annotationmetadata, attributes);
            this.checkexcludedclasses(configurations, exclusions);
            configurations.removeall(exclusions);
            configurations = this.filter(configurations, autoconfigurationmetadata);
            this.fireautoconfigurationimportevents(configurations, exclusions);
            return stringutils.tostringarray(configurations);
        }
    }
...

    protected list<string> getcandidateconfigurations(annotationmetadata metadata, annotationattributes attributes) {
        list configurations = springfactoriesloader.loadfactorynames(this.getspringfactoriesloaderfactoryclass(), this.getbeanclassloader());
        assert.notempty(configurations, "no auto configuration classes found in meta-inf/spring.factories. if you are using a custom packaging, make sure that file is correct.");
        return configurations;
    }

...

}

 

springfactoriesloader.loadfactorynames方法调用loadspringfactories方法从所有的jar包中读取meta-inf/spring.factories文件信息。

 

private static map<string, list<string>> loadspringfactories(@nullable classloader classloader) {
        multivaluemap result = (multivaluemap)cache.get(classloader);
        if(result != null) {
            return result;
        } else {
            try {
                enumeration ex = classloader != null?classloader.getresources("meta-inf/spring.factories"):classloader.getsystemresources("meta-inf/spring.factories");
                linkedmultivaluemap result1 = new linkedmultivaluemap();

                while(ex.hasmoreelements()) {
                    url url = (url)ex.nextelement();
                    urlresource resource = new urlresource(url);
                    properties properties = propertiesloaderutils.loadproperties(resource);
                    iterator var6 = properties.entryset().iterator();

                    while(var6.hasnext()) {
                        entry entry = (entry)var6.next();
                        list factoryclassnames = arrays.aslist(stringutils.commadelimitedlisttostringarray((string)entry.getvalue()));
                        result1.addall((string)entry.getkey(), factoryclassnames);
                    }
                }

                cache.put(classloader, result1);
                return result1;
            } catch (ioexception var9) {
                throw new illegalargumentexception("unable to load factories from location [meta-inf/spring.factories]", var9);
            }
        }
    }

 

下面是spring-boot-autoconfigure这个jar中spring.factories文件部分内容，其中有一个key为org.springframework.boot.autoconfigure.enableautoconfiguration的值定义了需要自动配置的bean，通过读取这个配置获取一组@configuration类。

 

org.springframework.boot.autoconfigure.autoconfigurationimportlistener=\
org.springframework.boot.autoconfigure.condition.conditionevaluationreportautoconfigurationimportlistener

# auto configuration import filters
org.springframework.boot.autoconfigure.autoconfigurationimportfilter=\
org.springframework.boot.autoconfigure.condition.onclasscondition

# auto configure
org.springframework.boot.autoconfigure.enableautoconfiguration=\
org.springframework.boot.autoconfigure.admin.springapplicationadminjmxautoconfiguration,\
org.springframework.boot.autoconfigure.aop.aopautoconfiguration,\
org.springframework.boot.autoconfigure.amqp.rabbitautoconfiguration,\
org.springframework.boot.autoconfigure.batch.batchautoconfiguration,\
org.springframework.boot.autoconfigure.cache.cacheautoconfiguration,\

 

每个xxxautoconfiguration都是一个基于java的bean配置类。实际上，这些xxxautoconfiguratio不是所有都会被加载，会根据xxxautoconfiguration上的@conditionalonclass等条件判断是否加载。

 

private static <t> t instantiatefactory(string instanceclassname, class<t> factoryclass, classloader classloader) {
        try {
            class ex = classutils.forname(instanceclassname, classloader);
            if(!factoryclass.isassignablefrom(ex)) {
                throw new illegalargumentexception("class [" + instanceclassname + "] is not assignable to [" + factoryclass.getname() + "]");
            } else {
                return reflectionutils.accessibleconstructor(ex, new class[0]).newinstance(new object[0]);
            }
        } catch (throwable var4) {
            throw new illegalargumentexception("unable to instantiate factory class: " + factoryclass.getname(), var4);
        }
    }

 如上代码段，通过反射机制将spring.factories中@configuration类实例化为对应的java实列。到此我们已经知道怎么发现要自动配置的bean了，最后一步就是怎么样将这些bean加载到spring容器。

bean加载

如果要让一个普通类交给spring容器管理，通常有以下方法：

1、使用 @configuration与@bean 注解

2、使用@controller @service @repository @component 注解标注该类，然后启用@componentscan自动扫描

3、使用@import 方法

 

springboot中使用了@import 方法

@enableautoconfiguration注解中使用了@import({autoconfigurationimportselector.class})注解，autoconfigurationimportselector实现了deferredimportselector接口，

deferredimportselector接口继承了importselector接口，importselector接口只有一个selectimports方法。

 

public class autoconfigurationimportselector implements deferredimportselector{
...
    public string[] selectimports(annotationmetadata annotationmetadata) {
        if(!this.isenabled(annotationmetadata)) {
            return no_imports;
        } else {
            autoconfigurationmetadata autoconfigurationmetadata = autoconfigurationmetadataloader.loadmetadata(this.beanclassloader);
            annotationattributes attributes = this.getattributes(annotationmetadata);
            list configurations = this.getcandidateconfigurations(annotationmetadata, attributes);
            configurations = this.removeduplicates(configurations);
            set exclusions = this.getexclusions(annotationmetadata, attributes);
            this.checkexcludedclasses(configurations, exclusions);
            configurations.removeall(exclusions);
            configurations = this.filter(configurations, autoconfigurationmetadata);
            this.fireautoconfigurationimportevents(configurations, exclusions);
            return stringutils.tostringarray(configurations);
        }
}
...
}
public interface deferredimportselector extends importselector {
    @nullable
    default class<? extends deferredimportselector.group> getimportgroup() {
        return null;
}
public interface group {...}
}
public interface importselector {
    string[] selectimports(annotationmetadata var1);
}

 我们先通过一个简单例子看看@import注解是如何将bean导入到spring容器的。

1、新建一个bean

 

public class user {
    private long id;
    private string name;
    private string password;
private string phone;
...
}

2、创建一个itpscselector类继承importselector接口并实现selectimports方法

public class itpscselector implements importselector {
    public string[] selectimports(annotationmetadata importingclassmetadata) {
        return new string[]{"com.itpsc.entity.user"};
    }
}

3、创建importconfig类，使用@configuration、@import(itpscselector.class)注解。

@configuration
@import(itpscselector.class)
public class importconfig {
}

4、从容器获取bean

@runwith(springrunner.class)
@springboottest
public class importselectortests {
    @test
    public void testselectimport() {
        applicationcontext ctx = new annotationconfigapplicationcontext(importconfig.class);
        string[] beandefinitionnames = ctx.getbeandefinitionnames();
        for (string name : beandefinitionnames) {
            system.out.println(name);
        }
    }
}

运行结果：

org.springframework.context.annotation.internalconfigurationannotationprocessor
org.springframework.context.annotation.internalautowiredannotationprocessor
org.springframework.context.annotation.internalrequiredannotationprocessor
org.springframework.context.annotation.internalcommonannotationprocessor
org.springframework.context.event.internaleventlistenerprocessor
org.springframework.context.event.internaleventlistenerfactory
importconfig
com.itpsc.entity.user

很直观，selectimports方法返回一组bean，@enableautoconfiguration注解借助@import注解将这组bean注入到spring容器中，springboot正式通过这种机制来完成bean的注入的。

总结

我们可以将自动配置的关键几步以及相应的注解总结如下：

您可能感兴趣的文章:

如对本文有疑问， 点击进行留言回复！！

相关文章:

验证码：
最近更新的文章
大家感兴趣的文章
移动技术网