Java Input类代码示例

import org.springframework.cloud.stream.annotation.Input; //导入依赖的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.Input; //导入依赖的package包/类
@Override
public void start() {
	try {
		lock.lock();
		if (!running) {
			mappedStreamEmitterMethods.forEach((k, v) -> v.forEach(item -> {
						Assert.isTrue(item.getAnnotation(Input.class) == null,
								StreamEmitterErrorMessages.INPUT_ANNOTATIONS_ARE_NOT_ALLOWED);
						String methodAnnotatedOutboundName =
								StreamAnnotationCommonMethodUtils.getOutboundBindingTargetName(item);
						int outputAnnotationCount = StreamAnnotationCommonMethodUtils.outputAnnotationCount(item);
						validateStreamEmitterMethod(item, outputAnnotationCount, methodAnnotatedOutboundName);
						invokeSetupMethodOnToTargetChannel(item, k, methodAnnotatedOutboundName);
					}
			));
			this.running = true;
		}
	}
	finally {
		lock.unlock();
	}
}
 

import org.springframework.cloud.stream.annotation.Input; //导入依赖的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.Input; //导入依赖的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.Input; //导入依赖的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.Input; //导入依赖的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.Input; //导入依赖的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.Input; //导入依赖的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.Input; //导入依赖的package包/类
@Override
public final Object postProcessAfterInitialization(Object bean, final String beanName) throws BeansException {
	Class<?> targetClass = AopUtils.isAopProxy(bean) ? AopUtils.getTargetClass(bean) : bean.getClass();
	Method[] uniqueDeclaredMethods = ReflectionUtils.getUniqueDeclaredMethods(targetClass);
	for (Method method : uniqueDeclaredMethods) {
		StreamListener streamListener = AnnotatedElementUtils.findMergedAnnotation(method, StreamListener.class);
		if (streamListener != null && !method.isBridge()) {
			streamListenerCallbacks.add(() -> {
				Assert.isTrue(method.getAnnotation(Input.class) == null, StreamListenerErrorMessages.INPUT_AT_STREAM_LISTENER);
				this.doPostProcess(streamListener, method, bean);
			});
		}
	}
	return bean;
}
 

import org.springframework.cloud.stream.annotation.Input; //导入依赖的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.Input; //导入依赖的package包/类
@StreamListener
public void receive(
		@Input(Processor.INPUT) @Payload StreamListenerTestUtils.FooPojo fooPojo,
		@Headers Map<String, Object> headers,
		@Header(MessageHeaders.CONTENT_TYPE) String contentType) {
	this.receivedArguments.add(fooPojo);
	this.receivedArguments.add(headers);
	this.receivedArguments.add(contentType);
}
 

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

import org.springframework.cloud.stream.annotation.Input; //导入依赖的package包/类
@StreamEmitter
@Output(Source.OUTPUT)
@Input(Processor.INPUT)
public Flux<String> emit() {
	return Flux.interval(Duration.ofMillis(1))
			.map(l -> "Hello World!!" + l);
}
 

import org.springframework.cloud.stream.annotation.Input; //导入依赖的package包/类
@StreamListener
public void receive(@Input(Sink.INPUT) Flux<String> input) {
	input.window(Duration.ofMillis(500), Duration.ofMillis(100))
			.flatMap(w -> w.reduce("", (x, y) -> x + y))
			.subscribe(x -> {
				interruptionState = Thread.currentThread().isInterrupted();
				latch.countDown();
			});
}
 

import org.springframework.cloud.stream.annotation.Input; //导入依赖的package包/类
@StreamListener
public void receive(@Input(Processor.INPUT) Flux<Message<String>> input,
		@Output(Processor.OUTPUT) FluxSender output) {
	output.send(input
			.map(m -> m.getPayload().toString())
			.map(m -> {
				if (!m.equals("fail")) {
					return m.toUpperCase();
				}
				else {
					throw new RuntimeException();
				}
			})
			.map(o -> MessageBuilder.withPayload(o).build()));
}