Spring Integration: reuse MessageProducer definition

Question

I have an outbound gateway for soap calls (MarshallingWebServiceOutboundGateway) with elaborate setup. I need to use that gateway definition from multiple flows. The question spring-integration: MessageProducer may only be referenced once is somewhat similar, but this question is about the proper use of the spring bean scope prototype for spring integration collaborators.

I have a separate config file which sets up the gateway and its dependencies:

@Bean
public MarshallingWebServiceOutboundGateway myServiceGateway() {
    Jaxb2Marshaller marshaller = new Jaxb2Marshaller();
    marshaller.setPackagesToScan("blah.*");

    MarshallingWebServiceOutboundGateway gateway = new MarshallingWebServiceOutboundGateway(
            serviceEndpoint, marshaller, messageFactory);
    gateway.setMessageSender(messageSender);
    gateway.setRequestCallback(messageCallback);

    return gateway;
}

This is how I initially tried to wire up the outbound gateway from two different flows in two different config files.

In one config file:

@Bean
public IntegrationFlow flow1() {
    MarshallingWebServiceOutboundGateway myServiceGateway = context.getBean("myServiceGateway", MarshallingWebServiceOutboundGateway.class);

    return IntegrationFlows
            .from(Http.inboundGateway("/res1")
                    .requestMapping(r -> r.methods(HttpMethod.GET))
            .transform(soapRequestTransformer)
            .handle(myServiceGateway) // wrong: cannot be same bean
            .transform(widgetTransformer)
            .get();
}

In a separate config file:

@Bean
public IntegrationFlow flow2() {
    MarshallingWebServiceOutboundGateway myServiceGateway = context.getBean("myServiceGateway", MarshallingWebServiceOutboundGateway.class);

    return IntegrationFlows
            .from(Http.inboundGateway("/res2")
                    .requestMapping(r -> r.methods(HttpMethod.GET))
            .transform(soapRequestTransformer)
            .handle(myServiceGateway) // wrong: cannot be same bean
            .transform(widgetTransformer)
            .handle(servicePojo)
            .get();
}

This is a problem because - as I understand it - myServiceGateway cannot be the same instance, since that instance has only one outbound channel and cannot belong to two different flows.

In the related question spring-integration: MessageProducer may only be referenced once, @artem-bilan advised not to create the outbound gateway in an @Bean method, rather to use a plain method which creates new instances for every call.

That works, but it is inconvenient in my case. I need to reuse the outbound gateway from several flows in different config files and I would have to copy the code to create the gateway into each config file. Also, the gateway dependencies inflate my Configuration file constructors, making Sonar bail.

Since the error message coming out of IntegrationFlowDefinition.checkReuse() says A reply MessageProducer may only be referenced once (myServiceGateway) - use @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE) on @Bean definition. I wanted to give the scope prototype another try.

So I try to make spring integration look up a prototype gateway from the context by name, hoping to get a different gateway instance in flow1 and flow2:

.handle(context.getBean("myServiceGateway", 
    MarshallingWebServiceOutboundGateway.class))

And I annotated the outbound gateway @Bean definition with

@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)

But I can see that the myServiceGateway() method is only invoked once, despite the prototype scope, and application startup still fails with the error message which advises to use the prototype scope - quite confusing, actually ;-)

Based on Mystery around Spring Integration and prototype scope I also tried:

@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE, proxyMode = ScopedProxyMode.TARGET_CLASS)

The application starts, but the responses never reach the step after the gateway, the widgetTransformer. (Even more strange, exactly the widgetTransformer is skipped: in flow1 the outcome is the untransformed gateway response and in flow2 the untransformed messages hit the step after the widgetTransformer, i.e. the servicePojo). Making a proxy out of a message producer seems not to be a good idea.

I really want to get to the bottom of this. Is the exception message wrong which asks to use the prototype scope or am I just getting it wrong? How can I avoid to repeat the bean definition for message producers if I need several such producers which are all set up the same way?

Using spring-integration 5.0.9.

Answer 1

I am not entirely sure why the @Scope is not working, but here is a work-around...

@SpringBootApplication
public class So52453934Application {

    public static void main(String[] args) {
        SpringApplication.run(So52453934Application.class, args);
    }

    @Autowired
    private HandlerConfig config;

    @Bean
    public IntegrationFlow flow1() {
        return f -> f.handle(this.config.myHandler())
                .handle(System.out::println);
    }

    @Bean
    public IntegrationFlow flow2() {
        return f -> f.handle(this.config.myHandler())
                .handle(System.out::println);
    }

    @Bean
    public ApplicationRunner runner() {
        return args -> {
            context.getBean("flow1.input", MessageChannel.class).send(new GenericMessage<>("foo"));
            context.getBean("flow2.input", MessageChannel.class).send(new GenericMessage<>("bar"));
        };
    }

}

@Configuration
class HandlerConfig {

    public AbstractReplyProducingMessageHandler myHandler() {
        return new AbstractReplyProducingMessageHandler() {

            @Override
            protected Object handleRequestMessage(Message<?> requestMessage) {
                return ((String) requestMessage.getPayload()).toUpperCase();
            }

        };
    }

}

i.e. do as @artem suggested, but inject the bean with the factory method.