Réflexeur à principe de responsabilité unique

Question

J'ai un code que je voudrais redéfinir pour ne pas enfreindre le principe de responsabilité unique (SRP).

Je comprends que la classe ci-dessous pourrait changer pour de multiples raisons:

• règles d'affaires pour analyser pourrait changer
• schéma des métadonnées pourrait changer
• Méthode de chargement pourrait changer

Cependant, J'ai du mal à comprendre comment je peux transformer en classes séparées.

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; 
    } 
} 

Answer 1

La SRP est principalement réalisé par le code abstraire derrière des interfaces et de déléguer la responsabilité de la fonctionnalité sans rapport avec l'implémentation qui se trouve être derrière l'interface à l'exécution.

Dans ce cas, vous devez faire abstraction des responsabilités derrière leur propre interface.

Par exemple ...

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); 
} 

et les ont en tant que dépendances injectent-mesure de la mise en œuvre 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); 
    } 
} 

Les implémentations de temps d'exécution peuvent être modifiés sans affecter la responsabilité globale de la mise en œuvre de classe dépendante qui le rend beaucoup plus d'adaptation au changement.

Answer 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..."); 
    } 

}