Memulai Spring JMS

1. Ikhtisar

Spring menyediakan kerangka kerja Integrasi JMS yang menyederhanakan penggunaan JMS API. Artikel ini memperkenalkan konsep dasar integrasi tersebut.

2. Ketergantungan Maven

Untuk menggunakan Spring JMS di aplikasi kita, kita perlu menambahkan artefak yang diperlukan di pom.xml :

 org.springframework spring-jms 4.3.3.RELEASE  

Versi terbaru dari artefak dapat ditemukan di sini.

3. JmsTemplate

Kelas JmsTemplate menangani pembuatan dan pelepasan sumber daya saat mengirim atau menerima pesan secara sinkron.

Karenanya kelas yang menggunakan JmsTemplate ini hanya perlu mengimplementasikan antarmuka callback seperti yang ditentukan dalam definisi metode.

Dimulai dengan Spring 4.1, JmsMessagingTemplate dibangun di atas JmsTemplate yang menyediakan integrasi dengan abstraksi perpesanan, yaitu org.springframework.messaging.Message. Ini, pada gilirannya, memungkinkan kita membuat pesan untuk dikirim secara umum.

4. Manajemen Koneksi

Untuk menghubungkan dan dapat mengirim / menerima pesan, kita perlu mengkonfigurasi ConnectionFactory .

A ConnectionFactory adalah salah satu objek yang dikelola JMS yang telah dikonfigurasi sebelumnya oleh administrator . Klien dengan bantuan konfigurasi akan membuat koneksi dengan penyedia JMS.

Spring menyediakan 2 jenis ConnectionFactory :

  • SingleConnectionFactory - adalah implementasi dariantarmuka ConnectionFactory , yang akan mengembalikan koneksi yang sama pada semuapanggilan createConnection () dan mengabaikan panggilan ke close ()
  • CachingConnectionFactory - memperluas fungsionalitas SingleConnectionFactory dan menambahkannya dengan caching Sesi , MessageProducers , dan MessageConsumers

5. Manajemen Destinasi

Seperti dibahas di atas, bersama dengan ConnectionFactory , tujuan juga objek yang dikelola JMS dan dapat disimpan dan diambil dari JNDI.

Spring menyediakan resolver generik seperti DynamicDestinationResolver dan resolver tertentu seperti JndiDestinationResolver .

The JmsTemplate akan mendelegasikan resolusi nama tujuan untuk salah satu implementasi mendasarkan pada pilihan.

Ini juga akan menyediakan properti bernama defaultDestination - yang akan digunakan dengan operasi kirim dan terima yang tidak merujuk ke tujuan tertentu.

6. Konversi Pesan

Spring JMS tidak akan lengkap tanpa dukungan Pengonversi Pesan.

Strategi konversi default yang digunakan oleh JmsTemplate untuk operasi ConvertAndSend () dan ReceiveAndConvert () adalah kelas SimpleMessageConverter .

SimpleMessageConverter mampu menangani TextMessages , BytesMessages , MapMessages , dan ObjectMessages . Kelas ini mengimplementasikan antarmuka MessageConverter .

Selain SimpleMessageConverter , Spring JMS menyediakan beberapa kelas MessageConverter lainnya seperti MappingJackson2MessageConverter , MarshallingMessageConverter , MessagingMessageConverter .

Selain itu, kita dapat membuat fungsionalitas konversi pesan khusus hanya dengan mengimplementasikan metode toMessage () dan FromMessage () pada antarmuka MessageConverter .

Mari kita lihat cuplikan kode contoh tentang penerapan MessageConverter kustom ,

