Overview | Package | Class | Tree | Deprecated | Index | Help
| Spring Framework
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.springframework.aop.interceptor
Class AbstractTraceInterceptor

    java.lang.Object
      org.springframework.aop.interceptor.AbstractTraceInterceptor

All Implemented Interfaces:
  java.io.Serializable, org.aopalliance.aop.Advice, org.aopalliance.intercept.Interceptor, org.aopalliance.intercept.MethodInterceptor

Direct Known Subclasses:
  AbstractMonitoringInterceptor, CustomizableTraceInterceptor, SimpleTraceInterceptor

    public abstract class AbstractTraceInterceptor

extends java.lang.Object
implements org.aopalliance.intercept.MethodInterceptor, java.io.Serializable

Base `MethodInterceptor` implementation for tracing.

By default, log messages are written to the log for the interceptor class, not the class which is being intercepted. Setting the `useDynamicLogger` bean property to `true` causes all log messages to be written to the `Log` for the target class being intercepted.

Subclasses must implement the `invokeUnderTrace` method, which is invoked by this class ONLY when a particular invocation SHOULD be traced. Subclasses should write to the `Log` instance provided.

Since:
  1.2
Author:
  Rob Harrop, Juergen Hoeller
See Also:
  `setUseDynamicLogger(boolean)`, `invokeUnderTrace(org.aopalliance.intercept.MethodInvocation, org.apache.commons.logging.Log)`, Serialized Form

Field Summary
`protected org.apache.commons.logging.Log` | `defaultLogger` The default `Log` instance used to write trace messages.

Constructor Summary
`AbstractTraceInterceptor()`

Method Summary
`protected java.lang.Class` | `getClassForLogging(java.lang.Object target)` Determine the class to use for logging purposes.
`protected org.apache.commons.logging.Log` | `getLoggerForInvocation(org.aopalliance.intercept.MethodInvocation invocation)` Return the appropriate `Log` instance to use for the given `MethodInvocation`.
`java.lang.Object` | `invoke(org.aopalliance.intercept.MethodInvocation invocation)` Determines whether or not logging is enabled for the particular `MethodInvocation`.
`protected abstract java.lang.Object` | `invokeUnderTrace(org.aopalliance.intercept.MethodInvocation invocation, org.apache.commons.logging.Log logger)` Subclasses must override this method to perform any tracing around the supplied `MethodInvocation`.
`protected boolean` | `isInterceptorEnabled(org.aopalliance.intercept.MethodInvocation invocation, org.apache.commons.logging.Log logger)` Determine whether the interceptor should kick in, that is, whether the `invokeUnderTrace` method should be called.
`protected boolean` | `isLogEnabled(org.apache.commons.logging.Log logger)` Determine whether the given `Log` instance is enabled.
`void` | `setHideProxyClassNames(boolean hideProxyClassNames)` Set to "true" to have `dynamic loggers` hide proxy class names wherever possible.
`void` | `setLoggerName(java.lang.String loggerName)` Set the name of the logger to use.
`void` | `setUseDynamicLogger(boolean useDynamicLogger)` Set whether to use a dynamic logger or a static logger.

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### defaultLogger

    protected transient org.apache.commons.logging.Log defaultLogger

  The default `Log` instance used to write trace messages. This instance is mapped to the implementing `Class`.

Constructor Detail

### AbstractTraceInterceptor

    public AbstractTraceInterceptor()

Method Detail

### setUseDynamicLogger

    public void setUseDynamicLogger(boolean useDynamicLogger)

  Set whether to use a dynamic logger or a static logger. Default is a static logger for this trace interceptor.

  Used to determine which `Log` instance should be used to write log messages for a particular method invocation: a dynamic one for the `Class` getting called, or a static one for the `Class` of the trace interceptor.

  NOTE: Specify either this property or "loggerName", not both.

  See Also:
    `getLoggerForInvocation(org.aopalliance.intercept.MethodInvocation)`

