io.smallrye.reactive.messaging.annotations.Blocking Java Examples

public void defineWorker(String className, String method, String poolName) {
    Objects.requireNonNull(className, "className was empty");
    Objects.requireNonNull(method, "Method was empty");

    if (!poolName.equals(Blocking.DEFAULT_WORKER_POOL)) {
        // Validate @Blocking value is not empty, if set
        if (Validation.isBlank(poolName)) {
            throw getBlockingError(className, method, "value is blank or null");
        }

        // Validate @Blocking worker pool has configuration to define concurrency
        String workerConfigKey = WORKER_CONFIG_PREFIX + "." + poolName + "." + WORKER_CONCURRENCY;
        Optional<Integer> concurrency = ConfigProvider.getConfig().getOptionalValue(workerConfigKey, Integer.class);
        if (!concurrency.isPresent()) {
            throw getBlockingError(className, method, workerConfigKey + " was not defined");
        }

        workerConcurrency.put(poolName, concurrency.get());
    }
}
 

@Incoming("data")
@Outgoing("out")
@Blocking
@Acknowledgment(Acknowledgment.Strategy.POST_PROCESSING)
public String process(Message<String> m) {
    String s = m.getPayload();
    return CompletableFuture.supplyAsync(() -> {
        if (s.equalsIgnoreCase("b")) {
            // nacked.
            throw new IllegalArgumentException("b");
        }

        if (s.equalsIgnoreCase("e")) {
            // acked but not forwarded
            return null;
        }

        return s.toUpperCase();
    }).join();
}
 

@Incoming("data")
@Outgoing("out")
@Blocking
public String process(String s) {
    return CompletableFuture.supplyAsync(() -> {
        if (s.equalsIgnoreCase("b")) {
            // nacked.
            throw new IllegalArgumentException("b");
        }

        if (s.equalsIgnoreCase("e")) {
            // acked but not forwarded
            return null;
        }

        return s.toUpperCase();
    }).join();
}
 

public void defineWorker(String className, String method, String poolName) {
    Objects.requireNonNull(className, msg.classNameWasEmpty());
    Objects.requireNonNull(method, msg.methodWasEmpty());

    if (!poolName.equals(Blocking.DEFAULT_WORKER_POOL)) {
        // Validate @Blocking value is not empty, if set
        if (Validation.isBlank(poolName)) {
            throw ex.illegalArgumentForAnnotationNullOrBlank("@Blocking", className + "#" + method);
        }

        // Validate @Blocking worker pool has configuration to define concurrency
        String workerConfigKey = WORKER_CONFIG_PREFIX + "." + poolName + "." + WORKER_CONCURRENCY;
        Optional<Integer> concurrency = configInstance.get().getOptionalValue(workerConfigKey, Integer.class);
        if (!concurrency.isPresent()) {
            throw ex.illegalArgumentForWorkerConfigKey("@Blocking", className + "#" + method,
                    workerConfigKey);
        }

        workerConcurrency.put(poolName, concurrency.get());
    }
}
 

private MediatorConfiguration createMediatorConfiguration(Method met, Bean<?> bean) {
    DefaultMediatorConfiguration configuration = new DefaultMediatorConfiguration(met, bean);

    Incomings incomings = met.getAnnotation(Incomings.class);
    Incoming incoming = met.getAnnotation(Incoming.class);
    Outgoing outgoing = met.getAnnotation(Outgoing.class);
    Blocking blocking = met.getAnnotation(Blocking.class);
    if (incomings != null) {
        configuration.compute(incomings, outgoing, blocking);
    } else if (incoming != null) {
        configuration.compute(Collections.singletonList(incoming), outgoing, blocking);
    } else {
        configuration.compute(Collections.emptyList(), outgoing, blocking);
    }
    return configuration;
}
 

@Incoming("data")
@Outgoing("out")
@Blocking
public Message<String> process(Message<String> m) {
    String s = m.getPayload();
    return CompletableFuture.supplyAsync(() -> {
        if (s.equalsIgnoreCase("b")) {
            // we cannot fail, we must nack explicitly.
            m.nack(new IllegalArgumentException("b")).toCompletableFuture().join();
            return null;
        }

        return m.withPayload(s.toUpperCase());
    }).join();
}
 

@Blocking
@Incoming("count")
@Outgoing("sink")
public Publisher<String> process(Integer payload) {
    return ReactiveStreams.of(payload)
            .map(i -> i + 1)
            .flatMapRsPublisher(i -> Flowable.just(i, i))
            .map(i -> Integer.toString(i))
            .buildRs();
}
 

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

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

