Cache ServiceLoader-calls without result

Iterating over the ServiceLoader results in class- and resource-loading, which becomes expensive if done extensively.
A common pattern used (in e.g. "com.sun.xml.ws.api.pipe.TransportTubeFactory::create") is to search first for multiple factory-implementations before falling back to a "default" factory / implementation:
  public Type exampleFunc(...) {
    for (_ : ServiceFinder.find(FactoryType1.class) { return if FactoryType1-impl found }
    for (_ : ServiceFinder.find(FactoryType2.class) { return if FactoryType2-impl found }
    return DEFAULT_FACTORY.createType(..);
  }
If there are no other implementations present besides the default-fallback-implementation, then each call to a method with this structure starts searching (again) for all non-default implementations - only to not find any implementing classes and finally falling back to the default-implementation.
Invoking such method-structures often, results in multiple unnecessary ServiceLoader-calls, because if the corresponding service-class and classloader are identical to a previous call and for this previous call the classloader was not able to determine the service-implementation, then it still won't be able to find it when retrying the ServiceLoader-call with the same parameters.

jaxws-ri/runtime/rt/src/main/java/com/sun/xml/ws/util/ServiceClassLoaderCacheKey.java

@@ -0,0 +1,34 @@
+package com.sun.xml.ws.util;
+
+import java.util.Objects;
+
+public class ServiceClassLoaderCacheKey<T> {
+  private final Class<T> service;
+  private final ClassLoader loader;
+
+  public ServiceClassLoaderCacheKey(Class<T> service, ClassLoader loader) {
+    this.service = service;
+    this.loader = loader;
+  }
+
+  public Class<T> getService() {
+    return service;
+  }
+
+  public ClassLoader getLoader() {
+    return loader;
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) return true;
+    if (!(o instanceof ServiceClassLoaderCacheKey)) return false;
+    ServiceClassLoaderCacheKey<?> that = (ServiceClassLoaderCacheKey<?>) o;
+    return Objects.equals(service, that.service) && Objects.equals(loader, that.loader);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(service, loader);
+  }
+}

jaxws-ri/runtime/rt/src/main/java/com/sun/xml/ws/util/ServiceFinder.java

@@ -10,6 +10,8 @@
 
 package com.sun.xml.ws.util;
 
+import com.google.common.cache.Cache;
+import com.google.common.cache.CacheBuilder;
 import com.sun.istack.NotNull;
 import com.sun.istack.Nullable;
 import com.sun.xml.ws.api.Component;
@@ -26,6 +28,7 @@
 import java.util.NoSuchElementException;
 import java.util.Objects;
 import java.util.ServiceLoader;
+import java.util.concurrent.TimeUnit;
 
 
 /**
@@ -116,22 +119,27 @@
 public final class ServiceFinder<T> implements Iterable<T> {
 
     private final @NotNull Class<T> serviceClass;
-    private final @NotNull ServiceLoader<T> serviceLoader;
+    private final @NotNull Iterable<T> serviceLoaderIterable;
     private final @Nullable ComponentEx component;
 
+    private static final Cache<ServiceClassLoaderCacheKey, Iterable> noResultServiceLoaderCache = CacheBuilder.newBuilder()
+        .maximumSize(100)
+        .expireAfterWrite(5, TimeUnit.MINUTES)
+        .build();
+
     public static <T> ServiceFinder<T> find(@NotNull Class<T> service, @Nullable ClassLoader loader, Component component) {
         ClassLoader cl = loader == null ? Thread.currentThread().getContextClassLoader() : loader;
-        return find(service, component, ServiceLoader.load(service, cl));
+        return find(service, component, retrieveServiceLoaderFromCacheOrCreateNew(service, cl));
     }
 
-    public static <T> ServiceFinder<T> find(@NotNull Class<T> service, Component component, @NotNull ServiceLoader<T> serviceLoader) {
+    public static <T> ServiceFinder<T> find(@NotNull Class<T> service, Component component, @NotNull Iterable<T> serviceLoaderIterable) {
         Class<T> svc = Objects.requireNonNull(service);
-        ServiceLoader<T> sl = Objects.requireNonNull(serviceLoader);
+        Iterable<T> sl = Objects.requireNonNull(serviceLoaderIterable);
         return new ServiceFinder<>(svc, component, sl);
     }
 
     public static <T> ServiceFinder<T> find(@NotNull Class<T> service, Component component) {
-        return find(service, component, ServiceLoader.load(service, Thread.currentThread().getContextClassLoader()));
+        return find(service, component, retrieveServiceLoaderFromCacheOrCreateNew(service, Thread.currentThread().getContextClassLoader()));
     }
 
     /**
@@ -184,17 +192,17 @@ public static <T> ServiceFinder<T> find(@NotNull Class<T> service, @Nullable Cla
      * @see #find(Class, ClassLoader)
      */
     public static <T> ServiceFinder<T> find(@NotNull Class<T> service) {
-        return find(service, ServiceLoader.load(service, Thread.currentThread().getContextClassLoader()));
+        return find(service, retrieveServiceLoaderFromCacheOrCreateNew(service, Thread.currentThread().getContextClassLoader()));
     }
 
-    public static <T> ServiceFinder<T> find(@NotNull Class<T> service, @NotNull ServiceLoader<T> serviceLoader) {
-        return find(service, ContainerResolver.getInstance().getContainer(), serviceLoader);
+    public static <T> ServiceFinder<T> find(@NotNull Class<T> service, @NotNull Iterable<T> serviceLoaderIterable) {
+        return find(service, ContainerResolver.getInstance().getContainer(), serviceLoaderIterable);
     }
 
-    private ServiceFinder(Class<T> service, Component component, ServiceLoader<T> serviceLoader) {
+    private ServiceFinder(Class<T> service, Component component, Iterable<T> serviceLoaderIterable) {
         this.serviceClass = service;
         this.component = getComponentEx(component);
-        this.serviceLoader = serviceLoader;
+        this.serviceLoaderIterable = serviceLoaderIterable;
     }
 
     /**
@@ -209,7 +217,7 @@ private ServiceFinder(Class<T> service, Component component, ServiceLoader<T> se
     @Override
     @SuppressWarnings("unchecked")
     public Iterator<T> iterator() {
-        Iterator<T> it = serviceLoader.iterator();
+        Iterator<T> it = serviceLoaderIterable.iterator();
         return component != null
                 ? new CompositeIterator<>(component.getIterableSPI(serviceClass).iterator(), it)
                 : it;
@@ -238,6 +246,20 @@ private static ComponentEx getComponentEx(Component component) {
         return component != null ? new ComponentExWrapper(component) : null;
     }
 
+    private static <T> Iterable<T> retrieveServiceLoaderFromCacheOrCreateNew(Class<T> service, ClassLoader cl) {
+        ServiceClassLoaderCacheKey<T> cacheKey = new ServiceClassLoaderCacheKey<>(service, cl);
+        Iterable<T> cachedServiceLoaderIterable = noResultServiceLoaderCache.getIfPresent(cacheKey);
+        if (cachedServiceLoaderIterable != null) {
+            return cachedServiceLoaderIterable;
+        }
+        ServiceLoader<T> serviceLoader = ServiceLoader.load(service, cl);
+        if (!serviceLoader.iterator().hasNext()) {
+            noResultServiceLoaderCache.put(cacheKey, Collections.emptyList());
+            return Collections.emptyList();
+        }
+        return serviceLoader;
+    }
+
     private static class ComponentExWrapper implements ComponentEx {
 
         private final Component component;