Java Processor.INPUT属性代码示例

@Bean
@Transformer(inputChannel = Processor.INPUT, outputChannel = Processor.OUTPUT)
public MessageProcessor<?> transformer() {
	String language = this.properties.getLanguage();
	String script = this.properties.getScript();
	logger.info(String.format("Input script is '%s', language is '%s'", script, language));
	Resource scriptResource = new ByteArrayResource(decodeScript(script).getBytes()) {

		// TODO until INT-3976
		@Override
		public String getFilename() {
			// Only the groovy script processor enforces this requirement for a name
			return "StaticScript";
		}

	};
	return Scripts.script(scriptResource)
			.lang(language)
			.variableGenerator(this.scriptVariableGenerator)
			.get();
}
 

@StreamListener
@Output(Processor.OUTPUT)
public Flux<Comment> save(@Input(Processor.INPUT) Flux<Comment> newComment) {
	return repository
		.saveAll(newComment)
		.map(comment -> {
			meterRegistry
				.counter("comments.consumed", "imageId", comment.getImageId())
				.increment();
			return comment;
		});
}
 

@StreamListener
@Output(Processor.OUTPUT)
public Flux<Comment> save(@Input(Processor.INPUT) Flux<Comment> newComment) {
	return repository
		.saveAll(newComment)
		.map(comment -> {
			log.info("Saving new comment " + comment);
			meterRegistry
				.counter("comments.consumed", "imageId", comment.getImageId())
				.increment();
			return comment;
		});
}
 

@StreamListener
@Output(Processor.OUTPUT)
public Flux<Void> save(@Input(Processor.INPUT) Flux<Comment> newComment) {
	return repository
		.saveAll(newComment)
		.flatMap(comment -> {
			meterRegistry
				.counter("comments.consumed", "imageId", comment.getImageId())
				.increment();
			return Mono.empty();
		});
}
 

@StreamListener
@Output(Processor.OUTPUT)
public Flux<String> verifyEmpString(@Input(Processor.INPUT) Flux<String> id) {
	System.out.println("first");
	id.delayElements(Duration.ofMillis(2))
	   .log();
	return id;
}
 

@ServiceActivator(inputChannel = Processor.INPUT, outputChannel = Processor.OUTPUT)
public Message<?> evaluate(Message<?> input) {

	Map<String, Object> processorContext = new ConcurrentHashMap<>();

	Map<String, Object> inputData = tensorflowInputConverter.convert(input, processorContext);

	Tensor outputTensor = tensorFlowService.evaluate(
			inputData, properties.getOutputName(), properties.getOutputIndex());

	Object outputData = tensorflowOutputConverter.convert(outputTensor, processorContext);

	if (properties.isSaveOutputInHeader()) {
		// Add the result to the message header
		return MessageBuilder
				.withPayload(input.getPayload())
				.copyHeadersIfAbsent(input.getHeaders())
				.setHeaderIfAbsent(TF_OUTPUT_HEADER, outputData)
				.build();
	}

	// Add the outputData as part of the message payload
	Message<?> outputMessage = MessageBuilder
			.withPayload(outputData)
			.copyHeadersIfAbsent(input.getHeaders())
			.build();

	return outputMessage;
}
 

@StreamListener(value = Processor.INPUT, condition = "headers['stream_routekey']=='words'")
public void uppercase(Message<String> input) {
	// TODO: this won't work without the Message<?> wrapper for the input because
	// the headers don't get copied.
	processor.output()
			.send(MessageBuilder.withPayload(input.getPayload().toUpperCase())
					.copyHeaders(input.getHeaders()).build());
}
 

@StreamListener
@Output(Processor.OUTPUT)
public Flux<String> toUpperCase(@Input(Processor.INPUT) Flux<String> inbound) {
	return inbound.
			log()
			.window(Duration.ofSeconds(10), Duration.ofSeconds(5))
			.flatMap(w -> w.reduce("", (s1,s2)->s1+s2))
			.log();
}
 

@StreamListener(Processor.INPUT)
@SendTo(Processor.OUTPUT)
public Message<String> uppercase(Message<String> input) {
	return MessageBuilder.withPayload(input.getPayload().toUpperCase())
			.copyHeadersIfAbsent(input.getHeaders()).setHeader("x-foo", "bar")
			.build();
}
 