### setLoggerName

    public void setLoggerName(java.lang.String loggerName)

  Set the name of the logger to use. The name will be passed to the underlying logger implementation through Commons Logging, getting interpreted as log category according to the logger's configuration.

  This can be specified to not log into the category of a class (whether this interceptor's class or the class getting called) but rather into a specific named category.

  NOTE: Specify either this property or "useDynamicLogger", not both.

  See Also:
    `LogFactory.getLog(String)`, `Logger.getLogger(String)`, `Logger.getLogger(String)`

### setHideProxyClassNames

    public void setHideProxyClassNames(boolean hideProxyClassNames)

  Set to "true" to have `dynamic loggers` hide proxy class names wherever possible. Default is "false".

### invoke

    public java.lang.Object invoke(org.aopalliance.intercept.MethodInvocation invocation)
                            throws java.lang.Throwable

  Determines whether or not logging is enabled for the particular `MethodInvocation`. If not, the method invocation proceeds as normal, otherwise the method invocation is passed to the `invokeUnderTrace` method for handling.

  Specified by:
    `invoke` in interface `org.aopalliance.intercept.MethodInterceptor`
  Throws:
    `java.lang.Throwable`
  See Also:
    `invokeUnderTrace(org.aopalliance.intercept.MethodInvocation, org.apache.commons.logging.Log)`

### getLoggerForInvocation

    protected org.apache.commons.logging.Log getLoggerForInvocation(org.aopalliance.intercept.MethodInvocation invocation)

  Return the appropriate `Log` instance to use for the given `MethodInvocation`. If the `useDynamicLogger` flag is set, the `Log` instance will be for the target class of the `MethodInvocation`, otherwise the `Log` will be the default static logger.

  Parameters:
    `invocation` - the `MethodInvocation` being traced
  Returns:
    the `Log` instance to use
  See Also:
    `setUseDynamicLogger(boolean)`

### getClassForLogging

    protected java.lang.Class getClassForLogging(java.lang.Object target)

  Determine the class to use for logging purposes.

  Parameters:
    `target` - the target object to introspect
  Returns:
    the target class for the given object
  See Also:
    `setHideProxyClassNames(boolean)`

### isInterceptorEnabled

    protected boolean isInterceptorEnabled(org.aopalliance.intercept.MethodInvocation invocation,
                                           org.apache.commons.logging.Log logger)

  Determine whether the interceptor should kick in, that is, whether the `invokeUnderTrace` method should be called.

  Default behavior is to check whether the given `Log` instance is enabled. Subclasses can override this to apply the interceptor in other cases as well.

  Parameters:
    `invocation` - the `MethodInvocation` being traced
    `logger` - the `Log` instance to check
  See Also:
    `invokeUnderTrace(org.aopalliance.intercept.MethodInvocation, org.apache.commons.logging.Log)`, `isLogEnabled(org.apache.commons.logging.Log)`

### isLogEnabled

    protected boolean isLogEnabled(org.apache.commons.logging.Log logger)

  Determine whether the given `Log` instance is enabled.

  Default is `true` when the "trace" level is enabled. Subclasses can override this to change the level under which 'tracing' occurs.

  Parameters:
    `logger` - the `Log` instance to check

### invokeUnderTrace

    protected abstract java.lang.Object invokeUnderTrace(org.aopalliance.intercept.MethodInvocation invocation,
                                                         org.apache.commons.logging.Log logger)
                                                  throws java.lang.Throwable

  Subclasses must override this method to perform any tracing around the supplied `MethodInvocation`. Subclasses are responsible for ensuring that the `MethodInvocation` actually executes by calling `MethodInvocation.proceed()`.

  By default, the passed-in `Log` instance will have log level "trace" enabled. Subclasses do not have to check for this again, unless they overwrite the `isInterceptorEnabled` method to modify the default behavior.

  Parameters:
    `logger` - the `Log` to write trace messages to
  Returns:
    the result of the call to `MethodInvocation.proceed()`
  Throws:
    `java.lang.Throwable` - if the call to `MethodInvocation.proceed()` encountered any errors
  See Also:
    `isInterceptorEnabled(org.aopalliance.intercept.MethodInvocation, org.apache.commons.logging.Log)`, `isLogEnabled(org.apache.commons.logging.Log)`

Overview | Package | Class | Tree | Deprecated | Index | Help
| Spring Framework
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD