Find Usages Diff Raw Download HTML Widget
Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
Copyright (c) 2004-2011 QOS.ch All rights reserved. Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 
24
 
25
 package org.slf4j;
26
 
28
 import java.net.URL;
29
 import java.util.*;
30
 
The LoggerFactory is a utility class producing Loggers for various logging APIs, most notably for log4j, logback and JDK 1.4 logging. Other implementations such as NOPLogger and SimpleLogger are also supported.

LoggerFactory is essentially a wrapper around an ILoggerFactory instance bound with LoggerFactory at compile time.

Please note that all methods in LoggerFactory are static.

Author(s):
Ceki Gülcü
Robert Elliot
52
 
53
 public final class LoggerFactory {
54
 
55
   static final String CODES_PREFIX = "http://www.slf4j.org/codes.html";
56
     
57
   static final String NO_STATICLOGGERBINDER_URL = +"#StaticLoggerBinder";
58
   static final String MULTIPLE_BINDINGS_URL = +"#multiple_bindings";
59
   static final String NULL_LF_URL = +"#null_LF";
60
   static final String VERSION_MISMATCH = +"#version_mismatch";
61
   static final String SUBSTITUTE_LOGGER_URL = +"#substituteLogger";
62
 
63
   static final String UNSUCCESSFUL_INIT_URL = +"#unsuccessfulInit";
64
   static final String UNSUCCESSFUL_INIT_MSG = "org.slf4j.LoggerFactory could not be successfully initialized. See also "
65
       + ;
66
 
67
   static final int UNINITIALIZED = 0;
68
   static final int ONGOING_INITILIZATION = 1;
69
   static final int FAILED_INITILIZATION = 2;
70
   static final int SUCCESSFUL_INITILIZATION = 3;
71
   static final int NOP_FALLBACK_INITILIZATION = 4;
72
 
73
   static int INITIALIZATION_STATE = ;
It is LoggerFactory's responsibility to track version changes and manage the compatibility list.

It is assumed that all versions in the 1.6 are mutually compatible. 

83
 
84
   static private final String[] API_COMPATIBILITY_LIST = new String[] { "1.6" };
85
 
86
   // private constructor prevents instantiation
87
   private LoggerFactory() {
88
   }

  
Force LoggerFactory to consider itself uninitialized.

This method is intended to be called by classes (in the same package) for testing purposes. This method is internal. It can be modified, renamed or removed at any time without notice.

You are strongly discouraged from calling this method in production code. 

101
  static void reset() {
104
  }
106
  private final static void performInitialization() {
108
    bind();
110
      versionSanityCheck();
111
   
112
    }
113
  }
115
  private static boolean messageContainsOrgSlf4jImplStaticLoggerBinder(String msg) {
116
    if(msg == null)
117
      return false;
118
    if(msg.indexOf("org/slf4j/impl/StaticLoggerBinder") != -1)
119
      return true;
120
    if(msg.indexOf("org.slf4j.impl.StaticLoggerBinder") != -1)
121
      return true;
122
    return false;
123
  }
125
  private final static void bind() {
126
    try {
127
      // the next line does the binding
128
      StaticLoggerBinder.getSingleton();
131
    } catch (NoClassDefFoundError ncde) {
132
      String msg = ncde.getMessage();
135
        Util
136
            .report("Failed to load class \"org.slf4j.impl.StaticLoggerBinder\".");
137
        Util.report("Defaulting to no-operation (NOP) logger implementation");
138
        Util.report("See " + 
139
            + " for further details.");
140
      } else {
141
        failedBinding(ncde);
142
        throw ncde;
143
      }
144
    } catch(java.lang.NoSuchMethodError nsme) {
145
      String msg = nsme.getMessage();
146
      if (msg != null && msg.indexOf("org.slf4j.impl.StaticLoggerBinder.getSingleton()") != -1) {
148
        Util.report("slf4j-api 1.6.x (or later) is incompatible with this binding.");
149
        Util.report("Your binding is version 1.5.5 or earlier.");
150
        Util.report("Upgrade your binding to version 1.6.x. or 2.0.x");
151
      }
152
      throw nsme;
153
    } catch (Exception e) {
154
      failedBinding(e);
155
      throw new IllegalStateException("Unexpected initialization failure", e);
156
    }
157
  }
