Java Code Examples for java.util.ServiceLoader#load()

public static DeviceInputOutput createInstance(AppProperties props) {

        ServiceLoader<InputOutputInterface> pluLoader = ServiceLoader.load(InputOutputInterface.class);

        DeviceInputOutput m_plu = new DeviceInputOutputNull();

        for (InputOutputInterface machineInterface : pluLoader) {
            try {
                m_plu = machineInterface.getDeviceIO(props.getProperty("machine.pludevice"));
            } catch (Exception ex) {
                logger.log(Level.WARNING, ex.getMessage(), ex);
            }
        }

        return m_plu;
    }
 

private static OASFactoryResolver loadSpi(ClassLoader cl) {
    if (cl == null) {
        return null;
    }

    OASFactoryResolver instance = loadSpi(cl.getParent());

    if (instance == null) {
        ServiceLoader<OASFactoryResolver> sl = ServiceLoader.load(OASFactoryResolver.class, cl);
        for (OASFactoryResolver spi : sl) {
            if (instance != null) {
                throw new IllegalStateException("Multiple OASFactoryResolver implementations found: " + spi.getClass().getName() + " and "
                        + instance.getClass().getName());
            }
            else {
                instance = spi;
            }
        }
    }
    return instance;
}
 

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;
        }
    }
}
 

/**
 * Loads a security provider as a service.
 *
 * @param provName the name
 * @param arg optional arg
 * @throws IllegalArgumentException if no provider matches the name
 */
public static void loadProviderByName(String provName, String arg) {
    Provider loaded = Security.getProvider(provName);
    if (loaded != null) {
        if (arg != null) {
            loaded = loaded.configure(arg);
            Security.addProvider(loaded);
        }
        return;
    }
    for (Provider p : ServiceLoader.load(Provider.class,
            ClassLoader.getSystemClassLoader())) {
        if (p.getName().equals(provName)) {
            if (arg != null) {
                p = p.configure(arg);
            }
            Security.addProvider(p);
            return;
        }
    }
    throw new IllegalArgumentException("No provider found");
}
 

private synchronized Map<String, Landsat8BandConverterSpi> getRegisteredConverters() {
  if (registeredBandConverters == null) {
    registeredBandConverters = new HashMap<>();
    final ServiceLoader<Landsat8BandConverterSpi> converters =
        ServiceLoader.load(Landsat8BandConverterSpi.class);
    final Iterator<Landsat8BandConverterSpi> it = converters.iterator();
    while (it.hasNext()) {
      final Landsat8BandConverterSpi converter = it.next();
      registeredBandConverters.put(converter.getName(), converter);
    }
  }
  return registeredBandConverters;
}
 

private static void testFactory(String scheme) {
	ServiceLoader<FileSystemFactory> serviceLoader = ServiceLoader.load(FileSystemFactory.class);
	for (FileSystemFactory fs : serviceLoader) {
		if (scheme.equals(fs.getScheme())) {
			// found the matching scheme
			return;
		}
	}

	fail("No factory available for scheme " + scheme);
}
 

/**
 * Returns the available chronologies.
 * <p>
 * Each returned {@code Chronology} is available for use in the system.
 * The set of chronologies includes the system chronologies and
 * any chronologies provided by the application via ServiceLoader
 * configuration.
 *
 * @return the independent, modifiable set of the available chronology IDs, not null
 */
static Set<Chronology> getAvailableChronologies() {
    initCache();       // force initialization
    HashSet<Chronology> chronos = new HashSet<>(CHRONOS_BY_ID.values());

    /// Add in Chronologies from the ServiceLoader configuration
    @SuppressWarnings("rawtypes")
    ServiceLoader<Chronology> loader = ServiceLoader.load(Chronology.class);
    for (Chronology chrono : loader) {
        chronos.add(chrono);
    }
    return chronos;
}
 

@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;
}
 

