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

CKTIS / Java

Flow.Subscriber — receber elementos com controlo da procura

Flow.Subscriber<T> recebe elementos e sinais terminais de um publicador. A subscrição permite-lhe expressar a procura através de request(n), permitindo ao recetor controlar quantos elementos são entregues.

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

Sintaxe

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> de java.util.concurrent é uma interface recetora. T especifica o tipo do elemento. As chamadas relativas à mesma Flow.Subscription são estritamente sequenciais; isto não significa que estejam associadas a uma única thread.

Flow.Subscriber.onSubscribe(Flow.Subscription subscription) recebe a subscrição antes dos outros métodos. Guarde-a e solicite elementos. Flow.Subscriber.onNext(T item) processa um elemento. request(n) acrescenta procura em vez de substituir a procura anterior. Numa subscrição ativa, uma chamada a request(n) com n <= 0 gera um sinal onError com IllegalArgumentException. Após o cancelamento da subscrição ou após um sinal terminal, uma chamada a request(n) não gera um novo sinal onError. Sem procura, não são entregues elementos. Este mecanismo é o controlo do fluxo, ou backpressure.

Flow.Subscriber.onError(Throwable throwable) assinala um erro irrecuperável, enquanto Flow.Subscriber.onComplete() assinala a conclusão normal. Ambos são terminais: depois de qualquer um deles, a subscrição não invoca mais métodos do recetor. Não utilize exceções lançadas pelos métodos do recetor como protocolo de erro: a interface não garante que o comportamento subsequente seja correto. cancel() atua segundo o melhor esforço possível: ainda podem chegar mensagens e não é garantido um sinal terminal.

O exemplo utiliza SubmissionPublisher e solicita outro elemento apenas depois de processar o atual. close() termina a publicação, mas não substitui a espera pela entrega; done.join() aguarda que o recetor termine. O exemplo mostra o percurso normal; um erro conclui done excecionalmente.

Exemplos

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

Resultado

item=10
item=20
complete

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