This is a very simple example using a Spring JMS Template to send messages and also having a JMS listener process the messages sent. An embedded ActiveMQ instance is used as the broker.
The Spring configuration shows a context:component-scan
that picks up the JMS producer and listener. Following this the
Spring custom namespace for Apache's ActiveMQ is used to create an
embedded JMS broker. A queue is configured for 'org.springbyexample.jms.test'.
Then a JMS connection factory is made for the
JmsTemplate to use. The template will be used by the
producer to send messages.
Excerpt from JmsMessageListenerTest-context.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:jms="http://www.springframework.org/schema/jms"
xmlns:amq="http://activemq.apache.org/schema/core"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/jms
http://www.springframework.org/schema/jms/spring-jms.xsd
http://activemq.apache.org/schema/core
http://activemq.apache.org/schema/core/activemq-core.xsd">
<context:component-scan base-package="org.springbyexample.jms" />
<!-- Embedded ActiveMQ Broker -->
<amq:broker id="broker" useJmx="false" persistent="false">
<amq:transportConnectors>
<amq:transportConnector uri="tcp://localhost:0" />
</amq:transportConnectors>
</amq:broker>
<!-- ActiveMQ Destination -->
<amq:queue id="destination" physicalName="org.springbyexample.jms.test" />
<!-- JMS ConnectionFactory to use, configuring the embedded broker using XML -->
<amq:connectionFactory id="jmsFactory" brokerURL="vm://localhost" />
<!-- JMS Producer Configuration -->
<bean id="jmsProducerConnectionFactory"
class="org.springframework.jms.connection.SingleConnectionFactory"
depends-on="broker"
p:targetConnectionFactory-ref="jmsFactory" />
<bean id="jmsProducerTemplate" class="org.springframework.jms.core.JmsTemplate"
p:connectionFactory-ref="jmsProducerConnectionFactory"
p:defaultDestination-ref="destination" />
...
</beans>
The producer uses @PostConstruct to indicate that
generateMessages() is an initialization method.
It uses the JmsTemplate to send text messages
and also sets an int property for the message count.
Example 1. JmsMessageProducer
@Component
public class JmsMessageProducer {
private static final Logger logger = LoggerFactory.getLogger(JmsMessageProducer.class);
protected static final String MESSAGE_COUNT = "messageCount";
@Autowired
private JmsTemplate template = null;
private int messageCount = 100;
/**
* Generates JMS messages
*/
@PostConstruct
public void generateMessages() throws JMSException {
for (int i = 0; i < messageCount; i++) {
final int index = i;
final String text = "Message number is " + i + ".";
template.send(new MessageCreator() {
public Message createMessage(Session session) throws JMSException {
TextMessage message = session.createTextMessage(text);
message.setIntProperty(MESSAGE_COUNT, index);
logger.info("Sending message: " + text);
return message;
}
});
}
}
}