La soluzione più elegante per concatenare chiamate asincrone in java?

Question

Attualmente sto sviluppando il livello di presentazione di un'app per Android.

l'API che sto usando simile a questa:

public interface errorInterface{ 
    public void onError(String reason); 
} 

public interface if1 extends errorInterface{ 
    public void dataReceived1(Data data); 
} 
public interface if2 extends errorInterface{ 
    public void dataReceived2(Data data); 
} 

public void fetchData1(if1 receiver) {} 
public void fetchData2(if2 receiver) {} 

che è; per recuperare i dati si fornisce un ricevitore che riceverà il risultato dell'operazione in futuro.

Questo funziona molto bene quando è necessario chiamare un solo metodo alla volta, ma ora ho raggiunto il punto in cui ho bisogno di chiamare più di 10 metodi in una volta sola, e devono eseguirne uno alla volta.

Come posso risolvere questo in modo flessibile ed elegante?

Grazie!

Answer 1

Mi permetta di rendere sicuro di capire .. si dispone di una serie di interfacce if1, if2 .. ifn e si desidera che tutti siano in grado di elaborare i dati ricevuto.

Prima di tutto, sarebbe meglio se if1, if2, ecc erano tutti la stessa interfaccia con i tuoi due metodi di base: public void dataReceived(Data d) e public void onError(String reason). Con questo, puoi semplicemente passare un List o Collection dei tuoi ricevitori a fetchData e può iterare sulla raccolta e chiamare dataReceived(d) su ciascuno di essi.

Se, per qualsiasi ragione, non è possibile, proverei un adattatore per collegarli a un'interfaccia simile per fetchData. Per esempio:

public interface DataReceiver extends ErrorInterface { 
    public void dataReceived(Data d); 
    //or just scrap the ErrorInterface all together and make these into 1 interface 
} 

public class AbstractIFAdapter<T extends ErrorInterface> implements DataReceiver { 
    private T target; 
    public AbstractIFAdapter(T target) { this.target = target); 
    public void onError(String reason) { target.onError(reason); } 
    protected T getTarget() { return target; } 
} 

public class IF1Adapter extends AbstractIFAdapter<IF1> { 
    public IF1Adapter(IF1 target) { super(target); } 
    public dataReceived(Data d) { getTarget().dataReceived1(d); } 
} 

public class IF2Adapter extends AbstractIFAdapter<IF2> { 
    public IF2Adapter(IF2 target) { super(target); } 
    public dataReceived(Data d) { getTarget().dataReceived2(d); } 
} 

Ora con quello in atto, possiamo fare qualcosa di simile:

List<DataReceiver> dataReceivers = new ArrayList<DataReceiver>(); 
dataReceivers.add(new IF1Adapter(someIf1Implementation)); 
dataReceivers.add(new IF2Adapter(someIf2Implementation)); 
fetchData(dataReceivers); 

public void fetchData(Collection<DataReceiver> receivers) { 

    try { 
    Data d = getSomeData(); 
    for (DataReceiver dr : receivers) { 
     dr.dataReceived(d); 
    } 
    } 
    catch (Exception e) { 
    for (DataReceiver dr : receivers) { 
     dr.onError(e.getMessage()); 
    } 
    } 
} 

Ci sono altri modelli che possono essere applicabili a seconda delle vostre esigenze, come visitatori o forse una catena di tipo di responsabilità in cui si concatenano i ricevitori in un costrutto di tipo di elenco collegato e ognuno chiama il successivo in un costrutto ricorsivo - sarebbe bello come fetchData non avrebbe bisogno di sapere che sta ottenendo una raccolta, si ottiene solo un riferimento all'adattatore superiore nella catena. Quindi, AbstractIFAdapter avrebbe un riferimento a un altro AbstractIFAdapter, chiamiamolo next e, se il riferimento non fosse nullo, chiamerebbe next.dataReceived(d) nel proprio metodo dataReceived. Idea simile a ServletFilter s in cui ogni filtro riceve ServletRequest e quindi chiama chain.doFilter(request,response).

Answer 2

È possibile utilizzare la Guava Biblioteca di Google, vedere this answer