Java >> Java Tutorial >  >> Tag >> Queue

Beispiel für eine JMS-Warteschlange

Die JMS-Nachrichtenwarteschlange ist ein Ziel, an das Produzenten Nachrichten senden. Der Verbraucher stellt eine Verbindung zum Broker her, um die in der Warteschlange befindliche Nachricht zu empfangen. Die Warteschlange wird beim Punkt-zu-Punkt-Messaging verwendet. Beim Punkt-zu-Punkt-Messaging kann mehr als ein Empfänger mit der Warteschlange verbunden sein, aber jede Nachricht in der Warteschlange darf nur von einem der Empfänger der Warteschlange verarbeitet werden.

Die Nachrichten können entweder synchron oder asynchron gesendet und empfangen werden.

In diesem Artikel sehen wir einige Beispiele für die JMS-Warteschlange.

1. Abhängigkeiten

Um JMS-Nachrichten an und von einem JMS-Nachrichtenbroker zu senden und zu empfangen, müssen wir die Nachrichtendienstbibliothek einbinden. In diesem Beispiel verwenden wir activeMq, sodass unsere pom.xml Abhängigkeiten sowohl zu spring als auch zu activeMq haben wird.

pom.xml:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.javacodegeeks.jms</groupId>
	<artifactId>springJmsQueue</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<dependencies>
		<dependency>
			<groupId>org.apache.activemq</groupId>
			<artifactId>activemq-all</artifactId>
			<version>5.12.0</version>
		</dependency>
	</dependencies>
	
</project>

2. Erstellen einer Warteschlange

Sehen wir uns zunächst an, wie eine Warteschlange erstellt wird.

Um ein Warteschlangenobjekt zu erstellen, müssen Sie zuerst eine Sitzung erstellen und dann createQueue() aufrufen auf dem Sitzungsobjekt. Sie müssen ihm den Namen der Warteschlange übergeben.

Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
Queue queue = session.createQueue("customerQueue");

Die Warteschlange speichert alle Nachrichten, bis sie zugestellt werden oder bis sie ablaufen.

3. Nachricht an eine Warteschlange senden

Nachdem wir nun ein Warteschlangenobjekt haben, senden wir eine Nachricht an es.

MessageProducer producer = session.createProducer(queue);
producer.send(msg);

Wie Sie oben sehen können, sendet ein Producer eine Nachricht an die Warteschlange.

4. Nachricht aus der Warteschlange empfangen

Jede in der Warteschlange empfangene Nachricht wird einmal und nur einmal an einen einzelnen Verbraucher zugestellt, weshalb diese Art der Nachrichtenübermittlung als Punkt-zu-Punkt-Nachrichtenübermittlung bezeichnet wird. Der Verbraucher stellt zunächst eine Verbindung zum Broker her, um die Nachricht aus der Warteschlange zu erhalten. Genau wie der Producer benötigt auch der Consumer eine Session, über die er sich mit der Queue verbindet.

MessageConsumer consumer = session.createConsumer(queue);
connection.start();

Beachten Sie, dass die Verbindung gestartet wird, damit jeder registrierte Nachrichten-Listener die Benachrichtigung erhält, sobald eine Nachricht in der Warteschlange landet.

Der Verbraucher erhält die Nachricht mit MessageConsumer.receive() -Methode oder asynchron durch Registrierung eines MessageListener Implementierung mit MessageConsumer.setMessageListener() Methode. Mehrere Verbraucher können in einer einzelnen Warteschlange registriert werden, aber nur ein Verbraucher erhält eine bestimmte Nachricht.

TextMessage textMsg = (TextMessage) consumer.receive();
System.out.println(textMsg);
System.out.println("Received: " + textMsg.getText());

JmsMessageQueueExample:

package com.javacodegeeks.jms;

import java.net.URI;
import java.net.URISyntaxException;

import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.Message;
import javax.jms.MessageConsumer;
import javax.jms.MessageProducer;
import javax.jms.Queue;
import javax.jms.Session;
import javax.jms.TextMessage;

import org.apache.activemq.ActiveMQConnectionFactory;
import org.apache.activemq.broker.BrokerFactory;
import org.apache.activemq.broker.BrokerService;

