基于接口设计与编程

问题###

可能很多开发者对“基于接口编程”的准则耳熟能详，也自觉不自觉地遵守着这条准则，可并不是真正明白为什么要这么做。大部分时候，我们定义Control, Service, Dao 接口，实际上却很少提供超过两个类的实现。似乎只是照搬准则，过度设计，并未起实际效用。不过，基于接口设计与编程，在通常情形下可以增强方法的通用性；而在特定场景下，则可以有助于系统更好地重构和精炼。

当需要从一个系统提炼出更通用的系统，或者重构出一个新的系统时，预先设计的接口就会起大作用。

举个例子吧，假设现在已经有一个订单导出的实现，如下所示：

package zzz.study.inf;

import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import lombok.Data;

/**
 * Created by shuqin on 18/3/29.
 */
public class OrderExportService {

  private static OrderExportService orderExportService;

  ExecutorService es = Executors.newFixedThreadPool(10);

  public static void main(String[] args) {
    getInstance().exportOrder(new OrderExportRequest());
  }

  public static OrderExportService getInstance() {
    // 实际需要考虑并发, 或者通过Spring容器管理实例
    if (orderExportService != null) {
      return orderExportService;
    }
    return new OrderExportService();
  }

  public String exportOrder(OrderExportRequest orderExportRequest) {
    check(orderExportRequest);
    String exportId = save(orderExportRequest);
    generateJobFor(orderExportRequest);
    return exportId;
  }

  private String save(OrderExportRequest orderExportRequest) {
    // save export request param into db
    // return exportId
    return "123";
  }

  private void generateJobFor(OrderExportRequest orderExportRequest) {
    es.execute(() -> exportFor(orderExportRequest));
  }

  private void exportFor(OrderExportRequest orderExportRequest) {
    // export for orderExportRequest
  }

  private void check(OrderExportRequest orderExportRequest) {
    // check bizType
    // check source
    // check templateId
    // check shopId
    // check biz params
  }

}

@Data
class OrderExportRequest {

  private String bizType;
  private String source;
  private String templateId;

  private String shopId;

  private String orderNos;

  private List<String> orderStates;

}

可以看到，几乎所有的方法都是基于实现类来完成的。如果这个系统就只需要订单导出也没什么问题，可是，如果你想提炼出一个更通用的导出，而这个导出的流程与订单导出非常相似，就尴尬了：无法复用已有的代码和流程。它的代码类似这样：

package zzz.study.inf;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import lombok.Data;

/**
 * Created by shuqin on 18/3/29.
 */
public class GeneralExportService {

  private static GeneralExportService generalExportService;

  ExecutorService es = Executors.newFixedThreadPool(10);

  public static void main(String[] args) {
    getInstance().exportOrder(new GeneralExportRequest());
  }

  public static GeneralExportService getInstance() {
    // 实际需要考虑并发, 或者通过Spring容器管理实例
    if (generalExportService != null) {
      return generalExportService;
    }
    return new GeneralExportService();
  }

  public String exportOrder(GeneralExportRequest generalExportRequest) {
    check(generalExportRequest);
    String exportId = save(generalExportRequest);
    generateJobFor(generalExportRequest);
    return exportId;
  }

  private String save(GeneralExportRequest generalExportRequest) {
    // save export request param into db
    // return exportId
    return "123";
  }

  private void generateJobFor(GeneralExportRequest generalExportRequest) {
    es.execute(() -> exportFor(generalExportRequest));
  }

  private void exportFor(GeneralExportRequest orderExportRequest) {
    // export for orderExportRequest
  }

  private void check(GeneralExportRequest generalExportRequest) {
    // check bizType
    // check source
    // check templateId
    // check shopId

    // check general params
  }

}

@Data
class GeneralExportRequest {

  private String bizType;
  private String source;
  private String templateId;

  private String shopId;

  // general export param

}

可以看到，检测基本的参数、保存导出记录，生成并提交导出任务，流程及实现几乎一样，可是由于之前方法限制传入请求的实现类，使得之前的方法都无法复用，进一步导致大段大段的重复代码，而若在原有基础上改造，则要冒破坏现有系统逻辑和实现的很大风险，真是进退两难。

解决###

