Java中如何可扩展地处理密封接口的不同实现？

针对你提出的问题，这里提供两种既保证类型安全又具备良好扩展性的实现方案，解决泛型类型擦除的问题，同时让新处理器的添加更便捷：

方案一：基于类型令牌的泛型处理器（推荐，低侵入扩展处理器） #

核心思路是通过**类型令牌（Class）**解决Java泛型擦除导致instanceof T无法编译的问题，同时可以对处理器按事件类型分组，提升分发效率。

1. 定义泛型Handler接口 #

import java.util.Objects;

public interface Handler<T extends Event> {
    // 返回当前处理器负责的事件类型
    Class<T> getEventType();

    // 默认实现：判断事件类型并转发到强类型处理方法
    default void handle(Event event) {
        Objects.requireNonNull(event);
        if (getEventType().isInstance(event)) {
            realHandle(getEventType().cast(event));
        }
    }

    // 强类型的事件处理方法，子类只需实现这个方法
    void realHandle(T event);
}

2. 实现具体的事件处理器 #

每个处理器只需指定对应的事件类型，实现强类型的处理逻辑，无需手动做类型判断：

public class MealEventHandler implements Handler<MealEvent> {
    @Override
    public Class<MealEvent> getEventType() {
        return MealEvent.class;
    }

    @Override
    public void realHandle(MealEvent mealEvent) {
        // 这里直接处理MealEvent，类型安全，无需instanceof判断
        System.out.println("处理MealEvent：" + mealEvent);
    }
}

3. 优化事件分发逻辑 #

初始化时将处理器按事件类型分组，分发时直接找到对应类型的处理器，避免遍历所有处理器：

import java.util.List;
import java.util.Map;
import java.util.Collections;
import java.util.stream.Collectors;

public class EventDispatcher {
    private final Map<Class<? extends Event>, List<Handler<? extends Event>>> handlerMap;

    public EventDispatcher(List<Handler<? extends Event>> handlers) {
        this.handlerMap = handlers.stream()
                .collect(Collectors.groupingBy(Handler::getEventType));
    }

    public void dispatch(Event event) {
        handlerMap.getOrDefault(event.getClass(), Collections.emptyList())
                .forEach(handler -> handler.handle(event));
    }
}

// 使用方式
List<Event> events = // 你的事件列表
List<Handler<? extends Event>> handlers = List.of(
        new MealEventHandler(),
        new OrderEventHandler() // 添加新处理器只需在这里注册
);
EventDispatcher dispatcher = new EventDispatcher(handlers);
events.forEach(dispatcher::dispatch);

扩展优势：添加新事件处理器时，只需实现Handler<T>接口并注册到列表中，完全不需要修改现有代码，符合开闭原则。

方案二：基于密封接口的访客模式（适合事件类型稳定的场景） #

由于你的Event是密封接口，编译时所有实现类已知，非常适合使用访客模式，实现完全的类型安全，避免类型判断。

1. 改造密封Event接口，添加accept方法 #

public sealed interface Event permits MealEvent, OrderEvent, NewEvent {
    void accept(EventVisitor visitor);
}

2. 定义访客接口 #

public interface EventVisitor {
    void visit(MealEvent event);
    void visit(OrderEvent event);
    // 添加新Event类型时，需要在这里新增对应的visit方法
}

3. 实现事件的accept方法 #

每个Event实现类只需调用访客对应的visit方法：

public final class MealEvent implements Event {
    // 事件属性...

    @Override
    public void accept(EventVisitor visitor) {
        visitor.visit(this);
    }
}

4. 实现事件处理器（基于访客） #

为了避免每次添加新Event都要修改所有处理器，可以先写一个适配器抽象类，默认空实现所有visit方法：

public abstract class AbstractEventVisitor implements EventVisitor {
    @Override
    public void visit(MealEvent event) {}

    @Override
    public void visit(OrderEvent event) {}

    // 添加新Event时，在这里新增默认空实现的visit方法
}

然后新处理器只需继承适配器，重写对应事件的处理方法：

public class MealEventHandler extends AbstractEventVisitor {
    @Override
    public void visit(MealEvent event) {
        // 类型安全的MealEvent处理逻辑
        System.out.println("处理MealEvent：" + event);
    }
}

5. 事件分发 #

直接调用Event的accept方法即可完成类型匹配和分发：

EventVisitor visitor = new MealEventHandler(); // 可以组合多个访客，或者用复合访客
events.forEach(event -> event.accept(visitor));

扩展优势：添加新处理器时，只需继承AbstractEventVisitor并重写对应方法；添加新Event时，需要修改Event接口、EventVisitor和AbstractEventVisitor，但因为Event是密封接口，本身添加新实现就需要修改接口，这个成本是可接受的。

内容的提问来源于stack exchange，提问作者tipoviy_tip