| tags | projects | |||
|---|---|---|---|---|
|
|
This guide walks you through the process of publishing and subscribing to messages using a JMS broker.
You’ll build an application that uses Spring’s JmsTemplate to post a single message and subscribes to it with a @JmsListener annotated method of a managed bean.
Spring provides the means to publish messages to any POJO.
src/main/java/hello/Receiver.java
link:complete/src/main/java/hello/Receiver.java[role=include]This is also known as a message driven POJO. As you can see in the code above, there is no need to implement any particular interface or for the method to have any particular name. Besides, the method may have a very flexible signature; in our simple example we will just extract the payload of a TextMessage.
The JmsListener annotation defines the name of the Destination that this method should listen to and the reference to the JmsListenerContainerFactory to use to create the underlying message listener container. Strictly speaking that last attribute is not necessary unless you need to customize the way the container is built as Spring Boot registers a default factory if necessary.
The reference documentation covers this in more detail.
Next, wire up a sender and a receiver.
src/main/java/hello/Application.java
link:complete/src/main/java/hello/Application.java[role=include]@SpringBootApplication is a convenience annotation that adds all of the following:
-
@Configurationtags the class as a source of bean definitions for the application context. -
@EnableAutoConfigurationtells Spring Boot to start adding beans based on classpath settings, other beans, and various property settings. -
@ComponentScantells Spring to look for other components, configurations, and services in the thehellopackage, allowing it to find theReceiver.
The main() method uses Spring Boot’s SpringApplication.run() method to launch an application. Did you notice that there wasn’t a single line of XML? No web.xml file either. This application is 100% pure Java and you didn’t have to deal with configuring any plumbing or infrastructure.
@EnableJms triggers the discovery of methods annotated with @JmsListener, creating the message listener container under the covers.
For clarity, we have also defined a myJmsContainerFactory bean that is referenced in the JmsListener annotation of the receiver. This creates a SimpleMessageListenerContainer, an asynchronous message receiver that is fired up when the application context starts.
Spring provides a convenient template class called JmsTemplate. JmsTemplate makes it very simple to send messages to a JMS message queue. In the main runner method, after starting things up, you create a MessageCreator and use it from jmsTemplate to send a message.
Two beans that you don’t see defined are JmsTemplate and ActiveMQConnectionFactory. These are created automatically by Spring Boot. In this case, the ActiveMQ broker runs embedded.
By default, Spring Boot creates a JmsTemplate configured to transmit to queues by having pubSubDomain set to false. The SimpleMessageListenerContainer is also configured the same.
To override, set spring.jms.isPubSubDomain=true via Boot’s property settings (either inside application.properties or by environment variable). Then make sure the receiving container
has the same setting.
|
Note
|
Spring’s JmsTemplate can receive messages directly through its receive method, but that only works synchronously, meaning it will block. That’s why Spring recommends that you use a listener container such as SimpleMessageListenerContainer with a cache-based connection factory, so you can consume messages asynchronously and with maximum connection efficiency.
|
When it runs, buried amidst all the logging, you should see these messages:
Sending a new message. Received <ping!>
Congratulations! You’ve just developed a publisher and consumer of JMS-based messages.