Type-safe heterogeneous container with generic parameter

Question

Given the following structure:

public static class Base { }

public static class Base2 extends Base { }

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

And a service, which maps BaseLoader objects dependent on their generic type parameter:

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

Now, i want to be able to query a database for a list of Base objects and then call a loader dependent on what actual class the object is of. A single object should do for now:

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

This works, but getLoaderUpper involves a truely unsafe cast. Using getLoader instead, i wont be able to pass Base objects to it. Any solution?