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ülcü 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 }