Intercept JMS messages

[jnizet]

I'm working on a Spring Boot app which communicates with other apps, or with itself, using JMS. In addition to the functional message payload being exchanged, some contextual information is added to the messages, as properties. For example: the identity of the user (or process) who triggered the sending of the message.

Instead of having to add this contextual information each time I send a message, and to extract this contextual information each time I receive one, I would like to do that once, in a single place (it's then stored it in a thread-local variable, and/or stored in the slf4J MDC).

The way I currently do it is by overriding methods of JmsTemplate and of DefaultMessageListenerContainer. This, however is not as elegant as I would like it: I need to provide my own configuration to provide a custom JmsTemplate, and a custom DefaultMessageListenerContainerFactory, which itself creates a custom DefaultMessageListenerContainer, instead of simply using the ones auto-configured by Spring Boot, leading to code that is more verbose than necessary, and which duplicates what Spring Boot does already (properties-based customization, etc.)

I also thought about using AOP to intercept the calls to the JmsListener-annotated methods. But then that prevents me from simply using the type of the payload for the method argument: every method must take a Message as argument, just to allow extracting the message properties inside the aspect.

Unless there is already a better way to achieve what I want, I would find it nice if I could simply add interceptors to the JmsTemplate and to the DefaultMessageListenerContainerFactory.

• the JmsTemplate interceptors would allow to preprocess the message before sending it
• the DefaultMessageListenerContainerFactory interceptors would be set on each of the created DefaultMessageListenerContainers (as the other properties are), and would allow preprocessing a message before invoking the listener, and postprocessing it after the listener is invoked, in a way similar to an MVC interceptor.

[destebanm]

Hi!
@jnizet do you have an example about this?

The way I currently do it is by overriding methods of JmsTemplate and of DefaultMessageListenerContainer. This, however is not as elegant as I would like it: I need to provide my own configuration to provide a custom JmsTemplate, and a custom DefaultMessageListenerContainerFactory, which itself creates a custom DefaultMessageListenerContainer, instead of simply using the ones auto-configured by Spring Boot, leading to code that is more verbose than necessary, and which duplicates what Spring Boot does already (properties-based customization, etc.)

I have exactly the same use case, and I am trying different solutions.

Thanks!

[jnizet]

@destebanm

Here's basically what I use for the listening part. For the JmsTemplate part, we plan to use inheritance, but we currently wrap the JmsTemplate into our own class for now, so I don't have any example.

    /**
     * Provides a custom <code>DefaultJmsListenerContainerFactory</code> which does the exact same thing as the one that would be
     * auto-configured by Spring Boot, except that it creates a <code>DefaultMessageListenerContainer</code> that
     * extracts the identity stored as properties in the message (if any) and stores it in the identity holder.
     * @see {@link org.springframework.boot.autoconfigure.jms.JmsAnnotationDrivenConfiguration} for the equivalent code of the Spring Boot auto-configuration
     */
    @Bean("jmsListenerContainerFactory")
    public DefaultJmsListenerContainerFactory jmsListenerContainerFactory(ConnectionFactory connectionFactory,
                                                                          DefaultJmsListenerContainerFactoryConfigurer configurer,
                                                                          IdentityHolder identityHolder) { // this is one of our beans
        DefaultJmsListenerContainerFactory factory = new DefaultJmsListenerContainerFactory() {
            @Override
            protected DefaultMessageListenerContainer createContainerInstance() {
                return new DefaultMessageListenerContainer() {
                    @Override
                    protected Message receiveMessage(MessageConsumer consumer) throws JMSException {
                        Message message = super.receiveMessage(consumer);
                        if (message != null) {
                            String identity = message.getStringProperty(Identity.JMS_PROPERTY_KEY);
                            identityHolder.setIdentity(identity)); // this stores the identity in a Thread-local variable
                        }
                        return message;
                    }
                };
            }
        };
        configurer.configure(factory, connectionFactory);
        return factory;
    }

[danieljohngomez]

I think you can use org.springframework.messaging.support.ChannelInterceptor for this. It lets you pre/post handle messages.

[destebanm]

@danieljohngomez I have tried this approach but I have not been able to get it working :_(

@jnizet thanks!!!! For the listening part I think I will use aspect approach. For the JmsTemplate part, how are you wrapping the jmsTemplate? I would like to override this method

protected void doSend(MessageProducer producer, Message message) throws JMSException {
		if (this.deliveryDelay >= 0) {
			producer.setDeliveryDelay(this.deliveryDelay);
		}
		if (isExplicitQosEnabled()) {
			producer.send(message, getDeliveryMode(), getPriority(), getTimeToLive());
		}
		else {
			producer.send(message);
		}
	}

modifying the message with my properties.

Thanks!

[jnizet]

@destebanm I just send all the messages using my own bean which itself delegates to JmsTemplate to send the message and set the appropriate message properties.

[danieljohngomez]

@destebanm Check out AbstractMessageBrokerConfiguration.brokerChannel() for a reference.

[destebanm]

Thanks @danieljohngomez, I will take a look!

[bound2]

Did you get it to work? Can't find any place where to plug in the ChannelInterceptor

[danieljohngomez]

@bound2 In my case, I have overridden these methods on org.springframework.messaging.simp.config.AbstractMessageBrokerConfiguration:

• configureClientInboundChannel(ChannelRegistration registration)
• configureClientOutboundChannel(ChannelRegistration registration)

With the ChannelRegistration, you can then do interceptors(ChannelInterceptor... interceptors).

If you want to do it on the broker channel, override AbstractMessageBrokerConfiguration.brokerChannel() then do super.brokerChannel().addInterceptor();