Java Code Examples for org.springframework.cloud.stream.messaging.Sink#INPUT

/**
 * Very generic listener for simplicity. It takes all events and checks, if a 
 * flow instance is interested. If yes, they are correlated, 
 * otherwise they are just discarded.
 *  
 * It might make more sense to handle each and every message type individually.
 */
@StreamListener(target = Sink.INPUT, 
    condition="(headers['type']?:'').endsWith('Event')")
@Transactional
public void messageReceived(String messageJson) throws Exception {
  Message<JsonNode> message = objectMapper.readValue( //
      messageJson, //
      new TypeReference<Message<JsonNode>>() {});
  
  long correlatingInstances = camunda.getRuntimeService().createExecutionQuery() //
    .messageEventSubscriptionName(message.getType()) //
    .processInstanceBusinessKey(message.getTraceid()) //
    .count();
  
  if (correlatingInstances==1) {
    System.out.println("Correlating " + message + " to waiting flow instance");
    
    camunda.getRuntimeService().createMessageCorrelation(message.getType())
      .processInstanceBusinessKey(message.getTraceid())
      .setVariable(//
          "PAYLOAD_" + message.getType(), // 
          SpinValues.jsonValue(message.getData().toString()).create())//
      .correlateWithResult();
  } 
  
}
 

@StreamListener(target = Sink.INPUT)
public void process(Event<Integer, Recommendation> event) {

    LOG.info("Process message created at {}...", event.getEventCreatedAt());

    switch (event.getEventType()) {

    case CREATE:
        Recommendation recommendation = event.getData();
        LOG.info("Create recommendation with ID: {}/{}", recommendation.getProductId(), recommendation.getRecommendationId());
        recommendationService.createRecommendation(recommendation);
        break;

    case DELETE:
        int productId = event.getKey();
        LOG.info("Delete recommendations with ProductID: {}", productId);
        recommendationService.deleteRecommendations(productId);
        break;

    default:
        String errorMessage = "Incorrect event type: " + event.getEventType() + ", expected a CREATE or DELETE event";
        LOG.warn(errorMessage);
        throw new EventProcessingException(errorMessage);
    }

    LOG.info("Message processing done!");
}
 

@StreamListener(target = Sink.INPUT, condition = "(headers['type']?:'')=='GoodsShippedEvent'")
@Transactional
public void goodsShippedReceived(String messageJson) throws Exception {
  Message<GoodsShippedEventPayload> message = objectMapper.readValue(messageJson, new TypeReference<Message<GoodsShippedEventPayload>>() {});

  String shipmentId = message.getData().getShipmentId();     

  zeebe.newPublishMessageCommand() //
      .messageName(message.getType()) //
      .correlationKey(message.getCorrelationid()) //
      .variables(Collections.singletonMap("shipmentId", shipmentId)) //
      .send().join();

  System.out.println("Correlated " + message );
}
 

@StreamListener(Sink.INPUT)
public void receiveConcurrentlyMsg(String receiveMsg) {
    log.info("invoke: " + count.get());
	if (count.getAndIncrement() <= 5) {
           throw new RuntimeException("Oops: " + receiveMsg);
	}
	else {
		log.info("receiveConcurrentlyMsg: " + receiveMsg);
	}
}
 

@StreamListener(target = Sink.INPUT)
public void process(Event<Integer, Recommendation> event) {

    LOG.info("Process message created at {}...", event.getEventCreatedAt());

    switch (event.getEventType()) {

    case CREATE:
        Recommendation recommendation = event.getData();
        LOG.info("Create recommendation with ID: {}/{}", recommendation.getProductId(), recommendation.getRecommendationId());
        recommendationService.createRecommendation(recommendation);
        break;

    case DELETE:
        int productId = event.getKey();
        LOG.info("Delete recommendations with ProductID: {}", productId);
        recommendationService.deleteRecommendations(productId);
        break;

    default:
        String errorMessage = "Incorrect event type: " + event.getEventType() + ", expected a CREATE or DELETE event";
        LOG.warn(errorMessage);
        throw new EventProcessingException(errorMessage);
    }

    LOG.info("Message processing done!");
}
 

