之前在排查一个线上问题时,不得不仔细跑了很多遍spring boot的代码,于是整理一下,我用的是1.4.3.release。
首先,普通的入口,这没什么好说的,我就随便贴贴代码了:
1
2
3
4
5
6
7
8
|
springapplication.run(application. class , args); --> public static configurableapplicationcontext run(object source, string... args) { return run( new object[] { source }, args); } public static configurableapplicationcontext run(object[] sources, string[] args) { return new springapplication(sources).run(args); } |
也就是一个静态方法,调用了构造函数创建实例,构造的参数是object数组,这里new这个数组的时候传入了一个元素就是启动类的类对象实例(一般就是“new object[] { application.class” }),构造函数里调用了一个initialize方法。
springapplication的initialize方法,首先在object数组有值的情况下将数组放入一个final的类实例私有object的set集合中;然后用deducewebenvironment方法判断当前应用环境是否是web环境,判断逻辑是看classpath是否同时存在javax.servlet.servlet和org.springframework.web.context.configurablewebapplicationcontext,缺一就认为不是。然后,调用setinitializers方法,设置类实例的私有list<applicationcontextinitializer<?>>类型变量initializers:
1
2
3
4
5
|
public void setinitializers( collection<? extends applicationcontextinitializer<?>> initializers) { this .initializers = new arraylist<applicationcontextinitializer<?>>(); this .initializers.addall(initializers); } |
设置的时候会先new,也就是说这方法每次都是整体更换,不会追加。这个方法的参数都是各个模块中配置在meta-inf/spring.factories中的key为org.springframework.context.applicationcontextinitializer的值,这些类都是接口applicationcontextinitializer<c extends configurableapplicationcontext>的泛型实现。
1
2
3
4
5
6
7
8
9
10
11
|
private <t> collection<? extends t> getspringfactoriesinstances( class <t> type, class <?>[] parametertypes, object... args) { classloader classloader = thread.currentthread().getcontextclassloader(); // use names and ensure unique to protect against duplicates set<string> names = new linkedhashset<string>( springfactoriesloader.loadfactorynames(type, classloader)); list<t> instances = createspringfactoriesinstances(type, parametertypes, classloader, args, names); annotationawareordercomparator.sort(instances); return instances; } |
使用springfactoriesloader.loadfactorynames方法去取上面说的被配置的applicationcontextinitializer的名字放进set<string>中,并用反射创建这些名字的实例。
setinitializers方法之后又是setinitializers,参数同上都是getspringfactoriesinstances方法获取,只不过这次参数class<t> type泛型类型是org.springframework.context.applicationlistener。
initialize方法的最后一个步是设置实例的class<?>类型私有属性mainapplicationclass,获取设置值的方法deducemainapplicationclass:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
private class <?> deducemainapplicationclass() { try { stacktraceelement[] stacktrace = new runtimeexception().getstacktrace(); for (stacktraceelement stacktraceelement : stacktrace) { if ( "main" .equals(stacktraceelement.getmethodname())) { return class .forname(stacktraceelement.getclassname()); } } } catch (classnotfoundexception ex) { // swallow and continue } return null ; } |
实例化springapplication后调用了它的run实例方法(注意不是上面的静态方法)。一进run方法首先启动了stopwatch,这个stopwatch的功能在类的注释写可,大概意思是这是个简单的秒表,用于在开发过程中方便程序员调试性能等,非线程安全,不建议用于生产。configureheadlessproperty设置使用headless,对于只有远程登录使用的服务器来说这样性能要好一些。接着是加载用于这个run方法启动过程的监听器,依然是getspringfactoriesinstances方法,这次的类型是org.springframework.boot.springapplicationrunlistener:
1
2
3
4
|
# run listeners org.springframework.boot.springapplicationrunlistener=\ org.springframework.boot.context.event.eventpublishingrunlistener |
1
2
3
4
5
|
springapplicationrunlisteners(log log, collection<? extends springapplicationrunlistener> listeners) { this .log = log; this .listeners = new arraylist<springapplicationrunlistener>(listeners); } |
先是加载所有可用监听,然后初始化springapplicationrunlisteners对象,最后循环启动所有springapplicationrunlistener监听。启动监听的方法:
1
2
3
4
5
|
@override public void started() { this .initialmulticaster .multicastevent( new applicationstartedevent( this .application, this .args)); } |
applicationstartedevent实例化传了两个参数,先看第一个参数this.application是怎么来的,实例的springapplication的run方法中,用于获取springapplicationrunlistener,也就是前面说的getspringfactoriesinstances被调用时:
1
2
3
4
5
|
private springapplicationrunlisteners getrunlisteners(string[] args) { class <?>[] types = new class <?>[] { springapplication. class , string[]. class }; return new springapplicationrunlisteners(logger, getspringfactoriesinstances( springapplicationrunlistener. class , types, this , args)); } |
getspringfactoriesinstances方法的参数包含springapplication.class和this,这两个参数被传入createspringfactoriesinstances方法:
可以看到,是通过反射创建实例的时候,将springapplication中的this传进来eventpublishingrunlistener构造的,然后eventpublishingrunlistener构造:
1
2
3
4
5
6
7
8
|
public eventpublishingrunlistener(springapplication application, string[] args) { this .application = application; this .args = args; this .initialmulticaster = new simpleapplicationeventmulticaster(); for (applicationlistener<?> listener : application.getlisteners()) { this .initialmulticaster.addapplicationlistener(listener); } } |
最后在构造applicationstartedevent时传给它的基类eventobject的protected不可序列化属性source。实例化applicationstartedevent后instance.getclass()并包装为resolvabletype类型以保存类型信息,并将它和event作为参数传入simpleapplicationeventmulticaster的multicastevent方法。multicastevent首先获取applicationlistener,使用getapplicationlisteners方法,这个方法中抛开对listener做了一些缓存类工作外,主要就是将事件和对应的监听器做了下是否支持的验证,返回通过了retrieveapplicationlisteners中通过了supportsevent验证的监听器集合,这里就体现出了resolvabletype的作用,它保存了类型的信息同时对泛型类型也支持。
得到了这些匹配的监听器后,判断当前executor是否被设置过,如果为null则同步循环执行所有:invokelistener(listener, event);如果不为null则:
1
2
3
4
5
6
|
executor.execute( new runnable() { @override public void run() { invokelistener(listener, event); } }); |
监听器执行的时候也会先判断是否是该由自己处理的事件,例如:
1
2
3
4
5
6
7
8
9
10
|
@override public void onapplicationevent(applicationevent event) { if (event instanceof applicationenvironmentpreparedevent) { onapplicationenvironmentpreparedevent( (applicationenvironmentpreparedevent) event); } if (event instanceof applicationpreparedevent) { onapplicationpreparedevent(event); } } |
监听启动后,只准备一些启动参数,和环境变量prepareenvironment方法先是读取了应用的启动参数和profile配置,然后用listeners.environmentprepared(environment)传给监听器:
1
2
3
4
|
public void environmentprepared(configurableenvironment environment) { this .initialmulticaster.multicastevent( new applicationenvironmentpreparedevent( this .application, this .args, environment)); } |
接着判断如果environment是org.springframework.web.context.configurablewebenvironment的实例,但webenvironment不是true,也就是说存在org.springframework.web.context.configurablewebenvironmen但不存在javax.servlet.servlet的情况,会多执行一步environment = converttostandardenvironment(environment)转换。
之后的printbanner就不细说了,如果你在resource下自定义了一个banner.txt文件,启动时会输出内容,否则输出:
. ____ _ __ _ _
/\\ / ___'_ __ _ _(_)_ __ __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
\\/ ___)| |_)| | | | | || (_| | ) ) ) )
' |____| .__|_| |_|_| |_\__, | / / / /
=========|_|==============|___/=/_/_/_/
:: spring boot :: (v1.4.3.release)
接着创建configurableapplicationcontext实例,方法也很简单,如果是web环境就beanutils.instantiate一个org.springframework.boot.context.embedded. annotationconfigembeddedwebapplicationcontext的实例并强转为configurableapplicationcontext,否则用org.springframework.context.annotation. annotationconfigapplicationcontext的实例强转。
创建failureanalyzers实例,记录了configurableapplicationcontext实例中需要关注的部分,如果启动出错了可以据此分析,可以配置,具体的逻辑依然是老方法spring.factories:
不同的analyzer关注不同的部分,自己可以扩展配置,最后preparefailureanalyzers方法给所有analyzer实例setbeanfactory(context.getbeanfactory()),一旦启动过程进入catch,被注册的analyzer实例的analyze方法就会被触发执行,分析结果会被loggedexceptions.add(exception)加入到抛出的异常中:
1
2
3
4
5
6
7
8
9
|
private failureanalysis analyze(throwable failure, list<failureanalyzer> analyzers) { for (failureanalyzer analyzer : analyzers) { failureanalysis analysis = analyzer.analyze(failure); if (analysis != null ) { return analysis; } } return null ; } |
例如:nosuchbeandefinitionfailureanalyzer
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
@override protected failureanalysis analyze(throwable rootfailure, nosuchbeandefinitionexception cause, string description) { if (cause.getnumberofbeansfound() != 0 ) { return null ; } list<autoconfigurationresult> autoconfigurationresults = getautoconfigurationresults( cause); stringbuilder message = new stringbuilder(); message.append(string.format( "%s required %s that could not be found.%n" , description == null ? "a component" : description, getbeandescription(cause))); if (!autoconfigurationresults.isempty()) { for (autoconfigurationresult provider : autoconfigurationresults) { message.append(string.format( "\t- %s%n" , provider)); } } string action = string.format( "consider %s %s in your configuration." , (!autoconfigurationresults.isempty() ? "revisiting the conditions above or defining" : "defining" ), getbeandescription(cause)); return new failureanalysis(message.tostring(), action, cause); } |
preparecontext方法中postprocessapplicationcontext会在this.beannamegenerator存在的情况下加载自定义命名策略,然后在this.resourceloader存在的情况下为context设置resourceloader和classloader。applyinitializers方法调用之前加载的initializer的实例并执行其initialize方法,例如加载环境变量信息、注册embeddedservletcontainerinitializedevent的监听、注册cachingmetadatareaderfactorypostprocessor等。listeners.contextprepared(context)由于eventpublishingrunlistener的contextprepared是空的,先不说了。logstartupinfo部分初始化了logger,然后根据配置情况打印了启动或运行以及profile是否配置的日志:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
|
protected void logstartupinfo( boolean isroot) { if (isroot) { new startupinfologger( this .mainapplicationclass) .logstarting(getapplicationlog()); } } protected log getapplicationlog() { if ( this .mainapplicationclass == null ) { return logger; } return logfactory.getlog( this .mainapplicationclass); } public void logstarting(log log) { assert .notnull(log, "log must not be null" ); if (log.isinfoenabled()) { log.info(getstartupmessage()); } if (log.isdebugenabled()) { log.debug(getrunningmessage()); } } protected void logstartupprofileinfo(configurableapplicationcontext context) { log log = getapplicationlog(); if (log.isinfoenabled()) { string[] activeprofiles = context.getenvironment().getactiveprofiles(); if (objectutils.isempty(activeprofiles)) { string[] defaultprofiles = context.getenvironment().getdefaultprofiles(); log.info( "no active profile set, falling back to default profiles: " + stringutils.arraytocommadelimitedstring(defaultprofiles)); } else { log.info( "the following profiles are active: " + stringutils.arraytocommadelimitedstring(activeprofiles)); } } } |
接着preparecontext中注册启动参数(applicationarguments)到bean工厂,包括logger、commandlineargs等。然后加载bean定义的来源并根据其中配置加载bean,这里的sources就是初始化启动类时传进来的那个sources:
1
2
3
4
5
6
7
8
9
10
11
12
|
beandefinitionloader(beandefinitionregistry registry, object... sources) { assert .notnull(registry, "registry must not be null" ); assert .notempty(sources, "sources must not be empty" ); this .sources = sources; this .annotatedreader = new annotatedbeandefinitionreader(registry); this .xmlreader = new xmlbeandefinitionreader(registry); if (isgroovypresent()) { this .groovyreader = new groovybeandefinitionreader(registry); } this .scanner = new classpathbeandefinitionscanner(registry); this .scanner.addexcludefilter( new classexcludefilter(sources)); } |
注意下面的sources是待加载的,和上面这段不是同一个:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
public int load() { int count = 0 ; for (object source : this .sources) { count += load(source); } return count; } private int load(object source) { assert .notnull(source, "source must not be null" ); if (source instanceof class <?>) { return load(( class <?>) source); } if (source instanceof resource) { return load((resource) source); } if (source instanceof package ) { return load(( package ) source); } if (source instanceof charsequence) { return load((charsequence) source); } throw new illegalargumentexception( "invalid source type " + source.getclass()); } |
类型不同加载过程不同,其中class<?>加载过程大概是通过beandefinitionloader调用annotatedbeandefinitionreader的registerbean方法:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
public void registerbean( class <?> annotatedclass, string name, class <? extends annotation>... qualifiers) { annotatedgenericbeandefinition abd = new annotatedgenericbeandefinition(annotatedclass); if ( this .conditionevaluator.shouldskip(abd.getmetadata())) { return ; } scopemetadata scopemetadata = this .scopemetadataresolver.resolvescopemetadata(abd); abd.setscope(scopemetadata.getscopename()); string beanname = (name != null ? name : this .beannamegenerator.generatebeanname(abd, this .registry)); annotationconfigutils.processcommondefinitionannotations(abd); if (qualifiers != null ) { for ( class <? extends annotation> qualifier : qualifiers) { if (primary. class == qualifier) { abd.setprimary( true ); } else if (lazy. class == qualifier) { abd.setlazyinit( true ); } else { abd.addqualifier( new autowirecandidatequalifier(qualifier)); } } } beandefinitionholder definitionholder = new beandefinitionholder(abd, beanname); definitionholder = annotationconfigutils.applyscopedproxymode(scopemetadata, definitionholder, this .registry); beandefinitionreaderutils.registerbeandefinition(definitionholder, this .registry); } |
可以看到有生成方法名,设置默认注入的实例、延迟以及过滤等等,注入的过程包括初始化一些信息,如构造、内部类、注解等:
1
2
3
4
5
6
7
8
9
|
protected abstractbeandefinition(constructorargumentvalues cargs, mutablepropertyvalues pvs) { setconstructorargumentvalues(cargs); setpropertyvalues(pvs); } public standardannotationmetadata( class <?> introspectedclass, boolean nestedannotationsasmap) { super (introspectedclass); this .annotations = introspectedclass.getannotations(); this .nestedannotationsasmap = nestedannotationsasmap; } |
其他三种比如有的有输入流什么的就不细总结了,这部分介绍spring ioc的相关文章应该不少。
preparecontext方法最后listeners.contextloaded(context),加载监听器到context并广播applicationpreparedevent事件。
咱最近用的github:https://github.com/saaavsaaa
以上所述是小编给大家介绍的spring boot启动过程完全解析(一),希望对大家有所帮助,如果大家有任何疑问请给我留言,小编会及时回复大家的。在此也非常感谢大家对服务器之家网站的支持!
原文链接:http://www.cnblogs.com/saaav/p/6259405.html