Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / Java

Flow.Publisher — publicar elementos com controlo da procura

Flow.Publisher<T> descreve uma origem de elementos recebidos pelos subscritores. O método subscribe liga um recetor à origem, enquanto Flow.Subscription permite pedir elementos e cancelar a receção.

Versão: Java SE 21; repository runtime, production runtime not attested

Sintaxe

Flow.Publisher<T>
void subscribe(Flow.Subscriber<? super T> subscriber)

Flow.Publisher<T> é uma interface funcional em java.util.concurrent. Flow.Publisher.subscribe tem a assinatura void subscribe(Flow.Subscriber<? super T> subscriber). O tipo curinga ? super T aceita um recetor do tipo T ou de um supertipo. Um recetor aceite recebe onSubscribe com um objeto Flow.Subscription; um argumento null provoca NullPointerException. Uma subscrição duplicada ou uma rejeição devido a uma política ou a um erro é assinalada através de onError com IllegalStateException.

Por si só, chamar subscribe não cria procura. request(n) acrescenta procura para até n elementos adicionais; se n <= 0, onError é chamado com IllegalArgumentException. Trata-se de controlo de fluxo (backpressure), não de uma garantia de entrega de exatamente n elementos. cancel() interrompe a receção segundo o princípio do melhor esforço: ainda podem chegar mensagens e não é obrigatório um sinal terminal.

Os elementos chegam através de onNext; onComplete indica uma conclusão normal e onError indica uma falha. Não há mais chamadas após um sinal terminal. As chamadas de uma subscrição são ordenadas pela relação happens-before. Não pressuponha a reprodução de elementos anteriores nem uma política uniforme de descarte: ambas dependem da implementação.

O exemplo usa SubmissionPublisher como implementação e chama subscribe através de uma referência Flow.Publisher<Integer>. O recetor pede dois elementos. O fecho da origem inicia a conclusão normal, mas a entrega é assíncrona, pelo que CountDownLatch mantém o programa em execução até o sinal terminal ser processado. Esta espera demonstrativa não tem limite de tempo; em código operacional, deve prever-se como lidar com a ausência de conclusão.

Exemplos

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();
    }
}

Resultado

10
20
Done

O código apresentado e o resultado declarado foram verificados num ambiente isolado pelo método registado na prova de verificação desta versão exata.

Fontes