Cargando implementaciones de servicios genéricos a través de java.util.ServiceLoader

Question

He tropezado con algún inconveniente el otro día usando java.util.ServiceLoader y algunas preguntas formadas en mí.

Supongamos que tengo un servicio genérico:

public interface Service<T> { ... } 

No podría decir de manera explícita ServiceLoader para cargar sólo implementaciones con un tipo genérico específico.

ServiceLoader<Service<String>> services = 
    ServiceLoader.load(Service.class); // Fail. 

Mi pregunta es: ¿cuáles son formas razonables para utilizar ServiceLoader para cargar con seguridad puestas en práctica de un servicio genérico?

---

Después de hacer la pregunta anterior y antes de la respuesta de Paŭlo, he logrado encontrar una solución.

public interface Service<T> { ... 
    // true if an implementation can handle the given `t' type; false otherwise. 
    public boolean canHandle(Class<?> t) { ... 

public final class StringService implements Service<String> { ... 
    @Override public boolean canHandle(Class<?> t) { 
     if (String.class.isAssignableFrom(type)) 
      return true; 
     return false; 
    } 

public final class DoubleService implements Service<Double> { ... 
    // ... 

public final class Services { ... 
    public static <T> Service<T> getService(Class<?> t) { 
     for (Service<T> s : ServiceLoader.load(Service.class)) 
      if (s.canServe(t)) 
       return s; 
     throw new UnsupportedOperationException("No servings today my son!"); 
    } 

Cambio boolean canServe(Class<?> t)-boolean canServe(Object o) y también cambiando <T> Service<T> getService(Class<?> t) de la misma manera puede ser más dinámico (estoy usando esta última para mí, ya que tenía un método boolean canHandle(T t) en mi interfaz en el principio.)

Answer 1

El problema aquí es que el cargador de servicios está utilizando un archivo que enumera todas las implementaciones de una clase/interfaz determinada, el nombre del nombre de las interfaces. No estaba previsto colocar el parámetro tipo en este nombre de archivo, y tampoco es posible pasar tipos genéricos como objetos Class.

Por lo tanto, aquí solo puede obtener sus servicios genéricos de cualquier tipo, y luego inspeccionar su objeto de clase para ver si es un subtipo de Service<String>.

Algo como esto:

class Test{ 

    public Service<String> getStringService() { 
     // it is a bit strange that we can't explicitely construct a 
     // parametrized type from raw type and parameters, so here 
     // we use this workaround. This may need a dummy method or 
     // variable if this method should have another return type. 
     ParametrizedType stringServiceType = 
      (ParametrizedType)Test.class.getMethod("getStringService").getGenericReturnType(); 

     ServiceLoader<Service<?>> loader = ServiceLoader.load(Service<?>.class); 
     for(Service<?> service : loader) { 
      if(isImplementing(service.getClass(), stringServiceType)) { 
       @SuppressWarnings("unchecked") 
       Service<String> s = (Service)service; 
       return s; 
      } 
     } 
    } 

    public boolean isImplementing(Class<?> candidate, ParametrizedType t) { 
     for(Type iFace : candidate.getGenericInterfaces()) { 
      if(iFace.equals(t)) { 
       return true; 
      } 
      if(iFace instanceof ParametrizedType && 
       ((ParametrizedType)iFace).getRawType().equals(t.getRawType())) { 
       return false; 
      } 
     } 
     return false; 
    } 

} 

Esto no se ha probado, y puede ser necesario extender a buscar también las interfaces extendidas por las interfaces de nuestra clase implementa directamente, e interfaces implementadas por nuestra superclase (genérico).

Y, por supuesto, esto sólo puede encontrar clases como

class Example implements Service<String> { ...} 

no

algo así como

class Example<X> implements Service<X> { ... } 

donde Example<String> podría ser una aplicación válida de su servicio.

Answer 2

También podría simplemente copiar el archivo de clase ServiceLoader y eliminar el argumento de tipo genérico del método load(), haciendo que siempre funcione. Solo tendrá que anular las advertencias.

public static <S> ServiceLoader load(final Class<S> service) 
    { 
     return load(service, Thread.currentThread().getContextClassLoader()); 
    }