Utilizzo dello stesso oggetto su più livelli nella gerarchia delle chiamate

Question

Utilizzo dello stesso oggetto su più livelli nella gerarchia delle chiamate

#1 da (1 voti)

0

Per spiegare il mio problema, inizierò con un esempio di codice. Immagina questo codice (molto semplificato):

public void entryPoint() {
    Foo foo = new Foo();
    foo.doSomething()
    method1(foo);
}

private void method1(Foo foo) {
    // do a lot of stuff before foo is needed again
    foo.doSomethingElse();
    method2(foo);
}

private void method2(Foo foo) {
    // do a lot of stuff before foo is needed again
    foo.doAnotherThing();
}

L'oggetto foo viene creato al livello superiore ed è necessario in più altri metodi nella gerarchia delle chiamate. Attualmente è risolto come sopra e foo è passato attraverso molti metodi in una gerarchia di chiamate profonde. Penso che questa soluzione sia un po 'maldestra, quindi ho provato a crearne una migliore.

Ecco alcune restrizioni che ho, principalmente a causa del framework in cui mi trovo:

Non riesco a cambiare la classe Foo
entryPoint() è un metodo da eseguire più volte
foo deve essere un oggetto nuovo ogni volta che entryPoint() è chiamato
Non ho il controllo del ciclo di vita degli oggetti che li racchiude, il che significa che non posso creare un nuovo oggetto ogni volta prima che entryPoint() sia chiamato
Non posso fare nulla nel costruttore

L'unica alternativa che sono riuscito a ottenere è trasformare foo in un campo. Ma in questo caso l'ambito di foo è un po 'più oscuro, che lo apre per errori di programmazione relativi alla terza restrizione.

Qualcuno ha qualche consiglio su questo? C'è una soluzione che non ho ancora considerato?

object-oriented-design

posta André Stannek 02.03.2017 - 17:26

fonte

1 risposta

Leggi altre domande sui tag object-oriented-design

Design Pattern per il risultato del metodo di elaborazione Come dovrei dividere le classi in un'applicazione MVC?

score 1 · Answer 1

Sembra che tu voglia adottare qualcosa come il modello di design Chain of Responsibility . Se stavi codificando in C # potresti configurare un'interfaccia fluente usando i metodi di estensione. Per Java puoi fare qualcosa di simile a questo:

public void entryPoint() {
    FooChain chain = new FooChain();
    chain.addToChain(new Method0Handler()).addToChain(new Method1Handler());

    Foo foo = new Foo();
    chain.handle(foo);
}

class Foo {
    public void doSomething(){}
    public void doSomethingElse(){}
}

interface FooHandler {
    Foo handle(Foo instance);
}

class FooChain implements FooHandler {
    FooChain addToChain(FooHandler handler){
        // add to list of handlers
        return this;
    }

    public Foo handle(Foo instance) {
        // iterate through list of handlers
        // call handler.handle(instance)
        return instance;
    }
}

class Method0Handler implements FooHandler{
    public Foo handle(Foo instance) {
        // do stuff
        instance.doSomething();
        // do more stuff
        return instance;
    }
}

class Method1Handler implements FooHandler {
    public Foo handle(Foo instance) {
        // do more stuff
        instance.doSomethingElse();
        // do even more stuff
        return instance;
    }
}