streamalism.org

1. Oversikt

Spring gir et JMS-integrasjonsrammeverk som forenkler bruken av JMS API. Denne artikkelen introduserer de grunnleggende konseptene for slik integrasjon.

2. Maven avhengighet

For å kunne bruke Spring JMS i applikasjonen vår, må vi legge til nødvendige gjenstander i pom.xml:

 org.springframework spring-jms 4.3.3.RELEASE 

Den nyeste versjonen av gjenstanden finner du her.

3. Den JmsTemplate

JmsTemplate klasse håndterer opprettelse og frigjøring av ressurser når du sender eller synkront mottar meldinger.

Derav klassen som bruker dette JmsTemplate trenger bare å implementere tilbakeringingsgrensesnitt som spesifisert i metodedefinisjonen.

Fra og med våren 4.1 JmsMessagingTemplate er bygget på toppen av JmsTemplate som gir en integrasjon med meldingsabstraksjonen, dvs. org.springframework.messaging.Message. Dette lar oss igjen lage en melding som skal sendes på en generisk måte.

4. Tilkoblingsadministrasjon

For å kunne koble til og kunne sende / motta meldinger, må vi konfigurere en ConnectionFactory.

EN ConnectionFactory er et av de JMS-administrerte objektene som er forhåndskonfigurert av en administrator. En klient ved hjelp av konfigurasjonen vil opprette forbindelse til en JMS-leverandør.

Våren gir to typer ConnectionFactory:

• SingleConnectionFactory - er en implementering av ConnectionFactory grensesnitt, som vil returnere den samme tilkoblingen på alle createConnection() ringer og ignorerer samtaler til Lukk()
• CachingConnectionFactory – utvider funksjonaliteten til SingleConnectionFactory og legger til forbedrer det med en caching av Økter, MessageProducers, og MeldingKonsumenter

5. Destinasjonsledelse

Som diskutert ovenfor, sammen med ConnectionFactory, destinasjoner er også JMS-administrerte objekter og kan lagres og hentes fra en JNDI.

Våren gir generiske resolvere som DynamicDestinationResolver og spesifikke oppløsere som JndiDestinationResolver.

De JmsTemplate vil delegere oppløsningen av destinasjonsnavnet til en av implementeringene basert på vårt valg.

Det vil også gi en eiendom som heter defaultDestination - som skal brukes med sende og motta operasjoner som ikke refererer til et bestemt mål.

6. Meldingskonvertering

Våren JMS ville være ufullstendig uten støtte fra Message Converters.

Standard konverteringsstrategi brukt av JmsTemplate for begge ConvertAndSend () og ReceiveAndConvert () operasjoner er SimpleMessageConverter klasse.

SimpleMessageConverter er i stand til å håndtere Tekstmeldinger, BytesMessages, MapMessages, og ObjectMessages. Denne klassen implementerer MessageConverter grensesnitt.

Bortsett fra SimpleMessageConverter, Spring JMS gir noen andre MessageConverter klasser ut av boksen som MappingJackson2MessageConverter, MarshallingMessageConverter, MessagingMessageConverter.

Videre kan vi lage tilpassede funksjoner for meldingskonvertering ganske enkelt ved å implementere MessageConverter grensesnitt toMessage () og FromMessage () metoder.

La oss se et eksempel på kodebit for implementering av en tilpasset MessageConverter,

offentlig klasse SampleMessageConverter implementerer MessageConverter {public Object fromMessage (Message message) kaster JMSException, MessageConversionException {// ...} public Message toMessage (Object object, Session session) kaster JMSException, MessageConversionException {// ...}}

7. Eksempel på vår JMS

I denne delen vil vi se hvordan du bruker a JmsTemplate for å sende og motta meldinger.

Standardmetoden for sending av meldingen er JmsTemplate.send (). Den har to viktige parametere, den første parameteren er JMS-destinasjonen og den andre parameteren er en implementering av MessageCreator. JmsTemplate bruker MessageCreator’Tilbakeringingsmetode createMessage () for å konstruere meldingen.

JmsTemplate.send () er bra for å sende vanlige tekstmeldinger, men for å sende tilpassede meldinger, JmsTemplate har en annen metode kalt convertAndSend ().

Vi kan se implementeringen av disse metodene nedenfor:

offentlig klasse SampleJmsMessageSender {private JmsTemplate jmsTemplate; privat kø; // setters for jmsTemplate & kø offentlig ugyldig simpleSend () {jmsTemplate.send (kø, s -> s.createTextMessage ("hallo køverden")); }

 public void sendMessage (ansatt ansatt) {System.out.println ("Jms Message Sender:" + medarbeider); Kartkart = nytt HashMap (); map.put ("navn", ansatt.getnavn ()); map.put ("alder", medarbeider.getAge ()); jmsTemplate.convertAndSend (kart); }}

Nedenfor er meldingsmottakerklassen, vi kaller den som Message-Driven POJO (MDP). Vi kan se at klassen SampleListener implementerer MessageListener grensesnitt og gir den tekstspesifikke implementeringen for grensesnittmetoden onMessage ().

Bortsett fra onMessage () metode, vår SampleListener klasse også kalt en metode receiveAndConvert () for mottak av tilpassede meldinger:

offentlig klasse SampleListener implementerer MessageListener {public JmsTemplate getJmsTemplate () {return getJmsTemplate (); } public void onMessage (Message message) {if (message instanceof TextMessage) {try {String msg = ((TextMessage) message) .getText (); System.out.println ("Meldingen er fortært:" + msg); } fange (JMSException ex) {kast ny RuntimeException (ex); }} annet {kast ny IllegalArgumentException ("Meldingsfeil"); }} offentlig ansatt mottaMessage () kaster JMSException {Map map = (Map) getJmsTemplate (). receiveAndConvert (); returner ny ansatt ((String) map.get ("name"), (Integer) map.get ("age")); }}

Vi så hvordan vi skulle implementere MessageListener og nedenfor ser vi konfigurasjonen i vårapplikasjonskontekst:

StandardMessageListenerContainer er standard meldings lyttercontainer Spring tilbyr sammen med mange andre spesialiserte containere.

8. Grunnleggende konfigurasjon med Java-merknader

De @JmsListener er den eneste merknaden som kreves for å konvertere en metode for en normal bønne til et JMS-lytterens endepunkt. Spring JMS gir mange flere kommentarer for å lette JMS-implementeringen.

Vi kan se noen av eksempelklassene som er kommentert nedenfor:

@JmsListener (destination = "myDestination") offentlig ugyldighet SampleJmsListenerMethod (Meldingsrekkefølge) {...}

For å legge til flere lyttere til en enkelt metode, trenger vi bare å legge til flere @JmsListener kommentarer.

Vi må legge til @EnableJms kommentar til en av våre konfigurasjonsklasser for å støtte @JmsListener merkede metoder:

@Configuration @EnableJms public class AppConfig {@Bean public DefaultJmsListenerContainerFactory jmsListenerContainerFactory () {DefaultJmsListenerContainerFactory fabrikk = ny DefaultJmsListenerContainerFactory (); factory.setConnectionFactory (connectionFactory ()); tilbake fabrikken; }}

9. Feilbehandler

Vi kan også konfigurere en tilpasset feilbehandler for beholderen for meldingslytter.

La oss først implementere org.springframework.util.ErrorHandler grensesnitt:

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

Merk at vi har overstyrt handleError () metode, som bare logger feilmeldingen.

Og så må vi referere til vår feilhåndteringstjeneste i StandardJmsListenerConnectionFactory bruker setErrorHandler () metode:

@Bean offentlig DefaultJmsListenerContainerFactorybjmsListenerContainerFactory () {DefaultJmsListenerContainerFactory fabrikk = ny DefaultJmsListenerContainerFactory (); factory.setConnectionFactory (connectionFactory ()); factory.setErrorHandler (sampleJmsErrorHandler); tilbake fabrikken; }

Med dette vil vår konfigurerte feilbehandler nå fange unbehandlede unntak og logge meldingen.

Eventuelt kan vi også konfigurere feilbehandleren ved hjelp av de gamle XML-konfigurasjonene ved å oppdatere vår appContext.xml:

10. Konklusjon

I denne opplæringen diskuterte vi konfigurasjonen og de grunnleggende konseptene til Spring JMS. Vi hadde også en kort titt på vårspesifikke JmsTemplate klasser som brukes til å sende og motta meldinger.

Du finner kodeimplementeringen i GitHub-prosjektet.