Java Output类代码示例

import org.springframework.cloud.stream.annotation.Output; //导入依赖的package包/类
@StreamListener
public void receive(@Input(Processor.INPUT) SubscribableChannel input,
		@Output(Processor.OUTPUT) final MessageChannel output1,
		@Output(StreamListenerTestUtils.FooOutboundChannel1.OUTPUT) final MessageChannel output2) {
	input.subscribe(new MessageHandler() {
		@Override
		public void handleMessage(Message<?> message) throws MessagingException {
			if (message.getHeaders().get("output").equals("output1")) {
				output1.send(org.springframework.messaging.support.MessageBuilder
						.withPayload(message.getPayload().toString().toUpperCase()).build());
			}
			else if (message.getHeaders().get("output").equals("output2")) {
				output2.send(org.springframework.messaging.support.MessageBuilder
						.withPayload(message.getPayload().toString().toLowerCase()).build());
			}
		}
	});
}
 

import org.springframework.cloud.stream.annotation.Output; //导入依赖的package包/类
@StreamListener
@Output(CustomProcessor.OUTPUT)
public Flux<Void> save(@Input(CustomProcessor.INPUT)
					   Flux<Comment> newComments) {
	return repository
		.saveAll(newComments)
		.flatMap(comment -> {
			meterRegistry
				.counter("comments.consumed", "imageId", comment.getImageId())
				.increment();
			return Mono.empty();
		});
}
 

import org.springframework.cloud.stream.annotation.Output; //导入依赖的package包/类
@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;
		});
}
 

import org.springframework.cloud.stream.annotation.Output; //导入依赖的package包/类
@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;
		});
}
 

import org.springframework.cloud.stream.annotation.Output; //导入依赖的package包/类
@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();
		});
}
 

import org.springframework.cloud.stream.annotation.Output; //导入依赖的package包/类
@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;
}
 

import org.springframework.cloud.stream.annotation.Output; //导入依赖的package包/类
@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();
}
 

import org.springframework.cloud.stream.annotation.Output; //导入依赖的package包/类
public static String getOutboundBindingTargetName(Method method) {
	SendTo sendTo = AnnotationUtils.findAnnotation(method, SendTo.class);
	if (sendTo != null) {
		Assert.isTrue(!ObjectUtils.isEmpty(sendTo.value()), StreamAnnotationErrorMessages.ATLEAST_ONE_OUTPUT);
		Assert.isTrue(sendTo.value().length == 1, StreamAnnotationErrorMessages.SEND_TO_MULTIPLE_DESTINATIONS);
		Assert.hasText(sendTo.value()[0], StreamAnnotationErrorMessages.SEND_TO_EMPTY_DESTINATION);
		return sendTo.value()[0];
	}
	Output output = AnnotationUtils.findAnnotation(method, Output.class);
	if (output != null) {
		Assert.isTrue(StringUtils.hasText(output.value()), StreamAnnotationErrorMessages.ATLEAST_ONE_OUTPUT);
		return output.value();
	}
	return null;
}
 

import org.springframework.cloud.stream.annotation.Output; //导入依赖的package包/类
protected static String getOutboundBindingTargetName(Method method) {
	SendTo sendTo = AnnotationUtils.findAnnotation(method, SendTo.class);
	if (sendTo != null) {
		Assert.isTrue(!ObjectUtils.isEmpty(sendTo.value()), StreamListenerErrorMessages.ATLEAST_ONE_OUTPUT);
		Assert.isTrue(sendTo.value().length == 1, StreamListenerErrorMessages.SEND_TO_MULTIPLE_DESTINATIONS);
		Assert.hasText(sendTo.value()[0], StreamListenerErrorMessages.SEND_TO_EMPTY_DESTINATION);
		return sendTo.value()[0];
	}
	Output output = AnnotationUtils.findAnnotation(method, Output.class);
	if (output != null) {
		Assert.isTrue(StringUtils.hasText(output.value()), StreamListenerErrorMessages.ATLEAST_ONE_OUTPUT);
		return output.value();
	}
	return null;
}
 

import org.springframework.cloud.stream.annotation.Output; //导入依赖的package包/类
private boolean checkDeclarativeMethod(Method method, String methodAnnotatedInboundName, String methodAnnotatedOutboundName) {
	int methodArgumentsLength = method.getParameterTypes().length;
	for (int parameterIndex = 0; parameterIndex < methodArgumentsLength; parameterIndex++) {
		MethodParameter methodParameter = MethodParameter.forExecutable(method, parameterIndex);
		if (methodParameter.hasParameterAnnotation(Input.class)) {
			String inboundName = (String) AnnotationUtils
					.getValue(methodParameter.getParameterAnnotation(Input.class));
			Assert.isTrue(StringUtils.hasText(inboundName), StreamListenerErrorMessages.INVALID_INBOUND_NAME);
			Assert.isTrue(isDeclarativeMethodParameter(inboundName, methodParameter),
					StreamListenerErrorMessages.INVALID_DECLARATIVE_METHOD_PARAMETERS);
			return true;
		}
		else if (methodParameter.hasParameterAnnotation(Output.class)) {
			String outboundName = (String) AnnotationUtils
					.getValue(methodParameter.getParameterAnnotation(Output.class));
			Assert.isTrue(StringUtils.hasText(outboundName), StreamListenerErrorMessages.INVALID_OUTBOUND_NAME);
			Assert.isTrue(isDeclarativeMethodParameter(outboundName, methodParameter),
					StreamListenerErrorMessages.INVALID_DECLARATIVE_METHOD_PARAMETERS);
			return true;
		}
		else if (StringUtils.hasText(methodAnnotatedOutboundName)) {
			return isDeclarativeMethodParameter(methodAnnotatedOutboundName, methodParameter);
		}
		else if (StringUtils.hasText(methodAnnotatedInboundName)) {
			return isDeclarativeMethodParameter(methodAnnotatedInboundName, methodParameter);
		}
	}
	return false;
}
 

import org.springframework.cloud.stream.annotation.Output; //导入依赖的package包/类
@StreamListener(Processor.INPUT)
@Output(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;
}
 

import org.springframework.cloud.stream.annotation.Output; //导入依赖的package包/类
@StreamListener(Processor.INPUT)
@Output(Processor.OUTPUT)
public Message<?> receive(StreamListenerTestUtils.FooPojo fooPojo) {
	this.receivedPojos.add(fooPojo);
	StreamListenerTestUtils.BarPojo bazPojo = new StreamListenerTestUtils.BarPojo();
	bazPojo.setBar(fooPojo.getFoo());
	return MessageBuilder.withPayload(bazPojo).setHeader("foo", "bar").build();
}
 

import org.springframework.cloud.stream.annotation.Output; //导入依赖的package包/类
@StreamListener(Processor.INPUT)
@Output(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;
}
 

import org.springframework.cloud.stream.annotation.Output; //导入依赖的package包/类
@StreamListener(Processor.INPUT)
@Output(Processor.OUTPUT)
public StreamListenerTestUtils.BarPojo receive(StreamListenerTestUtils.FooPojo fooPojo) {
	this.receivedPojos.add(fooPojo);
	StreamListenerTestUtils.BarPojo barPojo = new StreamListenerTestUtils.BarPojo();
	barPojo.setBar(fooPojo.getFoo());
	return barPojo;
}
 

import org.springframework.cloud.stream.annotation.Output; //导入依赖的package包/类
@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());
		}
	});
}