public class JmsMessageQueueExample {
	public static void main(String[] args) throws URISyntaxException, Exception {
		BrokerService broker = BrokerFactory.createBroker(new URI(
				"broker:(tcp://localhost:61616)"));
		broker.start();
		Connection connection = null;
		try {
			// Producer
			ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(
					"tcp://localhost:61616");
			connection = connectionFactory.createConnection();
			Session session = connection.createSession(false,
					Session.AUTO_ACKNOWLEDGE);
			Queue queue = session.createQueue("customerQueue");
			String payload = "Important Task";
			Message msg = session.createTextMessage(payload);
			MessageProducer producer = session.createProducer(queue);
			System.out.println("Sending text '" + payload + "'");
			producer.send(msg);

			// Consumer
			MessageConsumer consumer = session.createConsumer(queue);
			connection.start();
			TextMessage textMsg = (TextMessage) consumer.receive();
			System.out.println(textMsg);
			System.out.println("Received: " + textMsg.getText());
			session.close();
		} finally {
			if (connection != null) {
				connection.close();
			}
                        broker.stop();
		}
	}

}

Ausgabe:

 INFO | JMX consoles can connect to service:jmx:rmi:///jndi/rmi://localhost:1099/jmxrmi
 INFO | PListStore:[C:\javacodegeeks_ws\jmsMessageTypesExample\activemq-data\localhost\tmp_storage] started
 INFO | Using Persistence Adapter: KahaDBPersistenceAdapter[C:\javacodegeeks_ws\jmsMessageTypesExample\activemq-data\localhost\KahaDB]
 INFO | KahaDB is version 6
 INFO | Recovering from the journal @1:169756
 INFO | Recovery replayed 1 operations from the journal in 0.011 seconds.
 INFO | Apache ActiveMQ 5.12.0 (localhost, ID:INMAA1-L1005-57715-1446468253396-0:1) is starting
 INFO | Listening for connections at: tcp://127.0.0.1:61616
 INFO | Connector tcp://127.0.0.1:61616 started
 INFO | Apache ActiveMQ 5.12.0 (localhost, ID:INMAA1-L1005-57715-1446468253396-0:1) started
 INFO | For help or more information please see: http://activemq.apache.org
 WARN | Store limit is 102400 mb (current store usage is 0 mb). The data directory: C:\javacodegeeks_ws\jmsMessageTypesExample\activemq-data\localhost\KahaDB only has 34512 mb of usable space - resetting to maximum available disk space: 34512 mb
 WARN | Temporary Store limit is 51200 mb, whilst the temporary data directory: C:\javacodegeeks_ws\jmsMessageTypesExample\activemq-data\localhost\tmp_storage only has 34512 mb of usable space - resetting to maximum available 34512 mb.
