通过 java.util.ServiceLoader 加载通用服务实现

Question

前几天我在使用 java.util.ServiceLoader 时偶然发现了一些不便，并在我心中形成了一些问题。

假设我有一个通用服务：

public interface Service<T> { ... }

我无法明确告诉 ServiceLoader 仅加载具有特定通用类型的实现。

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

我的问题是：使用 ServiceLoader 安全加载通用服务的实现有哪些合理的方法？

---

在提出上述问题之后，在 Paŭlo 回答之前，我已经想出了一个解决方案。

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!");
    }

将 boolean canServe(Class t) 更改为 boolean canServe(Object o) 并更改 ;服务getService(Class t) 以同样的方式可以更加动态（我自己使用后者，因为我有一个方法 boolean canHandle(T t) ）开头的界面。）

Answer 1

这里的问题是服务加载器正在使用一个列出给定类/接口的所有实现的文件，该文件由接口名称命名。没有预见到将类型参数放入此文件名中，并且实际上也不可能将泛型类型作为 Class 对象传递。

因此，您在这里只能获取任何类型的通用服务，然后检查它们的类对象以查看它是否是 Service 的子类型。

像这样的东西：

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

}

这没有经过测试，可能需要扩展以搜索由我们的类直接实现的接口扩展的接口，以及由我们的（通用）超类实现的接口。

当然，这只能找到类似于

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

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

Example可能是服务的有效实现的类。

Answer 2

您还可以只复制 ServiceLoader 类文件并从 load() 方法中删除泛型类型参数，使其始终有效。您只需要忽略这些警告即可。

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