@ServiceActivator(inputChannel = Processor.INPUT, outputChannel = Processor.OUTPUT)
public Object process(Message<?> message) {
	try {
		/* construct headers */
		HttpHeaders headers = new HttpHeaders();
		if (properties.getHeadersExpression() != null) {
			Map<?, ?> headersMap = properties.getHeadersExpression().getValue(message, Map.class);
			for (Entry<?, ?> header : headersMap.entrySet()) {
				if (header.getKey() != null && header.getValue() != null) {
					headers.add(header.getKey().toString(),
							header.getValue().toString());
				}
			}
		}

		Class<?> responseType = properties.getExpectedResponseType();
		HttpMethod method = properties.getHttpMethod();
		String url = properties.getUrlExpression().getValue(message, String.class);
		Object body = null;
		if (properties.getBody() != null) {
			body = properties.getBody();
		}
		else if (properties.getBodyExpression() != null) {
			body = properties.getBodyExpression().getValue(message);
		}
		else {
			body = message.getPayload();
		}
		URI uri = new URI(url);
		RequestEntity<?> request = new RequestEntity<>(body, headers, method, uri);
		ResponseEntity<?> response = restTemplate.exchange(request, responseType);
		return properties.getReplyExpression().getValue(response);
	}
	catch (Exception e) {
		LOG.warn("Error in HTTP request", e);
		return null;
	}
}
 

@StreamListener(Processor.INPUT)
@SendTo(Processor.OUTPUT)
public StreamListenerTestUtils.BarPojo receive(StreamListenerTestUtils.FooPojo fooMessage) {
	this.receivedPojos.add(fooMessage);
	StreamListenerTestUtils.BarPojo barPojo = new StreamListenerTestUtils.BarPojo();
	barPojo.setBar(fooMessage.getFoo());
	return barPojo;
}
 

@StreamListener(Processor.INPUT)
public @Output(Processor.OUTPUT) Flux<String> receive(Flux<String> input) {
	return input.map(m -> {
		if (!m.equals("fail")) {
			return m.toUpperCase();
		}
		else {
			throw new RuntimeException();
		}
	});
}
 

@StreamListener(Processor.INPUT)
@SendTo(Processor.OUTPUT)
public StreamListenerTestUtils.BarPojo receive(Message<String> fooMessage) {
	this.receivedMessages.add(fooMessage);
	StreamListenerTestUtils.BarPojo barPojo = new StreamListenerTestUtils.BarPojo();
	barPojo.setBar(fooMessage.getPayload());
	return barPojo;
}
 

@StreamListener
public void receive(@Input(Processor.INPUT) SubscribableChannel input,
		@Output(Processor.OUTPUT) final MessageChannel output) {
	input.subscribe(new MessageHandler() {
		@Override
		public void handleMessage(Message<?> message) throws MessagingException {
			output.send(MessageBuilder.withPayload(message.getPayload().toString().toUpperCase()).build());
		}
	});
}
 

@ServiceActivator(inputChannel = Processor.INPUT, outputChannel = Processor.OUTPUT)
public Object evaluate(Message<?> input) {

	Object inputData =
			this.properties.getExpression() == null
					? input.getPayload()
					: this.properties.getExpression().getValue(this.evaluationContext, input, Object.class);

	// The processorContext allows to convey metadata from the Input to Output converter.
	Map<String, Object> processorContext = new ConcurrentHashMap<>();

	Map<String, Object> inputDataMap = this.tensorflowInputConverter.convert(inputData, processorContext);

	Tensor outputTensor = this.tensorFlowService.evaluate(inputDataMap, this.properties.getModelFetch(),
			this.properties.getModelFetchIndex());

	Object outputData = tensorflowOutputConverter.convert(outputTensor, processorContext);

	switch (this.properties.getMode()) {

		case tuple:
			TupleBuilder outTupleBuilder = TupleBuilder.tuple().put(properties.getOutputName(), outputData);

			Object payload = input.getPayload();

			if (payload instanceof Tuple && ((Tuple) payload).hasFieldName(ORIGINAL_INPUT_DATA)) {
				// If the payload is already a tuple that contains ORIGINAL_INPUT_DATA entry then copy the
				// content of the input tuple in the new tuple to be returned.
				outTupleBuilder.putAll((Tuple) payload);
			}
			else {
				// This is a new tuple so preserve the input data.
				outTupleBuilder.put(ORIGINAL_INPUT_DATA, payload);
			}

			return outTupleBuilder.build();

		case header:
			return MessageBuilder
					.withPayload(input.getPayload())
					.setHeader(this.properties.getOutputName(), outputData);

		default:
			return outputData;
	}

}