public class SampleMessageConverter implements MessageConverter { public Object fromMessage(Message message) throws JMSException, MessageConversionException { //... } public Message toMessage(Object object, Session session) throws JMSException, MessageConversionException { //... } }

7. Contoh Spring JMS

Di bagian ini, kita akan melihat bagaimana menggunakan JmsTemplate untuk mengirim dan menerima pesan.

Metode default untuk mengirim pesan adalah JmsTemplate.send () . Ini memiliki dua parameter kunci, parameter pertama adalah tujuan JMS dan parameter kedua adalah implementasi MessageCreator. JmsTemplate menggunakan metode callback MessageCreator createMessage () untuk membuat pesan.

JmsTemplate.send () bagus untuk mengirim pesan teks biasa tetapi untuk mengirim pesan khusus, JmsTemplate memiliki metode lain yang disebut c onvertAndSend () .

Kami dapat melihat di bawah penerapan metode ini:

public class SampleJmsMessageSender { private JmsTemplate jmsTemplate; private Queue queue; // setters for jmsTemplate & queue public void simpleSend() { jmsTemplate.send(queue, s -> s.createTextMessage("hello queue world")); }
 public void sendMessage(Employee employee) { System.out.println("Jms Message Sender : " + employee); Map map = new HashMap(); map.put("name", employee.getName()); map.put("age", employee.getAge()); jmsTemplate.convertAndSend(map); } }

Di bawah ini adalah kelas penerima pesan, kami menyebutnya sebagai Message-Driven POJO (MDP). Kita dapat melihat bahwa kelas SampleListener mengimplementasikan antarmuka MessageListener dan menyediakan implementasi khusus teks untuk metode antarmuka onMessage ().

Terlepas dari metode onMessage () , kelas SampleListener kami juga disebut metode acceptAndConvert () untuk menerima pesan khusus:

public class SampleListener implements MessageListener { public JmsTemplate getJmsTemplate() { return getJmsTemplate(); } public void onMessage(Message message) { if (message instanceof TextMessage) { try { String msg = ((TextMessage) message).getText(); System.out.println("Message has been consumed : " + msg); } catch (JMSException ex) { throw new RuntimeException(ex); } } else { throw new IllegalArgumentException("Message Error"); } } public Employee receiveMessage() throws JMSException { Map map = (Map) getJmsTemplate().receiveAndConvert(); return new Employee((String) map.get("name"), (Integer) map.get("age")); } }

Kami melihat cara mengimplementasikan MessageListener dan di bawah ini kami melihat konfigurasi dalam konteks aplikasi Spring:

DefaultMessageListenerContainer adalah kontainer pendengar pesan default yang disediakan Spring bersama dengan banyak kontainer khusus lainnya.

8. Basic Configuration With Java Annotations

The @JmsListener is the only annotation required to convert a method of a normal bean into a JMS listener endpoint. Spring JMS provides many more annotations to ease the JMS implementation.

We can see some of the sample classes annotated below:

@JmsListener(destination = "myDestination") public void SampleJmsListenerMethod(Message order) { ... }

In order to add multiple listeners to a single method we just need to add multiple @JmsListener annotations.

We need to add the @EnableJms annotation to one of our configuration classes to support the @JmsListener annotated methods:

@Configuration @EnableJms public class AppConfig { @Bean public DefaultJmsListenerContainerFactory jmsListenerContainerFactory() { DefaultJmsListenerContainerFactory factory = new DefaultJmsListenerContainerFactory(); factory.setConnectionFactory(connectionFactory()); return factory; } }

9. Error Handler

We can also configure a custom error handler for our message listener container.

Let's first implement the org.springframework.util.ErrorHandler interface:

@Service public class SampleJmsErrorHandler implements ErrorHandler { // ... logger @Override public void handleError(Throwable t) { LOG.warn("In default jms error handler..."); LOG.error("Error Message : {}", t.getMessage()); } }

Note that we have overridden the handleError() method, which simply logs the error message.

And then, we need to reference our error handler service in the DefaultJmsListenerConnectionFactory using the setErrorHandler() method:

@Bean public DefaultJmsListenerContainerFactorybjmsListenerContainerFactory() { DefaultJmsListenerContainerFactory factory = new DefaultJmsListenerContainerFactory(); factory.setConnectionFactory(connectionFactory()); factory.setErrorHandler(sampleJmsErrorHandler); return factory; }

With this, our configured error handler will now catch any unhandled exceptions and log the message.

Optionally, we can also configure the error handler using the plain-old XML configurations by updating our appContext.xml:

10. Conclusion

In this tutorial, we discussed the configuration and basic concepts of Spring JMS. We also had a brief look at the Spring-specific JmsTemplate classes which are used for sending and receiving messages.

Anda dapat menemukan implementasi kode di proyek GitHub.