怎么解决呢？最好能够预先做好设计，设计出基于接口的导出流程框架，然后编写所需要实现的方法。

定义接口####

由于传递具体的请求类限制了复用，因此，需要设计一个请求类的接口，可以获取通用导出参数，具体的请求类实现该接口：

public interface IExportRequest {

  // common methods to be implemented

}

class OrderExportRequest implements IExportRequest {
  // implementations for IExportRequest methods
}

class GeneralExportRequest implements IExportRequest {
  // implementations for IExportRequest methods
}

实现抽象导出####

接着，基于导出请求接口，实现抽象的导出流程骨架，如下所示：

package zzz.study.inf;

import com.alibaba.fastjson.JSON;

import java.util.concurrent.ExecutorService;

/**
 * Created by shuqin on 18/3/29.
 */
public abstract class AbstractExportService {

  public String export(IExportRequest exportRequest) {
    checkCommon(exportRequest);
    checkBizParam(exportRequest);
    String exportId = save(exportRequest);
    generateJobFor(exportRequest);
    return exportId;
  }

  private String save(IExportRequest exportRequest) {
    // save export request param into db
    // return exportId
    System.out.println("save export request successfully.");
    return "123";
  }

  private void generateJobFor(IExportRequest exportRequest) {
    getExecutor().execute(() -> exportFor(exportRequest));
    System.out.println("submit export job successfully.");
  }

  public void exportFor(IExportRequest exportRequest) {
    // export for orderExportRequest
    System.out.println("export for export request for" + JSON.toJSONString(exportRequest));
  }

  private void checkCommon(IExportRequest exportRequest) {
    // check bizType
    // check source
    // check templateId
    // check shopId
    System.out.println("check common request passed.");
  }

  public abstract void checkBizParam(IExportRequest exportRequest);
  public abstract ExecutorService getExecutor();

}

具体导出####

然后，就可以实现具体的导出了：

订单导出的实现如下：

public class OrderExportService extends AbstractExportService {

  ExecutorService es = Executors.newCachedThreadPool();

  @Override
  public void checkBizParam(IExportRequest exportRequest) {
    System.out.println("check order export request");
  }

  @Override
  public ExecutorService getExecutor() {
    return es;
  }
}

通用导出的实现如下：

public class GeneralExportService extends AbstractExportService {

  ExecutorService es = Executors.newFixedThreadPool(10);

  @Override
  public void checkBizParam(IExportRequest exportRequest) {
    System.out.println("check general export request");
  }

  @Override
  public ExecutorService getExecutor() {
    return es;
  }
}

导出服务工厂####

定义导出服务工厂，来获取导出服务实例。在实际应用中，通常通过Spring组件注入和管理的方式实现的。

public class ExportServiceFactory {

  private static OrderExportService orderExportService;

  private static GeneralExportService generalExportService;

  public static AbstractExportService getExportService(IExportRequest exportRequest) {
    if (exportRequest instanceof OrderExportRequest) {
      return getOrderExportServiceInstance();
    }
    if (exportRequest instanceof GeneralExportRequest) {
      return getGeneralExportServiceInstance();
    }
    throw new IllegalArgumentException("Invalid export request type" + exportRequest.getClass().getName());
  }

  public static OrderExportService getOrderExportServiceInstance() {
    // 实际需要考虑并发, 或者通过Spring容器管理实例
    if (orderExportService != null) {
      return orderExportService;
    }
    return new OrderExportService();
  }

  public static GeneralExportService getGeneralExportServiceInstance() {
    // 实际需要考虑并发, 或者通过Spring容器管理实例
    if (generalExportService != null) {
      return generalExportService;
    }
    return new GeneralExportService();
  }

}

客户端使用####

现在，可以在客户端使用已有的导出实现了。

public class ExportInstance {

  public static void main(String[] args) {
    OrderExportRequest orderExportRequest = new OrderExportRequest();
    ExportServiceFactory.getExportService(orderExportRequest).export(orderExportRequest);

    GeneralExportRequest generalExportRequest = new GeneralExportRequest();
    ExportServiceFactory.getExportService(generalExportRequest).export(generalExportRequest);
  }

}

现在，订单导出与通用导出能够复用相同的导出流程及导出方法了。