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

List<ConfigSource> discoverSources() {
    List<ConfigSource> discoveredSources = new ArrayList<>();
    ServiceLoader<ConfigSource> configSourceLoader = ServiceLoader.load(ConfigSource.class, classLoader);
    configSourceLoader.forEach(discoveredSources::add);

    // load all ConfigSources from ConfigSourceProviders
    ServiceLoader<ConfigSourceProvider> configSourceProviderLoader = ServiceLoader.load(ConfigSourceProvider.class,
            classLoader);
    configSourceProviderLoader.forEach(configSourceProvider -> configSourceProvider.getConfigSources(classLoader)
            .forEach(discoveredSources::add));

    ServiceLoader<ConfigSourceFactory> configSourceFactoryLoader = ServiceLoader.load(ConfigSourceFactory.class,
            classLoader);
    configSourceFactoryLoader.forEach(factory -> discoveredSources.add(new ConfigurableConfigSource(factory)));

    return discoveredSources;
}
 

/**
 * Snippet registry for a given language id.
 * 
 * @param languageId  the language id and null otherwise.
 * @param loadDefault true if default snippets from SPI must be loaded and false
 *                    otherwise.
 */
public SnippetRegistry(String languageId, boolean loadDefault) {
	snippets = new ArrayList<>();
	// Load snippets from SPI
	if (loadDefault) {
		ServiceLoader<ISnippetRegistryLoader> loaders = ServiceLoader.load(ISnippetRegistryLoader.class);
		loaders.forEach(loader -> {
			if (Objects.equals(languageId, loader.getLanguageId())) {
				try {
					loader.load(this);
				} catch (Exception e) {
					LOGGER.log(Level.SEVERE, "Error while consumming snippet loader " + loader.getClass().getName(),
							e);
				}
			}
		});
	}
}
 

private void loadDetectorsAndScanners() {
    if (detectorsLoaded) {
        return;
    }

    ServiceLoader<FractionDetector> detectorLoader = ServiceLoader.load(FractionDetector.class);
    detectorLoader.forEach(d -> detectors.add(d));

    scanners.add(new WarScanner());
    scanners.add(new JarScanner());
    scanners.add(new ClassAndPackageScanner());
    scanners.add(new WebXmlDescriptorScanner());
    scanners.add(new FilePresenceScanner());

    ClassAndPackageScanner.classesPackagesAlreadyDetected.clear();

    detectorsLoaded = true;
}
 

/**
 * Finds all statically loadable bleaches
 *
 * @return ordered list of statically loadable bleaches
 */
private static Bleach[] getDefaultBleaches() {
  ServiceLoader<Bleach> services = ServiceLoader.load(Bleach.class);

  Collection<Bleach> list = new ArrayList<>();
  services.forEach(list::add);

  return list.toArray(new Bleach[0]);
}
 

public static List<ExchangeRateProvider> providers() {
    List<ExchangeRateProvider> services = new ArrayList<>();
    ServiceLoader<ExchangeRateProvider> loader = ServiceLoader.load(ExchangeRateProvider.class);
    loader.forEach(exchangeRateProvider -> {
        services.add(exchangeRateProvider);
    });
    return services;
}
 

public static List<Module> findModules() {
  // also search if classes are provided through service loader mechanism
  // It's useful when the scanning is disabled or ServletContainerInitializer is disabled.
  // onStartup may not be called at all so it's another way of plugging modules.
  ServiceLoader<ModuleFinder> moduleFinderServiceLoader = ServiceLoader.load(ModuleFinder.class);
  moduleFinderServiceLoader.forEach(moduleFinder -> modules.addAll(moduleFinder.getModules()));
  return new ArrayList<>(modules);
}
 

private static Gson createConverter() {
    final GsonBuilder builder = new GsonBuilder();
    final ServiceLoader<TypeAdapterFactory> serviceLoader =
        ServiceLoader.load(TypeAdapterFactory.class);

    serviceLoader.forEach(builder::registerTypeAdapterFactory);

    return builder.create();
}
 

