How can I use ActiveMQ and Spring Integration JMS to receive messages one time in multiple groups? - jms

Question

I'm trying to use a messaging service to send messages to other services when a user in our system is created. The services receiving the messages are load balanced Spring Boot applications (in our case, pods in a Kubernetes environment).
I would like:
Every pod in each service is configured to receive messages.
One (and only one) pod in each service actually receives each message.
The message can be received by multiple services in this way.
So in the picture, the "New User" message is received by one pod in Notification Service and one pod in Logging Service.
I've set up ActiveMQ and Spring Integration to send/receive the messages and have got it working both as a) a Queue (one recipient) and b) a Topic (whoever's subscribed receives it). Problem is:
a) With a queue, one recipient means Notifications would receive it but Logging wouldn't (or vice versa).
b) With a topic, whoever's subscribed means all six pods would receive it.
I feel like what I want is a grouping, like "one recipient of type NOTIFICATION and one recipient of type LOGGING", but I'm not sure how to implement that. It seems like that's possible with a Message Routing pattern, but I was wondering if it could be achieved entirely using the Spring Integration.
Some code. The configuration for the sender:
import org.apache.activemq.spring.ActiveMQConnectionFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jms.core.JmsTemplate;
#Configuration
public class MessagingConfig {
#Bean
public ActiveMQConnectionFactory connectionFactory(){
ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory();
connectionFactory.setBrokerURL("tcp://myactivemq:61616");
return connectionFactory;
}
#Bean
public JmsTemplate jmsTemplate(){
JmsTemplate template = new JmsTemplate();
template.setConnectionFactory(connectionFactory());
template.setDefaultDestinationName("user-dest");
return template;
}
}
The service that sends the message (simplified):
#Service
public class MessageSender {
private final JmsTemplate jmsTemplate;
#Autowired
public MessageSender(JmsTemplate jmsTemplate) {
this.jmsTemplate = jmsTemplate;
}
public void sendMessage(String userId) {
jmsTemplate.send(new MessageCreator() {
#Override
public Message createMessage(Session session) throws JMSException{
return session.createTextMessage("NEW USER:" + userId);
}
});
}
}
Configuration of receiver:
import org.apache.activemq.spring.ActiveMQConnectionFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.jms.annotation.EnableJms;
import org.springframework.jms.config.DefaultJmsListenerContainerFactory;
#Configuration
#EnableJms
public class ReceiverConfig {
private ActiveMQConnectionFactory getConnectionFactory() {
ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory();
connectionFactory.setBrokerURL("tcp://myactivemq:61616");
return connectionFactory;
}
#Bean
public DefaultJmsListenerContainerFactory jmsListenerContainerFactory() {
DefaultJmsListenerContainerFactory factory = new DefaultJmsListenerContainerFactory();
factory.setConnectionFactory(getConnectionFactory());
factory.setConcurrency("1-1");
return factory;
}
}
And the service receiving the messages.
import javax.jms.JMSException;
import javax.jms.TextMessage;
import org.springframework.jms.annotation.JmsListener;
#Service
public class MessageReceiver {
#JmsListener(destination = "user-dest")
public void receiveMessage(final TextMessage message) throws JMSException {
// Do something with message.getText()
}
}
This is working, but acts like a Queue, only one recipient. Any idea how this could be received by one Notification Service pod and one Logging Service pod?

Answer 1

FYI. I ended up using RabbitMQ, possibly because I found the documentation much easier. With RabbitMQ, the solution was pretty straightforward:
Send the message to an exchange
Create a queue and bind the queue to the exchange
I used the Management UI, but the binding can be in code too.
From my example above, I created two queues, one for Notification and one for Logging.
The Notification and Logging services listen to their respective queues.
So the User Service sends a message to its Exchange, both queues pick it up, and only one pod of each listening service gets the message. Exactly what I was looking for.