上篇给大家介绍了spring boot启动过程完全解析(一)，大家可以点击参考下
该说refreshcontext(context)了，首先是判断context是否是abstractapplicationcontext派生类的实例，之后调用了强转为abstractapplicationcontext类型并调用它的refresh方法。由于annotationconfigembeddedwebapplicationcontext继承自embeddedwebapplicationcontext，所以会执行embeddedwebapplicationcontext的refresh方法，继而执行其中的super.refresh。这个refresh也就是abstractapplicationcontext的refresh方法了，它内部是一个synchronized锁全局的代码块，同样的加锁方法还有这个类里的close和registershutdownhook方法。
同步代码块中第一个方法preparerefresh，首先会执行annotationconfigembeddedwebapplicationcontext的preparerefresh方法：
|
1
2
3
4
|
protected void preparerefresh() {
this.scanner.clearcache();
super.preparerefresh();
}
|
这个super也就是abstractapplicationcontext，它的preparerefresh方法逻辑是：生成启动时间；设置closed状态为false；active状态为true；initpropertysources方法主要是调用了abstractenvironment的getpropertysources方法获取了之前springapplication的prepareenvironment方法中getorcreateenvironment方法准备的各种环境变量及配置并用于初始化servletpropertysources。具体的servletcontextinitparams这些是在环境对象初始化时由各集成级别environment的customizepropertysources方法中初始化的。
接着的getenvironment().validaterequiredproperties()方法实际执行了abstractenvironment中的this.propertyresolver.validaterequiredproperties()，主要是验证了被占位的key如果是required的值不能为null。preparerefresh的最后是初始化this.earlyapplicationevents = new linkedhashset<applicationevent>()。*****
只够是获取beanfactory实例的方法obtainfreshbeanfactory()，首先在refreshbeanfactory方法中用原子布尔类型判断是否刷新过，beanfactory实例是在createapplicationcontext创建context实例时被创建的，如果没有刷新则设置一个用于序列化的id，id是contextidapplicationcontextinitializer初始化设置的（如未配置该初始化器，是有一个默认objectutils.identitytostring(this)生成的），这个id的生成规则是spring.config.name截取的+":"+server.port的占位截取。设置序列化id时，同时保存了一个id和弱引用defaultlistablebeanfactory实例映射。
得到了beanfactory后就是preparebeanfactory(beanfactory)了，逻辑是注册了beanclassloader用于注入的bean实例的创建；standardbeanexpressionresolver用于el表达式，比如配置文件或者@value("#{…}")等使用；用resourceeditorregistrar注册属性转换器，比如xml配置的bean属性都是用的字符串配置的要转成真正的属性类型；addbeanpostprocessor(new applicationcontextawareprocessor(this))注册applicationcontextawareprocessor，它的invokeawareinterfaces方法会对实现指定接口的bean调用指定的set方法；ignoredependencyinterface忽略对这些接口的自动装配，比如aware这些是要做独立处理的，不适合通用的方法；然后是有几个类型直接手动注册，比如beanfactory，这个很好理解；接着注册一个后置处理器applicationlistenerdetector的实例，addbeanpostprocessor注册的会按照注册先后顺序执行；这个方法的最后判断了特定的4个bean名字，如果存在会做相应注册，包括loadtimeweaver、environment、systemproperties和systemenvironment。补充一点，在最开始创建实例的时候还执行过ignoredependencyinterface(beannameaware.class);ignoredependencyinterface(beanfactoryaware.class);ignoredependencyinterface(beanclassloaderaware.class)。
|
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
37
38
|
protected void preparebeanfactory(configurablelistablebeanfactory beanfactory) {
// tell the internal bean factory to use the context's class loader etc.
beanfactory.setbeanclassloader(getclassloader());
beanfactory.setbeanexpressionresolver(new standardbeanexpressionresolver(beanfactory.getbeanclassloader()));
beanfactory.addpropertyeditorregistrar(new resourceeditorregistrar(this, getenvironment()));
// configure the bean factory with context callbacks.
beanfactory.addbeanpostprocessor(new applicationcontextawareprocessor(this));
beanfactory.ignoredependencyinterface(environmentaware.class);
beanfactory.ignoredependencyinterface(embeddedvalueresolveraware.class);
beanfactory.ignoredependencyinterface(resourceloaderaware.class);
beanfactory.ignoredependencyinterface(applicationeventpublisheraware.class);
beanfactory.ignoredependencyinterface(messagesourceaware.class);
beanfactory.ignoredependencyinterface(applicationcontextaware.class);
// beanfactory interface not registered as resolvable type in a plain factory.
// messagesource registered (and found for autowiring) as a bean.
beanfactory.registerresolvabledependency(beanfactory.class, beanfactory);
beanfactory.registerresolvabledependency(resourceloader.class, this);
beanfactory.registerresolvabledependency(applicationeventpublisher.class, this);
beanfactory.registerresolvabledependency(applicationcontext.class, this);
// register early post-processor for detecting inner beans as applicationlisteners.
beanfactory.addbeanpostprocessor(new applicationlistenerdetector(this));
// detect a loadtimeweaver and prepare for weaving, if found.
if (beanfactory.containsbean(load_time_weaver_bean_name)) {
beanfactory.addbeanpostprocessor(new loadtimeweaverawareprocessor(beanfactory));
// set a temporary classloader for type matching.
beanfactory.settempclassloader(new contexttypematchclassloader(beanfactory.getbeanclassloader()));
}
// register default environment beans.
if (!beanfactory.containslocalbean(environment_bean_name)) {
beanfactory.registersingleton(environment_bean_name, getenvironment());
}
if (!beanfactory.containslocalbean(system_properties_bean_name)) {
beanfactory.registersingleton(system_properties_bean_name, getenvironment().getsystemproperties());
}
if (!beanfactory.containslocalbean(system_environment_bean_name)) {
beanfactory.registersingleton(system_environment_bean_name, getenvironment().getsystemenvironment());
}
}
|
之后到了refresh的postprocessbeanfactory方法，首先是会走到annotationconfigembeddedwebapplicationcontext的override，需要注意的一点是，这是web环境，如果不是是不会加载这个上下文的，也就不会这么走。它重写的第一步是先走super也就是embeddedwebapplicationcontext的postprocessbeanfactory，这里又注册了个后置处理器webapplicationcontextservletcontextawareprocessor的实例，构造参数是this，也就是当前上下文，同时忽略servletcontextaware接口，这个接口是用于获取servletcontext的，为什么要忽略呢，我猜应该是因为我们既然有了web应用并且内嵌servlet的上下文实例，还要servletcontext的实现就没什么用了，还有可能出现冲突的问题，有空我再确认下。然后是配置的basepackages和annotatedclasses：
|
1
2
3
4
5
6
7
8
9
10
|
@override
protected void postprocessbeanfactory(configurablelistablebeanfactory beanfactory) {
super.postprocessbeanfactory(beanfactory);
if (this.basepackages != null && this.basepackages.length > 0) {
this.scanner.scan(this.basepackages);
}
if (this.annotatedclasses != null && this.annotatedclasses.length > 0) {
this.reader.register(this.annotatedclasses);
}
}
|
到了invokebeanfactorypostprocessors方法，这个方法就是执行之前注册的beanfactory后置处理器的地方。代码一目了然，postprocessorregistrationdelegate的invokebeanfactorypostprocessors中只是有些排序的逻辑，我就不说了：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
/**
* instantiate and invoke all registered beanfactorypostprocessor beans,
* respecting explicit order if given.
* <p>must be called before singleton instantiation.
*/
protected void invokebeanfactorypostprocessors(configurablelistablebeanfactory beanfactory) {
postprocessorregistrationdelegate.invokebeanfactorypostprocessors(beanfactory, getbeanfactorypostprocessors());
// detect a loadtimeweaver and prepare for weaving, if found in the meantime
// (e.g. through an @bean method registered by configurationclasspostprocessor)
if (beanfactory.gettempclassloader() == null && beanfactory.containsbean(load_time_weaver_bean_name)) {
beanfactory.addbeanpostprocessor(new loadtimeweaverawareprocessor(beanfactory));
beanfactory.settempclassloader(new contexttypematchclassloader(beanfactory.getbeanclassloader()));
}
}
|
beanfactory后置处理器执行之后是注册bean的后置处理器方法registerbeanpostprocessors。例如new beanpostprocessorchecker(beanfactory, beanprocessortargetcount)会在bean没有合适的后置处理器时记条info级日志。applicationlistenerdetector也注册了一个。
initmessagesource这个方法在我这没什么用，都说是国际化的，随便百度一下一堆一堆的，而且其实严格来说这篇多数不属于spring boot的部分，这方法我就不细写了。
initapplicationeventmulticaster方法主要也就是初始化并注册applicationeventmulticaster的这两句代码：
|
1
2
|
this.applicationeventmulticaster = new simpleapplicationeventmulticaster(beanfactory);
beanfactory.registersingleton(application_event_multicaster_bean_name, this.applicationeventmulticaster);
|
onrefresh也是根据环境不同加载的上下文不同而不同的，用于支持子类扩展出来的上下文特定的逻辑的。embeddedwebapplicationcontext的onrefresh首先依然是super.onrefresh，逻辑就是初始化了主题；
createembeddedservletcontainer方法名我就不翻译了，一般情况下是使用getbeanfactory .getbeannamesfortype方法找到embeddedservletcontainerfactory类型的实例，这也就是我之前那个问题解决过程中，为什么只要排除掉tomcat引用，引入jetty引用就可以自动换成jetty的原因。创建容器的过程中初始化方法selfinitialize注册了filter和mappingforurlpatterns等，代码在abstractfilterregistrationbean等onstartup，这里就不细说了，如果能抽出时间说说之前查问题的时候查的容器代码再说。然后初始化propertysources，servletcontextinitparams和servletconfiginitparams：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
public static void initservletpropertysources(
mutablepropertysources propertysources, servletcontext servletcontext, servletconfig servletconfig) {
assert.notnull(propertysources, "'propertysources' must not be null");
if (servletcontext != null && propertysources.contains(standardservletenvironment.servlet_context_property_source_name) &&
propertysources.get(standardservletenvironment.servlet_context_property_source_name) instanceof stubpropertysource) {
propertysources.replace(standardservletenvironment.servlet_context_property_source_name,
new servletcontextpropertysource(standardservletenvironment.servlet_context_property_source_name, servletcontext));
}
if (servletconfig != null && propertysources.contains(standardservletenvironment.servlet_config_property_source_name) &&
propertysources.get(standardservletenvironment.servlet_config_property_source_name) instanceof stubpropertysource) {
propertysources.replace(standardservletenvironment.servlet_config_property_source_name,
new servletconfigpropertysource(standardservletenvironment.servlet_config_property_source_name, servletconfig));
}
}
|
registerlisteners首先注册静态监听：
|
1
2
3
4
5
6
7
|
@override
public void addapplicationlistener(applicationlistener<?> listener) {
synchronized (this.retrievalmutex) {
this.defaultretriever.applicationlisteners.add(listener);
this.retrievercache.clear();
}
}
|
接着是：
registerlisteners的最后，初始化过的earlyapplicationevents如果有事件，这时候会被发布。
finishbeanfactoryinitialization结束beanfactory的初始化并初始化所有非延迟加载的单例。事实上我们自定义的单例bean都是在这里getbean方法初始化的，所以如果注册的bean特别多的话，这个过程就是启动过程中最慢的。初始化开始前先设置configurationfrozen为true，并this.frozenbeandefinitionnames = stringutils.tostringarray ( this. beandefinitionnames )。如果有bean实例实现了smartinitializingsingleton会有后置处理触发，不包括延迟加载的。例如：org.springframework.context.event. internaleventlistenerprocessor会触发eventlistenermethodprocessor的aftersingletonsinstantiated方法对所有对象（object的子类）处理。
finishrefresh:refresh的最后一步，发布相应事件。同样先执行embeddedwebapplicationcontext中对应方法的super(embeddedwebapplicationcontext)的对应方法：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
/**
* finish the refresh of this context, invoking the lifecycleprocessor's
* onrefresh() method and publishing the
* {@link org.springframework.context.event.contextrefreshedevent}.
*/
protected void finishrefresh() {
// initialize lifecycle processor for this context.
initlifecycleprocessor();
// propagate refresh to lifecycle processor first.
getlifecycleprocessor().onrefresh();
// publish the final event.
publishevent(new contextrefreshedevent(this));
// participate in livebeansview mbean, if active.
livebeansview.registerapplicationcontext(this);
}
|
初始化生命周期处理器，逻辑是判断beanfactory中是否已经注册了lifecycleprocessor，没有就new一个defaultlifecycleprocessor并setbeanfactory(beanfactory)，然后将它赋值给私有lifecycleprocessor类型的this变量。然后执行生命周期处理器的onrefresh，其中先startbeans，被start的beans是通过getbeannamesfortype(lifecycle.class, false, false)从beanfactory中取出来的，例如endpointmbeanexporter和lifecycleprocessor，会去调用bean的start方法，endpointmbeanexporter的start中执行 locateandregisterendpoints方法并设置running属性为true，这个过程加了reentrantlock锁。bean都启动完会设置处理器的running为true。刷新完会发布contextrefreshedevent事件，这个事件除了都有的记录时间还执行了configurationpropertiesbindingpostprocessor的freelocalvalidator方法，我这的逻辑是实际上执行了validatorfactoryimpl的close方法。这个逻辑的最后会检查一个配置spring.livebeansview.mbeandomain是否存在，有就会创建一个mbeanserver：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
static void registerapplicationcontext(configurableapplicationcontext applicationcontext) {
string mbeandomain = applicationcontext.getenvironment().getproperty(mbean_domain_property_name);
if (mbeandomain != null) {
synchronized (applicationcontexts) {
if (applicationcontexts.isempty()) {
try {
mbeanserver server = managementfactory.getplatformmbeanserver();
applicationname = applicationcontext.getapplicationname();
server.registermbean(new livebeansview(),
new objectname(mbeandomain, mbean_application_key, applicationname));
}
catch (throwable ex) {
throw new applicationcontextexception("failed to register livebeansview mbean", ex);
}
}
applicationcontexts.add(applicationcontext);
}
}
}
|
finishrefresh最后会启动前面创建的内嵌容器，并发布embeddedservletcontainerinitializedevent事件，启动这一部分算是容器的逻辑了，有机会整理容器逻辑再细写，我这里是tomcat的：
|
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
|
@override
public void start() throws embeddedservletcontainerexception {
try {
addpreviouslyremovedconnectors();
connector connector = this.tomcat.getconnector();
if (connector != null && this.autostart) {
startconnector(connector);
}
checkthatconnectorshavestarted();
tomcatembeddedservletcontainer.logger
.info("tomcat started on port(s): " + getportsdescription(true));
}
catch (connectorstartfailedexception ex) {
stopsilently();
throw ex;
}
catch (exception ex) {
throw new embeddedservletcontainerexception(
"unable to start embedded tomcat servlet container", ex);
}
finally {
context context = findcontext();
contextbindings.unbindclassloader(context, getnamingtoken(context),
getclass().getclassloader());
}
}
|
然后是resetcommoncaches：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
/**
* reset spring's common core caches, in particular the {@link reflectionutils},
* {@link resolvabletype} and {@link cachedintrospectionresults} caches.
* @since 4.2
* @see reflectionutils#clearcache()
* @see resolvabletype#clearcache()
* @see cachedintrospectionresults#clearclassloader(classloader)
*/
protected void resetcommoncaches() {
reflectionutils.clearcache();
resolvabletype.clearcache();
cachedintrospectionresults.clearclassloader(getclassloader());
}
|
refreshcontext的最后是注册shutdown的钩子：
|
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
|
if (this.registershutdownhook) {
try {
context.registershutdownhook();
}
catch (accesscontrolexception ex) {
// not allowed in some environments.
}
}
/**
* register a shutdown hook with the jvm runtime, closing this context
* on jvm shutdown unless it has already been closed at that time.
* <p>delegates to {@code doclose()} for the actual closing procedure.
* @see runtime#addshutdownhook
* @see #close()
* @see #doclose()
*/
@override
public void registershutdownhook() {
if (this.shutdownhook == null) {
// no shutdown hook registered yet.
this.shutdownhook = new thread() {
@override
public void run() {
synchronized (startupshutdownmonitor) {
doclose();
}
}
};
runtime.getruntime().addshutdownhook(this.shutdownhook);
}
}
|
咱最近用的github：https://github.com/saaavsaaa
以上所述是小编给大家介绍的spring boot启动过程完全解析（二），希望对大家有所帮助，如果大家有任何疑问请给我留言，小编会及时回复大家的。在此也非常感谢大家对快网idc网站的支持！
原文链接：http://www.cnblogs.com/saaav/p/6292524.html
相关文章
- 个人服务器网站搭建：如何选择合适的服务器提供商？ 2025-06-10
- ASP.NET自助建站系统中如何实现多语言支持？ 2025-06-10
- 64M VPS建站：如何选择最适合的网站建设平台？ 2025-06-10
- ASP.NET本地开发时常见的配置错误及解决方法？ 2025-06-10
- ASP.NET自助建站系统的数据库备份与恢复操作指南 2025-06-10
