org.springframework.aop.interceptor

## 类 AbstractTraceInterceptor

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

- 所有已实现的接口:
    Serializable, Advice, Interceptor, MethodInterceptor
  直接已知子类:
    AbstractMonitoringInterceptor, CustomizableTraceInterceptor, SimpleTraceInterceptor

      public abstract class AbstractTraceInterceptor
      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.

  从以下版本开始:
    1.2
  作者:
    Rob Harrop, Juergen Hoeller
  另请参阅:
    `setUseDynamicLogger(boolean)`, `invokeUnderTrace(org.aopalliance.intercept.MethodInvocation, org.apache.commons.logging.Log)`, 序列化表格

- - ### 字段概要

    字段
    限定符和类型 | 字段和说明
    --- | ---
    `protected Log` | `defaultLogger` The default `Log` instance used to write trace messages.

  - ### 构造器概要

    构造器
    构造器和说明
    `AbstractTraceInterceptor()`

  - ### 方法概要

    所有方法 实例方法 抽象方法 具体方法
    限定符和类型 | 方法和说明
    --- | ---
    `protected Class<?>` | `getClassForLogging(Object target)` Determine the class to use for logging purposes.
    `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` | `setLogExceptionStackTrace(boolean logExceptionStackTrace)` Set whether to pass an exception to the logger, suggesting inclusion of its stack trace into the log.
    `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.
    `protected void` | `writeToLog(Log logger, String message)` Write the supplied trace message to the supplied `Log` instance.
    `protected void` | `writeToLog(Log logger, String message, Throwable ex)` Write the supplied trace message and `Throwable` to the supplied `Log` instance.

    - ### 从类继承的方法 java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### 字段详细资料

    - #### defaultLogger

          @Nullable
          protected transient Log defaultLogger

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

  - ### 构造器详细资料

    - #### AbstractTraceInterceptor

          public AbstractTraceInterceptor()

  - ### 方法详细资料

    - #### 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.

      另请参阅:
        `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.

      另请参阅:
        `LogFactory.getLog(String)`, `Logger`

    - #### setHideProxyClassNames

          public void setHideProxyClassNames(boolean hideProxyClassNames)

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

    - #### setLogExceptionStackTrace

          public void setLogExceptionStackTrace(boolean logExceptionStackTrace)

      Set whether to pass an exception to the logger, suggesting inclusion of its stack trace into the log. Default is "true"; set this to "false" in order to reduce the log output to just the trace message (which may include the exception class name and exception message, if applicable).
      从以下版本开始:
        4.3.10

    - #### invoke

          @Nullable
          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.
      指定者:
        `invoke` 在接口中 `MethodInterceptor`
      参数:
        `invocation` - 主要实现类:ReflectiveMethodInvocation
      抛出:
        `Throwable`
      另请参阅:
        `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.
      参数:
        `invocation` - the `MethodInvocation` being traced
      返回:
        the `Log` instance to use
      另请参阅:
        `setUseDynamicLogger(boolean)`

    - #### getClassForLogging

          protected Class<?> getClassForLogging(Object target)

      Determine the class to use for logging purposes.
      参数:
        `target` - the target object to introspect
      返回:
        the target class for the given object
      另请参阅:
        `setHideProxyClassNames(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.

      参数:
        `invocation` - the `MethodInvocation` being traced
        `logger` - the `Log` instance to check
      另请参阅:
        `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.

      参数:
        `logger` - the `Log` instance to check

    - #### writeToLog

          protected void writeToLog(Log logger,
                                    String message)

      Write the supplied trace message to the supplied `Log` instance.

      To be called by `invokeUnderTrace(org.aopalliance.intercept.MethodInvocation, org.apache.commons.logging.Log)` for enter/exit messages.

      Delegates to `writeToLog(Log, String, Throwable)` as the ultimate delegate that controls the underlying logger invocation.

      从以下版本开始:
        4.3.10
      另请参阅:
        `writeToLog(Log, String, Throwable)`

    - #### writeToLog

          protected void writeToLog(Log logger,
                                    String message,
                                    @Nullable
                                    Throwable ex)

      Write the supplied trace message and `Throwable` to the supplied `Log` instance.

      To be called by `invokeUnderTrace(org.aopalliance.intercept.MethodInvocation, org.apache.commons.logging.Log)` for enter/exit outcomes, potentially including an exception. Note that an exception's stack trace won't get logged when `setLogExceptionStackTrace(boolean)` is "false".

      By default messages are written at `TRACE` level. Subclasses can override this method to control which level the message is written at, typically also overriding `isLogEnabled(org.apache.commons.logging.Log)` accordingly.

      从以下版本开始:
        4.3.10
      另请参阅:
        `setLogExceptionStackTrace(boolean)`, `isLogEnabled(org.apache.commons.logging.Log)`

    - #### invokeUnderTrace

          @Nullable
          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, and may delegate to `writeToLog` for actual messages to be written.

      参数:
        `logger` - the `Log` to write trace messages to
      返回:
        the result of the call to `MethodInvocation.proceed()`
      抛出:
        `Throwable` - if the call to `MethodInvocation.proceed()` encountered any errors
      另请参阅:
        `isLogEnabled(org.apache.commons.logging.Log)`, `writeToLog(Log, String)`, `writeToLog(Log, String, Throwable)`