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

Update JavaLoggerConfigurer to use AC ClassLoader

Browse Source 
Update JavaLoggerConfigurer to use the ApplicationContext classloader
rather then the default classloader. Also refactored to introduce
LoggingSystem enum to act as a strategy for the specific logging
systems.
This commit is contained in:
Phillip Webb
2013-05-08 14:24:06 -07:00
parent 10c33db612
commit 4743d1803c
4 changed files with 124 additions and 89 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
spring-bootstrap/src/main/java/org/springframework/bootstrap/logging/JavaLoggerConfigurer.java
View File

@@ -26,7 +26,6 @@ import org.springframework.util.SystemPropertyUtils;
* Logging initializer for {@link Logger java.util.logging}.
*
* @author Dave Syer
*
*/
public abstract class JavaLoggerConfigurer {

1
spring-bootstrap/src/main/java/org/springframework/bootstrap/logging/LogbackConfigurer.java
View File

@@ -30,7 +30,6 @@ import ch.qos.logback.core.joran.spi.JoranException;
* Logging initializer for <a href="http://logback.qos.ch">logback</a>.
*
* @author Dave Syer
*
*/
public abstract class LogbackConfigurer {

210
spring-bootstrap/src/main/java/org/springframework/bootstrap/logging/LoggingInitializer.java
View File

@@ -13,29 +13,30 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.bootstrap.logging;
import java.lang.management.ManagementFactory;
import java.util.HashMap;
import java.util.Map;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextInitializer;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.core.Ordered;
import org.springframework.core.env.ConfigurableEnvironment;
import org.springframework.core.env.Environment;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.ResourceLoader;
import org.springframework.util.ClassUtils;
import org.springframework.util.Log4jConfigurer;
/**
* <p>
* An {@link ApplicationContextInitializer} that configures a logging framework depending
* on what it finds on the classpath and in the {@link Environment}. If the environment
* contains a property <code>logging.config</code> then that will be used to initialize
* the logging system, otherwise a default location is used. The classpath is probed for
* log4j and logback and if those are present they will be reconfigured, otherwise vanilla
* <code>java.util.logging</code> will be used.
* </p>
* <code>java.util.logging</code> will be used. </p>
*
* <p>
* The default config locations are <code>classpath:log4j.properties</code> or
@@ -57,12 +58,21 @@ import org.springframework.util.Log4jConfigurer;
* <li><code>PID</code> is set to the value of the current process ID if it can be
* determined</li>
* </ul>
* @author Dave Syer
*
* @author Dave Syer
* @author Phillip Webb
*/
public class LoggingInitializer implements
ApplicationContextInitializer<ConfigurableApplicationContext>, Ordered {
private static final Map<String, String> ENVIRONMENT_SYSTEM_PROPERTY_MAPPING;
static {
ENVIRONMENT_SYSTEM_PROPERTY_MAPPING = new HashMap<String, String>();
ENVIRONMENT_SYSTEM_PROPERTY_MAPPING.put("logging.file", "LOG_FILE");
ENVIRONMENT_SYSTEM_PROPERTY_MAPPING.put("logging.path", "LOG_PATH");
ENVIRONMENT_SYSTEM_PROPERTY_MAPPING.put("PID", "PID");
}
private int order = Integer.MIN_VALUE + 1;
/**
@@ -72,94 +82,22 @@ public class LoggingInitializer implements
@Override
public void initialize(ConfigurableApplicationContext applicationContext) {
String configLocation = getDefaultConfigLocation();
ConfigurableEnvironment environment = applicationContext.getEnvironment();
if (environment.containsProperty("logging.config")) {
configLocation = environment.getProperty("logging.config");
for (Map.Entry<String, String> mapping : ENVIRONMENT_SYSTEM_PROPERTY_MAPPING
.entrySet()) {
if (environment.containsProperty(mapping.getKey())) {
System.setProperty(mapping.getValue(),
environment.getProperty(mapping.getKey()));
}
}
if (environment.containsProperty("logging.file")) {
String location = environment.getProperty("logging.file");
System.setProperty("LOG_FILE", location);
}
if (environment.containsProperty("logging.path")) {
String location = environment.getProperty("logging.path");
System.setProperty("LOG_PATH", location);
}
if (!environment.containsProperty("PID")) {
if (System.getProperty("PID") == null) {
System.setProperty("PID", getPid());
}
initLogging(applicationContext, configLocation);
}
private void initLogging(ResourceLoader resourceLoader, String configLocation) {
try {
if (isLog4jPresent()) {
Log4jConfigurer.initLogging(configLocation);
} else {
if (isLogbackPresent()) {
LogbackConfigurer.initLogging(configLocation);
} else {
JavaLoggerConfigurer.initLogging(configLocation);
}
}
} catch (RuntimeException e) {
throw e;
} catch (Exception e) {
throw new IllegalStateException("Cannot initialize logging from "
+ configLocation, e);
}
}
private boolean isLogbackPresent() {
return ClassUtils.isPresent("ch.qos.logback.core.Appender",
ClassUtils.getDefaultClassLoader());
}
private boolean isLog4jPresent() {
return ClassUtils.isPresent("org.apache.log4j.PropertyConfigurator",
ClassUtils.getDefaultClassLoader());
}
private String getDefaultConfigLocation() {
String defaultPath = ClassUtils.getPackageName(LoggingInitializer.class).replace(
".", "/")
+ "/";
if (isLog4jPresent()) {
String path = "log4j.xml";
if (!new ClassPathResource(path).exists()) {
path = "log4j.properties";
if (!new ClassPathResource(path).exists()) {
path = defaultPath + path;
}
}
return "classpath:" + path;
}
if (isLogbackPresent()) {
String path = "logback.xml";
if (!new ClassPathResource(path).exists()) {
path = defaultPath + path;
}
return "classpath:" + path;
}
String path = "logging.properties";
if (!new ClassPathResource(path).exists()) {
path = defaultPath + path;
}
return "classpath:" + path;
LoggingSystem system = LoggingSystem.get(applicationContext.getClassLoader());
system.init(applicationContext);
}
private String getPid() {
@@ -178,4 +116,104 @@ public class LoggingInitializer implements
public int getOrder() {
return this.order;
}
private static enum LoggingSystem {
/**
* Log4J
*/
LOG4J("org.apache.log4j.PropertyConfigurator", "log4j.xml", "log4j.properties") {
@Override
protected void doInit(ApplicationContext applicationContext,
String configLocation) throws Exception {
Log4jConfigurer.initLogging(configLocation);
}
},
/**
* Logback
*/
LOGBACK("ch.qos.logback.core.Appender", "logback.xml") {
@Override
protected void doInit(ApplicationContext applicationContext,
String configLocation) throws Exception {
LogbackConfigurer.initLogging(configLocation);
}
},
/**
* Java Util Logging
*/
JAVA(null, "logging.properties") {
@Override
protected void doInit(ApplicationContext applicationContext,
String configLocation) throws Exception {
JavaLoggerConfigurer.initLogging(configLocation);
}
};
private final String className;
private final String[] paths;
private LoggingSystem(String className, String... paths) {
this.className = className;
this.paths = paths;
}
public void init(ApplicationContext applicationContext) {
String configLocation = getConfigLocation(applicationContext);
try {
doInit(applicationContext, configLocation);
} catch (RuntimeException ex) {
throw ex;
} catch (Exception ex) {
throw new IllegalStateException("Cannot initialize logging from "
+ configLocation, ex);
}
}
protected abstract void doInit(ApplicationContext applicationContext,
String configLocation) throws Exception;
private String getConfigLocation(ApplicationContext applicationContext) {
Environment environment = applicationContext.getEnvironment();
ClassLoader classLoader = applicationContext.getClassLoader();
// User specified config
if (environment.containsProperty("logging.config")) {
return environment.getProperty("logging.config");
}
// Common patterns
for (String path : this.paths) {
ClassPathResource resource = new ClassPathResource(path, classLoader);
if (resource.exists()) {
return "classpath:" + path;
}
}
// Fallback to the default
String defaultPath = ClassUtils.getPackageName(LoggingInitializer.class);
defaultPath = defaultPath.replace(".", "/");
defaultPath = defaultPath + "/" + this.paths[this.paths.length - 1];
return "classpath:" + defaultPath;
}
public static LoggingSystem get(ClassLoader classLoader) {
for (LoggingSystem loggingSystem : values()) {
String className = loggingSystem.className;
if (className == null || ClassUtils.isPresent(className, classLoader)) {
return loggingSystem;
}
}
return JAVA;
}
}
}

1
spring-bootstrap/src/test/java/org/springframework/bootstrap/logging/LoggingInitializerTests.java
View File

@@ -31,7 +31,6 @@ import static org.junit.Assert.assertTrue;
/**
* @author Dave Syer
*
*/
public class LoggingInitializerTests {