@Override
public void load() {
    synchronized (registryLock) {
        // Find subsystems asking for initialization. 
        ServiceLoader<T> sl = 
            // Use this->classloader form : better for OSGi 
            ServiceLoader.load(classAtRuntime, this.getClass().getClassLoader()) ;
        sl.forEach(this::add) ;
    }
}
 

@Override
public <T> List<ExtensionWrapper<T>> find(Class<T> type) {
  Map<Class<?>, ExtensionWrapper<T>> extensions = new HashMap<>();

  ServiceLoader<T> serviceLoader = ServiceLoader.load(type);
  serviceLoader.forEach(extension -> addExtension(extensions, extension));

  for (PluginWrapper pluginWrapper : pluginManager.getPlugins()) {
    ServiceLoader<T> pluginServiceLoader =
        ServiceLoader.load(type, pluginWrapper.getPluginClassLoader());
    pluginServiceLoader.forEach(extension -> addExtension(extensions, extension));
  }

  return new ArrayList<>(extensions.values());
}
 

private synchronized void initialize() {

		if (initialized) {
			return;
		}

		ServiceLoader<IXMLExtension> extensions = ServiceLoader.load(IXMLExtension.class);
		extensions.forEach(extension -> {
			registerExtension(extension);
		});
		initialized = true;
	}
 

List<InterceptorWithPriority> discoverInterceptors() {
    List<InterceptorWithPriority> interceptors = new ArrayList<>();
    ServiceLoader<ConfigSourceInterceptor> interceptorLoader = ServiceLoader.load(ConfigSourceInterceptor.class,
            classLoader);
    interceptorLoader.forEach(interceptor -> interceptors.add(new InterceptorWithPriority(interceptor)));

    ServiceLoader<ConfigSourceInterceptorFactory> interceptorFactoryLoader = ServiceLoader
            .load(ConfigSourceInterceptorFactory.class, classLoader);
    interceptorFactoryLoader.forEach(interceptor -> interceptors.add(new InterceptorWithPriority(interceptor)));

    return interceptors;
}
 

public ExpressionEvaluatorProvider() {
    ServiceLoader<ExpressionEvaluator> foundExpressionEvaluators = ServiceLoader.load(ExpressionEvaluator.class);
    foundExpressionEvaluators.forEach(expressionEvaluator -> {
        expressionEvaluatorMap.put(expressionEvaluator.getName(),
                                   expressionEvaluator);
        logger.info("Found expression evaluator with name: " + expressionEvaluator.getName());
    });
}
 

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

private static ModelTransformer createWithServiceLoader(ServiceLoader<ModelTransformerPlugin> serviceLoader) {
    List<ModelTransformerPlugin> plugins = new ArrayList<>();
    serviceLoader.forEach(plugins::add);
    return createWithPlugins(plugins);
}
 

private void init() {
    ServiceLoader<ErrorInterpreter> loader = ServiceLoader.load(ErrorInterpreter.class);
    loader.forEach(i -> interpreters.add(i));
    interpreters = interpreters.stream().sorted(Comparator.comparingInt(ErrorInterpreter::order))
            .collect(toList());
}
 

private void init() {
    ServiceLoader<CommandInfo> loader = ServiceLoader.load(CommandInfo.class);
    loader.forEach(c -> commands.add(c));
    commands = commands.stream().sorted(Comparator.comparingInt(CommandInfo::order))
            .collect(toList());
}
 

@Override
public ConfigBuilder addDiscoveredConverters() {
    ServiceLoader<Converter> converters = ServiceLoader.load(Converter.class, loader);
    converters.forEach(converter -> config.addConverter(converter));
    return this;
}
 

@Test
void shouldLoadProvider() {
  ServiceLoader loader = ServiceLoader.load(KubernetesResourceMappingProvider.class);
  loader.forEach(l -> System.out.println("Found loader:" + l ));
}
 

public UriTransportRegistry(ServiceLoader<UriHandler> services) {
  handlers = new ArrayList<>();
  services.forEach(handlers::add);
}
 

/**
 * Loads structure definitions for supported profiles.
 */
private static void loadProfiles(FhirContext context) {

  ServiceLoader<ProfileProvider> loader = ServiceLoader.load(ProfileProvider.class);

  loader.forEach(provider ->
      provider.loadStructureDefinitions(context));

}