CKTIS / Java
Flow.Publisher: pubblicare elementi con controllo della domanda
Flow.Publisher<T> descrive una sorgente di elementi ricevuti dai sottoscrittori. Il metodo subscribe collega un destinatario alla sorgente, mentre Flow.Subscription permette di richiedere elementi e annullare la ricezione.
Versione: Java SE 21; repository runtime, production runtime not attested
Sintassi
Flow.Publisher<T>
void subscribe(Flow.Subscriber<? super T> subscriber)Flow.Publisher<T> è un’interfaccia funzionale in java.util.concurrent. Flow.Publisher.subscribe ha la firma void subscribe(Flow.Subscriber<? super T> subscriber). Il carattere jolly ? super T accetta un destinatario di tipo T o di un supertipo. Un destinatario accettato riceve onSubscribe con un oggetto Flow.Subscription; un argomento null causa NullPointerException. Una sottoscrizione duplicata o un rifiuto dovuto a una policy o a un errore viene segnalato tramite onError con IllegalStateException.
La sola chiamata a subscribe non crea domanda. request(n) aggiunge domanda per un massimo di n elementi successivi; se n <= 0, viene chiamato onError con IllegalArgumentException. È backpressure, non una garanzia di ricevere esattamente n elementi. cancel() interrompe la ricezione secondo il principio del miglior sforzo: possono ancora arrivare messaggi e non è richiesto un segnale terminale.
Gli elementi arrivano tramite onNext; onComplete indica la conclusione normale e onError un errore. Dopo un segnale terminale non seguono altre chiamate. Le chiamate di una singola sottoscrizione sono ordinate dalla relazione happens-before. Non dare per scontati né la riproduzione degli elementi precedenti né una politica uniforme di scarto: dipendono dall’implementazione.
L’esempio usa SubmissionPublisher come implementazione e chiama subscribe tramite un riferimento Flow.Publisher<Integer>. Il destinatario richiede due elementi. La chiusura della sorgente avvia la conclusione normale, ma la consegna è asincrona, quindi CountDownLatch mantiene in esecuzione il programma finché il segnale terminale non viene gestito. Questa attesa dimostrativa non ha un limite di tempo; nel codice operativo occorre prevedere come gestire la mancata conclusione.
Esempi
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.Flow;
import java.util.concurrent.SubmissionPublisher;
public class Main {
public static void main(String[] args) throws InterruptedException {
CountDownLatch done = new CountDownLatch(1);
try (SubmissionPublisher<Integer> source = new SubmissionPublisher<>()) {
Flow.Publisher<Integer> publisher = source;
publisher.subscribe(new Flow.Subscriber<Integer>() {
public void onSubscribe(Flow.Subscription subscription) {
subscription.request(2);
}
public void onNext(Integer item) {
System.out.println(item);
}
public void onError(Throwable error) {
System.out.println("Error: " + error.getClass().getSimpleName());
done.countDown();
}
public void onComplete() {
System.out.println("Done");
done.countDown();
}
});
source.submit(10);
source.submit(20);
}
done.await();
}
}Risultato
10 20 Done
Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.