root
/
spring-boot
mirror of https://github.com/spring-projects/spring-boot.git
1
0
Fork 0
Code Issues Actions 6 Packages Projects Releases Wiki Activity

Provide Liquibase -> Commons Logging adapter 

Add `CommonsLoggingLiquibaseLogger` implementation to adapt Liquibase's
`Logger` to Apache Commons Logging.

The `LiquibaseAutoConfiguration` class has also been updated to
automatically use the adapter

Fixes gh-1840
This commit is contained in:
Michael Cramer 2014-11-06 15:32:00 +01:00 committed by Phillip Webb
parent ce4400291b
commit f966b3b1b7
4 changed files with 338 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/liquibase/LiquibaseAutoConfiguration.java
View File

@ -21,6 +21,7 @@ import javax.persistence.EntityManagerFactory;
import javax.sql.DataSource;
import liquibase.integration.spring.SpringLiquibase;
import liquibase.servicelocator.ServiceLocator;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.AutoConfigureAfter;
@ -33,6 +34,7 @@ import org.springframework.boot.autoconfigure.data.jpa.EntityManagerFactoryDepen
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
import org.springframework.boot.autoconfigure.jdbc.DataSourceBuilder;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.boot.liquibase.CommonsLoggingLiquibaseLogger;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
@ -82,6 +84,9 @@ public class LiquibaseAutoConfiguration {
+ resource + " (please add changelog or check your Liquibase "
+ "configuration)");
}
ServiceLocator serviceLocator = ServiceLocator.getInstance();
serviceLocator.addPackageToScan(CommonsLoggingLiquibaseLogger.class
.getPackage().getName());
}
@Bean

16
spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/liquibase/LiquibaseAutoConfigurationTests.java
View File

@ -26,12 +26,16 @@ import org.junit.rules.ExpectedException;
import org.springframework.beans.factory.BeanCreationException;
import org.springframework.boot.autoconfigure.PropertyPlaceholderAutoConfiguration;
import org.springframework.boot.autoconfigure.jdbc.EmbeddedDataSourceConfiguration;
import org.springframework.boot.liquibase.CommonsLoggingLiquibaseLogger;
import org.springframework.boot.test.EnvironmentTestUtils;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.test.util.ReflectionTestUtils;
import static org.hamcrest.Matchers.instanceOf;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
/**
@ -151,4 +155,16 @@ public class LiquibaseAutoConfigurationTests {
PropertyPlaceholderAutoConfiguration.class);
this.context.refresh();
}
@Test
public void testLogger() throws Exception {
this.context.register(EmbeddedDataSourceConfiguration.class,
LiquibaseAutoConfiguration.class,
PropertyPlaceholderAutoConfiguration.class);
this.context.refresh();
SpringLiquibase liquibase = this.context.getBean(SpringLiquibase.class);
Object log = ReflectionTestUtils.getField(liquibase, "log");
assertThat(log, instanceOf(CommonsLoggingLiquibaseLogger.class));
}
}

131
spring-boot/src/main/java/org/springframework/boot/liquibase/CommonsLoggingLiquibaseLogger.java Normal file
View File

@ -0,0 +1,131 @@
package org.springframework.boot.liquibase;
import liquibase.configuration.LiquibaseConfiguration;
import liquibase.logging.LogLevel;
import liquibase.logging.Logger;
import liquibase.logging.core.AbstractLogger;
import liquibase.logging.core.DefaultLoggerConfiguration;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
/**
* Liqubase {@link Logger} that that delegates to an Apache Commons {@link Log}.
*
* @author Michael Cramer
* @author Phillip Webb
* @since 1.2.0
*/
public class CommonsLoggingLiquibaseLogger extends AbstractLogger {
public static final int PRIORITY = 10;
private Log logger;
@Override
public void setName(String name) {
this.logger = createLogger(name);
}
/**
* Factory method used to create the logger.
* @param name the name of the logger
* @return a {@link Log} instance
*/
protected Log createLogger(String name) {
return LogFactory.getLog(name);
}
@Override
public void setLogLevel(String logLevel, String logFile) {
super.setLogLevel(logLevel);
}
@Override
public void severe(String message) {
if (isEnabled(LogLevel.SEVERE)) {
this.logger.error(buildMessage(message));
}
}
@Override
public void severe(String message, Throwable e) {
if (isEnabled(LogLevel.SEVERE)) {
this.logger.error(buildMessage(message), e);
}
}
@Override
public void warning(String message) {
if (isEnabled(LogLevel.WARNING)) {
this.logger.warn(buildMessage(message));
}
}
@Override
public void warning(String message, Throwable e) {
if (isEnabled(LogLevel.WARNING)) {
this.logger.warn(buildMessage(message), e);
}
}
@Override
public void info(String message) {
if (isEnabled(LogLevel.INFO)) {
this.logger.info(buildMessage(message));
}
}
@Override
public void info(String message, Throwable e) {
if (isEnabled(LogLevel.INFO)) {
this.logger.info(buildMessage(message), e);
}
}
@Override
public void debug(String message) {
if (isEnabled(LogLevel.DEBUG)) {
this.logger.debug(buildMessage(message));
}
}
@Override
public void debug(String message, Throwable e) {
if (isEnabled(LogLevel.DEBUG)) {
this.logger.debug(buildMessage(message), e);
}
}
@Override
public int getPriority() {
return PRIORITY;
}
private boolean isEnabled(LogLevel level) {
if (this.logger != null && getLogLevel().compareTo(level) <= 0) {
switch (level) {
case DEBUG:
return this.logger.isDebugEnabled();
case INFO:
return this.logger.isInfoEnabled();
case WARNING:
return this.logger.isWarnEnabled();
case SEVERE:
return this.logger.isErrorEnabled();
}
}
return false;
}
@Override
public LogLevel getLogLevel() {
LogLevel logLevel = super.getLogLevel();
if (logLevel == null) {
return toLogLevel(LiquibaseConfiguration.getInstance()
.getConfiguration(DefaultLoggerConfiguration.class).getLogLevel());
}
return logLevel;
}
}

