问题

大概许多开拓者对“基于接口编程”的准则耳熟能详，也自觉不自觉地遵守着这条准则，可并不是真正大白为什么要这么做。大部门时候，我们界说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().export(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().export(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

}

可以看到，检测根基的参数、生存导出记录，昆山软件开发，生成并提交导出任务，流程及实现险些一样，但是由于之前要领限制传入请求的实现类，使得之前的要领都无法复用，进一步导致大段大段的反复代码， 而若在原有基本上改革，则要冒粉碎现有系统逻辑和实现的很大风险，真是骑虎难下。

办理

怎么办理呢？ 最好可以或许预先做好设计，设计出基于接口的导出流程框架，然后编写所需要实现的要领。

界说接口