Design pattern Recommendation per la catena di responsabilità con la delega delle attività

Question

Design pattern Recommendation per la catena di responsabilità con la delega delle attività

#1 da (1 voti)

0

Ho un'interfaccia con diciamo 2 metodi e ha 3 diverse implementazioni.

public interface IFace {
    public void method1(Param1 param1);
    public void method2(Param2 param2);
}

public class A implements IFace {
    public void method1(Param1 param1){}
    public void method2(Param2 param2){}
}

public class B implements IFace {
    public void method1(Param1 param1){}
    public void method2(Param2 param2){}
}

public class C implements IFace {
    public void method1(Param1 param1){}
    public void method2(Param2 param2){}
}

Requisito: uno dei due metodi richiede modifiche. Le pre-condizioni decidono quale specifica implementazione chiamare.

Ho bisogno di un modello per passare attraverso queste implementazioni una alla volta. Questo mi è sembrato perfetto per una catena di responsabilità e l'ho creato così:

public interface IChain {
    public void method1(Param1 param1);
    public void setNextChain(IChain iChain);
} 

public class AA implements IChain {
    private IChain chain;

    private IFace a;

    public void method1(Param1 param1){
        if (thisConditionIsSatisfied(param1)) {
            a.method1(param1);
        } else {
            chain.method1();
        }
    }

    public void setNextChain(IChain chain){
        this.chain = chain
    }

    public void setA(IFace a) {
        this.a = a;
    }
}

public class BB implements IChain {
    private IChain chain;

    private IFace b;

    public void method1(Param1 param1){
        if (thisConditionIsSatisfied(param1)) {
            b.method1(param1);
        } else {
            chain.method1();
        }
    }

    public void setNextChain(IChain chain){
        this.chain = chain
    }

    public void setA(IFace b) {
        this.b = b;
    }
}

public class CC implements IChain {
    private IChain chain;

    public void method1(Param1 param1){
        if (thisConditionIsSatisfied(param1)) {
            //process it here
        } else {
            throw new RuntimeException("Couldn't process request.")
        }
    }

    public void setNextChain(IChain chain){
        this.chain = chain
    }

}

Come puoi vedere, CC non delega alla classe C che implementava IFace ed è un'implementazione completamente nuova.

Questa è una parte molto piccola che sto visualizzando, ma il problema in effetti è lo stesso che vedo molte duplicazioni in termini di valutazione delle condizioni, gestione delle eccezioni, chiamata alla corretta implementazione dell'interfaccia, ecc.

Anche se questo è molto meglio che provare ad estendere l'interfaccia esistente, ma mi chiedevo se ci fosse qualche raccomandazione per renderlo migliore in termini di estensibilità futura o pattern OOPS successivo.

object-oriented java design-patterns object-oriented-design

posta instanceOfObject 12.08.2017 - 02:08

fonte

1 risposta

Leggi altre domande sui tag object-oriented java design-patterns object-oriented-design

Come progettare validazioni configurabili per importare file Excel? Come rappresentare e convalidare gli URL dei siti Web per un'entità JPA

score 1 · Answer 1

Oltre alla modifica del nome di una variabile privata (% da% di% a% di% di%)% di% di% è esattamente la stessa di% di% di%. a è uguale ad eccezione di un hardcoding inutile di un'eccezione che potrebbe essere stata eseguita modificando l'implementazione di b sul membro della catena. Anche se AA non è usato da niente, eliminalo.

Hai un sacco di duplicati perché lo hai creato inutilmente. BB fa tutto ciò di cui hai bisogno. Dagli un nome migliore e usalo. Sbarazzati di CC e method1() .

I was wondering if there is any recommendation to make it better in terms of future extensibility or OOPS pattern following

Raccomando questa modifica:

public class AA implements IChain {
    private IChain chain;

    private IFace a;

    Condition condition; //New code

    public void method1(Param param1){
        if (condition.thisConditionIsSatisfied(param1)) { //New code
            a.method1(param1);
        } else {
            chain.method1();
        }
    }

    public void setNextChain(IChain chain){
        this.chain = chain
    }

    public void setA(IFace a) {
        this.a = a;
    }

    public void setCondition(Condition condition) { //New code
        this.condition = condition; //New code
    }
}

In questo modo l'implementazione del codice SOLO in questa classe di method2() chiamata terribilmente è il modello della catena di responsabilità. Che cosa sta controllando, facendo o concatenando è tutto un altro problema.