@StreamListener(target = Sink.INPUT)
public void process(Event<Integer, Product> event) {

    LOG.info("Process message created at {}...", event.getEventCreatedAt());

    switch (event.getEventType()) {

    case CREATE:
        Product product = event.getData();
        LOG.info("Create product with ID: {}", product.getProductId());
        productService.createProduct(product);
        break;

    case DELETE:
        int productId = event.getKey();
        LOG.info("Delete recommendations with ProductID: {}", productId);
        productService.deleteProduct(productId);
        break;

    default:
        String errorMessage = "Incorrect event type: " + event.getEventType() + ", expected a CREATE or DELETE event";
        LOG.warn(errorMessage);
        throw new EventProcessingException(errorMessage);
    }

    LOG.info("Message processing done!");
}
 

@StreamListener(target = Sink.INPUT)
public void process(Event<Integer, Product> event) {

    LOG.info("Process message created at {}...", event.getEventCreatedAt());

    switch (event.getEventType()) {

    case CREATE:
        Product product = event.getData();
        LOG.info("Create product with ID: {}", product.getProductId());
        productService.createProduct(product);
        break;

    case DELETE:
        int productId = event.getKey();
        LOG.info("Delete recommendations with ProductID: {}", productId);
        productService.deleteProduct(productId);
        break;

    default:
        String errorMessage = "Incorrect event type: " + event.getEventType() + ", expected a CREATE or DELETE event";
        LOG.warn(errorMessage);
        throw new EventProcessingException(errorMessage);
    }

    LOG.info("Message processing done!");
}
 

@StreamListener(target = Sink.INPUT)
public void process(Event<Integer, Recommendation> event) {

    LOG.info("Process message created at {}...", event.getEventCreatedAt());

    switch (event.getEventType()) {

    case CREATE:
        Recommendation recommendation = event.getData();
        LOG.info("Create recommendation with ID: {}/{}", recommendation.getProductId(), recommendation.getRecommendationId());
        recommendationService.createRecommendation(recommendation);
        break;

    case DELETE:
        int productId = event.getKey();
        LOG.info("Delete recommendations with ProductID: {}", productId);
        recommendationService.deleteRecommendations(productId);
        break;

    default:
        String errorMessage = "Incorrect event type: " + event.getEventType() + ", expected a CREATE or DELETE event";
        LOG.warn(errorMessage);
        throw new EventProcessingException(errorMessage);
    }

    LOG.info("Message processing done!");
}
 

@StreamListener
public void process(@Input(Sink.INPUT) Flux<String> names) {
		names
			.map(Author::new)
			.flatMap(this.repository::save)
			.subscribe(saved -> System.out.println("saved " + saved.toString() + '.'));
}
 

@StreamListener(Sink.INPUT)
public void receiveOrderlyMsg(String receiveMsg) {
	if (count.getAndIncrement() <= 5) {
           throw new RuntimeException("Oops: " + receiveMsg);
	}
	else {
		log.info("receiveOrderlyMsg: " + receiveMsg);
	}
}
 

@StreamListener(target = Sink.INPUT, condition = "(headers['type']?:'')=='PaymentReceivedEvent'")
@Transactional
public void paymentReceived(String messageJson) throws Exception {
  Message<PaymentReceivedEventPayload> message = objectMapper.readValue(messageJson, new TypeReference<Message<PaymentReceivedEventPayload>>() {});

  PaymentReceivedEventPayload event = message.getData(); // TODO: Read something from it? 

  zeebe.newPublishMessageCommand() //
    .messageName(message.getType())
    .correlationKey(message.getCorrelationid())
    .variables(Collections.singletonMap("paymentInfo", "YeahWeCouldAddSomething"))
    .send().join();
  
  System.out.println("Correlated " + message );
}
 

