Java ServiceLoader.iterator方法代码示例

import java.util.ServiceLoader; //导入方法依赖的package包/类
private static AsynchronousChannelProvider loadProviderAsService() {
    ServiceLoader<AsynchronousChannelProvider> sl =
        ServiceLoader.load(AsynchronousChannelProvider.class,
                           ClassLoader.getSystemClassLoader());
    Iterator<AsynchronousChannelProvider> i = sl.iterator();
    for (;;) {
        try {
            return (i.hasNext()) ? i.next() : null;
        } catch (ServiceConfigurationError sce) {
            if (sce.getCause() instanceof SecurityException) {
                // Ignore the security exception, try the next provider
                continue;
            }
            throw sce;
        }
    }
}
 

import java.util.ServiceLoader; //导入方法依赖的package包/类
private static boolean loadProviderAsService() {

        ServiceLoader<SelectorProvider> sl =
            ServiceLoader.load(SelectorProvider.class,
                               ClassLoader.getSystemClassLoader());
        Iterator<SelectorProvider> i = sl.iterator();
        for (;;) {
            try {
                if (!i.hasNext())
                    return false;
                provider = i.next();
                return true;
            } catch (ServiceConfigurationError sce) {
                if (sce.getCause() instanceof SecurityException) {
                    // Ignore the security exception, try the next provider
                    continue;
                }
                throw sce;
            }
        }
    }
 

import java.util.ServiceLoader; //导入方法依赖的package包/类
/**
 * Initialize a specific type
 * 
 * @param type
 *            the initializer specific type, see
 *            {@link Initializer#initialize(Object)}
 * @param classloader
 *            a specific class loader to use
 */
public static void initialize ( final Object type, final ClassLoader classloader )
{
    logger.debug ( "Initializing: {}", type );

    final ServiceLoader<Initializer> loader = ServiceLoader.load ( Initializer.class, classloader );
    final Iterator<Initializer> i = loader.iterator ();
    while ( i.hasNext () )
    {
        final Initializer initializer = i.next ();
        logger.debug ( "Processing: {}", initializer );

        try
        {
            initializer.initialize ( type );
        }
        catch ( final Exception e )
        {
            logger.info ( "Failed to initialize", e );
        }
    }
}
 

import java.util.ServiceLoader; //导入方法依赖的package包/类
@Test
public void test() {
	ServiceLoader<ClientModuleFactory> loader = ServiceLoader.load(ClientModuleFactory.class);
	Iterator<ClientModuleFactory> iterator = loader.iterator();

	Set<Class> moduleClasses = new HashSet<>();
	while (iterator.hasNext()) {
		ClientModuleFactory moduleFactory = iterator.next();
		Module module = moduleFactory.create();
		moduleClasses.add(module.getClass());
	}

	Assert.assertEquals(2, moduleClasses.size());
	Assert.assertTrue(moduleClasses.contains(ValidationModule.class));
	Assert.assertTrue(moduleClasses.contains(MetaModule.class));
}
 

import java.util.ServiceLoader; //导入方法依赖的package包/类
@Test(expectedExceptions = { ConcurrentModificationException.class })
public void testIteratorNext() {
    ServiceLoader<ScriptEngineFactory> sl = load(ScriptEngineFactory.class);
    Iterator<ScriptEngineFactory> iterator = sl.iterator();
    assertTrue(iterator.hasNext());
    sl.reload();
    iterator.next();
}
 

import java.util.ServiceLoader; //导入方法依赖的package包/类
public static BookService getInstance(){
	ServiceLoader<BookServiceProvider> sl
           = ServiceLoader.load(BookServiceProvider.class);
       Iterator<BookServiceProvider> iter = sl.iterator();
       if (!iter.hasNext())
           throw new RuntimeException("No service providers found!");
       BookServiceProvider provider = null;
       while(iter.hasNext()){
       	provider = iter.next();
       	System.out.println(provider.getClass());
       }
       return provider.getBookService();
}
 

import java.util.ServiceLoader; //导入方法依赖的package包/类
@Test
public void testSequentialUse1() {
    ServiceLoader<S> sl = ServiceLoader.load(S.class, testClassLoader);

    Iterator<S> iterator1 = sl.iterator();
    iterator1.next();
    iterator1.next();
    assertFalse(iterator1.hasNext());

    Iterator<S> iterator2 = sl.iterator();
    iterator2.next();
    iterator2.next();
    assertFalse(iterator2.hasNext());
}
 

import java.util.ServiceLoader; //导入方法依赖的package包/类
@Test
public void validateServiceIsLocatableViaServiceLoader() {
    ServiceLoader<ControllerService> loader = ServiceLoader.<ControllerService> load(ControllerService.class);
    Iterator<ControllerService> iter = loader.iterator();
    boolean present = false;
    while (iter.hasNext()) {
        ControllerService cs = iter.next();
        assertTrue(cs instanceof JMSConnectionFactoryProviderDefinition);
        present = true;
    }
    assertTrue(present);
}
 