186
spring-boot/src/test/java/org/springframework/boot/liquibase/CommonsLoggingLiquibaseLoggerTests.java Normal file
View File

@ -0,0 +1,186 @@
/*
* Copyright 2012-2014 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.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.boot.liquibase;
import liquibase.logging.LogLevel;
import org.apache.commons.logging.Log;
import org.junit.Before;
import org.junit.Test;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
/**
* Tests for {@link CommonsLoggingLiquibaseLogger}.
*
* @author Phillip Webb
*/
public class CommonsLoggingLiquibaseLoggerTests {
private Log delegate = mock(Log.class);
private CommonsLoggingLiquibaseLogger logger;
private Throwable ex = new Exception();
@Before
public void setup() {
this.logger = new MockCommonsLoggingLiquibaseLogger();
this.logger.setName("mylog");
}
@Test
public void debug() {
this.logger.setLogLevel(LogLevel.DEBUG);
given(this.delegate.isDebugEnabled()).willReturn(true);
this.logger.debug("debug");
verify(this.delegate).debug("debug");
}
@Test
public void debugWithException() {
this.logger.setLogLevel(LogLevel.DEBUG);
given(this.delegate.isDebugEnabled()).willReturn(true);
this.logger.debug("debug", this.ex);
verify(this.delegate).debug("debug", this.ex);
}
@Test
public void debugWithLoggerOff() {
this.logger.setLogLevel(LogLevel.DEBUG);
given(this.delegate.isDebugEnabled()).willReturn(false);
this.logger.debug("debug");
verify(this.delegate, never()).debug("debug");
}
@Test
public void debugBelowLevel() {
this.logger.setLogLevel(LogLevel.INFO);
given(this.delegate.isDebugEnabled()).willReturn(true);
this.logger.debug("debug", this.ex);
verify(this.delegate, never()).debug("debug", this.ex);
}
@Test
public void info() {
this.logger.setLogLevel(LogLevel.INFO);
given(this.delegate.isInfoEnabled()).willReturn(true);
this.logger.info("info");
verify(this.delegate).info("info");
}
@Test
public void infoWithException() {
this.logger.setLogLevel(LogLevel.INFO);
given(this.delegate.isInfoEnabled()).willReturn(true);
this.logger.info("info", this.ex);
verify(this.delegate).info("info", this.ex);
}
@Test
public void infoWithLoggerOff() {
this.logger.setLogLevel(LogLevel.INFO);
given(this.delegate.isInfoEnabled()).willReturn(false);
this.logger.info("info");
verify(this.delegate, never()).info("info");
}
@Test
public void infoBelowLevel() {
this.logger.setLogLevel(LogLevel.WARNING);
given(this.delegate.isInfoEnabled()).willReturn(true);
this.logger.info("info", this.ex);
verify(this.delegate, never()).info("info", this.ex);
}
@Test
public void warning() {
this.logger.setLogLevel(LogLevel.WARNING);
given(this.delegate.isWarnEnabled()).willReturn(true);
this.logger.warning("warning");
verify(this.delegate).warn("warning");
}
@Test
public void warningWithException() {
this.logger.setLogLevel(LogLevel.WARNING);
given(this.delegate.isWarnEnabled()).willReturn(true);
this.logger.warning("warning", this.ex);
verify(this.delegate).warn("warning", this.ex);
}
@Test
public void warningWithLoggerOff() {
this.logger.setLogLevel(LogLevel.WARNING);
given(this.delegate.isWarnEnabled()).willReturn(false);
this.logger.warning("warning");
verify(this.delegate, never()).warn("warning");
}
@Test
public void warningBelowLevel() {
this.logger.setLogLevel(LogLevel.SEVERE);
given(this.delegate.isWarnEnabled()).willReturn(true);
this.logger.warning("warning", this.ex);
verify(this.delegate, never()).warn("warning", this.ex);
}
@Test
public void severe() {
this.logger.setLogLevel(LogLevel.SEVERE);
given(this.delegate.isErrorEnabled()).willReturn(true);
this.logger.severe("severe");
verify(this.delegate).error("severe");
}
@Test
public void severeWithException() {
this.logger.setLogLevel(LogLevel.SEVERE);
given(this.delegate.isErrorEnabled()).willReturn(true);
this.logger.severe("severe", this.ex);
verify(this.delegate).error("severe", this.ex);
}
@Test
public void severeWithLoggerOff() {
this.logger.setLogLevel(LogLevel.SEVERE);
given(this.delegate.isErrorEnabled()).willReturn(false);
this.logger.severe("severe");
verify(this.delegate, never()).error("severe");
}
@Test
public void severeBelowLevel() {
this.logger.setLogLevel(LogLevel.OFF);
given(this.delegate.isErrorEnabled()).willReturn(true);
this.logger.severe("severe", this.ex);
verify(this.delegate, never()).error("severe", this.ex);
}
private class MockCommonsLoggingLiquibaseLogger extends CommonsLoggingLiquibaseLogger {
@Override
protected Log createLogger(String name) {
return CommonsLoggingLiquibaseLoggerTests.this.delegate;
}
}
}