## slf4j/slf4j-api/src/main/java/org/slf4j/LoggerFactory.java:116-138
116:     static List<SLF4JServiceProvider> findServiceProviders() {
117:         List<SLF4JServiceProvider> providerList = new ArrayList<>();
118: 
119:         // retain behaviour similar to that of 1.7 series and earlier. More specifically, use the class loader that
120:         // loaded the present class to search for services
121:         final ClassLoader classLoaderOfLoggerFactory = LoggerFactory.class.getClassLoader();
122: 
123:         SLF4JServiceProvider explicitProvider = loadExplicitlySpecified(classLoaderOfLoggerFactory);
124:         if(explicitProvider != null) {
125:             providerList.add(explicitProvider);
126:             return providerList;
127:         }
128: 
129: 
130:          ServiceLoader<SLF4JServiceProvider> serviceLoader = getServiceLoader(classLoaderOfLoggerFactory);
131: 
132:         Iterator<SLF4JServiceProvider> iterator = serviceLoader.iterator();
133:         while (iterator.hasNext()) {
134:             safelyInstantiate(providerList, iterator);
135:         }
136:         return providerList;
137:     }
138: 

## slf4j/slf4j-api/src/main/java/org/slf4j/LoggerFactory.java:193-213
193:     private final static void bind() {
194:         try {
195:             List<SLF4JServiceProvider> providersList = findServiceProviders();
196:             reportMultipleBindingAmbiguity(providersList);
197:             if (providersList != null && !providersList.isEmpty()) {
198:                 PROVIDER = providersList.get(0);
199:                 earlyBindMDCAdapter();
200:                 // SLF4JServiceProvider.initialize() is intended to be called here and nowhere else.
201:                 PROVIDER.initialize();
202:                 INITIALIZATION_STATE = SUCCESSFUL_INITIALIZATION;
203:                 reportActualBinding(providersList);
204:             } else {
205:                 INITIALIZATION_STATE = NOP_FALLBACK_INITIALIZATION;
206:                 Reporter.warn("No SLF4J providers were found.");
207:                 Reporter.warn("Defaulting to no-operation (NOP) logger implementation");
208:                 Reporter.warn("See " + NO_PROVIDERS_URL + " for further details.");
209: 
210:                 Set<URL> staticLoggerBinderPathSet = findPossibleStaticLoggerBinderPathSet();
211:                 reportIgnoredStaticLoggerBinders(staticLoggerBinderPathSet);
212:             }
213:             postBindCleanUp();

## slf4j/slf4j-api/src/main/java/org/slf4j/LoggerFactory.java:410-434
410:      * on the class path. No reporting is done otherwise.
411:      *
412:      */
413:     private static void reportMultipleBindingAmbiguity(List<SLF4JServiceProvider> providerList) {
414:         if (isAmbiguousProviderList(providerList)) {
415:             Reporter.warn("Class path contains multiple SLF4J providers.");
416:             for (SLF4JServiceProvider provider : providerList) {
417:                 Reporter.warn("Found provider [" + provider + "]");
418:             }
419:             Reporter.warn("See " + MULTIPLE_BINDINGS_URL + " for an explanation.");
420:         }
421:     }
422: 
423:     private static void reportActualBinding(List<SLF4JServiceProvider> providerList) {
424:         // impossible since a provider has been found
425:         if (providerList.isEmpty()) {
426:             throw new IllegalStateException("No providers were found which is impossible after successful initialization.");
427:         }
428: 
429:         if (isAmbiguousProviderList(providerList)) {
430:             Reporter.info("Actual provider is of type [" + providerList.get(0) + "]");
431:         } else {
432:             SLF4JServiceProvider provider = providerList.get(0);
433:             Reporter.debug(CONNECTED_WITH_MSG + provider.getClass().getName() + "]");
434:         }

## slf4j/slf4j-api/src/main/java/org/slf4j/spi/NOPLoggingEventBuilder.java:35-61
35: 
36:     @Override
37:     public LoggingEventBuilder addMarker(Marker marker) {
38:         return singleton();
39:     }
40: 
41:     @Override
42:     public LoggingEventBuilder addArgument(Object p) {
43:         return singleton();
44:     }
45: 
46:     @Override
47:     public LoggingEventBuilder addArgument(Supplier<?> objectSupplier) {
48:         return singleton();
49:     }
50: 
51:     @Override
52:     public LoggingEventBuilder addKeyValue(String key, Object value) {
53:         return singleton();
54:     }
55: 
56:     @Override
57:     public LoggingEventBuilder addKeyValue(String key, Supplier<Object> value) {
58:         return singleton();
59:     }
60: 
61:     @Override

## slf4j/slf4j-jdk14/src/main/java/org/slf4j/jul/JULServiceProvider.java:15-46
15:      */
16:     // to avoid constant folding by the compiler, this field must *not* be final
17:     public static String REQUESTED_API_VERSION = "2.0.99"; // !final
18: 
19:     private ILoggerFactory loggerFactory;
20:     // LoggerFactory expects providers to initialize markerFactory as early as possible.
21:     private final IMarkerFactory markerFactory;
22:     // LoggerFactory expects providers to initialize their MDCAdapter field
23:     // as early as possible, preferably at construction time.
24:     private final MDCAdapter mdcAdapter;
25: 
26:     public JULServiceProvider() {
27:         markerFactory = new BasicMarkerFactory();
28:         mdcAdapter = new BasicMDCAdapter();
29:     }
30: 
31:     @Override
32:     public ILoggerFactory getLoggerFactory() {
33:         return loggerFactory;
34:     }
35: 
36:     @Override
37:     public IMarkerFactory getMarkerFactory() {
38:         return markerFactory;
39:     }
40: 
41:     public MDCAdapter getMDCAdapter() {
42:         return mdcAdapter;
43:     }
44: 
45:     @Override
46:     public String getRequestedApiVersion() {

## slf4j/slf4j-api/src/test/java/org/slf4j/LoggerFactoryTest.java:35-65
35:     public void testExplicitlySpecified() {
36:         System.setProperty(LoggerFactory.PROVIDER_PROPERTY_KEY, "org.slf4j.LoggerFactoryTest$TestingProvider");
37:         SLF4JServiceProvider provider = LoggerFactory.loadExplicitlySpecified(classLoaderOfLoggerFactory);
38:         assertTrue("provider should be instance of TestingProvider class", provider instanceof  TestingProvider);
39:         assertTrue(mockedSyserr.toString().contains(" Attempting to load provider \"org.slf4j.LoggerFactoryTest$TestingProvider\" specified via \"slf4j.provider\" system property"));
40:         System.out.println(mockedSyserr.toString());
41: 
42: 
43:     }
44: 
45:     @Test
46:     public void testExplicitlySpecifiedNull() {
47:         assertNull(LoggerFactory.loadExplicitlySpecified(classLoaderOfLoggerFactory));
48:     }
49: 
50:     @Test
51:     public void testExplicitlySpecifyMissingServiceProvider() {
52:         System.setProperty(LoggerFactory.PROVIDER_PROPERTY_KEY, "com.example.ServiceProvider");
53:         SLF4JServiceProvider provider = LoggerFactory.loadExplicitlySpecified(classLoaderOfLoggerFactory);
54:         assertNull(provider);
55:         assertTrue(mockedSyserr.toString().contains("Failed to instantiate the specified SLF4JServiceProvider (com.example.ServiceProvider)"));
56:     }
57: 
58:     @Test
59:     public void testExplicitlySpecifyNonServiceProvider() {
60:         System.setProperty(LoggerFactory.PROVIDER_PROPERTY_KEY, "java.lang.String");
61:         assertNull(LoggerFactory.loadExplicitlySpecified(classLoaderOfLoggerFactory));
62:         assertTrue(mockedSyserr.toString().contains("Specified SLF4JServiceProvider (java.lang.String) does not implement SLF4JServiceProvider interface"));
63:     }
64: 
65:     public static class TestingProvider implements SLF4JServiceProvider {
