Как заставить работать эту систему вложенных общих параметров?

Вы пытаетесь использовать дженерики во время выполнения. Если во время компиляции вы не знаете, какие типы вам нужно обрабатывать (будь то реальный тип или сам параметр типа), вы не можете использовать дженерики, просто и понятно. Это только время компиляции (или в основном) конструкция.

Здесь вы пытаетесь обрабатывать вещи как в общем, так и в динамике. Это вообще невозможно. Используйте необработанные типы и живите с небезопасностью типов.

Сам я бы сказал, что вы просто напрашиваетесь на неприятности с этим:

abstract class RuleHandler<T extends Rule>
{
  abstract void doStuff(T rule);
}

Просто сделайте это:

abstract class RuleHandler
{
  abstract void doStuff(Rule rule);
}

И затем зарегистрируйте этот обработчик правил только с типами, которые он может обрабатывать.

Редактировать

Судя по вашему комментарию, ваша цель — навязать свой дизайн пользователям вашего интерфейса. Я поддерживаю аргумент о том, что вы должны разделить концепцию фильтрации и обработки.

Тем не менее, другой вариант — оставить токен класса вне самого обработчика и сгенерировать метод регистрации.

interface RuleHandler<T extends Rule> {
    void doStuff(T rule);
}

//...

public <T> void register(Class<T> type, RuleHandler<? super T> handler) {
   map.put(type, handler);
}

public void process() {
   for ( Rule r : rules ) {
       for(Map.Entry<Class<?>, RuleHandler<?>> entry : map.entrySet() ) {
           if ( entry.getKey().instanceOf(r) ) {
               @SuppressWarnings("unchecked")
               ((RuleHandler)entry.getValue()).doStuff(r);
           }
       }
   }
}

Здесь мы подавляем предупреждение при использовании необработанного типа RuleHandler. Мы знаем, что это безопасно, только проверив доступ к map и увидев, что класс всегда соответствует параметру типа RuleHandler. Однако это, очевидно, будет безопасным только в том случае, если для клиента не было предупреждений о безопасности типов при вызове register() (т. е. они параметризовали вызов register()).

(Внутренний цикл for был добавлен поверх get, чтобы можно было найти обработчик для подклассов заданных подклассов Rule)

Вы не можете избежать непроверенных приведений здесь.

Каждая запись на вашей карте handlers связывает Class<T> с RuleHandler<T> для некоторого класса T, который отличается для каждой записи. Методы Map не выражают это ограничение.

Что вы можете сделать, так это создать подкласс Map, который обеспечивает согласованность типов для каждой записи и выполняет все непроверенные приведения в вашем новом классе карты.

Например, посмотрите Guava на ClassToInstanceMap.

Заметив, что

• обработчики являются закрытыми и окончательными
• handler.clazz является окончательным
• RuleHandler<T extends Rule> подразумевает RuleHandler<?> === RuleHandler<? extends Rule>

следующий код правильный (и компилируется)

abstract class RuleHandler<T extends Rule>
{
  final Class<T> clazz;
  // as before
}

class HandlerDispatcher
{
  private final Map<Class<?>, RuleHandler<?>> handlers;
  void register(RuleHandler<?> handler)
  {
    handlers.put(handler.clazz, handler);
  }
  void doStuff(List<Rule> rules)
  {
    for(Rule rule : rules)
    {
      @SuppressWarnings("unchecked")
      RuleHandler<Rule> handler = (RuleHandler<Rule>) handlers.get(rule.getClass());
      handler.doStuff(rule);
    }
  }
}

class Test
{
  void main()
  {
    HandlerDispatcher hd = new HandlerDispatcher();
    hd.register(new ExampleRuleHandler());

    RuleHandler<?> handler = new ExampleRuleHandler();
    hd.register(handler);
  }
}

Проблема в этой строке.

RuleHandler<? extends Rule> handler = handlers.get(rule.getClass());

Компилятор этого не знает ‹? extends Rule> — правильный класс, потому что вы искали правильный обработчик для класса Rule. Вы можете заменить на

RuleHandler handler = handlers.get(rule.getClass());

Это вызовет предупреждение, потому что компилятор не знает, что во время выполнения вы выберете правильный тип. Если это беспокоит вас, вы можете добавить в свой класс.

@SuppressWarnings("unchecked")