org.springframework.aop.interceptor

Class AbstractTraceInterceptor

  • java.lang.Object
    • org.springframework.aop.interceptor.AbstractTraceInterceptor
    • Field Summary

      Fields 
      Modifier and Type Field and Description
      protected Log defaultLogger
      The default Log instance used to write trace messages.
    • Method Summary

      All Methods Instance Methods Abstract Methods Concrete Methods 
      Modifier and Type Method and Description
      protected java.lang.Class<?> getClassForLogging(java.lang.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.
      java.lang.Object invoke(MethodInvocation invocation)
      Determines whether or not logging is enabled for the particular MethodInvocation.
      protected abstract java.lang.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(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.
      protected void writeToLog(Log logger, java.lang.String message)
      Write the supplied trace message to the supplied Log instance.
      protected void writeToLog(Log logger, java.lang.String message, java.lang.Throwable ex)
      Write the supplied trace message and Throwable to the supplied Log instance.
      • Methods inherited from class java.lang.Object

        clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
    • Field Detail

      • defaultLogger

        @Nullable
        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(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)
      • 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).
        Since:
        4.3.10
      • 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)
      • 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)
      • 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 java.lang.Object invokeUnderTrace(MethodInvocation invocation,
                                                             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, and may delegate to writeToLog for actual messages to be written.

        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:
        isLogEnabled(org.apache.commons.logging.Log), writeToLog(Log, String), writeToLog(Log, String, Throwable)