JAVA外观模式，正确的实现吗？

Question

我有一个类似于构造函数的客户端，它在参数列表方面非常长，例如，

Class Client {
   private ServiceA _serviceA;
   private ServiceB _serviceB;
   ....
   private ServiceE _serviceE;

   public Client(ServiceA serviceA, ServiceB serviceB,...ServiceE service E) { ... }

   public doTask1(TypeA typeA) { //only serviceA, serviceB service being used... }

   public doTask2(TypeB typeB) { //only serviceD, serviceE being used ... }
}

我想在这里使用一个服务外观来修剪构造函数参数列表。但是，作为外观实现的核心责任，我感到非常困惑。因此，我用服务作为类变量及其getter编写了一个facade，如下所示：

Class Facade {
   private ServiceA _serviceA;
   private ServiceB _serviceB;
   ....
   private ServiceE _serviceE;

   getters () ...
}

在这种情况下，这种抽象外观的方法是否正确。如果不是，那么重构客户端类的正确方法是什么？

Answer 1

Facedes有一个完全不同的意图:它们的创建是为了封装和隐藏类的底层结构和行为。以一辆汽车为例。它由许多部件组成:车载计算机、燃油泵、发动机等。如果你想启动它，只需按下“启动”按钮：

class FuelPump {
  private boolean pumpTurnedOn;
  public FuelPump() {
    pumpTunrnedOn=false;
  }
  public boolean isPumpTunredOn() {
    return pumpTurnedOn;
  }
  public void setPumpTurnedOn (boolean newState) {
    pumpTurndeOn=newState;
    if (newState) {
      System.out.println ("fuel pump now is on");
    } else {
      System.out.println ("fuel pump now is turned off");
    }
  }
}

class Engine {
  private boolean engineStarted;
  public Engine() {
    engineStarted=false;
  }
  public boolean isEngineStarted() {
    return engineStarted;
  }
  public void setEngineStarted (boolean newState) {
    engineStarted=newState;
    if (newState) {
      System.out.println("engine now is on");
    } else {
      System.out.println("engine now is turned off");
    }
  }
}

// this is the Car facade:
class Car {
  private FuelPump fuelPump;
  private Engine engine;
  // + other components of Car
  public Car () {
    fuelPump = new FuelPump();
    engine = new Engine();
  }
  public void startCar() {
    fuelPump.setPumpTurnedOn(true);
    engine.setEngineStarted(true);
    // + other methods of start procedures with other components
    System.out.println("Your car has been startded");
  }
  public void stopCar() {
    engine.setEngineStarted(false);
    fuelPump.setPumpTurnedOn(false);
    // + other methods on other components for shutting down car
  }
}

客户端代码片段：

Car car=new Car();
car.startCar();
// later on
car.stopCar();

如您所见，客户端对启动汽车的底层组件一无所知。它只需要使用startCar()方法，剩下的就由车窗来完成。Facade是一种结构模式。如果您有许多构造器参数，并且希望重新处理它们，请使用一种创建模式。如果您有强制字段和非强制字段，我建议使用构建器模式。例如，强制构造函数参数是Service_A，Service_B和Service_C到Service_E并不是必需的。那么您的ClientBuilder类应该如下所示：

class ClientBuilder{
  private static Service_A serviceA;  // required
  private static Service_B serviceB;  // required
  private static Service_C serviceC;
  private static Service_D serviceD;
  private static Service_E serviceE;

  // since this builder is singleton
  private static ClientBuilder builderInstance = new ClientBuilder();
  private ClientBuilder () {};

  public static ClientBuilder getBuilderInstance (Service_A service_A, Service_B service_B){
    serviceA = service_A;
    serviceB = service_B;
    serviceC = null; 
    serviceD = null;
    serviceE = null;
    return builderInstance;
  }

  public static ClientBuilder addServiceC (Service_C service_C) {
    serviceC = service_C;
    return builderInstance; 
  }

  public static ClientBuilder addServiceD (Service_D service_D) {
    serviceC = service_D;
    return builderInstance; 
  }

  public static ClientBuilder addServiceE (Service_E service_E) {
    serviceE = service_E;
    return builderInstance; 
  }

  public static Client build(){
    return new Client (serviceA, ServiceB, ServiceC, ServiceD, ServiceE);
  }

在这种情况下，您只能使用强制参数实例化客户端类。最好的是，不需要的参数的顺序是可以互换的：

  Client aClient = ClientBuilder.getBuilderInstance(aServiceA, aServiceB)
        .addServiceE(aServiceE)
        .addServiceC(aServiceC)
        .build();

现在已经创建了aClient，服务A、B、C、E和serviceD仍然为空。稍后，您可以通过适当的setter设置它。getters和setter必须在客户端类中。简单地说，通过构建器类，您可以减少构造函数参数的数量，这些参数只适用于将来使用setters的强制和设置可选字段。您可以在四人帮书中阅读更多细节，或者如果您是一个严肃的Java乐趣，我建议阅读头第一的设计模式书籍。希望我能帮你，再见！