使用装饰器模式时如何保留接口？

Question

如果要装饰的对象实现其他接口的不同组合，那么如何实现装饰器而不丢失额外的接口方法？ 例如，假设我们具有以下类和接口，其中I是我们关心的装饰类，D是装饰器的实现：

class C1 implements I, I1, I2

class C2 implements I, I2, I3

class C3 implements I, I3, I4

class D implements I {
    I wrappedValue
    // Methods for I
}

一旦我们用包装的I（可能是C1，C2或C3）实例化了D的实例，就无法访​​问包装的I可能实现的I1，I2，I3和I4的其他方法。

Answer 1

如果C1，C2，C3是接口，则将有一个代理解决方案。

interface C1 extends I, I1, I2

否则，您将需要像cglib这样的库来装饰该类。

代理与通用工厂方法结合使用将保留其他接口，因此您无需在代码中进行任何强制转换：

class D<T_I extends I> implements InvocationHandler, I {

  public static <T_I extends I> T_I decorate(T_I wrappedValue) {
    return (T_I)Proxy.newProxyInstance(
        wrappedValue.getClass().getClassLoader(),
        getAllInterfaces(wrappedValue.getClass()),
        new D<T_I>(wrappedValue));
  }

  private static Class[] getAllInterfaces(Class type) {
    if (type.isInterface()) {
      Class[] all = new Class[type.getInterfaces().length + 1];
      int i = 0;
      all[i++] = type;
      for (Class t : type.getInterfaces()) {
        all[i++] = t;
      }
      return all;
    } else {
      return type.getInterfaces();
    }
  }


  private final T_I wrappedValue;

  private D(T_I wrappedValue) {
    this.wrappedValue = wrappedValue;
  }

  public Object invoke(Object proxy, Method method, Object[] args) {
    if (method.getDeclaringClass() == I.class) {
      // call wrapped method in D
      return method.invoke(this, args);
    }
    //call unwrapped method of other interface
    return methos.invoke(wrappedValue, args);
  }

  // Methods for I
}

现在，您可以通过以下方式使用它：

C1 c1 = ...;
c1 = D.decorate(c1);

Answer 2

该界面将是这样的。

interface I
{
   I objI {get;} // can hold reference to other objects of type I or null
   // If the requirement is to make setter as public, that should be fine as well.

   // You can have decorator related behavior here
   void DecoratorBehavior1(); 
   void DecoratorBehavior2(); 
}

D类不需要执行包装。 它的作用是实现我。

class D implements I
{
  public I objI {get; private set;}
  // You can have other overloaded constructors as well
  D(I obj)
  {
     this.objI = obj;
  }
}

类型为I的对象持有对类型为I的其他对象的引用，或者为null。 该对象可以实现其他类型的接口，或者可以从其他基类派生。

如果要使用其他类型的方法，则可以将对象类型转换为相应的类型并使用。 在进行类型转换之前，您可以验证对象是否确实是某种类型。

....
I objC1 = new C1(null);
I objC2 = new C2(objC1);
I objC3 = new C3(objC2);
I objD = new D(objC3);
...
I oGetBackC3 = objD.objI;
if(oGetBackC3 is typeof(C3))
{
   C3 oGotBackC3 = (C3)oGetBackC3;
   ...
   // You can now call C3 methods on object
}
....

我已经用C＃编写了代码段，但对于Java来说也可能相同。

Answer 3

您可以使用Proxy.newProxy（）作为装饰器。 您为它提供了要实现的接口列表，并且可以以编程方式包括和处理任意数量的接口，并且可以根据需要添加一些接口。 您唯一不能做的就是让Proxy扩展给定的类。