## Uses of Interface
org.apache.commons.logging.Log

- Packages that use Log
  Package | Description
  --- | ---
  org.apache.commons.logging | Spring's variant of the Commons Logging API: with special support for Log4J 2, SLF4J and `java.util.logging`.
  org.apache.commons.logging.impl | Spring's variant of the Commons Logging API: with special support for Log4J 2, SLF4J and `java.util.logging`.
  org.springframework.aop.aspectj.annotation | Classes enabling AspectJ 5 @Annotated classes to be used in Spring AOP.
  org.springframework.aop.framework | Package containing Spring's basic AOP infrastructure, compliant with the AOP Alliance interfaces.
  org.springframework.aop.framework.autoproxy | Bean post-processors for use in ApplicationContexts to simplify AOP usage by automatically creating AOP proxies without the need to use a ProxyFactoryBean.
  org.springframework.aop.framework.autoproxy.target | Various `TargetSourceCreator` implementations for use with Spring's AOP auto-proxying support.
  org.springframework.aop.interceptor | Provides miscellaneous interceptor implementations.
  org.springframework.aop.target |
  org.springframework.aop.target.dynamic |
  org.springframework.beans.factory.annotation | Support package for annotation-driven bean configuration.
  org.springframework.beans.factory.config | SPI interfaces and configuration-related convenience classes for bean factories.
  org.springframework.beans.factory.parsing | Support infrastructure for bean definition parsing.
  org.springframework.beans.factory.support | Classes supporting the `org.springframework.beans.factory` package.
  org.springframework.beans.factory.wiring | Mechanism to determine bean wiring metadata from a bean instance.
  org.springframework.beans.factory.xml | Contains an abstract XML-based `BeanFactory` implementation, including a standard "spring-beans" XSD.
  org.springframework.beans.support | Classes supporting the org.springframework.beans package, such as utility classes for sorting and holding lists of beans.
  org.springframework.cache.ehcache | Support classes for the open source cache EhCache 2.x, allowing to set up an EhCache CacheManager and Caches as beans in a Spring context.
  org.springframework.cache.interceptor | AOP-based solution for declarative caching demarcation.
  org.springframework.cache.jcache.interceptor | AOP-based solution for declarative caching demarcation using JSR-107 annotations.
  org.springframework.context.annotation | Annotation support for the Application Context, including JSR-250 "common" annotations, component-scanning, and Java-based metadata for creating Spring-managed objects.
  org.springframework.context.event | Support classes for application events, like standard context events.
  org.springframework.context.support | Classes supporting the org.springframework.context package, such as abstract base classes for ApplicationContext implementations and a MessageSource implementation.
  org.springframework.context.weaving | Load-time weaving support for a Spring application context, building on Spring's `LoadTimeWeaver` abstraction.
  org.springframework.core | Provides basic classes for exception handling and version detection, and other core helpers that are not specific to any part of the framework.
  org.springframework.core.codec | `Encoder` and `Decoder` abstractions to convert between a reactive stream of bytes and Java objects.
  org.springframework.core.env | Spring's environment abstraction consisting of bean definition profile and hierarchical property source support.
  org.springframework.core.io.support | Support classes for Spring's resource abstraction.
  org.springframework.core.log | Useful delegates for Spring's logging conventions.
  org.springframework.core.type.filter | Core support package for type filtering (e.g.
  org.springframework.dao.support | Support classes for DAO implementations, providing miscellaneous utility methods.
  org.springframework.http | Contains a basic abstraction over client/server-side HTTP.
  org.springframework.http.client.support | This package provides generic HTTP support classes, to be used by higher-level classes like RestTemplate.
  org.springframework.http.codec | Provides implementations of `Encoder` and `Decoder` for web use.
  org.springframework.http.codec.json | JSON encoder and decoder support.
  org.springframework.http.converter | Provides an HttpMessageConverter abstraction to convert between Java objects and HTTP input/output messages.
  org.springframework.http.server.reactive | Abstractions for reactive HTTP server support including a `ServerHttpRequest` and `ServerHttpResponse` along with an `HttpHandler` for processing.
  org.springframework.jca.cci.connection | Provides a utility class for easy ConnectionFactory access, a PlatformTransactionManager for local CCI transactions, and various simple ConnectionFactory proxies/adapters.
  org.springframework.jca.context | Integration package that allows for deploying a Spring application context as a JCA 1.7 compliant RAR file.
  org.springframework.jca.endpoint | This package provides a facility for generic JCA message endpoint management.
  org.springframework.jdbc.core | Provides the core JDBC framework, based on JdbcTemplate and its associated callback interfaces and helper objects.
  org.springframework.jdbc.core.metadata | Context metadata abstraction for the configuration and execution of table inserts and stored procedure calls.
  org.springframework.jdbc.core.simple | Simplification layer for table inserts and stored procedure calls.
  org.springframework.jdbc.datasource | Provides a utility class for easy DataSource access, a PlatformTransactionManager for a single DataSource, and various simple DataSource implementations.
  org.springframework.jdbc.object | The classes in this package represent RDBMS queries, updates, and stored procedures as threadsafe, reusable objects.
  org.springframework.jdbc.support | Support classes for the JDBC framework, used by the classes in the jdbc.core and jdbc.object packages.
  org.springframework.jdbc.support.lob | Provides a strategy interface for Large OBject handling, as well as a customizable default implementation.
  org.springframework.jms.annotation | Annotations and support classes for declarative JMS listener endpoints.
  org.springframework.jms.config | Support package for declarative messaging configuration, with Java configuration and XML schema support.
  org.springframework.jms.connection | Provides a PlatformTransactionManager implementation for a single JMS ConnectionFactory, and a SingleConnectionFactory adapter.
  org.springframework.jms.core.support | Classes supporting the `org.springframework.jms.core` package.
  org.springframework.jms.listener.adapter | Message listener adapter mechanism that delegates to target listener methods, converting messages to appropriate message content types (such as String or byte array) that get passed into listener methods.
  org.springframework.jms.listener.endpoint | This package provides JCA-based endpoint management for JMS message listeners.
  org.springframework.jms.support | This package provides generic JMS support classes, to be used by higher-level classes like JmsTemplate.
  org.springframework.jmx.access | Provides support for accessing remote MBean resources.
  org.springframework.jmx.export.naming | Provides a strategy for ObjectName creation.
  org.springframework.jmx.support | Contains support classes for connecting to local and remote `MBeanServer`s and for exposing an `MBeanServer` to remote clients.
  org.springframework.jndi | The classes in this package make JNDI easier to use, facilitating the accessing of configuration stored in JNDI, and provide useful superclasses for JNDI access classes.
  org.springframework.messaging.converter | Provides support for message conversion.
  org.springframework.messaging.core | Defines interfaces and implementation classes for messaging templates.
  org.springframework.messaging.handler | Basic abstractions for working with message handler methods.
  org.springframework.messaging.handler.annotation.reactive | Support classes for working with annotated message-handling methods with non-blocking, reactive contracts.
  org.springframework.messaging.handler.invocation | Common infrastructure for invoking message handler methods.
  org.springframework.messaging.handler.invocation.reactive | Common infrastructure for invoking message handler methods with non-blocking, and reactive contracts.
  org.springframework.messaging.simp | Generic support for Simple Messaging Protocols including protocols such as STOMP.
  org.springframework.messaging.simp.annotation.support | Support classes for handling messages from simple messaging protocols (like STOMP).
  org.springframework.messaging.simp.broker | Provides a "simple" message broker implementation along with an abstract base class and other supporting types such as a registry for subscriptions.
  org.springframework.messaging.support | Provides implementations of `Message` along with a MessageBuilder and MessageHeaderAccessor for building and working with messages and message headers, as well as various `MessageChannel` implementations and channel interceptor support.
  org.springframework.messaging.tcp.reactor | Contains support for TCP messaging based on Reactor.
  org.springframework.orm.hibernate5 | Package providing integration of Hibernate 5.x with Spring concepts.
  org.springframework.orm.hibernate5.support | Classes supporting the `org.springframework.orm.hibernate5` package.
  org.springframework.orm.jpa | Package providing integration of JPA (Java Persistence API) with Spring concepts.
  org.springframework.orm.jpa.persistenceunit | Internal support for managing JPA persistence units.
  org.springframework.oxm.jaxb | Package providing integration of JAXB with Spring's O/X Mapping support.
  org.springframework.oxm.support | Provides generic support classes for using Spring's O/X Mapping integration within various scenario's.
  org.springframework.remoting.httpinvoker | Remoting classes for transparent Java-to-Java remoting via HTTP invokers.
  org.springframework.remoting.jaxws | Remoting classes for Web Services via JAX-WS (the successor of JAX-RPC), as included in Java 6 and Java EE 5.
  org.springframework.remoting.rmi | Remoting classes for conventional RMI and transparent remoting via RMI invokers.
  org.springframework.remoting.support | Generic support classes for remoting implementations.
  org.springframework.scheduling.annotation | Annotation support for asynchronous method execution.
  org.springframework.scheduling.concurrent | Scheduling convenience classes for the `java.util.concurrent` and `javax.enterprise.concurrent` packages, allowing to set up a ThreadPoolExecutor or ScheduledThreadPoolExecutor as a bean in a Spring context.
  org.springframework.scheduling.quartz | Support classes for the open source scheduler Quartz, allowing to set up Quartz Schedulers, JobDetails and Triggers as beans in a Spring context.
  org.springframework.scheduling.support | Generic support classes for scheduling.
  org.springframework.scripting.support | Support classes for Spring's scripting package.
  org.springframework.test.context.junit4 | Support classes for integrating the Spring TestContext Framework with JUnit 4.12 or higher.
  org.springframework.test.context.junit4.statements | Custom JUnit 4 `Statements` used in the Spring TestContext Framework.
  org.springframework.test.context.support | Support classes for the Spring TestContext Framework.
  org.springframework.test.context.testng | Support classes for integrating the Spring TestContext Framework with TestNG.
  org.springframework.test.context.web | Web support classes for the Spring TestContext Framework.
  org.springframework.transaction.interceptor | AOP-based solution for declarative transaction demarcation.
  org.springframework.transaction.jta | Transaction SPI implementation for JTA.
  org.springframework.transaction.reactive | Support classes for reactive transaction management.
  org.springframework.transaction.support | Support classes for the org.springframework.transaction package.
  org.springframework.ui.context.support | Classes supporting the org.springframework.ui.context package.
  org.springframework.ui.freemarker | Support classes for setting up FreeMarker within a Spring application context.
  org.springframework.util | Miscellaneous utility classes, such as utilities for working with strings, classes, collections, reflection, etc.
  org.springframework.util.xml | Miscellaneous utility classes for XML parsing and transformation, such as error handlers that log warnings via Commons Logging.
  org.springframework.validation | Provides data binding and validation functionality, for usage in business and/or UI layers.
  org.springframework.web.accept | This package contains classes used to determine the requested the media types in a request.
  org.springframework.web.client.support | Classes supporting the `org.springframework.web.client` package.
  org.springframework.web.context | Contains a variant of the application context interface for web applications, and the ContextLoaderListener that bootstraps a root web application context.
  org.springframework.web.context.support | Classes supporting the `org.springframework.web.context` package, such as WebApplicationContext implementations and various utility classes.
  org.springframework.web.filter | Provides generic filter base classes allowing for bean-style configuration.
  org.springframework.web.jsf.el | ELResolvers for integrating a JSF web layer with a Spring service layer which is hosted in a Spring root WebApplicationContext.
  org.springframework.web.method | Common infrastructure for handler method processing, as used by Spring MVC's `org.springframework.web.servlet.mvc.method` package.
  org.springframework.web.method.annotation | Support classes for annotation-based handler method processing.
  org.springframework.web.multipart.commons | MultipartResolver implementation for Apache Commons FileUpload.
  org.springframework.web.reactive.handler | Provides HandlerMapping implementations including abstract base classes.
  org.springframework.web.reactive.resource | Support classes for serving static resources.
  org.springframework.web.reactive.result | Support for various programming model styles including the invocation of different types of handlers, e.g.
  org.springframework.web.reactive.result.method | Infrastructure for handler method processing.
  org.springframework.web.reactive.result.view | Support for result handling through view resolution.
  org.springframework.web.reactive.socket.adapter | Classes adapting Spring's Reactive WebSocket API to and from WebSocket runtimes.
  org.springframework.web.reactive.socket.server.support | Server-side support classes for WebSocket requests.
  org.springframework.web.servlet | Provides servlets that integrate with the application context infrastructure, and the core interfaces and classes for the Spring web MVC framework.
  org.springframework.web.servlet.handler | Provides standard HandlerMapping implementations, including abstract base classes for custom implementations.
  org.springframework.web.servlet.i18n | Locale support classes for Spring's web MVC framework.
  org.springframework.web.servlet.mvc.method.annotation | MVC infrastructure for annotation-based handler method processing, building on the `org.springframework.web.method.annotation` package.
  org.springframework.web.servlet.mvc.support | Support package for MVC controllers.
  org.springframework.web.servlet.resource | Support classes for serving static resources.
  org.springframework.web.servlet.support | Support classes for Spring's web MVC framework.
  org.springframework.web.servlet.tags | This package contains Spring's JSP standard tag library for JSP 2.0+.
  org.springframework.web.servlet.view.tiles3 | Support classes for the integration of Tiles 3 (the standalone version of Tiles) as Spring web view technology.
  org.springframework.web.socket.adapter | Classes adapting Spring's WebSocket API to and from WebSocket providers.
  org.springframework.web.socket.client | Client-side abstractions for WebSocket applications.
  org.springframework.web.socket.handler | Convenient `WebSocketHandler` implementations and decorators.
  org.springframework.web.socket.server.standard | Server-side classes for use with standard JSR-356 WebSocket endpoints.
  org.springframework.web.socket.server.support | Server-side support classes including container-specific strategies for upgrading a request.
  org.springframework.web.socket.sockjs.client | SockJS client implementation of `WebSocketClient`.
  org.springframework.web.socket.sockjs.support | Support classes for SockJS including an `AbstractSockJsService` implementation.
  org.springframework.web.socket.sockjs.transport.handler | `TransportHandler` implementation classes as well as a concrete `SockJsService`.
  org.springframework.web.socket.sockjs.transport.session | SockJS specific implementations of `WebSocketSession`.
  org.springframework.web.util | Miscellaneous web utility classes, such as HTML escaping and cookie handling.

- - ### Uses of Log in org.apache.commons.logging

    Methods in org.apache.commons.logging that return Log
    Modifier and Type | Method and Description
    --- | ---
    `Log` | LogFactory.`getInstance(Class<?> clazz)` Deprecated. in favor of `LogFactory.getLog(Class)`
    `Log` | LogFactoryService.`getInstance(Class<?> clazz)` Deprecated.
    `Log` | LogFactory.`getInstance(String name)` Deprecated. in favor of `LogFactory.getLog(String)`
    `Log` | LogFactoryService.`getInstance(String name)` Deprecated.
    `static Log` | LogFactory.`getLog(Class<?> clazz)` Convenience method to return a named logger.
    `static Log` | LogFactory.`getLog(String name)` Convenience method to return a named logger.

  - ### Uses of Log in org.apache.commons.logging.impl

    Classes in org.apache.commons.logging.impl that implement Log
    Modifier and Type | Class and Description
    --- | ---
    `class` | `NoOpLog` Trivial implementation of `Log` that throws away all messages.
    `class` | `SimpleLog` Deprecated. in `spring-jcl` (effectively equivalent to `NoOpLog`)

  - ### Uses of Log in org.springframework.aop.aspectj.annotation

    Fields in org.springframework.aop.aspectj.annotation declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | AbstractAspectJAdvisorFactory.`logger` Logger available to subclasses.

  - ### Uses of Log in org.springframework.aop.framework

    Fields in org.springframework.aop.framework declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | ProxyFactoryBean.`logger`

  - ### Uses of Log in org.springframework.aop.framework.autoproxy

    Fields in org.springframework.aop.framework.autoproxy declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | AbstractAutoProxyCreator.`logger` Logger available to subclasses.

  - ### Uses of Log in org.springframework.aop.framework.autoproxy.target

    Fields in org.springframework.aop.framework.autoproxy.target declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | AbstractBeanFactoryBasedTargetSourceCreator.`logger`

  - ### Uses of Log in org.springframework.aop.interceptor

    Fields in org.springframework.aop.interceptor declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | AbstractTraceInterceptor.`defaultLogger` The default `Log` instance used to write trace messages.
    `protected Log` | AsyncExecutionAspectSupport.`logger`

    Methods in org.springframework.aop.interceptor that return Log
    Modifier and Type | Method and Description
    --- | ---
    `protected Log` | AbstractTraceInterceptor.`getLoggerForInvocation(MethodInvocation invocation)` Return the appropriate `Log` instance to use for the given `MethodInvocation`.

    Methods in org.springframework.aop.interceptor with parameters of type Log
    Modifier and Type | Method and Description
    --- | ---
    `protected Object` | PerformanceMonitorInterceptor.`invokeUnderTrace(MethodInvocation invocation, Log logger)`
    `protected Object` | CustomizableTraceInterceptor.`invokeUnderTrace(MethodInvocation invocation, Log logger)` Writes a log message before the invocation based on the value of `enterMessage`.
    `protected abstract Object` | AbstractTraceInterceptor.`invokeUnderTrace(MethodInvocation invocation, Log logger)` Subclasses must override this method to perform any tracing around the supplied `MethodInvocation`.
    `protected Object` | JamonPerformanceMonitorInterceptor.`invokeUnderTrace(MethodInvocation invocation, Log logger)` Wraps the invocation with a JAMon Monitor and writes the current performance statistics to the log (if enabled).
    `protected Object` | SimpleTraceInterceptor.`invokeUnderTrace(MethodInvocation invocation, Log logger)`
    `protected boolean` | AbstractTraceInterceptor.`isInterceptorEnabled(MethodInvocation invocation, Log logger)` Determine whether the interceptor should kick in, that is, whether the `invokeUnderTrace` method should be called.
    `protected boolean` | JamonPerformanceMonitorInterceptor.`isInterceptorEnabled(MethodInvocation invocation, Log logger)` Always applies the interceptor if the "trackAllInvocations" flag has been set; else just kicks in if the log is enabled.
    `protected boolean` | AbstractTraceInterceptor.`isLogEnabled(Log logger)` Determine whether the given `Log` instance is enabled.
    `protected void` | AbstractTraceInterceptor.`writeToLog(Log logger, String message)` Write the supplied trace message to the supplied `Log` instance.
    `protected void` | AbstractTraceInterceptor.`writeToLog(Log logger, String message, Throwable ex)` Write the supplied trace message and `Throwable` to the supplied `Log` instance.

  - ### Uses of Log in org.springframework.aop.target

    Fields in org.springframework.aop.target declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | AbstractLazyCreationTargetSource.`logger` Logger available to subclasses.
    `protected Log` | AbstractBeanFactoryBasedTargetSource.`logger` Logger available to subclasses.

  - ### Uses of Log in org.springframework.aop.target.dynamic

    Fields in org.springframework.aop.target.dynamic declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | AbstractRefreshableTargetSource.`logger` Logger available to subclasses.

  - ### Uses of Log in org.springframework.beans.factory.annotation

    Fields in org.springframework.beans.factory.annotation declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | InitDestroyAnnotationBeanPostProcessor.`logger`
    `protected Log` | AutowiredAnnotationBeanPostProcessor.`logger`

  - ### Uses of Log in org.springframework.beans.factory.config

    Fields in org.springframework.beans.factory.config declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | DeprecatedBeanWarner.`logger` Logger available to subclasses.
    `protected Log` | CustomEditorConfigurer.`logger`
    `protected Log` | AbstractFactoryBean.`logger` Logger available to subclasses.

  - ### Uses of Log in org.springframework.beans.factory.parsing

    Methods in org.springframework.beans.factory.parsing with parameters of type Log
    Modifier and Type | Method and Description
    --- | ---
    `void` | FailFastProblemReporter.`setLogger(Log logger)` Set the `logger` that is to be used to report warnings.

  - ### Uses of Log in org.springframework.beans.factory.support

    Fields in org.springframework.beans.factory.support declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | AbstractBeanDefinitionReader.`logger` Logger available to subclasses.

  - ### Uses of Log in org.springframework.beans.factory.wiring

    Fields in org.springframework.beans.factory.wiring declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | BeanConfigurerSupport.`logger` Logger available to subclasses.

  - ### Uses of Log in org.springframework.beans.factory.xml

    Fields in org.springframework.beans.factory.xml declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | DefaultBeanDefinitionDocumentReader.`logger`
    `protected Log` | DefaultNamespaceHandlerResolver.`logger` Logger available to subclasses.
    `protected Log` | BeanDefinitionParserDelegate.`logger`

  - ### Uses of Log in org.springframework.beans.support

    Fields in org.springframework.beans.support declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | PropertyComparator.`logger`

  - ### Uses of Log in org.springframework.cache.ehcache

    Fields in org.springframework.cache.ehcache declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | EhCacheFactoryBean.`logger`
    `protected Log` | EhCacheManagerFactoryBean.`logger`

  - ### Uses of Log in org.springframework.cache.interceptor

    Fields in org.springframework.cache.interceptor declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | CacheAspectSupport.`logger`
    `protected Log` | AbstractFallbackCacheOperationSource.`logger` Logger available to subclasses.
    `protected static Log` | NameMatchCacheOperationSource.`logger` Logger available to subclasses.

    Methods in org.springframework.cache.interceptor that return Log
    Modifier and Type | Method and Description
    --- | ---
    `protected Log` | LoggingCacheErrorHandler.`getLogger()` Get the logger for this `LoggingCacheErrorHandler`.

    Constructors in org.springframework.cache.interceptor with parameters of type Log
    Constructor and Description
    `LoggingCacheErrorHandler(Log logger, boolean logStackTraces)` Create a `LoggingCacheErrorHandler` that uses the supplied `logger` and `logStackTraces` flag.

  - ### Uses of Log in org.springframework.cache.jcache.interceptor

    Fields in org.springframework.cache.jcache.interceptor declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | AbstractFallbackJCacheOperationSource.`logger`
    `protected Log` | JCacheAspectSupport.`logger`

  - ### Uses of Log in org.springframework.context.annotation

    Fields in org.springframework.context.annotation declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | ClassPathScanningCandidateComponentProvider.`logger`

  - ### Uses of Log in org.springframework.context.event

    Fields in org.springframework.context.event declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | ApplicationListenerMethodAdapter.`logger`
    `protected Log` | EventListenerMethodProcessor.`logger`

  - ### Uses of Log in org.springframework.context.support

    Fields in org.springframework.context.support declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | ApplicationObjectSupport.`logger` Logger that is available to subclasses.
    `protected Log` | AbstractApplicationContext.`logger` Logger used by this class.
    `protected Log` | MessageSourceSupport.`logger` Logger available to subclasses.

  - ### Uses of Log in org.springframework.context.weaving

    Fields in org.springframework.context.weaving declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | DefaultContextLoadTimeWeaver.`logger`

  - ### Uses of Log in org.springframework.core

    Fields in org.springframework.core declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | SimpleAliasRegistry.`logger` Logger available to subclasses.

  - ### Uses of Log in org.springframework.core.codec

    Fields in org.springframework.core.codec declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | AbstractEncoder.`logger`
    `protected Log` | AbstractDecoder.`logger`

    Methods in org.springframework.core.codec that return Log
    Modifier and Type | Method and Description
    --- | ---
    `Log` | AbstractEncoder.`getLogger()` Return the currently configured Logger.
    `Log` | AbstractDecoder.`getLogger()` Return the currently configured Logger.

    Methods in org.springframework.core.codec with parameters of type Log
    Modifier and Type | Method and Description
    --- | ---
    `void` | AbstractEncoder.`setLogger(Log logger)` Set an alternative logger to use than the one based on the class name.
    `void` | AbstractDecoder.`setLogger(Log logger)` Set an alternative logger to use than the one based on the class name.
    `static void` | Hints.`touchDataBuffer(DataBuffer buffer, Map<String,Object> hints, Log logger)` If the hints contain a `Hints.LOG_PREFIX_HINT` and the given logger has DEBUG level enabled, apply the log prefix as a hint to the given buffer via `DataBufferUtils.touch(DataBuffer, Object)`.

  - ### Uses of Log in org.springframework.core.env

    Fields in org.springframework.core.env declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | AbstractPropertyResolver.`logger`
    `protected Log` | AbstractEnvironment.`logger`
    `protected Log` | PropertySource.`logger`

  - ### Uses of Log in org.springframework.core.io.support

    Fields in org.springframework.core.io.support declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | PropertiesLoaderSupport.`logger` Logger available to subclasses.

  - ### Uses of Log in org.springframework.core.log

    Methods in org.springframework.core.log that return Log
    Modifier and Type | Method and Description
    --- | ---
    `static Log` | LogDelegateFactory.`getCompositeLog(Log primaryLogger, Log secondaryLogger, Log... tertiaryLoggers)` Create a composite logger that delegates to a primary or falls back on a secondary logger if logging for the primary logger is not enabled.
    `static Log` | LogDelegateFactory.`getHiddenLog(Class<?> clazz)` Create a "hidden" logger with a category name prefixed with "_", thus precluding it from being enabled together with other log categories from the same package.
    `static Log` | LogDelegateFactory.`getHiddenLog(String category)` Create a "hidden" logger with a category name prefixed with "_", thus precluding it from being enabled together with other log categories from the same package.
    `Log` | LogAccessor.`getLog()` Return the target Commons Log.

    Methods in org.springframework.core.log with parameters of type Log
    Modifier and Type | Method and Description
    --- | ---
    `static Log` | LogDelegateFactory.`getCompositeLog(Log primaryLogger, Log secondaryLogger, Log... tertiaryLoggers)` Create a composite logger that delegates to a primary or falls back on a secondary logger if logging for the primary logger is not enabled.
    `static Log` | LogDelegateFactory.`getCompositeLog(Log primaryLogger, Log secondaryLogger, Log... tertiaryLoggers)` Create a composite logger that delegates to a primary or falls back on a secondary logger if logging for the primary logger is not enabled.
    `static void` | LogFormatUtils.`traceDebug(Log logger, Function<Boolean,String> messageFactory)` Use this to log a message with different levels of detail (or different messages) at TRACE vs DEBUG log levels.

    Constructors in org.springframework.core.log with parameters of type Log
    Constructor and Description
    `LogAccessor(Log log)` Create a new accessor for the given Commons Log.

  - ### Uses of Log in org.springframework.core.type.filter

    Fields in org.springframework.core.type.filter declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | AbstractTypeHierarchyTraversingFilter.`logger`

  - ### Uses of Log in org.springframework.dao.support

    Fields in org.springframework.dao.support declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | DaoSupport.`logger` Logger available to subclasses.

  - ### Uses of Log in org.springframework.http

    Methods in org.springframework.http that return Log
    Modifier and Type | Method and Description
    --- | ---
    `static Log` | HttpLogging.`forLog(Log primaryLogger)` Wrap the given primary logger with a composite logger that delegates to it or to the fallback logger "org.springframework.web.HttpLogging", if the primary is not enabled.
    `static Log` | HttpLogging.`forLogName(Class<?> primaryLoggerClass)` Create a primary logger for the given class and wrap it with a composite that delegates to it or to the fallback logger "org.springframework.web.HttpLogging", if the primary is not enabled.

    Methods in org.springframework.http with parameters of type Log
    Modifier and Type | Method and Description
    --- | ---
    `static Log` | HttpLogging.`forLog(Log primaryLogger)` Wrap the given primary logger with a composite logger that delegates to it or to the fallback logger "org.springframework.web.HttpLogging", if the primary is not enabled.

  - ### Uses of Log in org.springframework.http.client.support

    Fields in org.springframework.http.client.support declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | AsyncHttpAccessor.`logger` Deprecated. Logger available to subclasses.
    `protected Log` | HttpAccessor.`logger` Logger available to subclasses.

  - ### Uses of Log in org.springframework.http.codec

    Fields in org.springframework.http.codec declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | LoggingCodecSupport.`logger`

  - ### Uses of Log in org.springframework.http.codec.json

    Fields in org.springframework.http.codec.json declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | Jackson2CodecSupport.`logger`

  - ### Uses of Log in org.springframework.http.converter

    Fields in org.springframework.http.converter declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | AbstractHttpMessageConverter.`logger` Logger available to subclasses.

  - ### Uses of Log in org.springframework.http.server.reactive

    Fields in org.springframework.http.server.reactive declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected static Log` | AbstractListenerReadPublisher.`rsReadLogger` Special logger for debugging Reactive Streams signals.
    `protected static Log` | AbstractListenerWriteFlushProcessor.`rsWriteFlushLogger` Special logger for debugging Reactive Streams signals.
    `protected static Log` | AbstractListenerWriteProcessor.`rsWriteLogger` Special logger for debugging Reactive Streams signals.

  - ### Uses of Log in org.springframework.jca.cci.connection

    Fields in org.springframework.jca.cci.connection declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | SingleConnectionFactory.`logger` Deprecated.

  - ### Uses of Log in org.springframework.jca.context

    Fields in org.springframework.jca.context declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | SpringContextResourceAdapter.`logger`

  - ### Uses of Log in org.springframework.jca.endpoint

    Fields in org.springframework.jca.endpoint declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | AbstractMessageEndpointFactory.`logger` Logger available to subclasses.

  - ### Uses of Log in org.springframework.jdbc.core

    Fields in org.springframework.jdbc.core declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | BeanPropertyRowMapper.`logger` Logger available to subclasses.

  - ### Uses of Log in org.springframework.jdbc.core.metadata

    Fields in org.springframework.jdbc.core.metadata declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected static Log` | GenericCallMetaDataProvider.`logger` Logger available to subclasses.
    `protected static Log` | GenericTableMetaDataProvider.`logger` Logger available to subclasses.
    `protected Log` | TableMetaDataContext.`logger`
    `protected Log` | CallMetaDataContext.`logger`

  - ### Uses of Log in org.springframework.jdbc.core.simple

    Fields in org.springframework.jdbc.core.simple declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | AbstractJdbcInsert.`logger` Logger available to subclasses.
    `protected Log` | AbstractJdbcCall.`logger` Logger available to subclasses.

  - ### Uses of Log in org.springframework.jdbc.datasource

    Fields in org.springframework.jdbc.datasource declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | AbstractDataSource.`logger` Logger available to subclasses.
    `protected Log` | WebSphereDataSourceAdapter.`logger`

  - ### Uses of Log in org.springframework.jdbc.object

    Fields in org.springframework.jdbc.object declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | RdbmsOperation.`logger` Logger available to subclasses.

  - ### Uses of Log in org.springframework.jdbc.support

    Fields in org.springframework.jdbc.support declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | AbstractFallbackSQLExceptionTranslator.`logger` Logger available to subclasses.
    `protected Log` | DatabaseStartupValidator.`logger`
    `protected Log` | JdbcAccessor.`logger` Logger available to subclasses.

  - ### Uses of Log in org.springframework.jdbc.support.lob

    Fields in org.springframework.jdbc.support.lob declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | DefaultLobHandler.`logger`
    `protected static Log` | TemporaryLobCreator.`logger`

  - ### Uses of Log in org.springframework.jms.annotation

    Fields in org.springframework.jms.annotation declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | JmsListenerAnnotationBeanPostProcessor.`logger`

  - ### Uses of Log in org.springframework.jms.config

    Fields in org.springframework.jms.config declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | JmsListenerEndpointRegistry.`logger`
    `protected Log` | AbstractJmsListenerContainerFactory.`logger`

  - ### Uses of Log in org.springframework.jms.connection

    Fields in org.springframework.jms.connection declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | SingleConnectionFactory.`logger`

  - ### Uses of Log in org.springframework.jms.core.support

    Fields in org.springframework.jms.core.support declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | JmsGatewaySupport.`logger` Logger available to subclasses.

  - ### Uses of Log in org.springframework.jms.listener.adapter

    Fields in org.springframework.jms.listener.adapter declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | AbstractAdaptableMessageListener.`logger` Logger available to subclasses.

  - ### Uses of Log in org.springframework.jms.listener.endpoint

    Fields in org.springframework.jms.listener.endpoint declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | DefaultJmsActivationSpecFactory.`logger` Logger available to subclasses.

  - ### Uses of Log in org.springframework.jms.support

    Fields in org.springframework.jms.support declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | JmsAccessor.`logger` Logger available to subclasses.

  - ### Uses of Log in org.springframework.jmx.access

    Fields in org.springframework.jmx.access declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | MBeanClientInterceptor.`logger` Logger available to subclasses.
    `protected Log` | NotificationListenerRegistrar.`logger` Logger available to subclasses.

  - ### Uses of Log in org.springframework.jmx.export.naming

    Fields in org.springframework.jmx.export.naming declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | KeyNamingStrategy.`logger` `Log` instance for this class.

  - ### Uses of Log in org.springframework.jmx.support

    Fields in org.springframework.jmx.support declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | MBeanRegistrationSupport.`logger` `Log` instance for this class.
    `protected Log` | MBeanServerFactoryBean.`logger`

  - ### Uses of Log in org.springframework.jndi

    Fields in org.springframework.jndi declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | JndiTemplate.`logger`
    `protected Log` | JndiAccessor.`logger` Logger, available to subclasses.

  - ### Uses of Log in org.springframework.messaging.converter

    Fields in org.springframework.messaging.converter declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | AbstractMessageConverter.`logger`

  - ### Uses of Log in org.springframework.messaging.core

    Fields in org.springframework.messaging.core declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | AbstractMessageSendingTemplate.`logger`

  - ### Uses of Log in org.springframework.messaging.handler

    Fields in org.springframework.messaging.handler declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `static Log` | HandlerMethod.`defaultLogger` Public for wrapping with fallback logger.
    `protected Log` | HandlerMethod.`logger`

    Methods in org.springframework.messaging.handler that return Log
    Modifier and Type | Method and Description
    --- | ---
    `Log` | HandlerMethod.`getLogger()` Return the currently configured Logger.

    Methods in org.springframework.messaging.handler with parameters of type Log
    Modifier and Type | Method and Description
    --- | ---
    `void` | HandlerMethod.`setLogger(Log logger)` Set an alternative logger to use than the one based on the class name.

  - ### Uses of Log in org.springframework.messaging.handler.annotation.reactive

    Fields in org.springframework.messaging.handler.annotation.reactive declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | PayloadMethodArgumentResolver.`logger`

  - ### Uses of Log in org.springframework.messaging.handler.invocation

    Fields in org.springframework.messaging.handler.invocation declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `static Log` | HandlerMethodReturnValueHandlerComposite.`defaultLogger` Public for wrapping with fallback logger.
    `protected Log` | AbstractMethodMessageHandler.`logger`

    Methods in org.springframework.messaging.handler.invocation that return Log
    Modifier and Type | Method and Description
    --- | ---
    `protected Log` | AbstractMethodMessageHandler.`getHandlerMethodLogger()` Return a logger to set on `InvocableHandlerMethod`.
    `Log` | HandlerMethodReturnValueHandlerComposite.`getLogger()` Return the currently configured Logger.
    `protected Log` | AbstractMethodMessageHandler.`getReturnValueHandlerLogger()` Return a logger to set on `HandlerMethodReturnValueHandlerComposite`.

    Methods in org.springframework.messaging.handler.invocation with parameters of type Log
    Modifier and Type | Method and Description
    --- | ---
    `void` | HandlerMethodReturnValueHandlerComposite.`setLogger(Log logger)` Set an alternative logger to use than the one based on the class name.

  - ### Uses of Log in org.springframework.messaging.handler.invocation.reactive

    Fields in org.springframework.messaging.handler.invocation.reactive declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | HandlerMethodArgumentResolverComposite.`logger`
    `protected Log` | HandlerMethodReturnValueHandlerComposite.`logger`
    `protected Log` | AbstractEncoderMethodReturnValueHandler.`logger`
    `protected Log` | AbstractMethodMessageHandler.`logger`

  - ### Uses of Log in org.springframework.messaging.simp

    Methods in org.springframework.messaging.simp that return Log
    Modifier and Type | Method and Description
    --- | ---
    `static Log` | SimpLogging.`forLog(Log primaryLogger)` Wrap the given primary logger with a composite logger that delegates to either the primary or to the shared fallback logger "org.springframework.web.HttpLogging", if the primary is not enabled.
    `static Log` | SimpLogging.`forLogName(Class<?> primaryLoggerClass)` Create a primary logger for the given class and wrap it with a composite that delegates to it or to the fallback logger named "org.springframework.web.SimpLogging", if the primary is not enabled.

    Methods in org.springframework.messaging.simp with parameters of type Log
    Modifier and Type | Method and Description
    --- | ---
    `static Log` | SimpLogging.`forLog(Log primaryLogger)` Wrap the given primary logger with a composite logger that delegates to either the primary or to the shared fallback logger "org.springframework.web.HttpLogging", if the primary is not enabled.

  - ### Uses of Log in org.springframework.messaging.simp.annotation.support

    Methods in org.springframework.messaging.simp.annotation.support that return Log
    Modifier and Type | Method and Description
    --- | ---
    `protected Log` | SimpAnnotationMethodMessageHandler.`getHandlerMethodLogger()`
    `protected Log` | SimpAnnotationMethodMessageHandler.`getReturnValueHandlerLogger()`

  - ### Uses of Log in org.springframework.messaging.simp.broker

    Fields in org.springframework.messaging.simp.broker declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | AbstractBrokerMessageHandler.`logger`
    `protected Log` | AbstractSubscriptionRegistry.`logger`

    Constructors in org.springframework.messaging.simp.broker with parameters of type Log
    Constructor and Description
    `OrderedMessageChannelDecorator(MessageChannel channel, Log logger)`

  - ### Uses of Log in org.springframework.messaging.support

    Fields in org.springframework.messaging.support declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | AbstractMessageChannel.`logger`
    `protected Log` | AbstractHeaderMapper.`logger`

    Methods in org.springframework.messaging.support that return Log
    Modifier and Type | Method and Description
    --- | ---
    `Log` | AbstractMessageChannel.`getLogger()` Return the currently configured Logger.

    Methods in org.springframework.messaging.support with parameters of type Log
    Modifier and Type | Method and Description
    --- | ---
    `void` | AbstractMessageChannel.`setLogger(Log logger)` Set an alternative logger to use than the one based on the class name.

  - ### Uses of Log in org.springframework.messaging.tcp.reactor

    Methods in org.springframework.messaging.tcp.reactor that return Log
    Modifier and Type | Method and Description
    --- | ---
    `Log` | ReactorNettyTcpClient.`getLogger()` Return the currently configured Logger.

    Methods in org.springframework.messaging.tcp.reactor with parameters of type Log
    Modifier and Type | Method and Description
    --- | ---
    `void` | ReactorNettyTcpClient.`setLogger(Log logger)` Set an alternative logger to use than the one based on the class name.

  - ### Uses of Log in org.springframework.orm.hibernate5

    Fields in org.springframework.orm.hibernate5 declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | HibernateTemplate.`logger`

  - ### Uses of Log in org.springframework.orm.hibernate5.support

    Fields in org.springframework.orm.hibernate5.support declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | OpenSessionInViewInterceptor.`logger`

  - ### Uses of Log in org.springframework.orm.jpa

    Fields in org.springframework.orm.jpa declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | AbstractEntityManagerFactoryBean.`logger` Logger available to subclasses.
    `protected Log` | EntityManagerFactoryAccessor.`logger` Logger available to subclasses.

  - ### Uses of Log in org.springframework.orm.jpa.persistenceunit

    Fields in org.springframework.orm.jpa.persistenceunit declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | DefaultPersistenceUnitManager.`logger`

  - ### Uses of Log in org.springframework.oxm.jaxb

    Fields in org.springframework.oxm.jaxb declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | Jaxb2Marshaller.`logger` Logger available to subclasses.

  - ### Uses of Log in org.springframework.oxm.support

    Fields in org.springframework.oxm.support declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | AbstractMarshaller.`logger` Logger available to subclasses.

  - ### Uses of Log in org.springframework.remoting.httpinvoker

    Fields in org.springframework.remoting.httpinvoker declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | AbstractHttpInvokerRequestExecutor.`logger` Deprecated.

  - ### Uses of Log in org.springframework.remoting.jaxws

    Fields in org.springframework.remoting.jaxws declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | SimpleHttpServerJaxWsServiceExporter.`logger` Deprecated.

  - ### Uses of Log in org.springframework.remoting.rmi

    Fields in org.springframework.remoting.rmi declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | RmiRegistryFactoryBean.`logger` Deprecated.

  - ### Uses of Log in org.springframework.remoting.support

    Fields in org.springframework.remoting.support declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | RemotingSupport.`logger` Logger available to subclasses.
    `protected static Log` | RemoteInvocationTraceInterceptor.`logger`
    `protected Log` | SimpleHttpServerFactoryBean.`logger` Deprecated.

  - ### Uses of Log in org.springframework.scheduling.annotation

    Fields in org.springframework.scheduling.annotation declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | ScheduledAnnotationBeanPostProcessor.`logger`
    `protected Log` | AsyncAnnotationBeanPostProcessor.`logger`

  - ### Uses of Log in org.springframework.scheduling.concurrent

    Fields in org.springframework.scheduling.concurrent declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | ExecutorConfigurationSupport.`logger`
    `protected Log` | DefaultManagedAwareThreadFactory.`logger`

  - ### Uses of Log in org.springframework.scheduling.quartz

    Fields in org.springframework.scheduling.quartz declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | LocalTaskExecutorThreadPool.`logger` Logger available to subclasses.
    `protected static Log` | MethodInvokingJobDetailFactoryBean.MethodInvokingJob.`logger`
    `protected Log` | SchedulerAccessor.`logger`
    `protected static Log` | ResourceLoaderClassLoadHelper.`logger`

  - ### Uses of Log in org.springframework.scheduling.support

    Fields in org.springframework.scheduling.support declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | MethodInvokingRunnable.`logger`

  - ### Uses of Log in org.springframework.scripting.support

    Fields in org.springframework.scripting.support declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | ResourceScriptSource.`logger` Logger available to subclasses.
    `protected Log` | ScriptFactoryPostProcessor.`logger` Logger available to subclasses.

  - ### Uses of Log in org.springframework.test.context.junit4

    Fields in org.springframework.test.context.junit4 declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | AbstractJUnit4SpringContextTests.`logger` Logger available to subclasses.

  - ### Uses of Log in org.springframework.test.context.junit4.statements

    Fields in org.springframework.test.context.junit4.statements declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected static Log` | SpringRepeat.`logger`

  - ### Uses of Log in org.springframework.test.context.support

    Fields in org.springframework.test.context.support declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected static Log` | AbstractGenericContextLoader.`logger`

  - ### Uses of Log in org.springframework.test.context.testng

    Fields in org.springframework.test.context.testng declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | AbstractTestNGSpringContextTests.`logger` Logger available to subclasses.

  - ### Uses of Log in org.springframework.test.context.web

    Fields in org.springframework.test.context.web declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected static Log` | AbstractGenericWebContextLoader.`logger`

  - ### Uses of Log in org.springframework.transaction.interceptor

    Fields in org.springframework.transaction.interceptor declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | AbstractFallbackTransactionAttributeSource.`logger` Logger available to subclasses.
    `protected Log` | TransactionAspectSupport.`logger`
    `protected static Log` | NameMatchTransactionAttributeSource.`logger` Logger available to subclasses.
    `protected Log` | MethodMapTransactionAttributeSource.`logger` Logger available to subclasses.

  - ### Uses of Log in org.springframework.transaction.jta

    Fields in org.springframework.transaction.jta declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected static Log` | SpringJtaSynchronizationAdapter.`logger`

  - ### Uses of Log in org.springframework.transaction.reactive

    Fields in org.springframework.transaction.reactive declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | AbstractReactiveTransactionManager.`logger`

  - ### Uses of Log in org.springframework.transaction.support

    Fields in org.springframework.transaction.support declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | AbstractPlatformTransactionManager.`logger`
    `protected Log` | TransactionTemplate.`logger` Logger available to subclasses.

  - ### Uses of Log in org.springframework.ui.context.support

    Fields in org.springframework.ui.context.support declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | ResourceBundleThemeSource.`logger`

  - ### Uses of Log in org.springframework.ui.freemarker

    Fields in org.springframework.ui.freemarker declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | FreeMarkerConfigurationFactory.`logger`
    `protected Log` | SpringTemplateLoader.`logger`

  - ### Uses of Log in org.springframework.util

    Fields in org.springframework.util declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | ConcurrencyThrottleSupport.`logger` Transient to optimize serialization.

    Constructors in org.springframework.util with parameters of type Log
    Constructor and Description
    `CommonsLogWriter(Log logger)` Create a new CommonsLogWriter for the given Commons Logging logger.

  - ### Uses of Log in org.springframework.util.xml

    Constructors in org.springframework.util.xml with parameters of type Log
    Constructor and Description
    `SimpleSaxErrorHandler(Log logger)` Create a new SimpleSaxErrorHandler for the given Commons Logging logger instance.
    `SimpleTransformErrorListener(Log logger)` Create a new SimpleTransformErrorListener for the given Commons Logging logger instance.

  - ### Uses of Log in org.springframework.validation

    Fields in org.springframework.validation declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected static Log` | DataBinder.`logger` We'll create a lot of DataBinder instances: Let's use a static logger.

  - ### Uses of Log in org.springframework.web.accept

    Fields in org.springframework.web.accept declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | AbstractMappingContentNegotiationStrategy.`logger`

  - ### Uses of Log in org.springframework.web.client.support

    Fields in org.springframework.web.client.support declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | RestGatewaySupport.`logger` Logger available to subclasses.

  - ### Uses of Log in org.springframework.web.context

    Fields in org.springframework.web.context declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | AbstractContextLoaderInitializer.`logger` Logger available to subclasses.

  - ### Uses of Log in org.springframework.web.context.support

    Fields in org.springframework.web.context.support declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | ServletContextAttributeExporter.`logger`

  - ### Uses of Log in org.springframework.web.filter

    Fields in org.springframework.web.filter declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | GenericFilterBean.`logger` Logger available to subclasses.

  - ### Uses of Log in org.springframework.web.jsf.el

    Fields in org.springframework.web.jsf.el declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | WebApplicationContextFacesELResolver.`logger` Logger available to subclasses.

  - ### Uses of Log in org.springframework.web.method

    Fields in org.springframework.web.method declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected static Log` | HandlerMethod.`logger` Logger that is available to subclasses.

  - ### Uses of Log in org.springframework.web.method.annotation

    Fields in org.springframework.web.method.annotation declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | ModelAttributeMethodProcessor.`logger`

  - ### Uses of Log in org.springframework.web.multipart.commons

    Fields in org.springframework.web.multipart.commons declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected static Log` | CommonsMultipartFile.`logger`
    `protected Log` | CommonsFileUploadSupport.`logger`

  - ### Uses of Log in org.springframework.web.reactive.handler

    Fields in org.springframework.web.reactive.handler declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | AbstractHandlerMapping.`mappingsLogger` Dedicated "hidden" logger for request mappings.

  - ### Uses of Log in org.springframework.web.reactive.resource

    Fields in org.springframework.web.reactive.resource declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | AbstractPrefixVersionStrategy.`logger`
    `protected Log` | AbstractResourceResolver.`logger`
    `protected Log` | AbstractFileNameVersionStrategy.`logger`

  - ### Uses of Log in org.springframework.web.reactive.result

    Fields in org.springframework.web.reactive.result declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | HandlerResultHandlerSupport.`logger`

  - ### Uses of Log in org.springframework.web.reactive.result.method

    Fields in org.springframework.web.reactive.result.method declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | HandlerMethodArgumentResolverSupport.`logger`

  - ### Uses of Log in org.springframework.web.reactive.result.view

    Fields in org.springframework.web.reactive.result.view declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | AbstractView.`logger` Logger that is available to subclasses.

  - ### Uses of Log in org.springframework.web.reactive.socket.adapter

    Fields in org.springframework.web.reactive.socket.adapter declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | AbstractWebSocketSession.`logger`

  - ### Uses of Log in org.springframework.web.reactive.socket.server.support

    Fields in org.springframework.web.reactive.socket.server.support declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected static Log` | HandshakeWebSocketService.`logger`

  - ### Uses of Log in org.springframework.web.servlet

    Fields in org.springframework.web.servlet declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | HttpServletBean.`logger` Logger available to subclasses.
    `protected static Log` | DispatcherServlet.`pageNotFoundLogger` Additional logger to use when no mapped handler is found for a request.

  - ### Uses of Log in org.springframework.web.servlet.handler

    Fields in org.springframework.web.servlet.handler declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | AbstractHandlerExceptionResolver.`logger` Logger available to subclasses.
    `protected Log` | AbstractHandlerMapping.`mappingsLogger` Dedicated "hidden" logger for request mappings.

  - ### Uses of Log in org.springframework.web.servlet.i18n

    Fields in org.springframework.web.servlet.i18n declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | LocaleChangeInterceptor.`logger`

  - ### Uses of Log in org.springframework.web.servlet.mvc.method.annotation

    Fields in org.springframework.web.servlet.mvc.method.annotation declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | ResponseEntityExceptionHandler.`logger` Common logger for use in subclasses.
    `protected Log` | AbstractMessageConverterMethodArgumentResolver.`logger`
    `protected static Log` | ResponseEntityExceptionHandler.`pageNotFoundLogger` Specific logger to use when no mapped handler is found for a request.

  - ### Uses of Log in org.springframework.web.servlet.mvc.support

    Fields in org.springframework.web.servlet.mvc.support declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected static Log` | DefaultHandlerExceptionResolver.`pageNotFoundLogger` Additional logger to use when no mapped handler is found for a request.

  - ### Uses of Log in org.springframework.web.servlet.resource

    Fields in org.springframework.web.servlet.resource declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | AbstractVersionStrategy.`logger`
    `protected Log` | AbstractResourceResolver.`logger`
    `protected Log` | ResourceUrlProvider.`logger`

  - ### Uses of Log in org.springframework.web.servlet.support

    Fields in org.springframework.web.servlet.support declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | AbstractFlashMapManager.`logger`

  - ### Uses of Log in org.springframework.web.servlet.tags

    Fields in org.springframework.web.servlet.tags declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | RequestContextAwareTag.`logger` Logger available to subclasses.

  - ### Uses of Log in org.springframework.web.servlet.view.tiles3

    Fields in org.springframework.web.servlet.view.tiles3 declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | TilesConfigurer.`logger`

  - ### Uses of Log in org.springframework.web.socket.adapter

    Fields in org.springframework.web.socket.adapter declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected static Log` | AbstractWebSocketSession.`logger`

  - ### Uses of Log in org.springframework.web.socket.client

    Fields in org.springframework.web.socket.client declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | AbstractWebSocketClient.`logger`
    `protected Log` | ConnectionManagerSupport.`logger`

  - ### Uses of Log in org.springframework.web.socket.handler

    Methods in org.springframework.web.socket.handler with parameters of type Log
    Modifier and Type | Method and Description
    --- | ---
    `static void` | ExceptionWebSocketHandlerDecorator.`tryCloseWithError(WebSocketSession session, Throwable exception, Log logger)`

  - ### Uses of Log in org.springframework.web.socket.server.standard

    Fields in org.springframework.web.socket.server.standard declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | AbstractStandardUpgradeStrategy.`logger`

  - ### Uses of Log in org.springframework.web.socket.server.support

    Fields in org.springframework.web.socket.server.support declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | OriginHandshakeInterceptor.`logger`
    `protected Log` | AbstractHandshakeHandler.`logger`

  - ### Uses of Log in org.springframework.web.socket.sockjs.client

    Fields in org.springframework.web.socket.sockjs.client declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | AbstractXhrTransport.`logger`
    `protected Log` | AbstractClientSockJsSession.`logger`

  - ### Uses of Log in org.springframework.web.socket.sockjs.support

    Fields in org.springframework.web.socket.sockjs.support declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | AbstractSockJsService.`logger`

  - ### Uses of Log in org.springframework.web.socket.sockjs.transport.handler

    Fields in org.springframework.web.socket.sockjs.transport.handler declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | AbstractTransportHandler.`logger`

  - ### Uses of Log in org.springframework.web.socket.sockjs.transport.session

    Fields in org.springframework.web.socket.sockjs.transport.session declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected static Log` | AbstractSockJsSession.`disconnectedClientLogger` Separate logger to use on network IO failure after a client has gone away.
    `protected Log` | AbstractSockJsSession.`logger`

  - ### Uses of Log in org.springframework.web.util

    Fields in org.springframework.web.util declared as Log
    Modifier and Type | Field and Description
    --- | ---
    `protected Log` | CookieGenerator.`logger`