View Javadoc

    1   /*
    2    * Copyright 2001-2004 The Apache Software Foundation.
    3    *
    4    * Licensed under the Apache License, Version 2.0 (the "License");
    5    * you may not use this file except in compliance with the License.
    6    * You may obtain a copy of the License at
    7    *
    8    *      http://www.apache.org/licenses/LICENSE-2.0
    9    *
    10   * Unless required by applicable law or agreed to in writing, software
    11   * distributed under the License is distributed on an "AS IS" BASIS,
    12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13   * See the License for the specific language governing permissions and
    14   * limitations under the License.
    15   */
    16
    17  package org.apache.commons.logging.impl;
    18
    19  import java.io.ObjectStreamException;
    20  import java.io.Serializable;
    21
    22  import org.apache.commons.logging.Log;
    23  import org.slf4j.Logger;
    24  import org.slf4j.LoggerFactory;
    25
    26  /**
    27   * Implementation of {@link Log org.apache.commons.logging.Log} interface which
    28   * delegates all processing to a wrapped {@link Logger org.slf4j.Logger}
    29   * instance.
    30   *
    31   * <p>
    32   * JCL's FATAL level is mapped to ERROR. All other levels map one to one.
    33   *
    34   * @author Ceki G&uuml;lc&uuml;
    35   */
    36  public class SLF4JLog implements Log, Serializable {
    37
    38      private static final long serialVersionUID = 680728617011167209L;
    39
    40      // used to store this logger's name to recreate it after serialization
    41      protected String name;
    42
    43      // in both Log4jLogger and Jdk14Logger classes in the original JCL, the
    44      // logger instance is transient
    45      private transient Logger logger;
    46
    47      SLF4JLog(Logger logger) {
    48          this.logger = logger;
    49          this.name = logger.getName();
    50      }
    51
    52      /**
    53       * Directly delegates to the wrapped <code>org.slf4j.Logger</code> instance.
    54       */
    55      public boolean isDebugEnabled() {
    56          return logger.isDebugEnabled();
    57      }
    58
    59      /**
    60       * Directly delegates to the wrapped <code>org.slf4j.Logger</code> instance.
    61       */
    62      public boolean isErrorEnabled() {
    63          return logger.isErrorEnabled();
    64      }
    65
    66      /**
    67       * Delegates to the <code>isErrorEnabled<code> method of the wrapped
    68       * <code>org.slf4j.Logger</code> instance.
    69       */
    70      public boolean isFatalEnabled() {
    71          return logger.isErrorEnabled();
    72      }
    73
    74      /**
    75       * Directly delegates to the wrapped <code>org.slf4j.Logger</code> instance.
    76       */
    77      public boolean isInfoEnabled() {
    78          return logger.isInfoEnabled();
    79      }
    80
    81      /**
    82       * Delegates to the <code>isDebugEnabled<code> method of the wrapped
    83       * <code>org.slf4j.Logger</code> instance.
    84       */
    85      public boolean isTraceEnabled() {
    86          return logger.isTraceEnabled();
    87      }
    88
    89      /**
    90       * Directly delegates to the wrapped <code>org.slf4j.Logger</code> instance.
    91       */
    92      public boolean isWarnEnabled() {
    93          return logger.isWarnEnabled();
    94      }
    95
    96      /**
    97       * Converts the input parameter to String and then delegates to the debug
    98       * method of the wrapped <code>org.slf4j.Logger</code> instance.
    99       *
    100      * @param message
    101      *          the message to log. Converted to {@link String}
    102      */
    103     public void trace(Object message) {
    104         logger.trace(String.valueOf(message));
    105     }
    106
    107     /**
    108      * Converts the first input parameter to String and then delegates to the
    109      * debug method of the wrapped <code>org.slf4j.Logger</code> instance.
    110      *
    111      * @param message
    112      *          the message to log. Converted to {@link String}
    113      * @param t
    114      *          the exception to log
    115      */
    116     public void trace(Object message, Throwable t) {
    117         logger.trace(String.valueOf(message), t);
    118     }
    119
    120     /**
    121      * Converts the input parameter to String and then delegates to the wrapped
    122      * <code>org.slf4j.Logger</code> instance.
    123      *
    124      * @param message
    125      *          the message to log. Converted to {@link String}
    126      */
    127     public void debug(Object message) {
    128         logger.debug(String.valueOf(message));
    129     }
    130
    131     /**
    132      * Converts the first input parameter to String and then delegates to the
    133      * wrapped <code>org.slf4j.Logger</code> instance.
    134      *
    135      * @param message
    136      *          the message to log. Converted to {@link String}
    137      * @param t
    138      *          the exception to log
    139      */
    140     public void debug(Object message, Throwable t) {
    141         logger.debug(String.valueOf(message), t);
    142     }
    143
    144     /**
    145      * Converts the input parameter to String and then delegates to the wrapped
    146      * <code>org.slf4j.Logger</code> instance.
    147      *
    148      * @param message
    149      *          the message to log. Converted to {@link String}
    150      */
    151     public void info(Object message) {
    152         logger.info(String.valueOf(message));
    153     }
    154
    155     /**
    156      * Converts the first input parameter to String and then delegates to the
    157      * wrapped <code>org.slf4j.Logger</code> instance.
    158      *
    159      * @param message
    160      *          the message to log. Converted to {@link String}
    161      * @param t
    162      *          the exception to log
    163      */
    164     public void info(Object message, Throwable t) {
    165         logger.info(String.valueOf(message), t);
    166     }
    167
    168     /**
    169      * Converts the input parameter to String and then delegates to the wrapped
    170      * <code>org.slf4j.Logger</code> instance.
    171      *
    172      * @param message
    173      *          the message to log. Converted to {@link String}
    174      */
    175     public void warn(Object message) {
    176         logger.warn(String.valueOf(message));
    177     }
    178
    179     /**
    180      * Converts the first input parameter to String and then delegates to the
    181      * wrapped <code>org.slf4j.Logger</code> instance.
    182      *
    183      * @param message
    184      *          the message to log. Converted to {@link String}
    185      * @param t
    186      *          the exception to log
    187      */
    188     public void warn(Object message, Throwable t) {
    189         logger.warn(String.valueOf(message), t);
    190     }
    191
    192     /**
    193      * Converts the input parameter to String and then delegates to the wrapped
    194      * <code>org.slf4j.Logger</code> instance.
    195      *
    196      * @param message
    197      *          the message to log. Converted to {@link String}
    198      */
    199     public void error(Object message) {
    200         logger.error(String.valueOf(message));
    201     }
    202
    203     /**
    204      * Converts the first input parameter to String and then delegates to the
    205      * wrapped <code>org.slf4j.Logger</code> instance.
    206      *
    207      * @param message
    208      *          the message to log. Converted to {@link String}
    209      * @param t
    210      *          the exception to log
    211      */
    212     public void error(Object message, Throwable t) {
    213         logger.error(String.valueOf(message), t);
    214     }
    215
    216     /**
    217      * Converts the input parameter to String and then delegates to the error
    218      * method of the wrapped <code>org.slf4j.Logger</code> instance.
    219      *
    220      * @param message
    221      *          the message to log. Converted to {@link String}
    222      */
    223     public void fatal(Object message) {
    224         logger.error(String.valueOf(message));
    225     }
    226
    227     /**
    228      * Converts the first input parameter to String and then delegates to the
    229      * error method of the wrapped <code>org.slf4j.Logger</code> instance.
    230      *
    231      * @param message
    232      *          the message to log. Converted to {@link String}
    233      * @param t
    234      *          the exception to log
    235      */
    236     public void fatal(Object message, Throwable t) {
    237         logger.error(String.valueOf(message), t);
    238     }
    239
    240     /**
    241      * Replace this instance with a homonymous (same name) logger returned by
    242      * LoggerFactory. Note that this method is only called during deserialization.
    243      *
    244      * @return logger with same name as returned by LoggerFactory
    245      * @throws ObjectStreamException
    246      */
    247     protected Object readResolve() throws ObjectStreamException {
    248         Logger logger = LoggerFactory.getLogger(this.name);
    249         return new SLF4JLog(logger);
    250     }
    251 }