Java Code Examples for org.eclipse.microprofile.reactive.messaging.Message#of()

@Test
public void testGetObject() {
    Person person = new Person();
    person.name = "mark";
    byte[] bytes = new byte[] { 1, 2, 3, 4 };

    Metadata metadata = Metadata.of(person, bytes);
    Message<String> message = Message.of("ignored", metadata);

    Person p = message.getMetadata(Person.class).orElseThrow(() -> new AssertionError("Metadata expected"));
    assertThat(p).isNotNull();
    assertThat(p.name).isEqualTo("mark");

    byte[] b = message.getMetadata(byte[].class).orElseThrow(() -> new AssertionError("Metadata expected"));
    assertThat(b).isNotNull().hasSize(4).containsExactly(1, 2, 3, 4);
}
 

public void copy() {
    Price price = new Price(20.5);
    Message<Price> message = Message.of(price);
    // tag::copy[]

    // Create a new message with a new payload but with the same metadata
    Message<Price> m1 = message.withPayload(new Price(12.4));

    // Create a new message with a new payload and add another metadata
    Message<Price> m2 = message
        .withPayload(new Price(15.0))
        .withMetadata(Metadata.of(new PriceMetadata()));

    // Create a new message with a new payload and a custom acknowledgement
    Message<Price> m3 = message
        .withPayload(new Price(15.0))
        .withAck(() ->
            // acknowledge the incoming message
            message.ack()
                .thenAccept(x -> {
                    // do something
                }));
    // end::copy[]
}
 

@Test
public void testFrom() {
    Message<String> message = Message.of("hello");
    assertThat(message.getPayload()).isEqualTo("hello");
    assertThat(message.getMetadata()).isEmpty();
    assertThat(message.ack()).isCompleted();

    Message<String> message2 = message.withMetadata(Metadata.of(new MyMetadata<>("bar")));
    assertThat(message2.getPayload()).isEqualTo("hello");
    assertThat(message2.getMetadata()).hasSize(1);
    assertThat(message2.getMetadata(MyMetadata.class).map(m -> m.v)).hasValue("bar");
    assertThat(message2.ack()).isCompleted();
    assertThat(message).isNotEqualTo(message2);

    Message<String> message3 = message2.withAck(CompletableFuture::new);
    assertThat(message3.getPayload()).isEqualTo("hello");
    assertThat(message3.getMetadata()).hasSize(1);
    assertThat(message3.getMetadata(MyMetadata.class).map(m -> m.v)).hasValue("bar");
    assertThat(message3.ack()).isNotCompleted();
    assertThat(message3).isNotEqualTo(message2).isNotEqualTo(message);

    Message<List<String>> message4 = message3.withPayload(Collections.singletonList("foo"));
    assertThat(message4.getPayload()).containsExactly("foo");
    assertThat(message4.getMetadata()).hasSize(1);
    assertThat(message4.getMetadata(MyMetadata.class).map(m -> m.v)).hasValue("bar");
    assertThat(message4.ack()).isNotCompleted();
    assertThat(message4).isNotEqualTo(message2).isNotEqualTo(message3).isNotEqualTo(message);
}
 

@Incoming("in")
@Outgoing("out")
public Message<Integer> processAndProduceNewMessage(Message<Integer> in) {
    // The acknowledgement is forwarded, when the consumer
    // acknowledges the message, `in` will be acknowledged
    return Message.of(in.getPayload() + 1,
        () -> {
            // Called when the consumer acknowledges the message
            // ...
            // Don't forget to acknowledge the incoming message:
            return in.ack();
        });
}
 

@Incoming("data")
@Outgoing("sink")
@Acknowledgment(Acknowledgment.Strategy.MANUAL)
public Message<Integer> process(Message<Integer> input) {
    kafka.add(input);
    return Message.of(input.getPayload() + 1, input::ack);
}
 

public void creation() {
    Price price = new Price(20.5);
    // tag::creation[]

    // Create a simple message wrapping a payload
    Message<Price> m1 = Message.of(price);

    // Create a message with metadata
    Message<Price> m2 = Message.of(price, Metadata.of(new PriceMetadata()));

    // Create a message with several metadata
    Message<Price> m3 = Message.of(price,
        Metadata.of(new PriceMetadata(), new MyMetadata()));

    // Create a message with an acknowledgement callback
    Message<Price> m4 = Message.of(price, () -> {
        // Called when the message is acknowledged by the next consumer.
        return CompletableFuture.completedFuture(null);
    });

    // Create a message with both metadata and acknowledgement callback
    Message<Price> m5 = Message.of(price,
        Metadata.of(new PriceMetadata()),
        () -> {
            // Called when the message is acknowledged by the next consumer.
            return CompletableFuture.completedFuture(null);
        });
    // end::creation[]
}
 

@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(NO_ACKNOWLEDGMENT)
@Acknowledgment(Acknowledgment.Strategy.NONE)
@Outgoing("sink")
public Message<String> processorWithNoAck(Message<String> input) {
    processed(NO_ACKNOWLEDGMENT, input);
    return Message.of(input.getPayload() + "1");
}
 

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

