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 }