Java 通用接口的工厂

我有一个界面：

public interface Handler<E extends Event> {
    void handle(E event);
}

我面临的问题是，我不能像它希望捕获的那样执行

HandlerFactory.getHandler（event）.handle（event）

？事件类型

Event event = getDeserialisedEvent(message, Event.class);
Handler<? extends Event> handler = HandlerFactory.getHandler(event);
handler.handle(event);    //can't do this

Event-Event=getDeserialisedEvent（消息，Event.class）；
Handler方法略有不同，但基本相同。他们都以这样或那样的方式使用cast

例如，您可以使用原始类型：

public static Handler getHandler(Event  event) 

一个可能的解决方案是更换
手柄（E）句柄（事件）的处理程序中的code>，然后将事件强制转换为从处理程序继承的类中所需的子类。我认为没有一种方法可以完全满足您的要求，因为编译器不知道处理程序的泛型类型。
我们可以尝试类似的方法。

问题是
无效句柄（E事件）无法捕获类型参数。因此，我们通过像
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{
    
}

现在
handle
方法能够用方法的type参数捕获类型。但是我们希望强制执行
处理程序
类的类型参数。因此，我们创建了单独的
handlerheloper
方法，该方法使用类的类型参数。并从我们的
handle
方法调用它。现在我们将获得取消勾选的施法警告，我们将取消该警告。

我们将使
handle
方法成为最终方法。这样子类就不会覆盖它。由于接口不能有最终的方法，我们必须将
Handler
类抽象化
此外，我们对
handlerHelper
方法进行保护，以便API用户只调用
handle
方法。
如果您有一个类委托给正确的处理程序，而不是工厂，则可以很好地解决此问题

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是在每次需要处理程序时创建处理程序（如代码中所示），还是保留处理程序并重用它们，它都可以工作

你可能还想和你所拥有的一起生活。泛型用于编译时类型检查。当您不知道编译时
事件
的实际（运行时）类型时，编译时类型检查没有多大意义。所以你可以选择放弃它

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

public static Handler getHandler(Event  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

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

}