159
  static void failedBinding(Throwable t) {
161
    Util.report("Failed to instantiate SLF4J LoggerFactory", t);
162
  }
164
  private final static void emitSubstituteLoggerWarning() {
165
    List loggerNameList = .getLoggerNameList();
166
    if (loggerNameList.size() == 0) {
167
      return;
168
    }
169
    Util
170
        .report("The following loggers will not work because they were created");
171
    Util
172
        .report("during the default configuration phase of the underlying logging system.");
173
    Util.report("See also " + );
174
    for (int i = 0; i < loggerNameList.size(); i++) {
175
      String loggerName = (String) loggerNameList.get(i);
176
      Util.report(loggerName);
177
    }
178
  }
180
  private final static void versionSanityCheck() {
181
    try {
184
      boolean match = false;
185
      for (int i = 0; i < .; i++) {
186
        if (requested.startsWith([i])) {
187
          match = true;
188
        }
189
      }
190
      if (!match) {
191
        Util.report("The requested version " + requested
192
            + " by your slf4j binding is not compatible with "
193
            + Arrays.asList().toString());
194
        Util.report("See " +  + " for further details.");
195
      }
196
    } catch (java.lang.NoSuchFieldError nsfe) {
197
      // given our large user base and SLF4J's commitment to backward
198
      // compatibility, we cannot cry here. Only for implementations
199
      // which willingly declare a REQUESTED_API_VERSION field do we
200
      // emit compatibility warnings.
201
    } catch (Throwable e) {
202
      // we should never reach here
203
      Util.report("Unexpected problem occured during version sanity check", e);
204
    }
205
  }
207
  // We need to use the name of the StaticLoggerBinder class, but we can't reference
208
  // the class itself.
209
  private static String STATIC_LOGGER_BINDER_PATH = "org/slf4j/impl/StaticLoggerBinder.class";
211
  private static void singleImplementationSanityCheck() {
212
    try {
213
      ClassLoader loggerFactoryClassLoader = LoggerFactory.class
214
          .getClassLoader();
215
      Enumeration paths;
216
      if (loggerFactoryClassLoader == null) {
217
        paths = ClassLoader.getSystemResources();
218
      } else {
219
        paths = loggerFactoryClassLoader
220
            .getResources();
221
      }
222
      // use Set instead of list in order to deal with  bug #138
223
      // LinkedHashSet appropriate here because it preserves insertion order during iteration
224
      Set implementationSet = new LinkedHashSet();
225
      while (paths.hasMoreElements()) {
226
        URL path = (URL) paths.nextElement();
227
        implementationSet.add(path);
228
      }
229
      if (implementationSet.size() > 1) {
230
        Util.report("Class path contains multiple SLF4J bindings.");
231
        Iterator iterator = implementationSet.iterator();
232
        while(iterator.hasNext()) {
233
          URL path = (URL) iterator.next();
234
          Util.report("Found binding in [" + path + "]");
235
        }
236
        Util.report("See " +  + " for an explanation.");
237
      }
238
    } catch (IOException ioe) {
239
      Util.report("Error getting resources from path", ioe);
240
    }
241
  }

  
Return a logger named according to the name parameter using the statically bound ILoggerFactory instance.

Parameters:
name The name of the logger.
Returns:
logger
251
  public static Logger getLogger(String name) {
252
    ILoggerFactory iLoggerFactory = getILoggerFactory();
253
    return iLoggerFactory.getLogger(name);
254
  }

  
Return a logger named corresponding to the class passed as parameter, using the statically bound ILoggerFactory instance.

Parameters:
clazz the returned logger will be named after clazz
Returns:
logger
264
  public static Logger getLogger(Class clazz) {
265
    return getLogger(clazz.getName());
266
  }

  
Return the ILoggerFactory instance in use.

ILoggerFactory instance is bound with this class at compile time.

Returns:
the ILoggerFactory instance in use
276
  public static ILoggerFactory getILoggerFactory() {
281
    }
282
    switch () {
284
      return StaticLoggerBinder.getSingleton().getLoggerFactory();
286
      return ;
290
      // support re-entrant behavior.
291
      // See also http://bugzilla.slf4j.org/show_bug.cgi?id=106
292
      return ;
293
    }
294
    throw new IllegalStateException("Unreachable code");
295
  }
New to GrepCode? Check out our FAQ X