@Blocking
@Incoming("count")
@Outgoing("sink")
public Multi<String> process(Integer payload) {
    return Multi.createFrom().publisher(
            ReactiveStreams.of(payload)
                    .map(i -> i + 1)
                    .flatMapRsPublisher(i -> Flowable.just(i, i))
                    .map(i -> Integer.toString(i)).buildRs());
}
 

@Incoming("data")
@Blocking
public void consume(String s) {
    CompletableFuture.runAsync(() -> {
        if (s.equalsIgnoreCase("2") || s.equalsIgnoreCase("8")) {
            throw new IllegalArgumentException("boom");
        }
        list.add(s);
    }).join();
}
 

@Blocking
@Incoming("count")
@Outgoing("sink")
public Multi<Message<String>> process(Message<Integer> message) {
    return Multi.createFrom().publisher(
            ReactiveStreams.of(message)
                    .map(Message::getPayload)
                    .map(i -> i + 1)
                    .flatMapRsPublisher(i -> Flowable.just(i, i))
                    .map(i -> Integer.toString(i))
                    .map(Message::of).buildRs());
}
 

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

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

@Blocking
@Outgoing("infinite-producer")
public Message<Integer> create() {
    try {
        Thread.sleep(200);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    threads.add(Thread.currentThread().getName());
    return Message.of(count.incrementAndGet());
}
 

@Incoming("in")
@Blocking(ordered = false)
public void consume(String s) {
    if (s.equals("a") || s.equals("c") || s.equals("e")) {
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
    threads.add(Thread.currentThread().getName());
    list.add(s);
}
 

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

@Blocking
@Incoming("count")
public Uni<String> consume(String payload) {
    return Uni.createFrom().item(() -> {
        list.add(payload);
        return "hello";
    });
}
 

@Blocking
@Incoming("count")
public Uni<String> consume(Message<String> msg) {
    return Uni.createFrom().item(() -> {
        list.add(msg.getPayload());
        return "hello";
    });
}
 

@Blocking
@Incoming("count")
public Uni<Void> consume(String payload) {
    return Uni.createFrom().item(() -> {
        list.add(payload);
        return null;
    });
}
 

@Incoming("in")
@Blocking(value = "my-pool", ordered = false)
public void consume(String s) {
    if (s.equals("b") || s.equals("d") || s.equals("f")) {
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
    threads.add(Thread.currentThread().getName());
    list.add(s);
}
 

@Blocking
@Incoming("count")
@Outgoing("sink")
public String process(int value) {
    try {
        Thread.sleep(200);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    threads.add(Thread.currentThread().getName());
    return Integer.toString(value + 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);
}
 

@Blocking
@Incoming("count")
public Uni<Void> consume(Message<String> message) {
    return Uni.createFrom().item(() -> {
        list.add(message.getPayload());
        return null;
    });
}
 

@Blocking
@Incoming("count")
public CompletionStage<String> consume(String payload) {
    return CompletableFuture.supplyAsync(() -> {
        list.add(payload);
        return "hello";
    }, executor);
}
 

@Blocking
@Incoming("count")
public CompletionStage<String> consume(Message<String> msg) {
    return CompletableFuture.supplyAsync(() -> {
        list.add(msg.getPayload());
        return "hello";
    }, executor);
}
 

@Blocking
@Incoming("count")
public CompletionStage<Void> consume(String payload) {
    return CompletableFuture.supplyAsync(() -> {
        list.add(payload);
        return null;
    }, executor);
}
 

@Blocking
@Incoming("count")
public CompletionStage<Void> consume(Message<String> message) {
    return CompletableFuture.supplyAsync(() -> {
        list.add(message.getPayload());
        return null;
    }, executor);
}
 

@Blocking
@Outgoing("sink")
public PublisherBuilder<Message<String>> publisher() {
    return ReactiveStreams.fromPublisher(Flowable.range(1, 10))
            .flatMapRsPublisher(i -> Flowable.just(i, i))
            .map(i -> Integer.toString(i))
            .map(Message::of);
}
 

@Blocking
@Outgoing("sink")
public PublisherBuilder<String> publisher() {
    return ReactiveStreams.fromPublisher(Flowable.range(1, 10))
            .flatMapRsPublisher(i -> Flowable.just(i, i))
            .map(i -> Integer.toString(i));
}