@StreamListener(target = Sink.INPUT)
public void process(Event<Integer, Recommendation> event) {

    LOG.info("Process message created at {}...", event.getEventCreatedAt());

    switch (event.getEventType()) {

    case CREATE:
        Recommendation recommendation = event.getData();
        LOG.info("Create recommendation with ID: {}/{}", recommendation.getProductId(), recommendation.getRecommendationId());
        recommendationService.createRecommendation(recommendation);
        break;

    case DELETE:
        int productId = event.getKey();
        LOG.info("Delete recommendations with ProductID: {}", productId);
        recommendationService.deleteRecommendations(productId);
        break;

    default:
        String errorMessage = "Incorrect event type: " + event.getEventType() + ", expected a CREATE or DELETE event";
        LOG.warn(errorMessage);
        throw new EventProcessingException(errorMessage);
    }

    LOG.info("Message processing done!");
}
 

@StreamListener
public void incomingMessages(@Input(Sink.INPUT) Flux<String> rnPublisher) {
	rnPublisher
			.map(rn -> new Reservation(null, rn))
			.flatMap(this.rr::save)
			.subscribe(r -> System.out.println("received and saved " + r.getId() + " with " + r.getReservationName() + "."));
}
 

@StreamListener(target = Sink.INPUT)
public void process(Event<Integer, Review> event) {

    LOG.info("Process message created at {}...", event.getEventCreatedAt());

    switch (event.getEventType()) {

    case CREATE:
        Review review = event.getData();
        LOG.info("Create review with ID: {}/{}", review.getProductId(), review.getReviewId());
        reviewService.createReview(review);
        break;

    case DELETE:
        int productId = event.getKey();
        LOG.info("Delete reviews with ProductID: {}", productId);
        reviewService.deleteReviews(productId);
        break;

    default:
        String errorMessage = "Incorrect event type: " + event.getEventType() + ", expected a CREATE or DELETE event";
        LOG.warn(errorMessage);
        throw new EventProcessingException(errorMessage);
    }

    LOG.info("Message processing done!");
}
 

@StreamListener(target = Sink.INPUT)
public void process(Event<Integer, Product> event) {

    LOG.info("Process message created at {}...", event.getEventCreatedAt());

    switch (event.getEventType()) {

    case CREATE:
        Product product = event.getData();
        LOG.info("Create product with ID: {}", product.getProductId());
        productService.createProduct(product);
        break;

    case DELETE:
        int productId = event.getKey();
        LOG.info("Delete recommendations with ProductID: {}", productId);
        productService.deleteProduct(productId);
        break;

    default:
        String errorMessage = "Incorrect event type: " + event.getEventType() + ", expected a CREATE or DELETE event";
        LOG.warn(errorMessage);
        throw new EventProcessingException(errorMessage);
    }

    LOG.info("Message processing done!");
}
 

/**
 * Sink.INPUT DirectChannel using RoundRobin LoadBalancingStrategy So 1st msg handle
 * by `test-topic.test-group1.errors` MessageChannel 2nd msg handle by LoggingHandler
 * 3rd msg handle by `test-topic.test-group1.errors` MessageChannel
 */

@StreamListener(Sink.INPUT)
public void receive(String receiveMsg) {
	throw new RuntimeException("Oops");
}
 

@StreamListener(Sink.INPUT)
public void loggerSink(SinkTimeInfo sinkTimeInfo) {
    System.out.println("TimeInfo Received: " + sinkTimeInfo.toString());
}
 

@StreamListener(Sink.INPUT)
public void receiveByStreamListener2(String receiveMsg) {
	System.out.println("receiveByStreamListener2: " + receiveMsg);
}
 

@StreamListener(Sink.INPUT)
public void loggerSink(String date) {
    logger.info("Received: " + date);
}
 

@ServiceActivator(inputChannel = Sink.INPUT)
public void updateLocationaddServiceLocations(String input) throws Exception {

	CurrentPosition payload = this.objectMapper.readValue(input, CurrentPosition.class);

	this.template.convertAndSend("/topic/vehicles", payload);
}