AbstractTraceInterceptor (Spring Framework) - Spring Framework 1.2.9 API 文档英文版

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

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:: Serializable, Advice, Interceptor, MethodInterceptor

Direct Known Subclasses:: AbstractMonitoringInterceptor, CustomizableTraceInterceptor, SimpleTraceInterceptor

public abstract class AbstractTraceInterceptor
extends Object
implements MethodInterceptor, Serializable
extends Object
implements MethodInterceptor, 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 Log defaultLogger
          The default Log instance used to write trace messages.

Constructor Summary

AbstractTraceInterceptor()


Method Summary

protected Log getLoggerForInvocation(MethodInvocation invocation)
          Return the appropriate Log instance to use for the given MethodInvocation.

Object invoke(MethodInvocation invocation)
          Determines whether or not logging is enabled for the particular MethodInvocation.

protected abstract Object invokeUnderTrace(MethodInvocation invocation, Log logger)
          Subclasses must override this method to perform any tracing around the supplied MethodInvocation.

protected boolean isInterceptorEnabled(MethodInvocation invocation, Log logger)
          Determine whether the interceptor should kick in, that is, whether the invokeUnderTrace method should be called.

protected boolean isLogEnabled(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(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 Summary
`protected Log`	`defaultLogger` The default `Log` instance used to write trace messages.

Constructor Summary
`AbstractTraceInterceptor()`

Method Summary
`protected Log`	`getLoggerForInvocation(MethodInvocation invocation)` Return the appropriate `Log` instance to use for the given `MethodInvocation`.
`Object`	`invoke(MethodInvocation invocation)` Determines whether or not logging is enabled for the particular `MethodInvocation`.
`protected abstract Object`	`invokeUnderTrace(MethodInvocation invocation, Log logger)` Subclasses must override this method to perform any tracing around the supplied `MethodInvocation`.
`protected boolean`	`isInterceptorEnabled(MethodInvocation invocation, Log logger)` Determine whether the interceptor should kick in, that is, whether the `invokeUnderTrace` method should be called.
`protected boolean`	`isLogEnabled(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(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 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(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

setHideProxyClassNames

public void setHideProxyClassNames(boolean hideProxyClassNames)

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

invoke

public Object invoke(MethodInvocation invocation)
              throws 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 MethodInterceptor

Throws:: Throwable
See Also:: invokeUnderTrace(org.aopalliance.intercept.MethodInvocation, org.apache.commons.logging.Log)

getLoggerForInvocation

protected Log getLoggerForInvocation(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)

isInterceptorEnabled

protected boolean isInterceptorEnabled(MethodInvocation invocation,
                                       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(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 Object invokeUnderTrace(MethodInvocation invocation,
                                           Log logger)
                                    throws 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:: 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)