View Javadoc

    1   /***
    2    * JFoxSOAF, Service-Oriented Application Framework
    3    *
    4    * Copyright (C) www.huihoo.org
    5    *
    6    * Distributable under GNU LGPL
    7    *
    8    * For more information, please visit: http://www.huihoo.org/jfox/jfoxsoaf
    9    */
    10
    11  package org.huihoo.jfox.soaf.services.logging;
    12
    13  /***
    14   * <p>
    15   * Logging serivce, Wrapper service for common-logging.
    16   * </p>
    17   *
    18   * @author <a href="mailto:founder_chen@yahoo.com.cn">Peter Cheng</a>
    19   * @version $Revision: 1.3 $ $Date: 2004/10/13 11:00:45 $
    20   * @version Revision: 1.0
    21   */
    22
    23  public interface LoggingService {
    24
    25      /***
    26       * <p>
    27       * Is debug logging currently enabled?
    28       * </p>
    29       *
    30       * <p>
    31       * Call this method to prevent having to perform expensive operations (for
    32       * example, <code>String</code> concatination) when the log level is more
    33       * than debug.
    34       * </p>
    35       */
    36      public boolean isDebugEnabled();
    37
    38      /***
    39       * <p>
    40       * Is error logging currently enabled?
    41       * </p>
    42       *
    43       * <p>
    44       * Call this method to prevent having to perform expensive operations (for
    45       * example, <code>String</code> concatination) when the log level is more
    46       * than error.
    47       * </p>
    48       */
    49      public boolean isErrorEnabled();
    50
    51      /***
    52       * <p>
    53       * Is fatal logging currently enabled?
    54       * </p>
    55       *
    56       * <p>
    57       * Call this method to prevent having to perform expensive operations (for
    58       * example, <code>String</code> concatination) when the log level is more
    59       * than fatal.
    60       * </p>
    61       */
    62      public boolean isFatalEnabled();
    63
    64      /***
    65       * <p>
    66       * Is info logging currently enabled?
    67       * </p>
    68       *
    69       * <p>
    70       * Call this method to prevent having to perform expensive operations (for
    71       * example, <code>String</code> concatination) when the log level is more
    72       * than info.
    73       * </p>
    74       */
    75      public boolean isInfoEnabled();
    76
    77      /***
    78       * <p>
    79       * Is trace logging currently enabled?
    80       * </p>
    81       *
    82       * <p>
    83       * Call this method to prevent having to perform expensive operations (for
    84       * example, <code>String</code> concatination) when the log level is more
    85       * than trace.
    86       * </p>
    87       */
    88      public boolean isTraceEnabled();
    89
    90      /***
    91       * <p>
    92       * Is warning logging currently enabled?
    93       * </p>
    94       *
    95       * <p>
    96       * Call this method to prevent having to perform expensive operations (for
    97       * example, <code>String</code> concatination) when the log level is more
    98       * than warning.
    99       * </p>
    100      */
    101     public boolean isWarnEnabled();
    102
    103     // -------------------------------------------------------- Logging Methods
    104
    105     /***
    106      * <p>
    107      * Log a message with trace log level.
    108      * </p>
    109      *
    110      * @param message
    111      *            log this message
    112      */
    113     public void trace(Object message);
    114
    115     /***
    116      * <p>
    117      * Log an error with trace log level.
    118      * </p>
    119      *
    120      * @param message
    121      *            log this message
    122      * @param t
    123      *            log this cause
    124      */
    125     public void trace(Object message, Throwable t);
    126
    127     /***
    128      * <p>
    129      * Log a message with debug log level.
    130      * </p>
    131      *
    132      * @param message
    133      *            log this message
    134      */
    135     public void debug(Object message);
    136
    137     /***
    138      * <p>
    139      * Log an error with debug log level.
    140      * </p>
    141      *
    142      * @param message
    143      *            log this message
    144      * @param t
    145      *            log this cause
    146      */
    147     public void debug(Object message, Throwable t);
    148
    149     /***
    150      * <p>
    151      * Log a message with info log level.
    152      * </p>
    153      *
    154      * @param message
    155      *            log this message
    156      */
    157     public void info(Object message);
    158
    159     /***
    160      * <p>
    161      * Log an error with info log level.
    162      * </p>
    163      *
    164      * @param message
    165      *            log this message
    166      * @param t
    167      *            log this cause
    168      */
    169     public void info(Object message, Throwable t);
    170
    171     /***
    172      * <p>
    173      * Log a message with warn log level.
    174      * </p>
    175      *
    176      * @param message
    177      *            log this message
    178      */
    179     public void warn(Object message);
    180
    181     /***
    182      * <p>
    183      * Log an error with warn log level.
    184      * </p>
    185      *
    186      * @param message
    187      *            log this message
    188      * @param t
    189      *            log this cause
    190      */
    191     public void warn(Object message, Throwable t);
    192
    193     /***
    194      * <p>
    195      * Log a message with error log level.
    196      * </p>
    197      *
    198      * @param message
    199      *            log this message
    200      */
    201     public void error(Object message);
    202
    203     /***
    204      * <p>
    205      * Log an error with error log level.
    206      * </p>
    207      *
    208      * @param message
    209      *            log this message
    210      * @param t
    211      *            log this cause
    212      */
    213     public void error(Object message, Throwable t);
    214
    215     /***
    216      * <p>
    217      * Log a message with fatal log level.
    218      * </p>
    219      *
    220      * @param message
    221      *            log this message
    222      */
    223     public void fatal(Object message);
    224
    225     /***
    226      * <p>
    227      * Log an error with fatal log level.
    228      * </p>
    229      *
    230      * @param message
    231      *            log this message
    232      * @param t
    233      *            log this cause
    234      */
    235     public void fatal(Object message, Throwable t);
    236 }