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