@Test
public void testMessageCreation() {
    Message<String> message = Message.of("hello");
    assertThat(message.getPayload()).isEqualTo("hello");
    assertThat(message.getMetadata()).isEmpty();
    assertThat(message.ack()).isCompleted();

    Supplier<CompletionStage<Void>> supplier = () -> CompletableFuture.completedFuture(null);
    message = Message.of("hello", supplier);
    assertThat(message.getPayload()).isEqualTo("hello");
    assertThat(message.getMetadata()).isEmpty();
    assertThat(message.getAck()).isEqualTo(supplier);
    assertThat(message.ack()).isCompleted();

    message = Message.of("hello", Metadata.of(new MyMetadata<>("v")));
    assertThat(message.getPayload()).isEqualTo("hello");
    assertThat(message.getMetadata()).hasSize(1);
    assertThat(message.getMetadata(MyMetadata.class).map(m -> m.v)).hasValue("v");
    assertThat(message.ack()).isCompleted();

    message = Message.of("hello", Metadata.of(new MyMetadata<>("v")), supplier);
    assertThat(message.getPayload()).isEqualTo("hello");
    assertThat(message.getMetadata()).hasSize(1);
    assertThat(message.getMetadata(MyMetadata.class).map(m -> m.v)).hasValue("v");
    assertThat(message.getAck()).isEqualTo(supplier);
    assertThat(message.ack()).isCompleted();

    message = Message.of("hello", Metadata.of(new MyMetadata<>("v")), null);
    assertThat(message.getPayload()).isEqualTo("hello");
    assertThat(message.getMetadata()).hasSize(1);
    assertThat(message.getMetadata(MyMetadata.class).map(m -> m.v)).hasValue("v");
    assertThat(message.getAck()).isNotEqualTo(supplier);
    assertThat(message.ack()).isCompleted();
}
 

@Incoming("data")
@Outgoing("sink")
@Acknowledgment(Acknowledgment.Strategy.MANUAL)
public Message<Integer> process(AmqpMessage<Integer> input) {
    int value = input.getPayload();
    return Message.of(value + 1, input::ack);
}
 

public void sendWithAcknowledgement(MockPayload payload) {
    System.out.println("Sending with ACK " + payload);
    AtomicReference<Message<MockPayload>> reference = new AtomicReference<>();
    Message<MockPayload> msg = Message.of(payload, () -> {
        System.out.println("Acknowledging " + payload);
        inflights.remove(reference.get());
        return CompletableFuture.completedFuture(null);
    });
    reference.set(msg);
    send(msg);
}
 

@Test
public void testPropagation() throws JMSException {
    MapBasedConfig config = new MapBasedConfig.Builder()
            .put("destination", "queue-one")
            .put("channel-name", "jms")
            .put("ttl", 10000L)
            .build();
    JmsSink sink = new JmsSink(jms, new JmsConnectorOutgoingConfiguration(config), json, executor);
    MyJmsClient client = new MyJmsClient(jms.createQueue("queue-one"));
    subscriber = sink.getSink().build();
    subscriber.onSubscribe(new Subscriptions.EmptySubscription());
    AtomicBoolean acked = new AtomicBoolean();
    Message<String> hello = Message.of("hello",
            () -> CompletableFuture.runAsync(() -> acked.set(true)));

    Destination rt = jms.createQueue("reply-to");

    OutgoingJmsMessageMetadata metadata = OutgoingJmsMessageMetadata.builder()
            .withCorrelationId("my-correlation-id")
            .withReplyTo(rt)
            .withDeliveryMode(DeliveryMode.PERSISTENT)
            .withType(String.class.getName())
            .build();

    hello = hello.withMetadata(Collections.singleton(metadata));
    subscriber.onNext(hello);

    await().until(() -> client.messages.size() >= 1);
    assertThat(acked).isTrue();
    javax.jms.Message message = client.messages.get(0);
    assertThat(message.getBody(String.class)).isEqualTo("hello");
    assertThat(message.getJMSCorrelationID()).isEqualTo("my-correlation-id");
    assertThat(message.getJMSReplyTo()).isEqualTo(rt);
    assertThat(message.getJMSDeliveryMode()).isEqualTo(2);
    assertThat(message.getJMSType()).isEqualTo(String.class.getName());

}
 

@Incoming("data")
@Outgoing("sink")
@Acknowledgment(Acknowledgment.Strategy.MANUAL)
public Message<Integer> process(Message<Integer> input) {
    return Message.of(input.getPayload() + 1, input::ack);
}
 

@Incoming("data")
@Outgoing("sink")
public Message<Integer> process(MqttMessage<byte[]> input) {
    String s = new String(input.getPayload());
    return Message.of(Integer.parseInt(s) + 1);
}
 

@Incoming("publisher-synchronous-message")
@Outgoing("synchronous-message")
public Message<String> messageSynchronous(Message<Integer> message) {
  increment("synchronous-message");
  return Message.of(Integer.toString(message.getPayload() + 1));
}
 

@Incoming("count")
@Outgoing("sink")
public Message<String> process(int value) {
    return Message.of(Integer.toString(value + 1));
}
 

@Incoming("numbers")
@Outgoing("http")
public Message<JsonObject> sink(int i) {
    return Message.of(new JsonObject().put("value", i + 1));
}
 

@Outgoing("my-channel")
public Message<Integer> generateMessagesSynchronously() {
    return Message.of(counter.getAndIncrement());
}
 

@Outgoing("F")
public Message<Integer> produce() {
    return Message.of(count.getAndIncrement());
}