Sending text 'Important Task'
ActiveMQTextMessage {commandId = 5, responseRequired = true, messageId = ID:INMAA1-L1005-57715-1446468253396-3:1:1:1:1, originalDestination = null, originalTransactionId = null, producerId = ID:INMAA1-L1005-57715-1446468253396-3:1:1:1, destination = queue://customerQueue, transactionId = null, expiration = 0, timestamp = 1446468253638, arrival = 0, brokerInTime = 1446468253639, brokerOutTime = 1446468253663, correlationId = null, replyTo = null, persistent = true, type = null, priority = 4, groupID = null, groupSequence = 0, targetConsumerId = null, compressed = false, userID = null, content = org.apache.activemq.util.ByteSequence@77be656f, marshalledProperties = null, dataStructure = null, redeliveryCounter = 0, size = 0, properties = null, readOnlyProperties = true, readOnlyBody = true, droppable = false, jmsXGroupFirstForConsumer = false, text = Important Task}
Received: Important Task
 INFO | Apache ActiveMQ 5.12.0 (localhost, ID:INMAA1-L1005-57715-1446468253396-0:1) is shutting down
 INFO | Connector tcp://127.0.0.1:61616 stopped
 INFO | PListStore:[C:\javacodegeeks_ws\jmsMessageTypesExample\activemq-data\localhost\tmp_storage] stopped
 INFO | Stopping async queue tasks
 INFO | Stopping async topic tasks
 INFO | Stopped KahaDB
 INFO | Apache ActiveMQ 5.12.0 (localhost, ID:INMAA1-L1005-57715-1446468253396-0:1) uptime 0.906 seconds
 INFO | Apache ActiveMQ 5.12.0 (localhost, ID:INMAA1-L1005-57715-1446468253396-0:1) is shutdown

5. Asynchrones Empfangen einer Nachricht

In unserem letzten Beispiel haben wir gesehen, wie Verbraucher Nachrichten explizit mit MessageConsumer.receive() empfangen haben. In diesem Abschnitt werden wir sehen, wie ein Verbraucher einen Nachrichten-Listener registrieren kann. Anstatt die Nachricht explizit zu empfangen, registriert der Verbraucher einfach einen Nachrichten-Listener. Sobald eine Nachricht in der Warteschlange landet, leitet der Broker die Nachricht an einen der Nachrichten-Listener weiter.

Lassen Sie uns zuerst einen Nachrichten-Listener erstellen.

Ein Nachrichten-Listener wird durch Implementieren von javax.jms.MessageListener erstellt und Implementieren von onMessage(Message) .

ConsumerMessageListener:

package com.javacodegeeks.jms;

import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.TextMessage;

public class ConsumerMessageListener implements MessageListener {
	private String consumerName;
	public ConsumerMessageListener(String consumerName) {
		this.consumerName = consumerName;
	}

	public void onMessage(Message message) {
		TextMessage textMessage = (TextMessage) message;
		try {
			System.out.println(consumerName + " received " + textMessage.getText());
		} catch (JMSException e) {			
			e.printStackTrace();
		}
	}

}

Der Verbraucher registriert seinen eigenen Nachrichten-Listener. Es wird ihm einen Namen übergeben, damit wir wissen, welcher Verbraucher die Nachricht konsumiert.

// Consumer
MessageConsumer consumer = session.createConsumer(queue);
consumer.setMessageListener(new ConsumerMessageListener("Consumer"));

Als nächstes müssen wir sicherstellen, dass start() wird auf Verbindungsobjekt aufgerufen. Dies ist ein wichtiger Schritt für den Broker, um sicherzustellen, dass die Nachricht an einen der Listener weitergeleitet wird.

connection.start();

JmsMessageAsynchronousQueueExample:

package com.javacodegeeks.jms;

import java.net.URI;
import java.net.URISyntaxException;

import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.Message;
import javax.jms.MessageConsumer;
import javax.jms.MessageProducer;
import javax.jms.Queue;
import javax.jms.Session;

import org.apache.activemq.ActiveMQConnectionFactory;
import org.apache.activemq.broker.BrokerFactory;
import org.apache.activemq.broker.BrokerService;

public class JmsMessageAsynchronousQueueExample {
	public static void main(String[] args) throws URISyntaxException, Exception {
		BrokerService broker = BrokerFactory.createBroker(new URI(
				"broker:(tcp://localhost:61616)"));
		broker.start();
		Connection connection = null;
		try {
			// Producer
			ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(
					"tcp://localhost:61616");
			connection = connectionFactory.createConnection();
			Session session = connection.createSession(false,
					Session.AUTO_ACKNOWLEDGE);
			Queue queue = session.createQueue("customerQueue");
			String payload = "Important Task";
			Message msg = session.createTextMessage(payload);
			MessageProducer producer = session.createProducer(queue);
			System.out.println("Sending text '" + payload + "'");
			producer.send(msg);

			// Consumer
			MessageConsumer consumer = session.createConsumer(queue);
			consumer.setMessageListener(new ConsumerMessageListener("Consumer"));
			connection.start();
			Thread.sleep(1000);
			session.close();
		} finally {
			if (connection != null) {
				connection.close();
			}
			broker.stop();
		}
	}

}

Ausgabe:

 INFO | JMX consoles can connect to service:jmx:rmi:///jndi/rmi://localhost:1099/jmxrmi
 INFO | PListStore:[C:\javacodegeeks_ws\jmsMessageTypesExample\activemq-data\localhost\tmp_storage] started
 INFO | Using Persistence Adapter: KahaDBPersistenceAdapter[C:\javacodegeeks_ws\jmsMessageTypesExample\activemq-data\localhost\KahaDB]
 INFO | KahaDB is version 6
 INFO | Recovering from the journal @1:153817
 INFO | Recovery replayed 1 operations from the journal in 0.011 seconds.
 INFO | Apache ActiveMQ 5.12.0 (localhost, ID:INMAA1-L1005-56230-1446467650870-0:1) is starting
 INFO | Listening for connections at: tcp://127.0.0.1:61616
 INFO | Connector tcp://127.0.0.1:61616 started
 INFO | Apache ActiveMQ 5.12.0 (localhost, ID:INMAA1-L1005-56230-1446467650870-0:1) started
 INFO | For help or more information please see: http://activemq.apache.org
 WARN | Store limit is 102400 mb (current store usage is 0 mb). The data directory: C:\javacodegeeks_ws\jmsMessageTypesExample\activemq-data\localhost\KahaDB only has 34515 mb of usable space - resetting to maximum available disk space: 34515 mb
 WARN | Temporary Store limit is 51200 mb, whilst the temporary data directory: C:\javacodegeeks_ws\jmsMessageTypesExample\activemq-data\localhost\tmp_storage only has 34515 mb of usable space - resetting to maximum available 34515 mb.
Sending text 'Important Task'
Consumer received Important Task
 INFO | Apache ActiveMQ 5.12.0 (localhost, ID:INMAA1-L1005-56230-1446467650870-0:1) is shutting down
 INFO | Connector tcp://127.0.0.1:61616 stopped
 INFO | PListStore:[C:\javacodegeeks_ws\jmsMessageTypesExample\activemq-data\localhost\tmp_storage] stopped
 INFO | Stopping async queue tasks
 INFO | Stopping async topic tasks
 INFO | Stopped KahaDB
 INFO | Apache ActiveMQ 5.12.0 (localhost, ID:INMAA1-L1005-56230-1446467650870-0:1) uptime 1.928 seconds
 INFO | Apache ActiveMQ 5.12.0 (localhost, ID:INMAA1-L1005-56230-1446467650870-0:1) is shutdown

6. Mehrere Verbraucher

Die Arbeitslast der Message-Verarbeitung kann auf mehr als einen Consumer verteilt werden. Wenn mehrere Empfänger mit einer Warteschlange verbunden sind, wird jede Nachricht in der Warteschlange an einen Empfänger übermittelt. Die absolute Reihenfolge der Nachrichten kann nicht garantiert werden, da ein Empfänger Nachrichten schneller verarbeiten kann als ein anderer.

Die Speicherung für die Warteschlange erfolgt auf der Grundlage der First-In-First-Out-Order (FIFO). Es wird jeweils eine Nachricht an einen einzelnen Verbraucher gesendet. Erst wenn diese Nachricht konsumiert und bestätigt wurde, wird sie aus der Warteschlange gelöscht.
Im folgenden Beispiel erstellen wir mehrere Verbraucher, von denen jeder bei einem Nachrichten-Listener registriert ist. Als Nächstes erstellen wir einen Producer und lassen ihn mehrere Nachrichten senden. Jede Nachricht wird von nur einem Verbraucher empfangen und die Reihenfolge, in der die Nachrichten empfangen werden, entspricht FIFO.

Jeder Verbraucher registriert seinen eigenen Nachrichten-Listener. Es wird ihm einen Namen übergeben, damit wir wissen, welcher Verbraucher die Nachricht konsumiert.

JmsMultipleCustomersMessageQueueExample:

package com.javacodegeeks.jms;

import java.net.URI;
import java.net.URISyntaxException;

import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.Message;
import javax.jms.MessageConsumer;
import javax.jms.MessageProducer;
import javax.jms.Queue;
import javax.jms.Session;

import org.apache.activemq.ActiveMQConnectionFactory;
import org.apache.activemq.broker.BrokerFactory;
import org.apache.activemq.broker.BrokerService;

public class JmsMultipleCustomersMessageQueueExample {
	public static void main(String[] args) throws URISyntaxException, Exception {
		BrokerService broker = BrokerFactory.createBroker(new URI(
				"broker:(tcp://localhost:61616)"));
		broker.start();
		Connection connection = null;
		try {
			// Producer
			ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(
					"tcp://localhost:61616");
			connection = connectionFactory.createConnection();
			Session session = connection.createSession(false,
					Session.AUTO_ACKNOWLEDGE);
			Queue queue = session.createQueue("customerQueue");

			// Consumer
			for (int i = 0; i < 4; i++) {
				MessageConsumer consumer = session.createConsumer(queue);
				consumer.setMessageListener(new ConsumerMessageListener(
						"Consumer " + i));
			}
			connection.start();

			String basePayload = "Important Task";
			MessageProducer producer = session.createProducer(queue);
			for (int i = 0; i < 10; i++) {
				String payload = basePayload + i;
				Message msg = session.createTextMessage(payload);
				System.out.println("Sending text '" + payload + "'");
				producer.send(msg);
			}

			Thread.sleep(1000);
			session.close();
		} finally {
			if (connection != null) {
				connection.close();
			}
			broker.stop();
		}
	}

}

Wie Sie der Ausgabe entnehmen können, werden die Nachrichten im Round-Robin-Verfahren zwischen allen Nachrichtenkonsumenten zugestellt.

Ausgabe:

 INFO | PListStore:[C:\javacodegeeks_ws\jmsMessageTypesExample\activemq-data\localhost\tmp_storage] started
 INFO | Using Persistence Adapter: KahaDBPersistenceAdapter[C:\javacodegeeks_ws\jmsMessageTypesExample\activemq-data\localhost\KahaDB]
 INFO | JMX consoles can connect to service:jmx:rmi:///jndi/rmi://localhost:1099/jmxrmi
 INFO | KahaDB is version 6
 INFO | Recovering from the journal @1:173161
 INFO | Recovery replayed 1 operations from the journal in 0.012 seconds.
 INFO | Apache ActiveMQ 5.12.0 (localhost, ID:INMAA1-L1005-62099-1446469937715-0:1) is starting
 INFO | Listening for connections at: tcp://127.0.0.1:61616
 INFO | Connector tcp://127.0.0.1:61616 started
 INFO | Apache ActiveMQ 5.12.0 (localhost, ID:INMAA1-L1005-62099-1446469937715-0:1) started
 INFO | For help or more information please see: http://activemq.apache.org
 WARN | Store limit is 102400 mb (current store usage is 0 mb). The data directory: C:\javacodegeeks_ws\jmsMessageTypesExample\activemq-data\localhost\KahaDB only has 34555 mb of usable space - resetting to maximum available disk space: 34556 mb
 WARN | Temporary Store limit is 51200 mb, whilst the temporary data directory: C:\javacodegeeks_ws\jmsMessageTypesExample\activemq-data\localhost\tmp_storage only has 34555 mb of usable space - resetting to maximum available 34555 mb.
Sending text 'Important Task0'
Consumer 0 received Important Task0
Sending text 'Important Task1'
Consumer 1 received Important Task1
Sending text 'Important Task2'
Consumer 2 received Important Task2
Sending text 'Important Task3'
Consumer 3 received Important Task3
Sending text 'Important Task4'
Consumer 0 received Important Task4
Sending text 'Important Task5'
Consumer 1 received Important Task5
Sending text 'Important Task6'
Consumer 2 received Important Task6
Sending text 'Important Task7'
Consumer 3 received Important Task7
Sending text 'Important Task8'
Consumer 0 received Important Task8
Sending text 'Important Task9'
Consumer 1 received Important Task9
 INFO | Apache ActiveMQ 5.12.0 (localhost, ID:INMAA1-L1005-62099-1446469937715-0:1) is shutting down
 INFO | Connector tcp://127.0.0.1:61616 stopped
 INFO | PListStore:[C:\javacodegeeks_ws\jmsMessageTypesExample\activemq-data\localhost\tmp_storage] stopped
 INFO | Stopping async queue tasks
 INFO | Stopping async topic tasks
 INFO | Stopped KahaDB
 INFO | Apache ActiveMQ 5.12.0 (localhost, ID:INMAA1-L1005-62099-1446469937715-0:1) uptime 2.009 seconds
 INFO | Apache ActiveMQ 5.12.0 (localhost, ID:INMAA1-L1005-62099-1446469937715-0:1) is shutdown

7. Erstellen einer temporären Warteschlange

Eine temporäre Warteschlange ist eine Warteschlange, die nur von dem JMS-Client verwendet werden kann, der sie erstellt hat. Es wird mit dem createTemporaryQueue() erstellt Methode auf QueueSession/code> object.

QueueSession.createTemporaryQueue();

8. Durchsuchen einer Warteschlange

Mit JMS können Sie mit QueueBrowser einen Blick auf ausstehende Nachrichten in einer Warteschlange werfen, ohne sie tatsächlich zu verbrauchen Objekt. Da wir die Nachrichten durchsuchen können, ohne sie tatsächlich zu konsumieren, ist dies eine sehr einzigartige und wichtige Funktion für Punkt-zu-Punkt-Nachrichten.

Wir erstellen den QueueBrowser Objekt mit der folgenden Anweisung für das Sitzungsobjekt.

QueueBrowser browser = session.createBrowser(queue);

Wie Sie createBrowser() sehen können nimmt die Queue Objekt, das wir durchsuchen möchten.

Um die Nachrichten aufzuzählen, rufen wir QueueBrowser.getEnumeration() auf .

Enumeration e = browser.getEnumeration();
while (e.hasMoreElements()) {
    TextMessage message = (TextMessage) e.nextElement();
    System.out.println("Get [" + message.getText() + "]");
}

Wenn wir mit dem Browser fertig sind, sollten wir ihn schließen.

QueueBrowser.close();

Im folgenden Beispiel erstellen wir einen Produzenten und senden eine Reihe von Nachrichten an eine Warteschlange. Als nächstes erstellen wir einen Verbraucher. Zum Browsen erstellen wir einen QueueBrowser Objekt und navigieren Sie durch die Nachrichten.

Schließlich rufen wir consumer.receive() auf um eine der Nachrichten aus der Warteschlange zu erhalten.

package com.javacodegeeks.jms;

import java.net.URI;
import java.net.URISyntaxException;
import java.util.Enumeration;

import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.Message;
import javax.jms.MessageConsumer;
import javax.jms.MessageProducer;
import javax.jms.Queue;
import javax.jms.QueueBrowser;
import javax.jms.Session;
import javax.jms.TextMessage;

import org.apache.activemq.ActiveMQConnectionFactory;
import org.apache.activemq.broker.BrokerFactory;
import org.apache.activemq.broker.BrokerService;

public class JmsBrowseQueueExample {
	public static void main(String[] args) throws URISyntaxException, Exception {
		BrokerService broker = BrokerFactory.createBroker(new URI(
				"broker:(tcp://localhost:61616)"));
		broker.start();
		Connection connection = null;
		try {
			// Producer
			ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(
					"tcp://localhost:61616");
			connection = connectionFactory.createConnection();
			Session session = connection.createSession(false,
					Session.AUTO_ACKNOWLEDGE);
			Queue queue = session.createQueue("browseQueue");

			String basePayload = "A";
			MessageProducer producer = session.createProducer(queue);
			for (int i = 0; i < 4; i++) {
				String payload = basePayload + i;
				Message msg = session.createTextMessage(payload);
				System.out.println("Sending text '" + payload + "'");
				producer.send(msg);
			}

			MessageConsumer consumer = session.createConsumer(queue);
			connection.start();
			
			System.out.println("Browse through the elements in queue");
			QueueBrowser browser = session.createBrowser(queue);
			Enumeration e = browser.getEnumeration();
			while (e.hasMoreElements()) {
				TextMessage message = (TextMessage) e.nextElement();
				System.out.println("Get [" + message.getText() + "]");
			}
			System.out.println("Done");
			browser.close();
			
			TextMessage textMsg = (TextMessage) consumer.receive();
			System.out.println(textMsg);
			System.out.println("Received: " + textMsg.getText());
			session.close();
		} finally {
			if (connection != null) {
				connection.close();
			}
			broker.stop();
		}
	}

}

Von einem QueueBrowser erhaltene Nachrichten sind Kopien von Nachrichten, die in der Warteschlange enthalten sind, und werden nicht als verbraucht betrachtet, da sie lediglich zum Durchsuchen dienen. Unten ist die Ausgabe.

Ausgabe:

 INFO | JMX consoles can connect to service:jmx:rmi:///jndi/rmi://localhost:1099/jmxrmi
 INFO | PListStore:[C:\javacodegeeks_ws\jmsMessageTypesExample\activemq-data\localhost\tmp_storage] started
 INFO | Using Persistence Adapter: KahaDBPersistenceAdapter[C:\javacodegeeks_ws\jmsMessageTypesExample\activemq-data\localhost\KahaDB]
 INFO | KahaDB is version 6
 INFO | Recovering from the journal @1:260856
 INFO | Recovery replayed 1 operations from the journal in 0.012 seconds.
 INFO | Apache ActiveMQ 5.12.0 (localhost, ID:INMAA1-L1005-53401-1446474681874-0:1) is starting
 INFO | Listening for connections at: tcp://127.0.0.1:61616
 INFO | Connector tcp://127.0.0.1:61616 started
 INFO | Apache ActiveMQ 5.12.0 (localhost, ID:INMAA1-L1005-53401-1446474681874-0:1) started
 INFO | For help or more information please see: http://activemq.apache.org
 WARN | Store limit is 102400 mb (current store usage is 0 mb). The data directory: C:\javacodegeeks_ws\jmsMessageTypesExample\activemq-data\localhost\KahaDB only has 34326 mb of usable space - resetting to maximum available disk space: 34327 mb
 WARN | Temporary Store limit is 51200 mb, whilst the temporary data directory: C:\javacodegeeks_ws\jmsMessageTypesExample\activemq-data\localhost\tmp_storage only has 34326 mb of usable space - resetting to maximum available 34326 mb.
Sending text 'A0'
Sending text 'A1'
Sending text 'A2'
Sending text 'A3'
Browse through the elements in queue
Get [A0]
Get [A1]
Get [A2]
Get [A3]
Done
ActiveMQTextMessage {commandId = 5, responseRequired = true, messageId = ID:INMAA1-L1005-53401-1446474681874-3:1:1:1:1, originalDestination = null, originalTransactionId = null, producerId = ID:INMAA1-L1005-53401-1446474681874-3:1:1:1, destination = queue://browseQueue, transactionId = null, expiration = 0, timestamp = 1446474682340, arrival = 0, brokerInTime = 1446474682341, brokerOutTime = 1446474682383, correlationId = null, replyTo = null, persistent = true, type = null, priority = 4, groupID = null, groupSequence = 0, targetConsumerId = null, compressed = false, userID = null, content = org.apache.activemq.util.ByteSequence@ba8d91c, marshalledProperties = null, dataStructure = null, redeliveryCounter = 0, size = 0, properties = null, readOnlyProperties = true, readOnlyBody = true, droppable = false, jmsXGroupFirstForConsumer = false, text = A0}
Received: A0
 INFO | Apache ActiveMQ 5.12.0 (localhost, ID:INMAA1-L1005-53401-1446474681874-0:1) is shutting down
 INFO | Connector tcp://127.0.0.1:61616 stopped
 INFO | PListStore:[C:\javacodegeeks_ws\jmsMessageTypesExample\activemq-data\localhost\tmp_storage] stopped
 INFO | Stopping async queue tasks
 INFO | Stopping async topic tasks
 INFO | Stopped KahaDB
 INFO | Apache ActiveMQ 5.12.0 (localhost, ID:INMAA1-L1005-53401-1446474681874-0:1) uptime 1.446 seconds
 INFO | Apache ActiveMQ 5.12.0 (localhost, ID:INMAA1-L1005-53401-1446474681874-0:1) is shutdown

9. Laden Sie das Eclipse-Projekt herunter

Dies war ein Beispiel für JMS Queue.

Java-Tag