Spring/spring-boot
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Allow FailureAnalizers without ApplicationContext

Browse Source 
Update `SpringApplication` so that `FailureAnalyzers` apply even if
the `ApplicationContext` was not created. If no `ApplicationContext`
is available, only `FailureAnalyzer` instances that do not implement
any `Aware` interfaces are considered.

Closes gh-23710
This commit is contained in:
Phillip Webb
2020-10-13 14:22:43 -07:00
parent 84f96033c5
commit f89b99bdbc
3 changed files with 58 additions and 33 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
spring-boot-project/spring-boot/src/main/java/org/springframework/boot/SpringApplication.java
View File

@@ -312,7 +312,6 @@ public class SpringApplication {
stopWatch.start();
DefaultBootstrapContext bootstrapContext = createBootstrapContext();
ConfigurableApplicationContext context = null;
Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
configureHeadlessProperty();
SpringApplicationRunListeners listeners = getRunListeners(args);
listeners.starting(bootstrapContext, this.mainApplicationClass);
@@ -323,8 +322,6 @@ public class SpringApplication {
Banner printedBanner = printBanner(environment);
context = createApplicationContext();
context.setApplicationStartup(this.applicationStartup);
exceptionReporters = getSpringFactoriesInstances(SpringBootExceptionReporter.class,
new Class<?>[] { ConfigurableApplicationContext.class }, context);
prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
refreshContext(context);
afterRefresh(context, applicationArguments);
@@ -336,7 +333,7 @@ public class SpringApplication {
callRunners(context, applicationArguments);
}
catch (Throwable ex) {
handleRunFailure(context, ex, exceptionReporters, listeners);
handleRunFailure(context, ex, listeners);
throw new IllegalStateException(ex);
}
@@ -344,7 +341,7 @@ public class SpringApplication {
listeners.running(context);
}
catch (Throwable ex) {
handleRunFailure(context, ex, exceptionReporters, null);
handleRunFailure(context, ex, null);
throw new IllegalStateException(ex);
}
return context;
@@ -812,7 +809,7 @@ public class SpringApplication {
}
private void handleRunFailure(ConfigurableApplicationContext context, Throwable exception,
Collection<SpringBootExceptionReporter> exceptionReporters, SpringApplicationRunListeners listeners) {
SpringApplicationRunListeners listeners) {
try {
try {
handleExitCode(context, exception);
@@ -821,7 +818,7 @@ public class SpringApplication {
}
}
finally {
reportFailure(exceptionReporters, exception);
reportFailure(getExceptionReporters(context), exception);
if (context != null) {
context.close();
}
@@ -833,6 +830,16 @@ public class SpringApplication {
ReflectionUtils.rethrowRuntimeException(exception);
}
private Collection<SpringBootExceptionReporter> getExceptionReporters(ConfigurableApplicationContext context) {
try {
return getSpringFactoriesInstances(SpringBootExceptionReporter.class,
new Class<?>[] { ConfigurableApplicationContext.class }, context);
}
catch (Throwable ex) {
return Collections.emptyList();
}
}
private void reportFailure(Collection<SpringBootExceptionReporter> exceptionReporters, Throwable failure) {
try {
for (SpringBootExceptionReporter reporter : exceptionReporters) {

57
spring-boot-project/spring-boot/src/main/java/org/springframework/boot/diagnostics/FailureAnalyzers.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2012-2019 the original author or authors.
* Copyright 2012-2020 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -31,7 +31,6 @@ import org.springframework.context.EnvironmentAware;
import org.springframework.core.annotation.AnnotationAwareOrderComparator;
import org.springframework.core.io.support.SpringFactoriesLoader;
import org.springframework.core.log.LogMessage;
import org.springframework.util.Assert;
import org.springframework.util.ClassUtils;
import org.springframework.util.ReflectionUtils;
@@ -61,42 +60,50 @@ final class FailureAnalyzers implements SpringBootExceptionReporter {
}
FailureAnalyzers(ConfigurableApplicationContext context, ClassLoader classLoader) {
Assert.notNull(context, "Context must not be null");
this.classLoader = (classLoader != null) ? classLoader : context.getClassLoader();
this.analyzers = loadFailureAnalyzers(this.classLoader);
prepareFailureAnalyzers(this.analyzers, context);
this.classLoader = (classLoader != null) ? classLoader : getClassLoader(context);
this.analyzers = loadFailureAnalyzers(context, this.classLoader);
}
private List<FailureAnalyzer> loadFailureAnalyzers(ClassLoader classLoader) {
List<String> analyzerNames = SpringFactoriesLoader.loadFactoryNames(FailureAnalyzer.class, classLoader);
private ClassLoader getClassLoader(ConfigurableApplicationContext context) {
return (context != null) ? context.getClassLoader() : null;
}
private List<FailureAnalyzer> loadFailureAnalyzers(ConfigurableApplicationContext context,
ClassLoader classLoader) {
List<String> classNames = SpringFactoriesLoader.loadFactoryNames(FailureAnalyzer.class, classLoader);
List<FailureAnalyzer> analyzers = new ArrayList<>();
for (String analyzerName : analyzerNames) {
for (String className : classNames) {
try {
Constructor<?> constructor = ClassUtils.forName(analyzerName, classLoader).getDeclaredConstructor();
ReflectionUtils.makeAccessible(constructor);
analyzers.add((FailureAnalyzer) constructor.newInstance());
FailureAnalyzer analyzer = createAnalyzer(context, className);
if (analyzer != null) {
analyzers.add(analyzer);
}
}
catch (Throwable ex) {
logger.trace(LogMessage.format("Failed to load %s", analyzerName), ex);
logger.trace(LogMessage.format("Failed to load %s", className), ex);
}
}
AnnotationAwareOrderComparator.sort(analyzers);
return analyzers;
}
private void prepareFailureAnalyzers(List<FailureAnalyzer> analyzers, ConfigurableApplicationContext context) {
for (FailureAnalyzer analyzer : analyzers) {
prepareAnalyzer(context, analyzer);
}
}
private void prepareAnalyzer(ConfigurableApplicationContext context, FailureAnalyzer analyzer) {
if (analyzer instanceof BeanFactoryAware) {
((BeanFactoryAware) analyzer).setBeanFactory(context.getBeanFactory());
}
if (analyzer instanceof EnvironmentAware) {
((EnvironmentAware) analyzer).setEnvironment(context.getEnvironment());
private FailureAnalyzer createAnalyzer(ConfigurableApplicationContext context, String className) throws Exception {
Constructor<?> constructor = ClassUtils.forName(className, this.classLoader).getDeclaredConstructor();
ReflectionUtils.makeAccessible(constructor);
FailureAnalyzer analyzer = (FailureAnalyzer) constructor.newInstance();
if (analyzer instanceof BeanFactoryAware || analyzer instanceof EnvironmentAware) {
if (context == null) {
logger.trace(LogMessage.format("Skipping %s due to missing context", className));
return null;
}
if (analyzer instanceof BeanFactoryAware) {
((BeanFactoryAware) analyzer).setBeanFactory(context.getBeanFactory());
}
if (analyzer instanceof EnvironmentAware) {
((EnvironmentAware) analyzer).setEnvironment(context.getEnvironment());
}
}
return analyzer;
}
@Override

13
spring-boot-project/spring-boot/src/test/java/org/springframework/boot/diagnostics/FailureAnalyzersTests.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2012-2019 the original author or authors.
* Copyright 2012-2020 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -85,8 +85,19 @@ class FailureAnalyzersTests {
verify(failureAnalyzer, times(1)).analyze(failure);
}
@Test
void createWithNullContextSkipsAwareAnalyzers() {
RuntimeException failure = new RuntimeException();
analyzeAndReport("basic.factories", failure, null);
verify(failureAnalyzer, times(1)).analyze(failure);
}
private void analyzeAndReport(String factoriesName, Throwable failure) {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
analyzeAndReport(factoriesName, failure, context);
}
private void analyzeAndReport(String factoriesName, Throwable failure, AnnotationConfigApplicationContext context) {
ClassLoader classLoader = new CustomSpringFactoriesClassLoader(factoriesName);
new FailureAnalyzers(context, classLoader).reportException(failure);
}