CKTIS / Java
Flow.Subscriber — prejemanje elementov z nadzorom povpraševanja
Flow.Subscriber<T> prejema elemente in zaključne signale od izdajatelja. Z naročnino lahko izrazi povpraševanje z request(n) in tako nadzoruje, koliko elementov bo dostavljenih.
Različica: Java SE 21; repository runtime, production runtime not attested
Sintaksa
class Receiver<T> implements Flow.Subscriber<T> {
public void onSubscribe(Flow.Subscription subscription) { }
public void onNext(T item) { }
public void onError(Throwable throwable) { }
public void onComplete() { }
}Flow.Subscriber<T> iz java.util.concurrent je vmesnik prejemnika. T določa vrsto elementa. Klici za isto Flow.Subscription potekajo strogo zaporedno; to ne pomeni, da so vezani na eno nit.
Flow.Subscriber.onSubscribe(Flow.Subscription subscription) prejme naročnino pred drugimi metodami. Shranite jo in zahtevajte elemente. Flow.Subscriber.onNext(T item) obdela en element. request(n) poveča povpraševanje, namesto da bi nadomestil prejšnje. Pri aktivni naročnini klic request(n) z n <= 0 sproži signal onError z IllegalArgumentException. Po preklicu naročnine ali po končnem signalu klic request(n) ne sproži novega signala onError. Brez povpraševanja se elementi ne dostavljajo. To je nadzor pretoka oziroma backpressure.
Flow.Subscriber.onError(Throwable throwable) sporoči nepopravljivo napako, Flow.Subscriber.onComplete() pa običajen zaključek. Oba signala sta končna: po katerem koli od njiju naročnina ne kliče več metod prejemnika. Izjem, vrženih iz metod prejemnika, ne uporabljajte kot protokol za napake: vmesnik v tem primeru ne zagotavlja pravilnega nadaljnjega delovanja. cancel() deluje po najboljših močeh: sporočila lahko še vedno prispejo, končni signal pa ni zagotovljen.
Primer uporablja SubmissionPublisher in naslednji element zahteva šele, ko obdela trenutnega. close() konča objavljanje, vendar ne nadomesti čakanja na dostavo; done.join() počaka, da se prejemnik konča. Primer prikazuje običajen potek; napaka zaključi done izjemoma.
Primeri
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Flow;
import java.util.concurrent.SubmissionPublisher;
public class Main {
static final class Receiver implements Flow.Subscriber<Integer> {
private Flow.Subscription subscription;
final CompletableFuture<Void> done = new CompletableFuture<>();
@Override
public void onSubscribe(Flow.Subscription subscription) {
this.subscription = subscription;
subscription.request(1);
}
@Override
public void onNext(Integer item) {
System.out.println("item=" + item);
subscription.request(1);
}
@Override
public void onError(Throwable throwable) {
done.completeExceptionally(throwable);
}
@Override
public void onComplete() {
System.out.println("complete");
done.complete(null);
}
}
public static void main(String[] args) {
Receiver receiver = new Receiver();
try (SubmissionPublisher<Integer> publisher = new SubmissionPublisher<>()) {
publisher.subscribe(receiver);
publisher.submit(10);
publisher.submit(20);
}
receiver.done.join();
}
}Rezultat
item=10 item=20 complete
Prikazana koda in navedeni rezultat sta bila preverjena v izoliranem okolju z metodo, zapisano v dokazilu o preverjanju te natančne različice.