我们一般来说是这么理解门面模式的:
将做成一件事情分为几个步骤
将这些步骤用一个统一的方法概括起来
由一个特定的类来负责这个事情的处理
从调用者来看,这个调用的接口很简单,通常是一个具有多参数的方法。各个参数通常是各个步骤所需要处理的输入。
先看一个简单的门面模式的例子。
过程接口
public interface Process {
public void doProcessA(Object inputA);
public void doProcessB(Object inputB);
public void doProcessC(Object inputC);
}
过程的实现
public class ProcessImpl implements Process {
@Override
public void doProcessA(Object inputA) {
System.out.println("Process A");
}
@Override
public void doProcessB(Object inputB) {
System.out.println("Process B");
}
@Override
public void doProcessC(Object inputC) {
System.out.println("Process C");
}
}
过程的门面
public class ProcessFacade {
private Process proc = new ProcessImpl();
public void doProcess(Object...inputs) {
proc.doProcessA(inputs[0]);
proc.doProcessB(inputs[1]);
proc.doProcessC(inputs[2]);
}
}
调用者
public class ProcessCaller {
public static void main(String[] args) {
ProcessFacade pf = new ProcessFacade();
pf.doProcess("inputA", "inputB", "inputC");
}
}
这是门面模式的简单应用。如何泛型化?
对于门面模式的泛型化,其考虑就是如何接受泛型参数或者类型限定的参数类型。
改过之后的代码:
过程接口
public interface Process<T, M, N> {
public void doProcessA(T inputA);
public void doProcessB(M inputB);
public void doProcessC(N inputC);
}
过程实现
public class ProcessImpl<T, M, N> implements Process<T, M, N> {
@Override
public void doProcessA(T inputA) {
System.out.println("Process A");
}
@Override
public void doProcessB(M inputB) {
System.out.println("Process B");
}
@Override
public void doProcessC(N inputC) {
System.out.println("Process C");
}
}
过程门面
public class ProcessFacade<T, M, N> {
private Process<T, M, N> proc = new ProcessImpl<T, M, N>();
public void doProcess(T t, M m, N n) {
proc.doProcessA(t);
proc.doProcessB(m);
proc.doProcessC(n);
}
}
调用者
public class ProcessCaller {
public static void main(String[] args) {
ProcessFacade<String, Integer, Double> pf = new ProcessFacade<String, Integer, Double>();
pf.doProcess("String", 1, 2.0);
}
}
当然,你也可以做一些限定式的改变。