溫馨提示×
您好，登錄后才能下訂單哦！
點(diǎn)擊 登錄注冊 即表示同意《億速云用戶服務(wù)條款》
您好，登錄后才能下訂單哦！
之前在排查一個(gè)線上問題時(shí)，不得不仔細(xì)跑了很多遍Spring Boot的代碼，于是整理一下，我用的是1.4.3.RELEASE。
首先，普通的入口，這沒什么好說的，我就隨便貼貼代碼了:
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);
}
也就是一個(gè)靜態(tài)方法，調(diào)用了構(gòu)造函數(shù)創(chuàng)建實(shí)例，構(gòu)造的參數(shù)是Object數(shù)組，這里new這個(gè)數(shù)組的時(shí)候傳入了一個(gè)元素就是啟動(dòng)類的類對象實(shí)例(一般就是“new Object[] { Application.class” })，構(gòu)造函數(shù)里調(diào)用了一個(gè)initialize方法。
SpringApplication的initialize方法，首先在Object數(shù)組有值的情況下將數(shù)組放入一個(gè)final的類實(shí)例私有Object的Set集合中；然后用deduceWebEnvironment方法判斷當(dāng)前應(yīng)用環(huán)境是否是web環(huán)境，判斷邏輯是看Classpath是否同時(shí)存在javax.servlet.Servlet和org.springframework.web.context.ConfigurableWebApplicationContext，缺一就認(rèn)為不是。然后，調(diào)用setInitializers方法，設(shè)置類實(shí)例的私有List<ApplicationContextInitializer<?>>類型變量initializers：
public void setInitializers(
Collection<? extends ApplicationContextInitializer<?>> initializers) {
this.initializers = new ArrayList<ApplicationContextInitializer<?>>();
this.initializers.addAll(initializers);
}
設(shè)置的時(shí)候會先new，也就是說這方法每次都是整體更換，不會追加。這個(gè)方法的參數(shù)都是各個(gè)模塊中配置在META-INF/spring.factories中的key為org.springframework.context.ApplicationContextInitializer的值，這些類都是接口ApplicationContextInitializer<C extends ConfigurableApplicationContext>的泛型實(shí)現(xiàn)。
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的名字放進(jìn)Set<String>中，并用反射創(chuàng)建這些名字的實(shí)例。
setInitializers方法之后又是setInitializers，參數(shù)同上都是getSpringFactoriesInstances方法獲取，只不過這次參數(shù)Class<T> type泛型類型是org.springframework.context.ApplicationListener。
initialize方法的最后一個(gè)步是設(shè)置實(shí)例的Class<?>類型私有屬性mainApplicationClass，獲取設(shè)置值的方法deduceMainApplicationClass：
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;
}
實(shí)例化SpringApplication后調(diào)用了它的run實(shí)例方法（注意不是上面的靜態(tài)方法）。一進(jìn)run方法首先啟動(dòng)了StopWatch，這個(gè)StopWatch的功能在類的注釋寫可，大概意思是這是個(gè)簡單的秒表，用于在開發(fā)過程中方便程序員調(diào)試性能等，非線程安全，不建議用于生產(chǎn)。configureHeadlessProperty設(shè)置使用Headless，對于只有遠(yuǎn)程登錄使用的服務(wù)器來說這樣性能要好一些。接著是加載用于這個(gè)run方法啟動(dòng)過程的監(jiān)聽器，依然是getSpringFactoriesInstances方法，這次的類型是org.springframework.boot.SpringApplicationRunListener：
# Run Listeners org.springframework.boot.SpringApplicationRunListener=\ org.springframework.boot.context.event.EventPublishingRunListener
SpringApplicationRunListeners(Log log,
Collection<? extends SpringApplicationRunListener> listeners) {
this.log = log;
this.listeners = new ArrayList<SpringApplicationRunListener>(listeners);
}
先是加載所有可用監(jiān)聽，然后初始化SpringApplicationRunListeners對象，最后循環(huán)啟動(dòng)所有SpringApplicationRunListener監(jiān)聽。啟動(dòng)監(jiān)聽的方法：
@Override
public void started() {
this.initialMulticaster
.multicastEvent(new ApplicationStartedEvent(this.application, this.args));
}
ApplicationStartedEvent實(shí)例化傳了兩個(gè)參數(shù)，先看第一個(gè)參數(shù)this.application是怎么來的，實(shí)例的SpringApplication的run方法中，用于獲取SpringApplicationRunListener，也就是前面說的getSpringFactoriesInstances被調(diào)用時(shí)：
private SpringApplicationRunListeners getRunListeners(String[] args) {
Class<?>[] types = new Class<?>[] { SpringApplication.class, String[].class };
return new SpringApplicationRunListeners(logger, getSpringFactoriesInstances(
SpringApplicationRunListener.class, types, this, args));
}
getSpringFactoriesInstances方法的參數(shù)包含SpringApplication.class和this，這兩個(gè)參數(shù)被傳入createSpringFactoriesInstances方法：
可以看到，是通過反射創(chuàng)建實(shí)例的時(shí)候，將SpringApplication中的this傳進(jìn)來EventPublishingRunListener構(gòu)造的，然后EventPublishingRunListener構(gòu)造：
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);
}
}
最后在構(gòu)造ApplicationStartedEvent時(shí)傳給它的基類EventObject的protected不可序列化屬性source。實(shí)例化ApplicationStartedEvent后instance.getClass()并包裝為ResolvableType類型以保存類型信息，并將它和event作為參數(shù)傳入SimpleApplicationEventMulticaster的multicastEvent方法。multicastEvent首先獲取ApplicationListener，使用getApplicationListeners方法，這個(gè)方法中拋開對listener做了一些緩存類工作外，主要就是將事件和對應(yīng)的監(jiān)聽器做了下是否支持的驗(yàn)證，返回通過了retrieveApplicationListeners中通過了supportsEvent驗(yàn)證的監(jiān)聽器集合，這里就體現(xiàn)出了ResolvableType的作用，它保存了類型的信息同時(shí)對泛型類型也支持。
得到了這些匹配的監(jiān)聽器后，判斷當(dāng)前Executor是否被設(shè)置過，如果為null則同步循環(huán)執(zhí)行所有：invokeListener(listener, event);如果不為null則：
executor.execute(new Runnable() {
@Override
public void run() {
invokeListener(listener, event);
}
});
監(jiān)聽器執(zhí)行的時(shí)候也會先判斷是否是該由自己處理的事件，例如：
@Override
public void onApplicationEvent(ApplicationEvent event) {
if (event instanceof ApplicationEnvironmentPreparedEvent) {
onApplicationEnvironmentPreparedEvent(
(ApplicationEnvironmentPreparedEvent) event);
}
if (event instanceof ApplicationPreparedEvent) {
onApplicationPreparedEvent(event);
}
}
監(jiān)聽啟動(dòng)后，只準(zhǔn)備一些啟動(dòng)參數(shù)，和環(huán)境變量prepareEnvironment方法先是讀取了應(yīng)用的啟動(dòng)參數(shù)和profile配置，然后用listeners.environmentPrepared(environment)傳給監(jiān)聽器：
public void environmentPrepared(ConfigurableEnvironment environment) {
this.initialMulticaster.multicastEvent(new ApplicationEnvironmentPreparedEvent(
this.application, this.args, environment));
}
接著判斷如果environment是org.springframework.web.context.ConfigurableWebEnvironment的實(shí)例，但webEnvironment不是true，也就是說存在org.springframework.web.context.ConfigurableWebEnvironmen但不存在javax.servlet.Servlet的情況，會多執(zhí)行一步environment = convertToStandardEnvironment(environment)轉(zhuǎn)換。
之后的printBanner就不細(xì)說了，如果你在resource下自定義了一個(gè)banner.txt文件，啟動(dòng)時(shí)會輸出內(nèi)容，否則輸出：
. ____ _ __ _ _
/\\ / ___'_ __ _ _(_)_ __ __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
\\/ ___)| |_)| | | | | || (_| | ) ) ) )
' |____| .__|_| |_|_| |_\__, | / / / /
=========|_|==============|___/=/_/_/_/
:: Spring Boot :: (v1.4.3.RELEASE)
接著創(chuàng)建ConfigurableApplicationContext實(shí)例，方法也很簡單，如果是web環(huán)境就BeanUtils.instantiate一個(gè)org.springframework.boot.context.embedded. AnnotationConfigEmbeddedWebApplicationContext的實(shí)例并強(qiáng)轉(zhuǎn)為ConfigurableApplicationContext，否則用org.springframework.context.annotation. AnnotationConfigApplicationContext的實(shí)例強(qiáng)轉(zhuǎn)。
創(chuàng)建FailureAnalyzers實(shí)例，記錄了ConfigurableApplicationContext實(shí)例中需要關(guān)注的部分，如果啟動(dòng)出錯(cuò)了可以據(jù)此分析，可以配置，具體的邏輯依然是老方法spring.factories：
不同的Analyzer關(guān)注不同的部分，自己可以擴(kuò)展配置，最后prepareFailureAnalyzers方法給所有Analyzer實(shí)例setBeanFactory(context.getBeanFactory())，一旦啟動(dòng)過程進(jìn)入catch，被注冊的Analyzer實(shí)例的analyze方法就會被觸發(fā)執(zhí)行，分析結(jié)果會被loggedExceptions.add(exception)加入到拋出的異常中：
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
@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設(shè)置resourceLoader和classLoader。applyInitializers方法調(diào)用之前加載的Initializer的實(shí)例并執(zhí)行其initialize方法，例如加載環(huán)境變量信息、注冊EmbeddedServletContainerInitializedEvent的監(jiān)聽、注冊CachingMetadataReaderFactoryPostProcessor等。listeners.contextPrepared(context)由于EventPublishingRunListener的contextPrepared是空的，先不說了。logStartupInfo部分初始化了logger，然后根據(jù)配置情況打印了啟動(dòng)或運(yùn)行以及profile是否配置的日志：
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中注冊啟動(dòng)參數(shù)（applicationArguments）到bean工廠，包括logger、commandLineArgs等。然后加載bean定義的來源并根據(jù)其中配置加載bean，這里的sources就是初始化啟動(dòng)類時(shí)傳進(jìn)來的那個(gè)sources：
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是待加載的，和上面這段不是同一個(gè)：
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調(diào)用AnnotatedBeanDefinitionReader的registerBean方法：
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);
}
可以看到有生成方法名，設(shè)置默認(rèn)注入的實(shí)例、延遲以及過濾等等，注入的過程包括初始化一些信息，如構(gòu)造、內(nèi)部類、注解等：
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;
}
其他三種比如有的有輸入流什么的就不細(xì)總結(jié)了，這部分介紹Spring IOC的相關(guān)文章應(yīng)該不少。
prepareContext方法最后listeners.contextLoaded(context)，加載監(jiān)聽器到context并廣播ApplicationPreparedEvent事件。
咱最近用的github：https://github.com/saaavsaaa
以上所述是小編給大家介紹的Spring Boot啟動(dòng)過程完全解析(一)，希望對大家有所幫助，如果大家有任何疑問請給我留言，小編會及時(shí)回復(fù)大家的。在此也非常感謝大家對億速云網(wǎng)站的支持！
免責(zé)聲明：本站發(fā)布的內(nèi)容（圖片、視頻和文字）以原創(chuàng)、轉(zhuǎn)載和分享為主，文章觀點(diǎn)不代表本網(wǎng)站立場，如果涉及侵權(quán)請聯(lián)系站長郵箱：is@yisu.com進(jìn)行舉報(bào)，并提供相關(guān)證據(jù)，一經(jīng)查實(shí)，將立刻刪除涉嫌侵權(quán)內(nèi)容。
億速云公眾號
手機(jī)網(wǎng)站二維碼