/** * Populate the {@code MessageTransformingHandler} for the {@link MethodInvokingTransformer} * to invoke the discovered service method at runtime. * @param service the service to use. * @return the current {@link IntegrationFlowDefinition}. * @see ExpressionEvaluatingTransformer */ public B transform(Object service) { return transform(service, null); }
/** * Populate the {@code MessageTransformingHandler} for the {@link MethodInvokingTransformer} * to invoke the service method at runtime. * @param service the service to use. * @param methodName the method to invoke. * @return the current {@link IntegrationFlowDefinition}. * @see MethodInvokingTransformer */ public B transform(Object service, String methodName) { return transform(service, methodName, null); }
/** * Populate the {@code Transformer} EI Pattern specific {@link MessageHandler} implementation * for the SpEL {@link Expression}. * @param expression the {@code Transformer} {@link Expression}. * @return the current {@link IntegrationFlowDefinition}. * @see ExpressionEvaluatingTransformer */ public B transform(String expression) { return transform(expression, (Consumer<GenericEndpointSpec<MessageTransformingHandler>>) null); }
/** * Populate the provided {@link MessageTransformingHandler} for the provided * {@link HeaderFilter}. * @param headerFilter the {@link HeaderFilter} to use. * @param endpointConfigurer the {@link Consumer} to provide integration endpoint options. * @return the current {@link IntegrationFlowDefinition}. * @see GenericEndpointSpec */ public B headerFilter(HeaderFilter headerFilter, Consumer<GenericEndpointSpec<MessageTransformingHandler>> endpointConfigurer) { return transform(headerFilter, endpointConfigurer); }
/** * Populate the {@link MessageTransformingHandler} instance for the provided * {@link GenericTransformer}. Use {@link #transform(Class, GenericTransformer)} if * you need to access the entire message. * @param genericTransformer the {@link GenericTransformer} to populate. * @param <S> the source type - 'transform from'. * @param <T> the target type - 'transform to'. * @return the current {@link IntegrationFlowDefinition}. * @see MethodInvokingTransformer * @see LambdaMessageProcessor */ public <S, T> B transform(GenericTransformer<S, T> genericTransformer) { return transform(null, genericTransformer); }
/** * Populate the {@link MessageTransformingHandler} instance * for the provided {@code payloadType} to convert at runtime. * @param payloadType the {@link Class} for expected payload type. * @param <P> the payload type - 'convert to'. * @return the current {@link IntegrationFlowDefinition}. * @since 5.1 * @see MethodInvokingTransformer * @see LambdaMessageProcessor */ public <P> B convert(Class<P> payloadType) { Assert.isTrue(!payloadType.equals(Message.class), ".convert() does not support Message as an explicit type"); return transform(payloadType, p -> p); }
/** * Populate the {@link MessageTransformingHandler} for the {@link ClaimCheckInTransformer} * with provided {@link MessageStore}. * In addition accept options for the integration endpoint using {@link GenericEndpointSpec}. * @param messageStore the {@link MessageStore} to use. * @param endpointConfigurer the {@link Consumer} to provide integration endpoint options. * @return the current {@link IntegrationFlowDefinition}. * @see GenericEndpointSpec */ public B claimCheckIn(MessageStore messageStore, Consumer<GenericEndpointSpec<MessageTransformingHandler>> endpointConfigurer) { return transform(new ClaimCheckInTransformer(messageStore), endpointConfigurer); }
/** * Populate the {@code Transformer} EI Pattern specific {@link MessageHandler} implementation * for the SpEL {@link Expression}. * @param expression the {@code Transformer} {@link Expression}. * @param endpointConfigurer the {@link Consumer} to provide integration endpoint options. * @return the current {@link IntegrationFlowDefinition}. * @see ExpressionEvaluatingTransformer */ public B transform(String expression, Consumer<GenericEndpointSpec<MessageTransformingHandler>> endpointConfigurer) { Assert.hasText(expression, "'expression' must not be empty"); return transform(new ExpressionEvaluatingTransformer(PARSER.parseExpression(expression)), endpointConfigurer); }
@Override public void configure(IntegrationFlowDefinition<?> f) { f.<String, String>transform(String::toUpperCase) .log(LoggingHandler.Level.ERROR, m -> { resultOverLoggingHandler.set(m.getPayload()); return m; }); }
@Bean public IntegrationFlow httpProxyErrorFlow() { return f -> f .transform(Throwable::getCause) .<HttpClientErrorException>handle((p, h) -> new ResponseEntity<>(p.getResponseBodyAsString(), p.getStatusCode())); }
@Bean public IntegrationFlow encodingFlow() { return f -> f .transform(Transformers.encoding(new MyCodec())) .channel("codecReplyChannel"); }
@Bean public IntegrationFlow decodingFlow() { return f -> f .transform(Transformers.decoding(new MyCodec(), m -> Integer.class)) .channel("codecReplyChannel"); }
@Bean public IntegrationFlow wireTapFlow3() { return f -> f .transform("payload") .wireTap("tapChannel", wt -> wt.selector("payload == 'foo'")) .handle(loggingMessageHandler()); }
@Bean public IntegrationFlow wireTapFlow5() { return f -> f .wireTap(sf -> sf .<String, String>transform(String::toUpperCase) .channel(MessageChannels.queue("wireTapSubflowResult"))) .channel("nullChannel"); }
@Bean public IntegrationFlow flow1() { return f -> f .fixedSubscriberChannel("integerChannel") .transform("payload.toString()") .channel(Jms.pollableChannel("flow1QueueChannel", jmsConnectionFactory()) .destination("flow1QueueChannel")); }
@Bean public IntegrationFlow scriptTransformer() { return f -> f .transform(Scripts.processor("scripts/TestTransformerScript.rb") .lang("ruby") .variable("foo", "bar")) .channel(results()); }
@Bean public IntegrationFlow clientTcpFlow() { return f -> f .handle(tcpOut(), e -> e.advice(testAdvice())) .transform(Transformers.objectToString()); }
@Bean public IntegrationFlow gatewayFlow() { return IntegrationFlows.from("gatewayInput") .gateway("gatewayRequest", g -> g.errorChannel("gatewayError").replyTimeout(10L)) .gateway(f -> f.transform("From Gateway SubFlow: "::concat)) .get(); }
@Bean public IntegrationFlow pojoTransformFlow() { return f -> f .enrichHeaders(h -> h .header("Foo", "Bar") .advice(idempotentReceiverInterceptor(), requestHandlerAdvice())) .transform(new PojoTransformer()); }
@Bean public IntegrationFlow routeSubflowWithoutReplyToMainFlow() { return f -> f .<String, Boolean>route("BOO"::equals, m -> m .resolutionRequired(false) .subFlowMapping(true, sf -> sf .transform(String.class, String::toLowerCase) .channel(MessageChannels.queue("routerSubflowResult"))) .defaultSubFlowMapping(sf -> sf.channel("defaultOutputChannel"))); }