单一职责原则重构答案

【问题标题】：Single Responsibility Principle Refactor单一职责原则重构
【发布时间】：2016-10-16 12:02:49
【问题描述】：

我有一些代码我想重新分解，这样它就不会违反单一职责原则 (SRP)。

我了解以下课程可能因多种原因而更改：

分析的业务规则可能会改变
元数据架构可能会改变
上传方式可能会改变

但是，我很难弄清楚如何将因素重新分解为单独的类。

Engine.java

package com.example;

import java.util.List;

public interface Engine {
  public List<Recording> analyze(List<String> files);
  public List<Recording> getMetadata(List<Recording> recordings);
  public List<Recording> upload(List<Recording> recordings);
}

CallEngine.java

package com.example;

import java.util.ArrayList;
import java.util.List;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class CallEngine implements Engine {

  final static Logger log = LoggerFactory.getLogger(Main.class);

  public List<Recording> analyze(List<String> files) {
    log.info("Analyzing recording files per business rules...");

    List<Recording> recordings = new ArrayList<Recording>();
    return recordings;
  }

  public List<Recording> getMetadata(List<Recording> r) {
    log.info("Retrieving metadata for calls...");
    List<Recording> recordings = new ArrayList<Recording>();
    return recordings;
  }

  public List<Recording> upload(List<Recording> r) {
    log.info("Uploading calls...");
    List<Recording> recordings = new ArrayList<Recording>();
    return recordings;
  }
}

【问题讨论】：

标签： java class interface solid-principles single-responsibility-principle

【解决方案1】：

SRP 主要是通过抽象接口后面的代码并将无关功能的责任委托给运行时恰好位于接口后面的任何实现来实现的。

在这种情况下，您需要在自己的接口后面抽象出职责。

例如...

public interface Analyzer {
    public List<Recording> analyze(List<String> files);
}
public interface Retriever {
    public List<Recording> getMetadata(List<Recording> recordings);
}
public interface Uploader {
    public List<Recording> upload(List<Recording> r);
}

并将它们作为Engine 实现的可注入依赖项。

public class CallEngine implements Engine {
    private Analyzer analyzer;
    private Retriever retriever;
    private Uploader uploader;

    public CallEngine(Analyzer analyzer, Retriever retriever, Uploader uploader) {
        this.analyzer = analyzer;
        this.retriever = retriever;
        this.uploader = uploader;        
    }

    public List<Recording> analyze(List<String> files) {
        return analyzer.analyze(files);
    }

    public List<Recording> getMetadata(List<Recording> r) {
        return retriever.getMetadata(r);
    }

    public List<Recording> upload(List<Recording> r) {
        return uploader.upload(r);
    }
}

可以在不影响依赖类实现的整体职责的情况下更改它们的运行时实现，从而使其更适应变化。

【讨论】：

【解决方案2】：

public interface Analyzer {
  public void analyze();
}
public interface Retriever {
  public void retrieveMetadata();
}
public interface Uploader {
  public void upload();
}

public class EngineAnalyzer implements Analyzer {

  final static Logger log = LoggerFactory.getLogger(Main.class);

  public List<Recording> recordings;

  EngineAnaylzer(List<String> Files) {

  }

  public void analyze() {
    log.info("Analyzing recording files per business rules...");
  }  

}

【讨论】：