Question

我在Java中使用了责任链设计模式。链作为一个整体代表对某些类型的对象的请求。链中的每个“处理程序”负责处理所请求的1种单位。所有请求都以基本相同的方式处理，因此我尝试使用“Handler”类通用。所以在Handle-class中我需要一个像这样的方法（处理本身是简化的，因为它只会模糊我的问题）：

public class Handler<T>{
   int required;
   Handler<?> next;

   public void handle(Object O){
      if(o instanceof T){
         required --;
      }else{
         next.handle(o);
      }
   }
}

问题是像这样的实例是不可能的。因为类型T在运行时没有明确存储（或者这是我在互联网研究中所理解的）。所以我的问题是：什么是最好的选择？

Answer 1

使用构造函数参数来定义处理程序支持的类，使用泛型实现处理程序：

public class Handler<T> {
    private int required;
    private Handler<?> next;
    private Class<? extends T> c;

    public Handler(Class<? extends T> c) {
        this.c = c;
    }

    public void handle(Object o) {
        if (c.isInstance(o)) {
            required--;
        } else {
            next.handle(o);
        }
    }

    // ...
}

Answer 2

这会很难看，但你可以试试这个：

public abstract class Handler {
   int required;
   Handler next;

   public void handle(Object o){
      if(getMyClass().isInstance(o)){
         required --;
      }else{
         next.handle(o);
      }
   }

   protected abstract Class getMyClass();
}

Answer 3

看起来你根本就没有使用链，除非你遇到基类和子类都引发事件的情况。如果除非部分不适用，您可以执行类似

的操作

Map<Class, Handler> handlers = //...initialize however

并在root处理程序中：

public void handle(Object o) {
 handlers.get(o.getClass()).handle(o);
}

Answer 4

如果在每个对象上调用句柄，那么使用泛型的处理程序是没有意义的。要么为这样的类型实例化一个处理程序：

public class Handler<T>{
   int required;
   Handler<?> next;

   public void handle(T O){
     ...
   }
}

或者您定义一个抽象类处理程序，让特定的子类处理特定的类型或只是将事件传递给链。也使用

if( x.isInstance(o)) {...}

实际上是一个反模式，你可以打破OOP规则。

使用java泛型的责任链处理程序

4 个答案: