Aan de slag met Spring JMS

1. Overzicht

Spring biedt een JMS-integratieframework dat het gebruik van de JMS-API vereenvoudigt. Dit artikel introduceert de basisconcepten van een dergelijke integratie.

2. Maven Afhankelijkheid

Om Spring JMS in onze applicatie te gebruiken, moeten we de nodige artefacten toevoegen in het pom.xml:

 org.springframework spring-jms 4.3.3.RELEASE 

De nieuwste versie van het artefact is hier te vinden.

3. Het JmsTemplate

JmsTemplate class zorgt voor het maken en vrijgeven van bronnen bij het verzenden of synchroon ontvangen van berichten.

Vandaar de klasse die dit gebruikt JmsTemplate hoeft alleen callback-interfaces te implementeren zoals gespecificeerd in de methodedefinitie.

Beginnend met Spring 4.1, de JmsMessagingTemplate is bovenop gebouwd JmsTemplate die een integratie biedt met de abstractie van berichten, d.w.z. org.springframework.messaging.Message. Dit stelt ons op zijn beurt in staat om een ​​bericht op een generieke manier te verzenden.

4. Verbindingsbeheer

Om verbinding te maken en berichten te kunnen verzenden / ontvangen, moeten we een ConnectionFactory.

EEN ConnectionFactory is een van de door JMS beheerde objecten die vooraf zijn geconfigureerd door een beheerder. Een klant zal met behulp van de configuratie de verbinding maken met een JMS-provider.

De lente biedt 2 soorten ConnectionFactory:

  • SingleConnectionFactory - is een implementatie van ConnectionFactory interface, die voor iedereen dezelfde verbinding zal retourneren createConnection() oproepen en negeren oproepen naar dichtbij()
  • CachingConnectionFactory breidt de functionaliteit van de SingleConnectionFactory en voegt het toe met een caching van Sessies, Berichtproducenten, en MessageConsumers

5. Bestemmingsbeheer

Zoals hierboven besproken, samen met de ConnectionFactory, bestemmingen zijn ook door JMS beheerde objecten en kunnen worden opgeslagen en opgehaald uit een JNDI.

Spring biedt generieke resolvers zoals DynamicDestinationResolver en specifieke resolvers zoals JndiDestinationResolver.

De JmsTemplate zal de resolutie van de bestemmingsnaam delegeren aan een van de implementaties op basis van onze selectie.

Het biedt ook een eigenschap genaamd defaultDestination - die zal worden gebruikt met sturen en te ontvangen bewerkingen die niet naar een specifieke bestemming verwijzen.

6. Berichtconversie

Spring JMS zou onvolledig zijn zonder de ondersteuning van Message Converters.

De standaard conversiestrategie die wordt gebruikt door JmsTemplate voor beide ConvertAndSend () en ReceiveAndConvert () operaties is de SimpleMessageConverter klasse.

De SimpleMessageConverter is in staat om te hanteren Tekstberichten, BytesMessages, MapMessages, en ObjectMessages. Deze klasse implementeert het MessageConverter koppel.

Losstaand van SimpleMessageConverter, Spring JMS biedt een ander MessageConverter klassen uit de doos, zoals Toewijzing Jackson2MessageConverter, MarshallingMessageConverter, MessagingMessageConverter.

Bovendien kunnen we aangepaste berichtconversiefuncties creëren door simpelweg het MessageConverter interface's berichten() en VanMessage () methoden.

Laten we een voorbeeld van een codefragment bekijken over het implementeren van een aangepast MessageConverter,

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

7. Monster Spring JMS

In deze sectie zullen we zien hoe u een JmsTemplate om berichten te verzenden en te ontvangen.

De standaardmethode voor het verzenden van het bericht is JmsTemplate.send (). Het heeft twee belangrijke parameters, waarvan de eerste parameter de JMS-bestemming is en de tweede parameter een implementatie van MessageCreator. Het JmsTemplate gebruikt de MessageCreator‘Callback-methode creeër bericht() voor het construeren van het bericht.

JmsTemplate.send () is goed voor het verzenden van platte tekstberichten, maar om aangepaste berichten te verzenden, JmsTemplate heeft een andere methode genaamd convertAndSend ().

We kunnen hieronder de implementatie van deze methoden zien:

openbare klasse SampleJmsMessageSender {privé JmsTemplate jmsTemplate; privé wachtrij; // setters voor jmsTemplate & wachtrij public void simpleSend () {jmsTemplate.send (wachtrij, s -> s.createTextMessage ("hallo wachtrijwereld")); }
 public void sendMessage (werknemer werknemer) {System.out.println ("Jms Message Sender:" + werknemer); Map map = nieuwe HashMap (); map.put ("naam", employee.getName ()); map.put ("leeftijd", employee.getAge ()); jmsTemplate.convertAndSend (kaart); }}

Hieronder vindt u de klasse van de berichtontvanger, we noemen deze Message-Driven POJO (MDP). We kunnen zien dat de klas SampleListener implementeert het MessageListener interface en biedt de tekstspecifieke implementatie voor de interfacemethode onMessage ().

Losstaand van onMessage () methode, onze SampleListener class ook wel een methode genoemd ontvangenAndConvert () voor het ontvangen van aangepaste berichten:

openbare klasse SampleListener implementeert MessageListener {openbare JmsTemplate getJmsTemplate () {retour getJmsTemplate (); } public void onMessage (Message message) {if (message instanceof TextMessage) {probeer {String msg = ((TextMessage) bericht) .getText (); System.out.println ("Bericht is verbruikt:" + msg); } catch (JMSException ex) {throw nieuwe RuntimeException (ex); }} else {gooi nieuwe IllegalArgumentException ("Berichtfout"); }} openbare werknemer ReceiveMessage () gooit JMSException {Map map = (Map) getJmsTemplate (). ReceiveAndConvert (); retourneer nieuwe werknemer ((String) map.get ("naam"), (geheel getal) map.get ("leeftijd")); }}

We hebben gezien hoe we het moesten implementeren MessageListener en hieronder zien we de configuratie in de Spring-toepassingscontext:

DefaultMessageListenerContainer is de standaardcontainer voor berichtenluisteraars die Spring biedt, samen met vele andere gespecialiseerde containers.

8. Basisconfiguratie met Java-annotaties

De @JmsListener is de enige annotatie die nodig is om een ​​methode van een normale bean om te zetten in een JMS-listener-eindpunt. Spring JMS biedt veel meer annotaties om de JMS-implementatie te vergemakkelijken.

We kunnen enkele van de onderstaande voorbeeldklassen zien:

@JmsListener (bestemming = "myDestination") public void SampleJmsListenerMethod (Berichtvolgorde) {...}

Om meerdere luisteraars aan een enkele methode toe te voegen, hoeven we er alleen maar meerdere toe te voegen @JmsListener annotaties.

We moeten de @BuienRadarNL annotatie bij een van onze configuratieklassen ter ondersteuning van de @JmsListener geannoteerde methoden:

@Configuration @EnableJms openbare klasse AppConfig {@Bean openbaar DefaultJmsListenerContainerFactory jmsListenerContainerFactory () {DefaultJmsListenerContainerFactory factory = nieuw DefaultJmsListenerContainerFactory (); factory.setConnectionFactory (connectionFactory ()); terugkeer fabriek; }}

9. Foutafhandelaar

We kunnen ook een aangepaste foutafhandelaar configureren voor onze berichtenlistener-container.

Laten we eerst het org.springframework.util.ErrorHandler koppel:

@Service openbare klasse SampleJmsErrorHandler implementeert ErrorHandler {// ... logger @Override public void handleError (Throwable t) {LOG.warn ("In standaard jms error handler ..."); LOG.error ("Foutbericht: {}", t.getMessage ()); }}

Merk op dat we de handleError () methode, die eenvoudig het foutbericht registreert.

En dan moeten we verwijzen naar onze foutafhandelingsservice in het DefaultJmsListenerConnectionFactory de ... gebruiken setErrorHandler () methode:

@Bean openbaar DefaultJmsListenerContainerFactorybjmsListenerContainerFactory () {DefaultJmsListenerContainerFactory factory = nieuw DefaultJmsListenerContainerFactory (); factory.setConnectionFactory (connectionFactory ()); factory.setErrorHandler (sampleJmsErrorHandler); terugkeer fabriek; }

Hiermee zal onze geconfigureerde foutafhandelaar nu alle niet-verwerkte uitzonderingen opvangen en het bericht loggen.

Optioneel kunnen we de foutafhandelaar ook configureren met behulp van de gewone oude XML-configuraties door onze appContext.xml:

10. Conclusie

In deze tutorial hebben we de configuratie en basisconcepten van Spring JMS besproken. We hebben ook kort gekeken naar de Spring-specificatie JmsTemplate klassen die worden gebruikt voor het verzenden en ontvangen van berichten.

U kunt de code-implementatie vinden in het GitHub-project.