public static AuthorizationFactory newAuthorizationFactory(){
    ServiceLoader<AuthorizationFactory> factoryService = ServiceLoader.load(AuthorizationFactory.class);
    Iterator<AuthorizationFactory> iter = factoryService.iterator();
    if(!iter.hasNext())
        throw new IllegalStateException("No AuthorizationFactory service found!");
    AuthorizationFactory af = null;
    AuthorizationFactory currentAF = null;
    while (iter.hasNext()) {
        currentAF = (AuthorizationFactory) iter.next();
        if (af == null || af.getPriority() < currentAF.getPriority())
            af = currentAF;
    }
    return af;
}
 

public synchronized static AbstractAnnotationHandler handlerFor(Annotation annotation) {
	if (handlers == null) {
		 handlers = new HashMap<Class<?>, AbstractAnnotationHandler>();
		 ServiceLoader<AbstractAnnotationHandler> loader = ServiceLoader.load(AbstractAnnotationHandler.class);
		 for (AbstractAnnotationHandler handler : loader) {
			 handlers.put(handler.getAnnotationType(), handler);
		 }
	}
	return handlers.get(annotation.annotationType());
}
 

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();
}
 

public CounterServiceAsyncClient() {
  this.serviceName = "com.github.dapeng.basic.api.counter.service.CounterService";
  this.version = "1.0.0";

  ServiceLoader<SoaConnectionPoolFactory> factories = ServiceLoader.load(SoaConnectionPoolFactory.class,getClass().getClassLoader());
  this.pool = factories.iterator().next().getPool();
  this.clientInfo = this.pool.registerClientInfo(serviceName,version);
}
 

/**
 * Description: <br>
 * 
 * @author 王伟<br>
 * @taskId <br>
 * @param flowName
 * @return <br>
 */
private static FlowConfig match(final String flowName) {
    if (serviceLoader == null) {
        serviceLoader = ServiceLoader.load(FlowLoader.class);
    }

    FlowConfig flowConfig = null;
    for (FlowLoader flowLoader : serviceLoader) {
        flowConfig = flowLoader.load(flowName);
        if (flowConfig != null) {
            break;
        }
    }
    return flowConfig;
}
 

private static Map<String, CloudObjectTranslator<? extends Coder>>
    populateCloudObjectTranslators() {
  ImmutableMap.Builder<String, CloudObjectTranslator<? extends Coder>> builder =
      ImmutableMap.builder();
  for (CoderCloudObjectTranslatorRegistrar coderRegistrar :
      ServiceLoader.load(CoderCloudObjectTranslatorRegistrar.class)) {
    builder.putAll(coderRegistrar.classNamesToTranslators());
  }
  return builder.build();
}
 

private static List<ProcessDataEventListenerProvider> collectProviders() {
    ServiceLoader<ProcessDataEventListenerProvider> availableProviders = ServiceLoader.load(ProcessDataEventListenerProvider.class);
    List<ProcessDataEventListenerProvider> collected = new ArrayList<ProcessDataEventListenerProvider>();
    try {
        for (ProcessDataEventListenerProvider provider : availableProviders) {
            collected.add(provider);
        }
    } catch (Throwable e) {
        logger.debug("Unable to collect process data event listeners due to {}", e.getMessage());
    }
    return collected;
}
 

@Test
public void sayHello() {
    ServiceLoader<Robot> serviceLoader = ServiceLoader.load(Robot.class);
    System.out.println("Java SPI");
    serviceLoader.forEach(Robot::sayHello);
}
 

@SuppressWarnings("unchecked")
public static Iterator loadProviders(Class clazz) {
    ServiceLoader sl = ServiceLoader.load(clazz);
    return sl.iterator();
}
 

@Override
public <S> Iterable<S> services(Class<S> serviceInterface) {

    return ServiceLoader.load(serviceInterface, serviceInterface.getClassLoader());

}
 

void run() { ServiceLoader.load(null); } 

void run() { ServiceLoader.load(null, NPE.class.getClassLoader()); }