我有一个接口：
public interface Handler<E extends Event> {
void handle(E event);
}
以及它的两个实现：
public class SignupEventHandler implements Handler<SignupEvent> {
@Override
public void handle(SignupEvent event) {}
}
和
public class SignoutEventHandler implements Handler<SignoutEvent> {
@Override
public void handle(SignoutEvent event) {}
}
注意，Event本身就是一个接口，由SignupEvent和SignoutEvent实现。
我想知道实现Handler工厂的正确方法是什么。
public class HandlerFactory {
public static Handler<? extends Event> getHandler(Event event) {
if(event.type().equals("SignupEvent")) {
return new SignupEventHandler();
} else if(event.type().equals("SignoutEvent")) {
return new SignoutEventHandler();
} else {
throw new IllegalArguementException("Unrecognised event type");
}
}
}
我面临的问题是，我不能做HandlerFactory.getHandler(event).handle(event)，因为它想要一个capture of ? of Event。
Event event = getDeserialisedEvent(message, Event.class);
Handler<? extends Event> handler = HandlerFactory.getHandler(event);
handler.handle(event); //can't do this
有没有一种干净的方法可以做到这一点？我发现的一种方法是：
public class HandlerFactory {
public static <E extends Event> Handler<E> getHandler(E event) {
if(event.type().equals("SignupEvent")) {
return (Handler<E>) new SignupEventHandler(); //unchecked cast, but it's guaranteed to be type-safe
} else if(event.type().equals("SignoutEvent")) {
return (Handler<E>) new SignoutEventHandler(); //unchecked cast, but it's guaranteed to be type-safe
} else {
throw new IllegalArguementException("Unrecognised event type");
}
}
}
这种方法有效，但我想知道是否有更清洁的方法。
方法略有不同，但基本相同。所有这些都以这样或那样的方式使用cast。
例如，您可以使用原始类型：
public static Handler getHandler(Event event)
如果您有一个委托给正确处理程序的类，而不是一个工厂，那么您可以很好地解决它。
public class EventHandlerFacade {
public void handle(Event event) {
if (event instanceof SignupEvent) {
new SignupEventHandler().handle((SignupEvent) event);
}
else if (event instanceof SignoutEvent) {
new SignoutEventHandler().handle((SignoutEvent) event);
}
else {
System.out.println("Unhandled event of class " + event.getClass());
}
}
}
在这段代码中，Java可以看到强制转换是安全的。无论facade是在每次需要处理程序时创建处理程序(如代码中所示(，还是保留处理程序并重用它们，它都能工作。
你可能还想用你所拥有的生活。泛型用于编译时类型检查。当您在编译时不知道event的实际(运行时(类型时，编译时类型检查就没有那么大意义了。所以你可以选择放弃它。
一个可能的解决方案是用handle(Event);替换Handler中的handle(E);，然后将Event强制转换为从Handler继承的类中所需的子类。我不认为有一种方法可以完全按照您的意愿执行，因为编译器不知道Handler的泛型类型。
我们可以试试这样的方法
问题是void handle(E event);无法捕获类型参数。因此，我们通过将其声明为<T extends Event> void handle(T event)来捕获它。其余解释在以下代码之后。
public class Test{
public static void main(final String[] args) throws Exception {
Event e =new SignupEvent();
Handler<? extends Event> handler = HandlerFactory.getHandler(e);
handler.handle(e); //yeppie!
e = new SignoutEvent();
handler = HandlerFactory.getHandler(e);
handler.handle(e);
}
}
class HandlerFactory {
public static Handler<? extends Event> getHandler(Event event) {
if(event instanceof SignupEvent)
return new SignupEventHandler();
return new SignoutEventHandler();
}
}
abstract class Handler<E extends Event> {
@SuppressWarnings("unchecked") //<-- we know what we are doing
final <T extends Event> void handle(T event) {
handlerHelper((E)event);
}
protected abstract void handlerHelper(E event);
}
class SignupEventHandler extends Handler<SignupEvent> {
@Override
protected void handlerHelper(SignupEvent event) {
System.out.println("Handling sign UP");
}
}
class SignoutEventHandler extends Handler<SignoutEvent> {
@Override
protected void handlerHelper(SignoutEvent event) {
System.out.println("Handling sign OUT");
}
}
interface Event{
}
class SignupEvent implements Event{
}
class SignoutEvent implements Event{
}
输出：
Handling sign UP
Handling sign OUT
现在handle方法能够用该方法的类型参数捕获类型。但是我们想要强制使用Handler类的类型参数。因此，我们创建了单独的handlerHelper方法，该方法使用类的类型参数。并从我们的handle方法中调用它。现在我们得到了不受约束的施法警告，我们将压制它
我们将最终确定handle方法。这样子类就不会覆盖它。由于接口不能有最终方法，我们必须使Handler类抽象
此外，我们对handlerHelper方法进行保护，以便API用户仅调用handle方法。