From c037e75f26ac5ef69e4d5fc3045e101ca674dcaf Mon Sep 17 00:00:00 2001 From: Juergen Hoeller Date: Fri, 27 Jul 2018 17:46:05 +0200 Subject: [PATCH] Improve debug logging at BeanDefinitionReader and BeanFactory level Issue: SPR-17090 --- .../aop/framework/CglibAopProxy.java | 38 ++++++++++--------- .../aop/framework/JdkDynamicAopProxy.java | 4 +- .../adapter/ThrowsAdviceInterceptor.java | 4 +- .../org/springframework/beans/BeanUtils.java | 4 +- .../groovy/GroovyBeanDefinitionReader.java | 11 +++++- .../AbstractAutowireCapableBeanFactory.java | 32 ++++++++-------- .../support/AbstractBeanDefinitionReader.java | 37 +++++++++--------- .../factory/support/AbstractBeanFactory.java | 22 +++++------ .../support/DefaultListableBeanFactory.java | 20 +++++----- .../support/DefaultSingletonBeanRegistry.java | 12 +++--- .../support/DisposableBeanAdapter.java | 18 ++++----- .../PropertiesBeanDefinitionReader.java | 19 +++++++--- .../xml/BeanDefinitionParserDelegate.java | 12 +++--- .../beans/factory/xml/BeansDtdResolver.java | 7 ++-- .../DefaultBeanDefinitionDocumentReader.java | 16 ++++---- .../factory/xml/DefaultDocumentLoader.java | 6 +-- .../xml/DefaultNamespaceHandlerResolver.java | 7 +++- .../factory/xml/PluggableSchemaResolver.java | 14 +++---- .../factory/xml/XmlBeanDefinitionReader.java | 17 ++++++--- ...athScanningCandidateComponentProvider.java | 6 +-- ...onfigurationClassBeanDefinitionReader.java | 9 ++--- .../ConfigurationClassEnhancer.java | 4 +- .../ConfigurationClassPostProcessor.java | 4 +- .../env/PropertySourcesPropertyResolver.java | 4 +- 24 files changed, 177 insertions(+), 150 deletions(-) diff --git a/spring-aop/src/main/java/org/springframework/aop/framework/CglibAopProxy.java b/spring-aop/src/main/java/org/springframework/aop/framework/CglibAopProxy.java index 825d904c50e..fb0644ab686 100644 --- a/spring-aop/src/main/java/org/springframework/aop/framework/CglibAopProxy.java +++ b/spring-aop/src/main/java/org/springframework/aop/framework/CglibAopProxy.java @@ -157,8 +157,8 @@ class CglibAopProxy implements AopProxy, Serializable { @Override public Object getProxy(@Nullable ClassLoader classLoader) { - if (logger.isDebugEnabled()) { - logger.debug("Creating CGLIB proxy: target source is " + this.advised.getTargetSource()); + if (logger.isTraceEnabled()) { + logger.trace("Creating CGLIB proxy: " + this.advised.getTargetSource()); } try { @@ -810,24 +810,28 @@ class CglibAopProxy implements AopProxy, Serializable { @Override public int accept(Method method) { if (AopUtils.isFinalizeMethod(method)) { - logger.debug("Found finalize() method - using NO_OVERRIDE"); + logger.trace("Found finalize() method - using NO_OVERRIDE"); return NO_OVERRIDE; } if (!this.advised.isOpaque() && method.getDeclaringClass().isInterface() && method.getDeclaringClass().isAssignableFrom(Advised.class)) { - if (logger.isDebugEnabled()) { - logger.debug("Method is declared on Advised interface: " + method); + if (logger.isTraceEnabled()) { + logger.trace("Method is declared on Advised interface: " + method); } return DISPATCH_ADVISED; } // We must always proxy equals, to direct calls to this. if (AopUtils.isEqualsMethod(method)) { - logger.debug("Found 'equals' method: " + method); + if (logger.isTraceEnabled()) { + logger.trace("Found 'equals' method: " + method); + } return INVOKE_EQUALS; } // We must always calculate hashCode based on the proxy. if (AopUtils.isHashCodeMethod(method)) { - logger.debug("Found 'hashCode' method: " + method); + if (logger.isTraceEnabled()) { + logger.trace("Found 'hashCode' method: " + method); + } return INVOKE_HASHCODE; } Class targetClass = this.advised.getTargetClass(); @@ -840,8 +844,8 @@ class CglibAopProxy implements AopProxy, Serializable { if (haveAdvice || !isFrozen) { // If exposing the proxy, then AOP_PROXY must be used. if (exposeProxy) { - if (logger.isDebugEnabled()) { - logger.debug("Must expose proxy on advised method: " + method); + if (logger.isTraceEnabled()) { + logger.trace("Must expose proxy on advised method: " + method); } return AOP_PROXY; } @@ -849,16 +853,16 @@ class CglibAopProxy implements AopProxy, Serializable { // Check to see if we have fixed interceptor to serve this method. // Else use the AOP_PROXY. if (isStatic && isFrozen && this.fixedInterceptorMap.containsKey(key)) { - if (logger.isDebugEnabled()) { - logger.debug("Method has advice and optimizations are enabled: " + method); + if (logger.isTraceEnabled()) { + logger.trace("Method has advice and optimizations are enabled: " + method); } // We know that we are optimizing so we can use the FixedStaticChainInterceptors. int index = this.fixedInterceptorMap.get(key); return (index + this.fixedInterceptorOffset); } else { - if (logger.isDebugEnabled()) { - logger.debug("Unable to apply any optimizations to advised method: " + method); + if (logger.isTraceEnabled()) { + logger.trace("Unable to apply any optimizations to advised method: " + method); } return AOP_PROXY; } @@ -874,15 +878,15 @@ class CglibAopProxy implements AopProxy, Serializable { } Class returnType = method.getReturnType(); if (targetClass != null && returnType.isAssignableFrom(targetClass)) { - if (logger.isDebugEnabled()) { - logger.debug("Method return type is assignable from target type and " + + if (logger.isTraceEnabled()) { + logger.trace("Method return type is assignable from target type and " + "may therefore return 'this' - using INVOKE_TARGET: " + method); } return INVOKE_TARGET; } else { - if (logger.isDebugEnabled()) { - logger.debug("Method return type ensures 'this' cannot be returned - " + + if (logger.isTraceEnabled()) { + logger.trace("Method return type ensures 'this' cannot be returned - " + "using DISPATCH_TARGET: " + method); } return DISPATCH_TARGET; diff --git a/spring-aop/src/main/java/org/springframework/aop/framework/JdkDynamicAopProxy.java b/spring-aop/src/main/java/org/springframework/aop/framework/JdkDynamicAopProxy.java index 25ed051fbe8..f31cd878e6b 100644 --- a/spring-aop/src/main/java/org/springframework/aop/framework/JdkDynamicAopProxy.java +++ b/spring-aop/src/main/java/org/springframework/aop/framework/JdkDynamicAopProxy.java @@ -115,8 +115,8 @@ final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializa @Override public Object getProxy(@Nullable ClassLoader classLoader) { - if (logger.isDebugEnabled()) { - logger.debug("Creating JDK dynamic proxy: target source is " + this.advised.getTargetSource()); + if (logger.isTraceEnabled()) { + logger.trace("Creating JDK dynamic proxy: " + this.advised.getTargetSource()); } Class[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true); findDefinedEqualsAndHashCodeMethods(proxiedInterfaces); diff --git a/spring-aop/src/main/java/org/springframework/aop/framework/adapter/ThrowsAdviceInterceptor.java b/spring-aop/src/main/java/org/springframework/aop/framework/adapter/ThrowsAdviceInterceptor.java index 2e3a791d006..bea87cfd68f 100644 --- a/spring-aop/src/main/java/org/springframework/aop/framework/adapter/ThrowsAdviceInterceptor.java +++ b/spring-aop/src/main/java/org/springframework/aop/framework/adapter/ThrowsAdviceInterceptor.java @@ -136,8 +136,8 @@ public class ThrowsAdviceInterceptor implements MethodInterceptor, AfterAdvice { exceptionClass = exceptionClass.getSuperclass(); handler = this.exceptionHandlerMap.get(exceptionClass); } - if (handler != null && logger.isDebugEnabled()) { - logger.debug("Found handler for exception of type [" + exceptionClass.getName() + "]: " + handler); + if (handler != null && logger.isTraceEnabled()) { + logger.trace("Found handler for exception of type [" + exceptionClass.getName() + "]: " + handler); } return handler; } diff --git a/spring-beans/src/main/java/org/springframework/beans/BeanUtils.java b/spring-beans/src/main/java/org/springframework/beans/BeanUtils.java index 0cb8d53f856..248d92b485e 100644 --- a/spring-beans/src/main/java/org/springframework/beans/BeanUtils.java +++ b/spring-beans/src/main/java/org/springframework/beans/BeanUtils.java @@ -511,8 +511,8 @@ public abstract class BeanUtils { return (PropertyEditor) instantiateClass(editorClass); } catch (ClassNotFoundException ex) { - if (logger.isDebugEnabled()) { - logger.debug("No property editor [" + editorName + "] found for type " + + if (logger.isTraceEnabled()) { + logger.trace("No property editor [" + editorName + "] found for type " + targetType.getName() + " according to 'Editor' suffix convention"); } unknownEditorTypes.add(targetType); diff --git a/spring-beans/src/main/java/org/springframework/beans/factory/groovy/GroovyBeanDefinitionReader.java b/spring-beans/src/main/java/org/springframework/beans/factory/groovy/GroovyBeanDefinitionReader.java index a474a0d7918..4581f921415 100644 --- a/spring-beans/src/main/java/org/springframework/beans/factory/groovy/GroovyBeanDefinitionReader.java +++ b/spring-beans/src/main/java/org/springframework/beans/factory/groovy/GroovyBeanDefinitionReader.java @@ -236,6 +236,10 @@ public class GroovyBeanDefinitionReader extends AbstractBeanDefinitionReader imp return this.standardXmlBeanDefinitionReader.loadBeanDefinitions(encodedResource); } + if (logger.isTraceEnabled()) { + logger.trace("Loading Groovy bean definitions from " + encodedResource); + } + Closure beans = new Closure(this) { @Override public Object call(Object[] args) { @@ -265,7 +269,12 @@ public class GroovyBeanDefinitionReader extends AbstractBeanDefinitionReader imp throw new BeanDefinitionParsingException(new Problem("Error evaluating Groovy script: " + ex.getMessage(), new Location(encodedResource.getResource()), null, ex)); } - return getRegistry().getBeanDefinitionCount() - countBefore; + + int count = getRegistry().getBeanDefinitionCount() - countBefore; + if (logger.isDebugEnabled()) { + logger.debug("Loaded " + count + " bean definitions from " + encodedResource); + } + return count; } diff --git a/spring-beans/src/main/java/org/springframework/beans/factory/support/AbstractAutowireCapableBeanFactory.java b/spring-beans/src/main/java/org/springframework/beans/factory/support/AbstractAutowireCapableBeanFactory.java index 5f89d16ddf6..a0d6fa4494c 100644 --- a/spring-beans/src/main/java/org/springframework/beans/factory/support/AbstractAutowireCapableBeanFactory.java +++ b/spring-beans/src/main/java/org/springframework/beans/factory/support/AbstractAutowireCapableBeanFactory.java @@ -459,8 +459,8 @@ public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFac protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException { - if (logger.isDebugEnabled()) { - logger.debug("Creating instance of bean '" + beanName + "'"); + if (logger.isTraceEnabled()) { + logger.trace("Creating instance of bean '" + beanName + "'"); } RootBeanDefinition mbdToUse = mbd; @@ -496,8 +496,8 @@ public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFac try { Object beanInstance = doCreateBean(beanName, mbdToUse, args); - if (logger.isDebugEnabled()) { - logger.debug("Finished creating instance of bean '" + beanName + "'"); + if (logger.isTraceEnabled()) { + logger.trace("Finished creating instance of bean '" + beanName + "'"); } return beanInstance; } @@ -562,8 +562,8 @@ public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFac boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletonCurrentlyInCreation(beanName)); if (earlySingletonExposure) { - if (logger.isDebugEnabled()) { - logger.debug("Eagerly caching bean '" + beanName + + if (logger.isTraceEnabled()) { + logger.trace("Eagerly caching bean '" + beanName + "' to allow for resolving potential circular references"); } addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean)); @@ -1417,8 +1417,8 @@ public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFac Object bean = getBean(propertyName); pvs.add(propertyName, bean); registerDependentBean(propertyName, beanName); - if (logger.isDebugEnabled()) { - logger.debug("Added autowiring by name from bean name '" + beanName + + if (logger.isTraceEnabled()) { + logger.trace("Added autowiring by name from bean name '" + beanName + "' via property '" + propertyName + "' to bean named '" + propertyName + "'"); } } @@ -1468,8 +1468,8 @@ public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFac } for (String autowiredBeanName : autowiredBeanNames) { registerDependentBean(autowiredBeanName, beanName); - if (logger.isDebugEnabled()) { - logger.debug("Autowiring by type from bean name '" + beanName + "' via property '" + + if (logger.isTraceEnabled()) { + logger.trace("Autowiring by type from bean name '" + beanName + "' via property '" + propertyName + "' to bean named '" + autowiredBeanName + "'"); } } @@ -1784,8 +1784,8 @@ public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFac boolean isInitializingBean = (bean instanceof InitializingBean); if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) { - if (logger.isDebugEnabled()) { - logger.debug("Invoking afterPropertiesSet() on bean with name '" + beanName + "'"); + if (logger.isTraceEnabled()) { + logger.trace("Invoking afterPropertiesSet() on bean with name '" + beanName + "'"); } if (System.getSecurityManager() != null) { try { @@ -1835,8 +1835,8 @@ public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFac initMethodName + "' on bean with name '" + beanName + "'"); } else { - if (logger.isDebugEnabled()) { - logger.debug("No default init method named '" + initMethodName + + if (logger.isTraceEnabled()) { + logger.trace("No default init method named '" + initMethodName + "' found on bean with name '" + beanName + "'"); } // Ignore non-existent default lifecycle methods. @@ -1844,8 +1844,8 @@ public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFac } } - if (logger.isDebugEnabled()) { - logger.debug("Invoking init method '" + initMethodName + "' on bean with name '" + beanName + "'"); + if (logger.isTraceEnabled()) { + logger.trace("Invoking init method '" + initMethodName + "' on bean with name '" + beanName + "'"); } if (System.getSecurityManager() != null) { diff --git a/spring-beans/src/main/java/org/springframework/beans/factory/support/AbstractBeanDefinitionReader.java b/spring-beans/src/main/java/org/springframework/beans/factory/support/AbstractBeanDefinitionReader.java index f49a89cc798..cd46b51b63b 100644 --- a/spring-beans/src/main/java/org/springframework/beans/factory/support/AbstractBeanDefinitionReader.java +++ b/spring-beans/src/main/java/org/springframework/beans/factory/support/AbstractBeanDefinitionReader.java @@ -17,6 +17,7 @@ package org.springframework.beans.factory.support; import java.io.IOException; +import java.util.Collections; import java.util.Set; import org.apache.commons.logging.Log; @@ -45,7 +46,7 @@ import org.springframework.util.Assert; * @since 11.12.2003 * @see BeanDefinitionReaderUtils */ -public abstract class AbstractBeanDefinitionReader implements EnvironmentCapable, BeanDefinitionReader { +public abstract class AbstractBeanDefinitionReader implements BeanDefinitionReader, EnvironmentCapable { /** Logger available to subclasses. */ protected final Log logger = LogFactory.getLog(getClass()); @@ -182,11 +183,11 @@ public abstract class AbstractBeanDefinitionReader implements EnvironmentCapable @Override public int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException { Assert.notNull(resources, "Resource array must not be null"); - int counter = 0; + int count = 0; for (Resource resource : resources) { - counter += loadBeanDefinitions(resource); + count += loadBeanDefinitions(resource); } - return counter; + return count; } @Override @@ -213,23 +214,21 @@ public abstract class AbstractBeanDefinitionReader implements EnvironmentCapable ResourceLoader resourceLoader = getResourceLoader(); if (resourceLoader == null) { throw new BeanDefinitionStoreException( - "Cannot import bean definitions from location [" + location + "]: no ResourceLoader available"); + "Cannot load bean definitions from location [" + location + "]: no ResourceLoader available"); } if (resourceLoader instanceof ResourcePatternResolver) { // Resource pattern matching available. try { Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location); - int loadCount = loadBeanDefinitions(resources); + int count = loadBeanDefinitions(resources); if (actualResources != null) { - for (Resource resource : resources) { - actualResources.add(resource); - } + Collections.addAll(actualResources, resources); } - if (logger.isDebugEnabled()) { - logger.debug("Loaded " + loadCount + " bean definitions from location pattern [" + location + "]"); + if (logger.isTraceEnabled()) { + logger.trace("Loaded " + count + " bean definitions from location pattern [" + location + "]"); } - return loadCount; + return count; } catch (IOException ex) { throw new BeanDefinitionStoreException( @@ -239,25 +238,25 @@ public abstract class AbstractBeanDefinitionReader implements EnvironmentCapable else { // Can only load single resources by absolute URL. Resource resource = resourceLoader.getResource(location); - int loadCount = loadBeanDefinitions(resource); + int count = loadBeanDefinitions(resource); if (actualResources != null) { actualResources.add(resource); } - if (logger.isDebugEnabled()) { - logger.debug("Loaded " + loadCount + " bean definitions from location [" + location + "]"); + if (logger.isTraceEnabled()) { + logger.trace("Loaded " + count + " bean definitions from location [" + location + "]"); } - return loadCount; + return count; } } @Override public int loadBeanDefinitions(String... locations) throws BeanDefinitionStoreException { Assert.notNull(locations, "Location array must not be null"); - int counter = 0; + int count = 0; for (String location : locations) { - counter += loadBeanDefinitions(location); + count += loadBeanDefinitions(location); } - return counter; + return count; } } diff --git a/spring-beans/src/main/java/org/springframework/beans/factory/support/AbstractBeanFactory.java b/spring-beans/src/main/java/org/springframework/beans/factory/support/AbstractBeanFactory.java index aa7da4c04cf..2208b8c4f14 100644 --- a/spring-beans/src/main/java/org/springframework/beans/factory/support/AbstractBeanFactory.java +++ b/spring-beans/src/main/java/org/springframework/beans/factory/support/AbstractBeanFactory.java @@ -245,13 +245,13 @@ public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport imp // Eagerly check singleton cache for manually registered singletons. Object sharedInstance = getSingleton(beanName); if (sharedInstance != null && args == null) { - if (logger.isDebugEnabled()) { + if (logger.isTraceEnabled()) { if (isSingletonCurrentlyInCreation(beanName)) { - logger.debug("Returning eagerly cached instance of singleton bean '" + beanName + + logger.trace("Returning eagerly cached instance of singleton bean '" + beanName + "' that is not fully initialized yet - a consequence of a circular reference"); } else { - logger.debug("Returning cached instance of singleton bean '" + beanName + "'"); + logger.trace("Returning cached instance of singleton bean '" + beanName + "'"); } } bean = getObjectForBeanInstance(sharedInstance, name, beanName, null); @@ -385,8 +385,8 @@ public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport imp return convertedBean; } catch (TypeMismatchException ex) { - if (logger.isDebugEnabled()) { - logger.debug("Failed to convert bean '" + name + "' to required type '" + + if (logger.isTraceEnabled()) { + logger.trace("Failed to convert bean '" + name + "' to required type '" + ClassUtils.getQualifiedName(requiredType) + "'", ex); } throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass()); @@ -1519,18 +1519,18 @@ public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport imp } catch (BeanCreationException ex) { if (ex.contains(BeanCurrentlyInCreationException.class)) { - if (logger.isDebugEnabled()) { - logger.debug("Bean currently in creation on FactoryBean type check: " + ex); + if (logger.isTraceEnabled()) { + logger.trace("Bean currently in creation on FactoryBean type check: " + ex); } } else if (mbd.isLazyInit()) { - if (logger.isDebugEnabled()) { - logger.debug("Bean creation exception on lazy FactoryBean type check: " + ex); + if (logger.isTraceEnabled()) { + logger.trace("Bean creation exception on lazy FactoryBean type check: " + ex); } } else { - if (logger.isInfoEnabled()) { - logger.info("Bean creation exception on non-lazy FactoryBean type check: " + ex); + if (logger.isDebugEnabled()) { + logger.debug("Bean creation exception on non-lazy FactoryBean type check: " + ex); } } onSuppressedException(ex); diff --git a/spring-beans/src/main/java/org/springframework/beans/factory/support/DefaultListableBeanFactory.java b/spring-beans/src/main/java/org/springframework/beans/factory/support/DefaultListableBeanFactory.java index f0f8163e308..ed40ab417fc 100644 --- a/spring-beans/src/main/java/org/springframework/beans/factory/support/DefaultListableBeanFactory.java +++ b/spring-beans/src/main/java/org/springframework/beans/factory/support/DefaultListableBeanFactory.java @@ -503,8 +503,8 @@ public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFacto throw ex; } // Probably a class name with a placeholder: let's ignore it for type matching purposes. - if (logger.isDebugEnabled()) { - logger.debug("Ignoring bean class loading failure for bean '" + beanName + "'", ex); + if (logger.isTraceEnabled()) { + logger.trace("Ignoring bean class loading failure for bean '" + beanName + "'", ex); } onSuppressedException(ex); } @@ -513,8 +513,8 @@ public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFacto throw ex; } // Probably some metadata with a placeholder: let's ignore it for type matching purposes. - if (logger.isDebugEnabled()) { - logger.debug("Ignoring unresolvable metadata in bean definition '" + beanName + "'", ex); + if (logger.isTraceEnabled()) { + logger.trace("Ignoring unresolvable metadata in bean definition '" + beanName + "'", ex); } onSuppressedException(ex); } @@ -541,8 +541,8 @@ public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFacto } catch (NoSuchBeanDefinitionException ex) { // Shouldn't happen - probably a result of circular reference resolution... - if (logger.isDebugEnabled()) { - logger.debug("Failed to check manually registered singleton with name '" + beanName + "'", ex); + if (logger.isTraceEnabled()) { + logger.trace("Failed to check manually registered singleton with name '" + beanName + "'", ex); } } } @@ -586,8 +586,8 @@ public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFacto BeanCreationException bce = (BeanCreationException) rootCause; String exBeanName = bce.getBeanName(); if (exBeanName != null && isCurrentlyInCreation(exBeanName)) { - if (logger.isDebugEnabled()) { - logger.debug("Ignoring match to currently created bean '" + exBeanName + "': " + + if (logger.isTraceEnabled()) { + logger.trace("Ignoring match to currently created bean '" + exBeanName + "': " + ex.getMessage()); } onSuppressedException(ex); @@ -790,8 +790,8 @@ public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFacto @Override public void preInstantiateSingletons() throws BeansException { - if (logger.isDebugEnabled()) { - logger.debug("Pre-instantiating singletons in " + this); + if (logger.isTraceEnabled()) { + logger.trace("Pre-instantiating singletons in " + this); } // Iterate over a copy to allow for init methods which in turn register new bean definitions. diff --git a/spring-beans/src/main/java/org/springframework/beans/factory/support/DefaultSingletonBeanRegistry.java b/spring-beans/src/main/java/org/springframework/beans/factory/support/DefaultSingletonBeanRegistry.java index a7c6a125b4b..8ab6806f259 100644 --- a/spring-beans/src/main/java/org/springframework/beans/factory/support/DefaultSingletonBeanRegistry.java +++ b/spring-beans/src/main/java/org/springframework/beans/factory/support/DefaultSingletonBeanRegistry.java @@ -489,8 +489,8 @@ public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements } public void destroySingletons() { - if (logger.isDebugEnabled()) { - logger.debug("Destroying singletons in " + this); + if (logger.isTraceEnabled()) { + logger.trace("Destroying singletons in " + this); } synchronized (this.singletonObjects) { this.singletonsCurrentlyInDestruction = true; @@ -557,8 +557,8 @@ public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements dependencies = this.dependentBeanMap.remove(beanName); } if (dependencies != null) { - if (logger.isDebugEnabled()) { - logger.debug("Retrieved dependent beans for bean '" + beanName + "': " + dependencies); + if (logger.isTraceEnabled()) { + logger.trace("Retrieved dependent beans for bean '" + beanName + "': " + dependencies); } for (String dependentBeanName : dependencies) { destroySingleton(dependentBeanName); @@ -571,7 +571,9 @@ public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements bean.destroy(); } catch (Throwable ex) { - logger.warn("Destroy method on bean with name '" + beanName + "' threw an exception", ex); + if (logger.isInfoEnabled()) { + logger.info("Destroy method on bean with name '" + beanName + "' threw an exception", ex); + } } } diff --git a/spring-beans/src/main/java/org/springframework/beans/factory/support/DisposableBeanAdapter.java b/spring-beans/src/main/java/org/springframework/beans/factory/support/DisposableBeanAdapter.java index 6519ebc8b49..2eed8cbaa34 100644 --- a/spring-beans/src/main/java/org/springframework/beans/factory/support/DisposableBeanAdapter.java +++ b/spring-beans/src/main/java/org/springframework/beans/factory/support/DisposableBeanAdapter.java @@ -242,8 +242,8 @@ class DisposableBeanAdapter implements DisposableBean, Runnable, Serializable { } if (this.invokeDisposableBean) { - if (logger.isDebugEnabled()) { - logger.debug("Invoking destroy() on bean with name '" + this.beanName + "'"); + if (logger.isTraceEnabled()) { + logger.trace("Invoking destroy() on bean with name '" + this.beanName + "'"); } try { if (System.getSecurityManager() != null) { @@ -259,10 +259,10 @@ class DisposableBeanAdapter implements DisposableBean, Runnable, Serializable { catch (Throwable ex) { String msg = "Invocation of destroy method failed on bean with name '" + this.beanName + "'"; if (logger.isDebugEnabled()) { - logger.warn(msg, ex); + logger.info(msg, ex); } else { - logger.warn(msg + ": " + ex); + logger.info(msg + ": " + ex); } } } @@ -314,8 +314,8 @@ class DisposableBeanAdapter implements DisposableBean, Runnable, Serializable { if (paramTypes.length == 1) { args[0] = Boolean.TRUE; } - if (logger.isDebugEnabled()) { - logger.debug("Invoking destroy method '" + this.destroyMethodName + + if (logger.isTraceEnabled()) { + logger.trace("Invoking destroy method '" + this.destroyMethodName + "' on bean with name '" + this.beanName + "'"); } try { @@ -341,14 +341,14 @@ class DisposableBeanAdapter implements DisposableBean, Runnable, Serializable { String msg = "Destroy method '" + this.destroyMethodName + "' on bean with name '" + this.beanName + "' threw an exception"; if (logger.isDebugEnabled()) { - logger.warn(msg, ex.getTargetException()); + logger.info(msg, ex.getTargetException()); } else { - logger.warn(msg + ": " + ex.getTargetException()); + logger.info(msg + ": " + ex.getTargetException()); } } catch (Throwable ex) { - logger.warn("Failed to invoke destroy method '" + this.destroyMethodName + + logger.info("Failed to invoke destroy method '" + this.destroyMethodName + "' on bean with name '" + this.beanName + "'", ex); } } diff --git a/spring-beans/src/main/java/org/springframework/beans/factory/support/PropertiesBeanDefinitionReader.java b/spring-beans/src/main/java/org/springframework/beans/factory/support/PropertiesBeanDefinitionReader.java index 41bcbd70bf9..84e298cfd54 100644 --- a/spring-beans/src/main/java/org/springframework/beans/factory/support/PropertiesBeanDefinitionReader.java +++ b/spring-beans/src/main/java/org/springframework/beans/factory/support/PropertiesBeanDefinitionReader.java @@ -247,6 +247,10 @@ public class PropertiesBeanDefinitionReader extends AbstractBeanDefinitionReader public int loadBeanDefinitions(EncodedResource encodedResource, @Nullable String prefix) throws BeanDefinitionStoreException { + if (logger.isTraceEnabled()) { + logger.trace("Loading properties bean definitions from " + encodedResource); + } + Properties props = new Properties(); try { try (InputStream is = encodedResource.getResource().getInputStream()) { @@ -257,7 +261,12 @@ public class PropertiesBeanDefinitionReader extends AbstractBeanDefinitionReader getPropertiesPersister().load(props, is); } } - return registerBeanDefinitions(props, prefix, encodedResource.getResource().getDescription()); + + int count = registerBeanDefinitions(props, prefix, encodedResource.getResource().getDescription()); + if (logger.isDebugEnabled()) { + logger.debug("Loaded " + count + " bean definitions from " + encodedResource); + } + return count; } catch (IOException ex) { throw new BeanDefinitionStoreException("Could not parse properties from " + encodedResource.getResource(), ex); @@ -368,8 +377,8 @@ public class PropertiesBeanDefinitionReader extends AbstractBeanDefinitionReader } if (sepIdx != -1) { String beanName = nameAndProperty.substring(0, sepIdx); - if (logger.isDebugEnabled()) { - logger.debug("Found bean name '" + beanName + "'"); + if (logger.isTraceEnabled()) { + logger.trace("Found bean name '" + beanName + "'"); } if (!getRegistry().containsBeanDefinition(beanName)) { // If we haven't already registered it... @@ -468,8 +477,8 @@ public class PropertiesBeanDefinitionReader extends AbstractBeanDefinitionReader } } - if (logger.isDebugEnabled()) { - logger.debug("Registering bean definition for bean name '" + beanName + "' with " + pvs); + if (logger.isTraceEnabled()) { + logger.trace("Registering bean definition for bean name '" + beanName + "' with " + pvs); } // Just use default parent if we're not dealing with the parent itself, diff --git a/spring-beans/src/main/java/org/springframework/beans/factory/xml/BeanDefinitionParserDelegate.java b/spring-beans/src/main/java/org/springframework/beans/factory/xml/BeanDefinitionParserDelegate.java index 3dc012d5a70..5da0bf53b20 100644 --- a/spring-beans/src/main/java/org/springframework/beans/factory/xml/BeanDefinitionParserDelegate.java +++ b/spring-beans/src/main/java/org/springframework/beans/factory/xml/BeanDefinitionParserDelegate.java @@ -424,8 +424,8 @@ public class BeanDefinitionParserDelegate { String beanName = id; if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) { beanName = aliases.remove(0); - if (logger.isDebugEnabled()) { - logger.debug("No XML 'id' specified - using '" + beanName + + if (logger.isTraceEnabled()) { + logger.trace("No XML 'id' specified - using '" + beanName + "' as bean name and " + aliases + " as aliases"); } } @@ -454,8 +454,8 @@ public class BeanDefinitionParserDelegate { aliases.add(beanClassName); } } - if (logger.isDebugEnabled()) { - logger.debug("Neither XML 'id' nor 'name' specified - " + + if (logger.isTraceEnabled()) { + logger.trace("Neither XML 'id' nor 'name' specified - " + "using generated bean name [" + beanName + "]"); } } @@ -1429,8 +1429,8 @@ public class BeanDefinitionParserDelegate { } String id = ele.getNodeName() + BeanDefinitionReaderUtils.GENERATED_BEAN_NAME_SEPARATOR + ObjectUtils.getIdentityHexString(innerDefinition); - if (logger.isDebugEnabled()) { - logger.debug("Using generated bean name [" + id + + if (logger.isTraceEnabled()) { + logger.trace("Using generated bean name [" + id + "] for nested custom element '" + ele.getNodeName() + "'"); } return new BeanDefinitionHolder(innerDefinition, id); diff --git a/spring-beans/src/main/java/org/springframework/beans/factory/xml/BeansDtdResolver.java b/spring-beans/src/main/java/org/springframework/beans/factory/xml/BeansDtdResolver.java index 559de3b6b83..b77b31700ad 100644 --- a/spring-beans/src/main/java/org/springframework/beans/factory/xml/BeansDtdResolver.java +++ b/spring-beans/src/main/java/org/springframework/beans/factory/xml/BeansDtdResolver.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2017 the original author or authors. + * Copyright 2002-2018 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. @@ -70,8 +70,8 @@ public class BeansDtdResolver implements EntityResolver { InputSource source = new InputSource(resource.getInputStream()); source.setPublicId(publicId); source.setSystemId(systemId); - if (logger.isDebugEnabled()) { - logger.debug("Found beans DTD [" + systemId + "] in classpath: " + dtdFile); + if (logger.isTraceEnabled()) { + logger.trace("Found beans DTD [" + systemId + "] in classpath: " + dtdFile); } return source; } @@ -80,7 +80,6 @@ public class BeansDtdResolver implements EntityResolver { logger.debug("Could not resolve beans DTD [" + systemId + "]: not found in classpath", ex); } } - } } diff --git a/spring-beans/src/main/java/org/springframework/beans/factory/xml/DefaultBeanDefinitionDocumentReader.java b/spring-beans/src/main/java/org/springframework/beans/factory/xml/DefaultBeanDefinitionDocumentReader.java index eda06c5a0f4..54587fd4126 100644 --- a/spring-beans/src/main/java/org/springframework/beans/factory/xml/DefaultBeanDefinitionDocumentReader.java +++ b/spring-beans/src/main/java/org/springframework/beans/factory/xml/DefaultBeanDefinitionDocumentReader.java @@ -93,9 +93,7 @@ public class DefaultBeanDefinitionDocumentReader implements BeanDefinitionDocume @Override public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) { this.readerContext = readerContext; - logger.debug("Loading bean definitions"); - Element root = doc.getDocumentElement(); - doRegisterBeanDefinitions(root); + doRegisterBeanDefinitions(doc.getDocumentElement()); } /** @@ -234,8 +232,8 @@ public class DefaultBeanDefinitionDocumentReader implements BeanDefinitionDocume if (absoluteLocation) { try { int importCount = getReaderContext().getReader().loadBeanDefinitions(location, actualResources); - if (logger.isDebugEnabled()) { - logger.debug("Imported " + importCount + " bean definitions from URL location [" + location + "]"); + if (logger.isTraceEnabled()) { + logger.trace("Imported " + importCount + " bean definitions from URL location [" + location + "]"); } } catch (BeanDefinitionStoreException ex) { @@ -257,16 +255,16 @@ public class DefaultBeanDefinitionDocumentReader implements BeanDefinitionDocume importCount = getReaderContext().getReader().loadBeanDefinitions( StringUtils.applyRelativePath(baseLocation, location), actualResources); } - if (logger.isDebugEnabled()) { - logger.debug("Imported " + importCount + " bean definitions from relative location [" + location + "]"); + if (logger.isTraceEnabled()) { + logger.trace("Imported " + importCount + " bean definitions from relative location [" + location + "]"); } } catch (IOException ex) { getReaderContext().error("Failed to resolve current resource location", ele, ex); } catch (BeanDefinitionStoreException ex) { - getReaderContext().error("Failed to import bean definitions from relative location [" + location + "]", - ele, ex); + getReaderContext().error( + "Failed to import bean definitions from relative location [" + location + "]", ele, ex); } } Resource[] actResArray = actualResources.toArray(new Resource[0]); diff --git a/spring-beans/src/main/java/org/springframework/beans/factory/xml/DefaultDocumentLoader.java b/spring-beans/src/main/java/org/springframework/beans/factory/xml/DefaultDocumentLoader.java index 7f1bd1b6591..88ae6b64bdd 100644 --- a/spring-beans/src/main/java/org/springframework/beans/factory/xml/DefaultDocumentLoader.java +++ b/spring-beans/src/main/java/org/springframework/beans/factory/xml/DefaultDocumentLoader.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2017 the original author or authors. + * Copyright 2002-2018 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. @@ -70,8 +70,8 @@ public class DefaultDocumentLoader implements DocumentLoader { ErrorHandler errorHandler, int validationMode, boolean namespaceAware) throws Exception { DocumentBuilderFactory factory = createDocumentBuilderFactory(validationMode, namespaceAware); - if (logger.isDebugEnabled()) { - logger.debug("Using JAXP provider [" + factory.getClass().getName() + "]"); + if (logger.isTraceEnabled()) { + logger.trace("Using JAXP provider [" + factory.getClass().getName() + "]"); } DocumentBuilder builder = createDocumentBuilder(factory, entityResolver, errorHandler); return builder.parse(inputSource); diff --git a/spring-beans/src/main/java/org/springframework/beans/factory/xml/DefaultNamespaceHandlerResolver.java b/spring-beans/src/main/java/org/springframework/beans/factory/xml/DefaultNamespaceHandlerResolver.java index c3908fe4c53..1fd873d381c 100644 --- a/spring-beans/src/main/java/org/springframework/beans/factory/xml/DefaultNamespaceHandlerResolver.java +++ b/spring-beans/src/main/java/org/springframework/beans/factory/xml/DefaultNamespaceHandlerResolver.java @@ -156,11 +156,14 @@ public class DefaultNamespaceHandlerResolver implements NamespaceHandlerResolver synchronized (this) { handlerMappings = this.handlerMappings; if (handlerMappings == null) { + if (logger.isTraceEnabled()) { + logger.trace("Loading NamespaceHandler mappings from [" + this.handlerMappingsLocation + "]"); + } try { Properties mappings = PropertiesLoaderUtils.loadAllProperties(this.handlerMappingsLocation, this.classLoader); - if (logger.isDebugEnabled()) { - logger.debug("Loaded NamespaceHandler mappings: " + mappings); + if (logger.isTraceEnabled()) { + logger.trace("Loaded NamespaceHandler mappings: " + mappings); } Map mappingsToUse = new ConcurrentHashMap<>(mappings.size()); CollectionUtils.mergePropertiesIntoMap(mappings, mappingsToUse); diff --git a/spring-beans/src/main/java/org/springframework/beans/factory/xml/PluggableSchemaResolver.java b/spring-beans/src/main/java/org/springframework/beans/factory/xml/PluggableSchemaResolver.java index 745cf7fa718..257461792ca 100644 --- a/spring-beans/src/main/java/org/springframework/beans/factory/xml/PluggableSchemaResolver.java +++ b/spring-beans/src/main/java/org/springframework/beans/factory/xml/PluggableSchemaResolver.java @@ -119,14 +119,14 @@ public class PluggableSchemaResolver implements EntityResolver { InputSource source = new InputSource(resource.getInputStream()); source.setPublicId(publicId); source.setSystemId(systemId); - if (logger.isDebugEnabled()) { - logger.debug("Found XML schema [" + systemId + "] in classpath: " + resourceLocation); + if (logger.isTraceEnabled()) { + logger.trace("Found XML schema [" + systemId + "] in classpath: " + resourceLocation); } return source; } catch (FileNotFoundException ex) { if (logger.isDebugEnabled()) { - logger.debug("Couldn't find XML schema [" + systemId + "]: " + resource, ex); + logger.debug("Could not find XML schema [" + systemId + "]: " + resource, ex); } } } @@ -143,14 +143,14 @@ public class PluggableSchemaResolver implements EntityResolver { synchronized (this) { schemaMappings = this.schemaMappings; if (schemaMappings == null) { - if (logger.isDebugEnabled()) { - logger.debug("Loading schema mappings from [" + this.schemaMappingsLocation + "]"); + if (logger.isTraceEnabled()) { + logger.trace("Loading schema mappings from [" + this.schemaMappingsLocation + "]"); } try { Properties mappings = PropertiesLoaderUtils.loadAllProperties(this.schemaMappingsLocation, this.classLoader); - if (logger.isDebugEnabled()) { - logger.debug("Loaded schema mappings: " + mappings); + if (logger.isTraceEnabled()) { + logger.trace("Loaded schema mappings: " + mappings); } Map mappingsToUse = new ConcurrentHashMap<>(mappings.size()); CollectionUtils.mergePropertiesIntoMap(mappings, mappingsToUse); diff --git a/spring-beans/src/main/java/org/springframework/beans/factory/xml/XmlBeanDefinitionReader.java b/spring-beans/src/main/java/org/springframework/beans/factory/xml/XmlBeanDefinitionReader.java index 6a4dcb6252c..1540f21b05c 100644 --- a/spring-beans/src/main/java/org/springframework/beans/factory/xml/XmlBeanDefinitionReader.java +++ b/spring-beans/src/main/java/org/springframework/beans/factory/xml/XmlBeanDefinitionReader.java @@ -105,7 +105,8 @@ public class XmlBeanDefinitionReader extends AbstractBeanDefinitionReader { private boolean namespaceAware = false; - private Class documentReaderClass = DefaultBeanDefinitionDocumentReader.class; + private Class documentReaderClass = + DefaultBeanDefinitionDocumentReader.class; private ProblemReporter problemReporter = new FailFastProblemReporter(); @@ -312,8 +313,8 @@ public class XmlBeanDefinitionReader extends AbstractBeanDefinitionReader { */ public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException { Assert.notNull(encodedResource, "EncodedResource must not be null"); - if (logger.isDebugEnabled()) { - logger.debug("Loading XML bean definitions from " + encodedResource.getResource()); + if (logger.isTraceEnabled()) { + logger.trace("Loading XML bean definitions from " + encodedResource); } Set currentResources = this.resourcesCurrentlyBeingLoaded.get(); @@ -386,9 +387,14 @@ public class XmlBeanDefinitionReader extends AbstractBeanDefinitionReader { */ protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource) throws BeanDefinitionStoreException { + try { Document doc = doLoadDocument(inputSource, resource); - return registerBeanDefinitions(doc, resource); + int count = registerBeanDefinitions(doc, resource); + if (logger.isDebugEnabled()) { + logger.debug("Loaded " + count + " bean definitions from " + resource); + } + return count; } catch (BeanDefinitionStoreException ex) { throw ex; @@ -429,7 +435,6 @@ public class XmlBeanDefinitionReader extends AbstractBeanDefinitionReader { getValidationModeForResource(resource), isNamespaceAware()); } - /** * Gets the validation mode for the specified {@link Resource}. If no explicit * validation mode has been configured then the validation mode is @@ -515,7 +520,7 @@ public class XmlBeanDefinitionReader extends AbstractBeanDefinitionReader { * @see #setDocumentReaderClass */ protected BeanDefinitionDocumentReader createBeanDefinitionDocumentReader() { - return BeanDefinitionDocumentReader.class.cast(BeanUtils.instantiateClass(this.documentReaderClass)); + return BeanUtils.instantiateClass(this.documentReaderClass); } /** diff --git a/spring-context/src/main/java/org/springframework/context/annotation/ClassPathScanningCandidateComponentProvider.java b/spring-context/src/main/java/org/springframework/context/annotation/ClassPathScanningCandidateComponentProvider.java index 6a5f31df6fc..0d7e4ddd056 100644 --- a/spring-context/src/main/java/org/springframework/context/annotation/ClassPathScanningCandidateComponentProvider.java +++ b/spring-context/src/main/java/org/springframework/context/annotation/ClassPathScanningCandidateComponentProvider.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2017 the original author or authors. + * Copyright 2002-2018 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. @@ -209,7 +209,7 @@ public class ClassPathScanningCandidateComponentProvider implements EnvironmentC try { this.includeFilters.add(new AnnotationTypeFilter( ((Class) ClassUtils.forName("javax.annotation.ManagedBean", cl)), false)); - logger.debug("JSR-250 'javax.annotation.ManagedBean' found and supported for component scanning"); + logger.trace("JSR-250 'javax.annotation.ManagedBean' found and supported for component scanning"); } catch (ClassNotFoundException ex) { // JSR-250 1.1 API (as included in Java EE 6) not available - simply skip. @@ -217,7 +217,7 @@ public class ClassPathScanningCandidateComponentProvider implements EnvironmentC try { this.includeFilters.add(new AnnotationTypeFilter( ((Class) ClassUtils.forName("javax.inject.Named", cl)), false)); - logger.debug("JSR-330 'javax.inject.Named' annotation found and supported for component scanning"); + logger.trace("JSR-330 'javax.inject.Named' annotation found and supported for component scanning"); } catch (ClassNotFoundException ex) { // JSR-330 API not available - simply skip. diff --git a/spring-context/src/main/java/org/springframework/context/annotation/ConfigurationClassBeanDefinitionReader.java b/spring-context/src/main/java/org/springframework/context/annotation/ConfigurationClassBeanDefinitionReader.java index 1f3fa1439b1..107cb90973d 100644 --- a/spring-context/src/main/java/org/springframework/context/annotation/ConfigurationClassBeanDefinitionReader.java +++ b/spring-context/src/main/java/org/springframework/context/annotation/ConfigurationClassBeanDefinitionReader.java @@ -89,8 +89,8 @@ class ConfigurationClassBeanDefinitionReader { /** - * Create a new {@link ConfigurationClassBeanDefinitionReader} instance that will be used - * to populate the given {@link BeanDefinitionRegistry}. + * Create a new {@link ConfigurationClassBeanDefinitionReader} instance + * that will be used to populate the given {@link BeanDefinitionRegistry}. */ ConfigurationClassBeanDefinitionReader(BeanDefinitionRegistry registry, SourceExtractor sourceExtractor, ResourceLoader resourceLoader, Environment environment, BeanNameGenerator importBeanNameGenerator, @@ -266,11 +266,10 @@ class ConfigurationClassBeanDefinitionReader { (RootBeanDefinition) proxyDef.getBeanDefinition(), configClass, metadata); } - if (logger.isDebugEnabled()) { - logger.debug(String.format("Registering bean definition for @Bean method %s.%s()", + if (logger.isTraceEnabled()) { + logger.trace(String.format("Registering bean definition for @Bean method %s.%s()", configClass.getMetadata().getClassName(), beanName)); } - this.registry.registerBeanDefinition(beanName, beanDefToRegister); } diff --git a/spring-context/src/main/java/org/springframework/context/annotation/ConfigurationClassEnhancer.java b/spring-context/src/main/java/org/springframework/context/annotation/ConfigurationClassEnhancer.java index d91f546a3d6..d2f29a1885b 100644 --- a/spring-context/src/main/java/org/springframework/context/annotation/ConfigurationClassEnhancer.java +++ b/spring-context/src/main/java/org/springframework/context/annotation/ConfigurationClassEnhancer.java @@ -108,8 +108,8 @@ class ConfigurationClassEnhancer { return configClass; } Class enhancedClass = createClass(newEnhancer(configClass, classLoader)); - if (logger.isDebugEnabled()) { - logger.debug(String.format("Successfully enhanced %s; enhanced class name is: %s", + if (logger.isTraceEnabled()) { + logger.trace(String.format("Successfully enhanced %s; enhanced class name is: %s", configClass.getName(), enhancedClass.getName())); } return enhancedClass; diff --git a/spring-context/src/main/java/org/springframework/context/annotation/ConfigurationClassPostProcessor.java b/spring-context/src/main/java/org/springframework/context/annotation/ConfigurationClassPostProcessor.java index e7376044733..a5f9cbfd644 100644 --- a/spring-context/src/main/java/org/springframework/context/annotation/ConfigurationClassPostProcessor.java +++ b/spring-context/src/main/java/org/springframework/context/annotation/ConfigurationClassPostProcessor.java @@ -401,8 +401,8 @@ public class ConfigurationClassPostProcessor implements BeanDefinitionRegistryPo if (configClass != null) { Class enhancedClass = enhancer.enhance(configClass, this.beanClassLoader); if (configClass != enhancedClass) { - if (logger.isDebugEnabled()) { - logger.debug(String.format("Replacing bean definition '%s' existing class '%s' with " + + if (logger.isTraceEnabled()) { + logger.trace(String.format("Replacing bean definition '%s' existing class '%s' with " + "enhanced class '%s'", entry.getKey(), configClass.getName(), enhancedClass.getName())); } beanDef.setBeanClass(enhancedClass); diff --git a/spring-core/src/main/java/org/springframework/core/env/PropertySourcesPropertyResolver.java b/spring-core/src/main/java/org/springframework/core/env/PropertySourcesPropertyResolver.java index e6cd31d64ba..f515916a699 100644 --- a/spring-core/src/main/java/org/springframework/core/env/PropertySourcesPropertyResolver.java +++ b/spring-core/src/main/java/org/springframework/core/env/PropertySourcesPropertyResolver.java @@ -92,8 +92,8 @@ public class PropertySourcesPropertyResolver extends AbstractPropertyResolver { } } } - if (logger.isDebugEnabled()) { - logger.debug("Could not find key '" + key + "' in any property source"); + if (logger.isTraceEnabled()) { + logger.trace("Could not find key '" + key + "' in any property source"); } return null; }