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  import org.slf4j.spi.LocationAwareLogger;
26  
27  /**
28   * Implementation of {@link Log org.apache.commons.logging.Log} interface which
29   * delegates all processing to a wrapped {@link Logger org.slf4j.Logger}
30   * instance.
31   * 
32   * <p>
33   * JCL's FATAL level is mapped to ERROR. All other levels map one to one.
34   * 
35   * @author Ceki G&uuml;lc&uuml;
36   */
37  public class SLF4JLocationAwareLog implements Log, Serializable {
38  
39      private static final long serialVersionUID = -2379157579039314822L;
40  
41      // used to store this logger's name to recreate it after serialization
42      protected String name;
43  
44      // in both Log4jLogger and Jdk14Logger classes in the original JCL, the
45      // logger instance is transient
46      private transient LocationAwareLogger logger;
47  
48      private static final String FQCN = SLF4JLocationAwareLog.class.getName();
49  
50      SLF4JLocationAwareLog(LocationAwareLogger logger) {
51          this.logger = logger;
52          this.name = logger.getName();
53      }
54  
55      /**
56       * Delegates to the <code>isTraceEnabled<code> method of the wrapped 
57       * <code>org.slf4j.Logger</code> instance.
58       */
59      public boolean isTraceEnabled() {
60          return logger.isTraceEnabled();
61      }
62  
63      /**
64       * Directly delegates to the wrapped <code>org.slf4j.Logger</code> instance.
65       */
66      public boolean isDebugEnabled() {
67          return logger.isDebugEnabled();
68      }
69  
70      /**
71       * Directly delegates to the wrapped <code>org.slf4j.Logger</code> instance.
72       */
73      public boolean isInfoEnabled() {
74          return logger.isInfoEnabled();
75      }
76  
77      /**
78       * Directly delegates to the wrapped <code>org.slf4j.Logger</code> instance.
79       */
80      public boolean isWarnEnabled() {
81          return logger.isWarnEnabled();
82      }
83  
84      /**
85       * Directly delegates to the wrapped <code>org.slf4j.Logger</code> instance.
86       */
87      public boolean isErrorEnabled() {
88          return logger.isErrorEnabled();
89      }
90  
91      /**
92       * Delegates to the <code>isErrorEnabled<code> method of the wrapped 
93       * <code>org.slf4j.Logger</code> instance.
94       */
95      public boolean isFatalEnabled() {
96          return logger.isErrorEnabled();
97      }
98  
99      /**
100      * Converts the input parameter to String and then delegates to the debug
101      * method of the wrapped <code>org.slf4j.Logger</code> instance.
102      * 
103      * @param message
104      *          the message to log. Converted to {@link String}
105      */
106     public void trace(Object message) {
107         logger.log(null, FQCN, LocationAwareLogger.TRACE_INT, String.valueOf(message), null, null);
108     }
109 
110     /**
111      * Converts the first input parameter to String and then delegates to the
112      * debug method of the wrapped <code>org.slf4j.Logger</code> instance.
113      * 
114      * @param message
115      *          the message to log. Converted to {@link String}
116      * @param t
117      *          the exception to log
118      */
119     public void trace(Object message, Throwable t) {
120         logger.log(null, FQCN, LocationAwareLogger.TRACE_INT, String.valueOf(message), null, t);
121     }
122 
123     /**
124      * Converts the input parameter to String and then delegates to the wrapped
125      * <code>org.slf4j.Logger</code> instance.
126      * 
127      * @param message
128      *          the message to log. Converted to {@link String}
129      */
130     public void debug(Object message) {
131         logger.log(null, FQCN, LocationAwareLogger.DEBUG_INT, String.valueOf(message), null, null);
132     }
133 
134     /**
135      * Converts the first input parameter to String and then delegates to the
136      * wrapped <code>org.slf4j.Logger</code> instance.
137      * 
138      * @param message
139      *          the message to log. Converted to {@link String}
140      * @param t
141      *          the exception to log
142      */
143     public void debug(Object message, Throwable t) {
144         logger.log(null, FQCN, LocationAwareLogger.DEBUG_INT, String.valueOf(message), null, t);
145     }
146 
147     /**
148      * Converts the input parameter to String and then delegates to the wrapped
149      * <code>org.slf4j.Logger</code> instance.
150      * 
151      * @param message
152      *          the message to log. Converted to {@link String}
153      */
154     public void info(Object message) {
155         logger.log(null, FQCN, LocationAwareLogger.INFO_INT, String.valueOf(message), null, null);
156     }
157 
158     /**
159      * Converts the first input parameter to String and then delegates to the
160      * wrapped <code>org.slf4j.Logger</code> instance.
161      * 
162      * @param message
163      *          the message to log. Converted to {@link String}
164      * @param t
165      *          the exception to log
166      */
167     public void info(Object message, Throwable t) {
168         logger.log(null, FQCN, LocationAwareLogger.INFO_INT, String.valueOf(message), null, t);
169     }
170 
171     /**
172      * Converts the input parameter to String and then delegates to the wrapped
173      * <code>org.slf4j.Logger</code> instance.
174      * 
175      * @param message
176      *          the message to log. Converted to {@link String}
177      */
178     public void warn(Object message) {
179         logger.log(null, FQCN, LocationAwareLogger.WARN_INT, String.valueOf(message), null, null);
180     }
181 
182     /**
183      * Converts the first input parameter to String and then delegates to the
184      * wrapped <code>org.slf4j.Logger</code> instance.
185      * 
186      * @param message
187      *          the message to log. Converted to {@link String}
188      * @param t
189      *          the exception to log
190      */
191     public void warn(Object message, Throwable t) {
192         logger.log(null, FQCN, LocationAwareLogger.WARN_INT, String.valueOf(message), null, t);
193     }
194 
195     /**
196      * Converts the input parameter to String and then delegates to the wrapped
197      * <code>org.slf4j.Logger</code> instance.
198      * 
199      * @param message
200      *          the message to log. Converted to {@link String}
201      */
202     public void error(Object message) {
203         logger.log(null, FQCN, LocationAwareLogger.ERROR_INT, String.valueOf(message), null, null);
204     }
205 
206     /**
207      * Converts the first input parameter to String and then delegates to the
208      * wrapped <code>org.slf4j.Logger</code> instance.
209      * 
210      * @param message
211      *          the message to log. Converted to {@link String}
212      * @param t
213      *          the exception to log
214      */
215     public void error(Object message, Throwable t) {
216         logger.log(null, FQCN, LocationAwareLogger.ERROR_INT, String.valueOf(message), null, t);
217     }
218 
219     /**
220      * Converts the input parameter to String and then delegates to the error
221      * method of the wrapped <code>org.slf4j.Logger</code> instance.
222      * 
223      * @param message
224      *          the message to log. Converted to {@link String}
225      */
226     public void fatal(Object message) {
227         logger.log(null, FQCN, LocationAwareLogger.ERROR_INT, String.valueOf(message), null, null);
228     }
229 
230     /**
231      * Converts the first input parameter to String and then delegates to the
232      * error method of the wrapped <code>org.slf4j.Logger</code> instance.
233      * 
234      * @param message
235      *          the message to log. Converted to {@link String}
236      * @param t
237      *          the exception to log
238      */
239     public void fatal(Object message, Throwable t) {
240         logger.log(null, FQCN, LocationAwareLogger.ERROR_INT, String.valueOf(message), null, t);
241     }
242 
243     /**
244      * Replace this instance with a homonymous (same name) logger returned by
245      * LoggerFactory. Note that this method is only called during deserialization.
246      * 
247      * @return logger with same name as returned by LoggerFactory
248      * @throws ObjectStreamException
249      */
250     protected Object readResolve() throws ObjectStreamException {
251         Logger logger = LoggerFactory.getLogger(this.name);
252         return new SLF4JLocationAwareLog((LocationAwareLogger) logger);
253     }
254 }