import java.util.ServiceLoader; //导入方法依赖的package包/类
public static <S> S loadFirst(Class<S> clazz) {
    final ServiceLoader<S> loader = loadAll(clazz);
    final Iterator<S> iterator = loader.iterator();
    if (!iterator.hasNext()) {
        throw new IllegalStateException(String.format(
                "No implementation defined in /META-INF/services/%s, please check whether the file exists and has the right implementation class!",
                clazz.getName()));
    }
    return iterator.next();
}
 

import java.util.ServiceLoader; //导入方法依赖的package包/类
@Override
public ServiceDiscovery getInstance() {
	ServiceLoader<ServiceDiscovery> loader = ServiceLoader.load(ServiceDiscovery.class);
	Iterator<ServiceDiscovery> iterator = loader.iterator();
	if (iterator.hasNext()) {
		ServiceDiscovery discovery = iterator.next();
		PreconditionUtil.assertFalse("expected unique ServiceDiscovery implementation, got: " + loader, iterator.hasNext());
		return discovery;
	}
	return null;
}
 

import java.util.ServiceLoader; //导入方法依赖的package包/类
@Test
public void test() {
	ServiceLoader<ClientModuleFactory> loader = ServiceLoader.load(ClientModuleFactory.class);
	Iterator<ClientModuleFactory> iterator = loader.iterator();
	Assert.assertTrue(iterator.hasNext());
	ClientModuleFactory moduleFactory = iterator.next();
	Assert.assertFalse(iterator.hasNext());
	Module module = moduleFactory.create();
	Assert.assertTrue(module instanceof MetaModule);
}
 

import java.util.ServiceLoader; //导入方法依赖的package包/类
public static ReportWriter getInstance() {
    ServiceLoader<ReportWriter> loader = ServiceLoader.load(ReportWriter.class);
    final Iterator<ReportWriter> it = loader.iterator();
    final ReportWriter server;
    if (!it.hasNext()) {
        throw new RuntimeException("No ReportWriter in classpath");
    } else {
        server = it.next();
    }
    if (it.hasNext()) {
        LoggerFactory.getLogger(ReportWriter.class).warn("Multiple bindings for ReportWriter found: {}", loader.iterator());
    }
    return server;
}
 

import java.util.ServiceLoader; //导入方法依赖的package包/类
public static void loadAdditionalSuits(List<PluginProvider> providers) {

        ServiceLoader<PluginProvider> serviceLoader = ServiceLoader
                .load(PluginProvider.class);

        Iterator<PluginProvider> iterator = serviceLoader.iterator();

        while (iterator.hasNext()) {
            PluginProvider provider = iterator.next();
            providers.add(provider);
        }
    }
 

import java.util.ServiceLoader; //导入方法依赖的package包/类
public static HttpServer create(int port) {
    ServiceLoader<HttpServerProvider> sl
        = ServiceLoader.load(HttpServerProvider.class);
    Iterator<HttpServerProvider> iterator = sl.iterator();
    if (iterator.hasNext()) {
        HttpServerProvider provider = iterator.next();
        return provider.createHttpServer(port);
    } else {
        return new HttpServer(port) { };
    }
}
 

import java.util.ServiceLoader; //导入方法依赖的package包/类
private void determineCompilerOrThrow()
{
	final String preferedCompiler = getProperty("preferedCompiler");
	LinkedList<JavaCompiler> allCompilers = null;
	
	JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
	if (compiler != null)
	{
		if ((preferedCompiler == null) || compiler.getClass().getName().equals(preferedCompiler))
		{
			_compiler = compiler;
			return;
		}
		
		allCompilers = new LinkedList<>();
		allCompilers.add(compiler);
	}
	
	final ServiceLoader<JavaCompiler> thirdPartyCompilers = ServiceLoader.load(JavaCompiler.class);
	Iterator<JavaCompiler> compilersIterator = thirdPartyCompilers.iterator();
	while (compilersIterator.hasNext())
	{
		compiler = compilersIterator.next();
		if ((preferedCompiler == null) || compiler.getClass().getName().equals(preferedCompiler))
		{
			_compiler = compiler;
			return;
		}
		
		if (allCompilers == null)
		{
			allCompilers = new LinkedList<>();
		}
		allCompilers.add(compilersIterator.next());
	}
	
	if (allCompilers != null)
	{
		compilersIterator = allCompilers.iterator();
		while (compilersIterator.hasNext())
		{
			compiler = compilersIterator.next();
			if ((preferedCompiler == null) || compiler.getClass().getName().equals(preferedCompiler))
			{
				break;
			}
		}
	}
	
	if (compiler == null)
	{
		throw new IllegalStateException("No javax.tools.JavaCompiler service installed!");
	}
	
	_compiler = compiler;
}