日志那点事儿——slf4j源码剖析

             1
            package com.xingoo.test;

             2
             3
            import java.util.Date;

             4
             5
            import org.slf4j.Logger;

             6
            import org.slf4j.LoggerFactory;

             7
             8
            public
            class
             LogTest {

             9
            public
            static
            void
             main(String[] args) {

            10         Logger logger = LoggerFactory.getLogger(LogTest.class);
11         logger.info("hello {}",new Date());
12    }
13 }

            1
            public
            static
             Logger getLogger(Class clazz) {

            2
            return
             getLogger(clazz.getName());

            3   }

            public
            static
             Logger getLogger(String name) {
    ILoggerFactory iLoggerFactory = getILoggerFactory();
    return iLoggerFactory.getLogger(name);
  }

             1
            public
            static
             ILoggerFactory getILoggerFactory() {

             2
            if (INITIALIZATION_STATE == UNINITIALIZED) {
 3       INITIALIZATION_STATE = ONGOING_INITIALIZATION;
 4      performInitialization();
 5    }
 6switch (INITIALIZATION_STATE) {
 7case SUCCESSFUL_INITIALIZATION:
 8return StaticLoggerBinder.getSingleton().getLoggerFactory();
 9case NOP_FALLBACK_INITIALIZATION:
10return NOP_FALLBACK_FACTORY;
11case FAILED_INITIALIZATION:
12thrownew IllegalStateException(UNSUCCESSFUL_INIT_MSG);
13case ONGOING_INITIALIZATION:
14// support re-entrant behavior.
15// See also http://bugzilla.slf4j.org/show_bug.cgi?id=10616return TEMP_FACTORY;
17    }
18thrownew IllegalStateException("Unreachable code");
19  }
20 }

            private final staticvoid performInitialization() {
    bind();
    if (INITIALIZATION_STATE == SUCCESSFUL_INITIALIZATION) {
      versionSanityCheck();
    }
  }

            private final staticvoid versionSanityCheck() {
    try {
      String requested = StaticLoggerBinder.REQUESTED_API_VERSION;

      boolean match = false;
      for (int i = 0; i < API_COMPATIBILITY_LIST.length; i++) {
        if (requested.startsWith(API_COMPATIBILITY_LIST[i])) {
          match = true;
        }
      }
      if (!match) {
        Util.report("The requested version " + requested
                + " by your slf4j binding is not compatible with "
                + Arrays.asList(API_COMPATIBILITY_LIST).toString());
        Util.report("See " + VERSION_MISMATCH + " for further details.");
      }
    } catch (java.lang.NoSuchFieldError nsfe) {
      // given our large user base and SLF4J‘s commitment to backward
      // compatibility, we cannot cry here. Only for implementations
      // which willingly declare a REQUESTED_API_VERSION field do we
      // emit compatibility warnings.
    } catch (Throwable e) {
      // we should never reach here
      Util.report("Unexpected problem occured during version sanity check", e);
    }
  }

             1
            private final staticvoid bind() {
 2try {
 3       Set<URL> staticLoggerBinderPathSet = findPossibleStaticLoggerBinderPathSet();
 4      reportMultipleBindingAmbiguity(staticLoggerBinderPathSet);
 5// the next line does the binding 6      StaticLoggerBinder.getSingleton();
 7       INITIALIZATION_STATE = SUCCESSFUL_INITIALIZATION;
 8      reportActualBinding(staticLoggerBinderPathSet);
 9      fixSubstitutedLoggers();
10     } catch (NoClassDefFoundError ncde) {
11       String msg = ncde.getMessage();
12if (messageContainsOrgSlf4jImplStaticLoggerBinder(msg)) {
13         INITIALIZATION_STATE = NOP_FALLBACK_INITIALIZATION;
14         Util.report("Failed to load class \"org.slf4j.impl.StaticLoggerBinder\".");
15         Util.report("Defaulting to no-operation (NOP) logger implementation");
16         Util.report("See " + NO_STATICLOGGERBINDER_URL
17                 + " for further details.");
18       } else {
19        failedBinding(ncde);
20throw ncde;
21      }
22     } catch (java.lang.NoSuchMethodError nsme) {
23       String msg = nsme.getMessage();
24if (msg != null && msg.indexOf("org.slf4j.impl.StaticLoggerBinder.getSingleton()") != -1) {
25         INITIALIZATION_STATE = FAILED_INITIALIZATION;
26         Util.report("slf4j-api 1.6.x (or later) is incompatible with this binding.");
27         Util.report("Your binding is version 1.5.5 or earlier.");
28         Util.report("Upgrade your binding to version 1.6.x.");
29      }
30throw nsme;
31     } catch (Exception e) {
32      failedBinding(e);
33thrownew IllegalStateException("Unexpected initialization failure", e);
34    }
35   }

             1
            private
            static String STATIC_LOGGER_BINDER_PATH = "org/slf4j/impl/StaticLoggerBinder.class";
 2 3privatestatic Set<URL> findPossibleStaticLoggerBinderPathSet() {
 4// use Set instead of list in order to deal with  bug #138
 5// LinkedHashSet appropriate here because it preserves insertion order during iteration 6     Set<URL> staticLoggerBinderPathSet = new LinkedHashSet<URL>();
 7try {
 8       ClassLoader loggerFactoryClassLoader = LoggerFactory.class 9              .getClassLoader();
10       Enumeration<URL> paths;
11if (loggerFactoryClassLoader == null) {
12         paths = ClassLoader.getSystemResources(STATIC_LOGGER_BINDER_PATH);
13       } else {
14         paths = loggerFactoryClassLoader
15                .getResources(STATIC_LOGGER_BINDER_PATH);
16      }
17while (paths.hasMoreElements()) {
18         URL path = (URL) paths.nextElement();
19        staticLoggerBinderPathSet.add(path);
20      }
21     } catch (IOException ioe) {
22       Util.report("Error getting resources from path", ioe);
23    }
24return staticLoggerBinderPathSet;
25   }