Question

给出以下结构：

public static class Base { }

public static class Base2 extends Base { }

@FunctionalInterface
public interface BaseLoader<T extends Base> {
    void load(T base);
}

还有一个服务，该服务根据其通用类型参数映射BaseLoader对象：

public static class Service {

    private Map<Class<?>, BaseLoader<?>> map = new HashMap<>();

    public <T extends Base> void save(BaseLoader<T> loader, Class<T> type) {
        map.put(type, loader);
    }

    public <T extends Base> BaseLoader<T> getLoader(Class<T> type) {
        return (BaseLoader<T>) map.get(type);
    }

    public BaseLoader<Base> getLoaderUpper(Class<? extends Base> type) {
        return (BaseLoader<Base>) map.get(type); // not typesafe
    }
}

现在，我希望能够在数据库中查询Base对象的列表，然后根据对象所属的实际类来调用加载程序。单个对象现在应该做：

public static void main(String[] args) {
    Base b = new Base2();

    BaseLoader<Base2> loader = base -> System.out.println(base.getClass());

    Service service = new Service();
    service.save(loader, Base2.class);

    BaseLoader<Base> loader2 = service.getLoaderUpper(b.getClass());
    loader2.load(b); 
}

这有效，但是getLoaderUpper涉及一个确实不安全的强制转换。相反，使用getLoader，我将无法将Base对象传递给它。有解决办法吗？

具有泛型参数的类型安全的异构容器

0 个答案: