org.eclipse.microprofile.reactive.messaging.Outgoing Java Examples

@Blocking
@Outgoing("infinite-producer-payload")
public int create() {
    try {
        Thread.sleep(200);
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
    threads.add(Thread.currentThread().getName());
    return count.incrementAndGet();
}
 

@Incoming("source")
@Outgoing("p1")
public Message<Integer> processMessage(Message<Integer> input) {
    JmsProperties properties = JmsProperties.builder().with("prop", "bar").build();
    return Message.of(input.getPayload())
            .withMetadata(Metadata.of(OutgoingJmsMessageMetadata.builder()
                    .withProperties(properties)
                    .withCorrelationId("my-correlation-" + input.getPayload())
                    .withDestination(queue)
                    .build()));
}
 

@Incoming("in")
@Outgoing("out-1")
public Multi<String> processPayload(String s) {
    if (s.equalsIgnoreCase("skip")) {
        return Multi.createFrom().empty();
    }
    return Multi.createFrom().item(s.toUpperCase());
}
 

@Incoming(NO_ACKNOWLEDGMENT)
@Acknowledgment(Acknowledgment.Strategy.NONE)
@Outgoing("sink-" + NO_ACKNOWLEDGMENT)
public Publisher<Message<String>> processorWithNoAck(Message<String> input) {
    return ReactiveStreams.of(input)
            .flatMap(m -> ReactiveStreams.of(Message.of(m.getPayload()), Message.of(m.getPayload())))
            .peek(m -> processed(NO_ACKNOWLEDGMENT, m))
            .buildRs();
}
 

@Incoming(MANUAL_ACKNOWLEDGMENT)
@Acknowledgment(Acknowledgment.Strategy.MANUAL)
@Outgoing("sink-" + MANUAL_ACKNOWLEDGMENT)
public Publisher<Message<String>> processorWithAck(Publisher<Message<String>> input) {
    return ReactiveStreams.fromPublisher(input)
            .flatMapCompletionStage(m -> m.ack().thenApply(x -> m))
            .flatMap(m -> ReactiveStreams.of(Message.of(m.getPayload()), Message.of(m.getPayload())))
            .peek(m -> processed(MANUAL_ACKNOWLEDGMENT, m.getPayload()))
            .buildRs();
}
 

@Outgoing("prices")
public Multi<Double> generate() {
    // Build an infinite stream of random prices
    // It emits a price every second
    return Multi.createFrom().ticks().every(Duration.ofSeconds(1))
        .map(x -> random.nextDouble());
}
 

@Incoming(MANUAL_ACKNOWLEDGMENT)
@Acknowledgment(Acknowledgment.Strategy.MANUAL)
@Outgoing("sink-" + MANUAL_ACKNOWLEDGMENT)
public Publisher<Message<String>> processorWithAck(Message<String> input) {
    return ReactiveStreams.of(input)
            .flatMapCompletionStage(m -> m.ack().thenApply(x -> m))
            .flatMap(m -> ReactiveStreams.of(Message.of(m.getPayload()), Message.of(m.getPayload())))
            .peek(i -> processed(MANUAL_ACKNOWLEDGMENT, input))
            .buildRs();
}
 

@Incoming("count")
@Outgoing("sink")
public Publisher<String> process(Flux<Integer> source) {
    return source
            .map(i -> i + 1)
            .flatMap(i -> Flowable.just(i, i))
            .map(i -> Integer.toString(i));
}
 

@Outgoing("temperature-values")
public Flowable<KafkaRecord<Integer, String>> generate() {

    return Flowable.interval(500, TimeUnit.MILLISECONDS)
            .onBackpressureDrop()
            .map(tick -> {
                WeatherStation station = stations.get(random.nextInt(stations.size()));
                double temperature = BigDecimal.valueOf(random.nextGaussian() * 15 + station.averageTemperature)
                        .setScale(1, RoundingMode.HALF_UP)
                        .doubleValue();

                LOG.infov("station: {0}, temperature: {1}", station.name, temperature);
                return KafkaRecord.of(station.id, Instant.now() + ";" + temperature);
            });
}
 

@Incoming("numbers")
@Outgoing("http")
public HttpMessage<JsonObject> sink(int i) {
    return HttpMessage.HttpMessageBuilder.<JsonObject> create()
            .withMethod("PUT")
            .withPayload(new JsonObject().put("value", i + 1))
            .withHeader("Content-Type", "application/json")
            .build();
}
 

@Incoming(NO_ACKNOWLEDGMENT)
@Acknowledgment(Acknowledgment.Strategy.NONE)
@Outgoing("sink-" + NO_ACKNOWLEDGMENT)
public Publisher<Message<String>> processorWithNoAck(Publisher<Message<String>> input) {
    return ReactiveStreams.fromPublisher(input)
            .flatMap(m -> ReactiveStreams.of(Message.of(m.getPayload()), Message.of(m.getPayload())))
            .peek(m -> processed(NO_ACKNOWLEDGMENT, m.getPayload()))
            .buildRs();
}
 

@Incoming("count")
@Outgoing("sink")
public Flux<Message<String>> process(Flux<Message<Integer>> source) {
    return source
            .map(Message::getPayload)
            .map(i -> i + 1)
            .flatMap(i -> Flowable.just(i, i))
            .map(i -> Integer.toString(i))
            .map(Message::of);
}
 

@Outgoing("temperature-values")
public Flowable<KafkaRecord<String, String>> generate() {

    return Flowable.interval(10, TimeUnit.MILLISECONDS)
            .map(tick -> {
                double temperature = BigDecimal.valueOf(random.nextGaussian() * 15)
                        .setScale(1, RoundingMode.HALF_UP)
                        .doubleValue();
                return KafkaRecord.of("1", Instant.now().toEpochMilli() + ";" + temperature);
            });
}
 

@Incoming(PAYLOAD_PRE_ACKNOWLEDGMENT)
@Acknowledgment(Acknowledgment.Strategy.PRE_PROCESSING)
@Outgoing("sink-" + PAYLOAD_PRE_ACKNOWLEDGMENT)
public Publisher<String> processorWithPrePayloadAck(Publisher<String> input) {
    return ReactiveStreams.fromPublisher(input)
            .flatMap(p -> ReactiveStreams.of(p, p))
            .peek(m -> processed(PAYLOAD_PRE_ACKNOWLEDGMENT, m))
            .buildRs();
}
 

@Outgoing("prices")
public Multi<Message<String>> generate() {
    // Build an infinite stream of random prices
    return Multi.createFrom().ticks().every(Duration.ofMillis(100))
            .on().overflow().drop()
            .map(x -> random.nextDouble())
            .map(p -> Double.toString(p))
            .map(Message::of);
}
 

@Incoming("in")
@Outgoing("out-3")
public Multi<String> processPayloadStream(Multi<String> stream) {
    return stream
            .transform().byFilteringItemsWith(s -> !s.equalsIgnoreCase("skip"))
            .onItem().apply(String::toUpperCase);
}
 

@Incoming("in")
@Outgoing("out")
public Multi<Message<String>> processMessageStream(Multi<Message<Integer>> stream) {
    return
        stream
            .onItem().produceUni(message ->
            invokeService(message.getPayload())
                .onFailure().recoverWithItem("fallback")
                .onItem().apply(message::withPayload)
        )
            .concatenate();

}
 

@Outgoing(POST_ACKNOWLEDGMENT)
public Publisher<Message<String>> sourceToPostAck() {
    return Multi.createFrom().items("a", "b", "c", "d", "e")
            .map(payload -> Message.of(payload, () -> {
                nap();
                acknowledged(POST_ACKNOWLEDGMENT, payload);
                return CompletableFuture.completedFuture(null);
            }));
}
 

@Outgoing(MANUAL_ACKNOWLEDGMENT_BUILDER)
public PublisherBuilder<Message<String>> sourceToManualAckWithBuilder() {
    return ReactiveStreams.of("a", "b", "c", "d", "e")
            .map(payload -> Message.of(payload, () -> CompletableFuture.runAsync(() -> {
                nap();
                acknowledged(MANUAL_ACKNOWLEDGMENT_BUILDER, payload);
            })));
}
 

@Outgoing(PRE_ACKNOWLEDGMENT_BUILDER)
public Publisher<Message<String>> sourceToPreAckBuilder() {
    return Multi.createFrom().items("a", "b", "c", "d", "e")
            .map(payload -> Message.of(payload, () -> {
                nap();
                acknowledged(PRE_ACKNOWLEDGMENT_BUILDER, payload);
                return CompletableFuture.completedFuture(null);
            }));
}
 

@Outgoing(PRE_ACKNOWLEDGMENT_UNI)
public Publisher<Message<String>> sourceToPreAckUni() {
    return Multi.createFrom().items("a", "b", "c", "d", "e")
            .map(payload -> Message.of(payload, () -> {
                nap();
                acknowledged(PRE_ACKNOWLEDGMENT_UNI, payload);
                return CompletableFuture.completedFuture(null);
            }));
}
 

@Incoming("source")
@Outgoing("output")
public Message<Integer> processMessage(Message<Integer> input) {
    return KafkaRecord.from(input)
            .withNack(cause -> {
                assertThat(cause).isNotNull();
                m2Nack.incrementAndGet();
                input.nack(cause);
                return CompletableFuture.completedFuture(null);
            });
}
 

@Incoming("count")
@Outgoing("sink")
public PublisherBuilder<String> process(PublisherBuilder<Integer> source) {
    return source
            .map(i -> i + 1)
            .flatMapRsPublisher(i -> Flowable.just(i, i))
            .map(i -> Integer.toString(i));
}
 

@Incoming(NO_ACKNOWLEDGMENT)
@Acknowledgment(Acknowledgment.Strategy.NONE)
@Outgoing("sink-" + NO_ACKNOWLEDGMENT)
public String processorWithNoAck(String input) {
    processed(NO_ACKNOWLEDGMENT, input);
    return input + "1";
}
 

@Blocking
@Incoming("count")
@Outgoing("sink")
public String process(Message<Integer> value) {
    try {
        Thread.sleep(200);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    threads.add(Thread.currentThread().getName());
    return Integer.toString(value.getPayload() + 1);
}
 

@Outgoing(PAYLOAD_PRE_ACKNOWLEDGMENT_BUILDER)
public Publisher<Message<String>> sourceToPreWithPayloadAckWithBuilder() {
    return Multi.createFrom().items("a", "b", "c", "d", "e")
            .map(payload -> Message.of(payload, () -> {
                nap();
                acknowledged(PAYLOAD_PRE_ACKNOWLEDGMENT_BUILDER, payload);
                return CompletableFuture.completedFuture(null);
            }));
}
 

@Outgoing(NO_ACKNOWLEDGMENT_BUILDER)
public Publisher<Message<String>> sourceToNoAckWithBuilder() {
    return Multi.createFrom().items("a", "b", "c", "d", "e")
            .map(payload -> Message.of(payload, () -> {
                nap();
                acknowledged(NO_ACKNOWLEDGMENT_BUILDER, payload);
                return CompletableFuture.completedFuture(null);
            }));
}
 

@Incoming("in")
@Outgoing("out")
@Acknowledgment(Acknowledgment.Strategy.PRE_PROCESSING)
public String process(String input) {
    // The message wrapping the payload is already acknowledged
    // The default would have waited the produced message to be
    // acknowledged
    return input.toUpperCase();
}
 

@Incoming(PRE_ACKNOWLEDGMENT)
@Acknowledgment(Acknowledgment.Strategy.PRE_PROCESSING)
@Outgoing("sink-" + PRE_ACKNOWLEDGMENT)
public Processor<String, String> processorWithPreAck() {
    return ReactiveStreams.<String> builder()
            .flatMap(m -> ReactiveStreams.of(m, m))
            .peek(m -> processed(PRE_ACKNOWLEDGMENT, m))
            .buildRs();
}
 

@Incoming("hello")
@Outgoing("out")
public Flowable<String> consume(Flowable<String> values) {
    Scheduler scheduler = Schedulers.from(executor);
    return values
            .observeOn(scheduler)
            .delay(1, TimeUnit.MILLISECONDS, scheduler)
            .doOnError(err -> {
                downstreamFailure = err;
            });
}