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ülcü 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 108 .valueOf(message), null, null); 109 } 110 111 /** 112 * Converts the first input parameter to String and then delegates to the 113 * debug method of the wrapped <code>org.slf4j.Logger</code> instance. 114 * 115 * @param message 116 * the message to log. Converted to {@link String} 117 * @param t 118 * the exception to log 119 */ 120 public void trace(Object message, Throwable t) { 121 logger.log(null, FQCN, LocationAwareLogger.TRACE_INT, String 122 .valueOf(message), null, t); 123 } 124 125 /** 126 * Converts the input parameter to String and then delegates to the wrapped 127 * <code>org.slf4j.Logger</code> instance. 128 * 129 * @param message 130 * the message to log. Converted to {@link String} 131 */ 132 public void debug(Object message) { 133 logger.log(null, FQCN, LocationAwareLogger.DEBUG_INT, String 134 .valueOf(message), null, null); 135 } 136 137 /** 138 * Converts the first input parameter to String and then delegates to the 139 * wrapped <code>org.slf4j.Logger</code> instance. 140 * 141 * @param message 142 * the message to log. Converted to {@link String} 143 * @param t 144 * the exception to log 145 */ 146 public void debug(Object message, Throwable t) { 147 logger.log(null, FQCN, LocationAwareLogger.DEBUG_INT, String 148 .valueOf(message), null, t); 149 } 150 151 /** 152 * Converts the input parameter to String and then delegates to the wrapped 153 * <code>org.slf4j.Logger</code> instance. 154 * 155 * @param message 156 * the message to log. Converted to {@link String} 157 */ 158 public void info(Object message) { 159 logger.log(null, FQCN, LocationAwareLogger.INFO_INT, String 160 .valueOf(message), null, null); 161 } 162 163 /** 164 * Converts the first input parameter to String and then delegates to the 165 * wrapped <code>org.slf4j.Logger</code> instance. 166 * 167 * @param message 168 * the message to log. Converted to {@link String} 169 * @param t 170 * the exception to log 171 */ 172 public void info(Object message, Throwable t) { 173 logger.log(null, FQCN, LocationAwareLogger.INFO_INT, String 174 .valueOf(message), null, t); 175 } 176 177 /** 178 * Converts the input parameter to String and then delegates to the wrapped 179 * <code>org.slf4j.Logger</code> instance. 180 * 181 * @param message 182 * the message to log. Converted to {@link String} 183 */ 184 public void warn(Object message) { 185 logger.log(null, FQCN, LocationAwareLogger.WARN_INT, String 186 .valueOf(message), null, null); 187 } 188 189 /** 190 * Converts the first input parameter to String and then delegates to the 191 * wrapped <code>org.slf4j.Logger</code> instance. 192 * 193 * @param message 194 * the message to log. Converted to {@link String} 195 * @param t 196 * the exception to log 197 */ 198 public void warn(Object message, Throwable t) { 199 logger.log(null, FQCN, LocationAwareLogger.WARN_INT, String 200 .valueOf(message), null, t); 201 } 202 203 /** 204 * Converts the input parameter to String and then delegates to the wrapped 205 * <code>org.slf4j.Logger</code> instance. 206 * 207 * @param message 208 * the message to log. Converted to {@link String} 209 */ 210 public void error(Object message) { 211 logger.log(null, FQCN, LocationAwareLogger.ERROR_INT, String 212 .valueOf(message), null, null); 213 } 214 215 /** 216 * Converts the first input parameter to String and then delegates to the 217 * wrapped <code>org.slf4j.Logger</code> instance. 218 * 219 * @param message 220 * the message to log. Converted to {@link String} 221 * @param t 222 * the exception to log 223 */ 224 public void error(Object message, Throwable t) { 225 logger.log(null, FQCN, LocationAwareLogger.ERROR_INT, String 226 .valueOf(message), null, t); 227 } 228 229 /** 230 * Converts the input parameter to String and then delegates to the error 231 * method of the wrapped <code>org.slf4j.Logger</code> instance. 232 * 233 * @param message 234 * the message to log. Converted to {@link String} 235 */ 236 public void fatal(Object message) { 237 logger.log(null, FQCN, LocationAwareLogger.ERROR_INT, String 238 .valueOf(message), null, null); 239 } 240 241 /** 242 * Converts the first input parameter to String and then delegates to the 243 * error method of the wrapped <code>org.slf4j.Logger</code> instance. 244 * 245 * @param message 246 * the message to log. Converted to {@link String} 247 * @param t 248 * the exception to log 249 */ 250 public void fatal(Object message, Throwable t) { 251 logger.log(null, FQCN, LocationAwareLogger.ERROR_INT, String 252 .valueOf(message), null, t); 253 } 254 255 /** 256 * Replace this instance with a homonymous (same name) logger returned by 257 * LoggerFactory. Note that this method is only called during deserialization. 258 * 259 * @return logger with same name as returned by LoggerFactory 260 * @throws ObjectStreamException 261 */ 262 protected Object readResolve() throws ObjectStreamException { 263 Logger logger = LoggerFactory.getLogger(this.name); 264 return new SLF4JLocationAwareLog((LocationAwareLogger) logger); 265 } 266 }