tags	projects
messaging jms	spring-framework

Table of Contents

• What you’ll build
• What you’ll need
• Set up the project
• Create a message receiver
• Send and receive JMS messages with Spring
• Summary

This guide walks you through the process of publishing and subscribing to messages using a JMS broker.

What you’ll build

You’ll build an application that uses Spring’s JmsTemplate to post a single message and subscribes to it with a POJO using MessageListenerAdapter.

What you’ll need

https://raw.githubusercontent.com/spring-guides/getting-started-macros/master/prereq_editor_jdk_buildtools.adoc

https://raw.githubusercontent.com/spring-guides/getting-started-macros/master/how_to_complete_this_guide.adoc

Set up the project

https://raw.githubusercontent.com/spring-guides/getting-started-macros/master/build_system_intro.adoc

https://raw.githubusercontent.com/spring-guides/getting-started-macros/master/create_directory_structure_hello.adoc

https://raw.githubusercontent.com/spring-guides/getting-started-macros/master/create_both_builds.adoc

build.gradle

link:initial/build.gradle[role=include]

https://raw.githubusercontent.com/spring-guides/getting-started-macros/master/spring-boot-gradle-plugin.adoc

Create a message receiver

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.

Send and receive JMS messages with Spring

Next, wire up a sender and a receiver.

src/main/java/hello/Application.java

link:complete/src/main/java/hello/Application.java[role=include]

To wrap the Receiver you coded earlier, use MessageListenerAdapter. Then use the setDefaultListenerMethod to configure which method to invoke when a message comes in. Thus you avoid implementing any JMS or broker-specific interfaces.

The SimpleMessageListenerContainer class is an asynchronous message receiver. It uses the MessageListenerAdapter and the ConnectionFactory and is fired up when the application context starts. Another parameter is the queue name set in mailboxDestination. It is also set up to receive messages in a publish/subscribe fashion.

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.

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.

https://raw.githubusercontent.com/spring-guides/getting-started-macros/master/build_an_executable_jar_subhead.adoc

https://raw.githubusercontent.com/spring-guides/getting-started-macros/master/build_an_executable_jar_with_both.adoc

When it runs, buried amidst all the logging, you should see these messages:

Sending a new message.
Received <ping!>

Summary

Congratulations! You’ve just developed a publisher and consumer of JMS-based messages.