Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Funktionierende Beispiele für die Verwendung von Java Message Service (JMS) mit ActiveMQ
Die folgenden Beispiele zeigen, wie Sie programmgesteuert mit ActiveMQ arbeiten können:
+ Der OpenWire Java-Beispielcode stellt eine Verbindung zu einem Broker her, erstellt eine Warteschlange und sendet und empfängt eine Nachricht. Eine detaillierte Aufschlüsselung und Erläuterung finden Sie unter [Verbinden einer Java-Anwendung mit Ihrem Amazon MQ-Broker](amazon-mq-connecting-application.md).
+ Mit dem MQTT Java-Beispielcode wird eine Verbindung zu einem Broker hergestellt, eine Warteschlange erstellt und eine Nachricht gesendet und empfangen.
+ Der Java-Beispielcode für STOMP\$1WSS stellt eine Verbindung zu einem Broker her, erstellt eine Warteschlange und veröffentlicht und empfängt eine Nachricht.
## Voraussetzungen
### Aktivieren der VPC-Attribute
Um sicherzustellen, dass Ihr Broker innerhalb Ihrer VPC zugänglich ist, müssen Sie die`enableDnsHostnames`und`enableDnsSupport`VPC Attribute Weitere Informationen finden Sie unter [DNS-Support in Ihrer VPC](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-dns.html#vpc-dns-support) im *Amazon-VPC-Benutzerhandbuch*.
### Eingehende Verbindungen aktivieren
Um programmgesteuert mit Amazon MQ arbeiten zu können, müssen Sie eingehende Verbindungen verwenden.
1. Melden Sie sich bei der [Amazon-MQ-Konsole](https://console.aws.amazon.com/amazon-mq/) an.
1. Wählen Sie aus der Brokerliste den Namen Ihres Brokers aus (z. B.). **MyBroker**
1. Notieren Sie sich auf der ***MyBroker***Seite im Abschnitt **Verbindungen** die Adressen und Ports der Webkonsolen-URL und der Wire-Level-Protokolle des Brokers.
1. Wählen Sie im Abschnitt **Details** unter **Sicherheit und Netzwerk** den Namen Ihrer Sicherheitsgruppe oder ![\[Pencil icon indicating an edit or modification action.\]](http://docs.aws.amazon.com/de_de/amazon-mq/latest/developer-guide/images/amazon-mq-tutorials-broker-details-link.png).
Die Seite **Security Groups** (Sicherheitsgruppen) des EC2-Dashboards wird angezeigt.
1. Wählen Sie in der Liste der Sicherheitsgruppen Ihre Sicherheitsgruppe.
1. Klicken Sie unten auf der Seite auf **Inbound** (Eingehend) und anschließend auf **Edit** (Bearbeiten).
1. In dem Dialogfeld **Edit inbound rules** (Bearbeiten von Regeln für eingehenden Datenverkehr), fügen Sie eine Regel für jede URL oder jeden Endpunkt hinzu, auf den Sie öffentlich zugreifen möchten (im folgenden Beispiel wird gezeigt, wie Sie dies für eine Broker-Webkonsole tun).
1. Klicken Sie auf **Add Rule** (Regel hinzufügen).
1. Wählen Sie für **Type** (Typ) **Custom TCP** (Benutzerdefiniertes TCP).
1. Für **Port-Bereich**, geben Sie den Port der Webkonsole ein (`8162`).
1. Für **Source** (Quelle), lassen Sie **Custom** (Benutzerdefiniert) ausgewählt, und geben Sie dann die IP-Adresse des Systems ein, auf das auf die Webkonsole zugegriffen werden soll (z. B. `192.0.2.1`) enthalten.
1. Wählen Sie **Save**.
Ihr Broker kann nun eingehende Verbindungen akzeptieren.
### Java-Abhängigkeiten hinzufügen
------
#### [ OpenWire ]
Fügen Sie dem Pfad für Ihre Java-Build-Klasse die Pakete `activemq-client.jar` und `activemq-pool.jar`hinzu. Das folgende Beispiel zeigt diese Abhängigkeiten in der `pom.xml`-Datei eines Maven-Projekts.
```
org.apache.activemq
activemq-client
5.15.16
org.apache.activemq
activemq-pool
5.15.16
```
Weitere Informationen über `activemq-client.jar` finden Sie unter [Ursprüngliche Konfiguration](http://activemq.apache.org/initial-configuration.html) in der Apache ActiveMQ-Dokumentation.
------
#### [ MQTT ]
Fügen Sie dem Pfad für Ihre Java-Klasse das `org.eclipse.paho.client.mqttv3.jar`-Pakete hinzu. Das folgende Beispiel zeigt diese Abhängigkeit in der `pom.xml`-Datei eines Maven-Projekts.
```
org.eclipse.paho
org.eclipse.paho.client.mqttv3
1.2.0
```
Weitere Informationen zu `org.eclipse.paho.client.mqttv3.jar` finden Sie unter [Eclipse Paho-Java-Client](https://www.eclipse.org/paho/clients/java/).
------
#### [ STOMP\$1WSS ]
Fügen Sie die folgenden Pakete zu Ihrem Java-Klassenpfad hinzu:
+ `spring-messaging.jar`
+ `spring-websocket.jar`
+ `javax.websocket-api.jar`
+ `jetty-all.jar`
+ `slf4j-simple.jar`
+ `jackson-databind.jar`
Das folgende Beispiel zeigt diese Abhängigkeiten in der `pom.xml`-Datei eines Maven-Projekts.
```
org.springframework
spring-messaging
5.0.5.RELEASE
org.springframework
spring-websocket
5.0.5.RELEASE
javax.websocket
javax.websocket-api
1.1
org.eclipse.jetty.aggregate
jetty-all
pom
9.3.3.v20150827
org.slf4j
slf4j-simple
1.6.6
com.fasterxml.jackson.core
jackson-databind
2.5.0
```
Weitere Informationen finden Sie unter [STOMP-Unterstützung](https://docs.spring.io/spring-integration/docs/5.0.5.RELEASE/reference/html/stomp.html) in der Spring Framework-Dokumentation.
------
## MQExampleAmazon.java
**Wichtig**
Im folgenden Beispielcode laufen Hersteller und Verbraucher in einem einzigen Thread. Stellen Sie für Produktionssysteme (oder zum Testen des Failovers von Broker-Instances) sicher, dass Ihre Produzenten und Verbraucher auf separaten Hosts oder Threads ausgeführt werden.
------
#### [ OpenWire ]
```
/*
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* https://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*
*/
import org.apache.activemq.ActiveMQConnectionFactory;
import org.apache.activemq.jms.pool.PooledConnectionFactory;
import javax.jms.*;
public class AmazonMQExample {
// Specify the connection parameters.
private final static String WIRE_LEVEL_ENDPOINT
= "ssl://b-1234a5b6-78cd-901e-2fgh-3i45j6k178l9-1.mq.us-east-2.amazonaws.com:61617";
private final static String ACTIVE_MQ_USERNAME = "MyUsername123";
private final static String ACTIVE_MQ_PASSWORD = "MyPassword456";
public static void main(String[] args) throws JMSException {
final ActiveMQConnectionFactory connectionFactory =
createActiveMQConnectionFactory();
final PooledConnectionFactory pooledConnectionFactory =
createPooledConnectionFactory(connectionFactory);
sendMessage(pooledConnectionFactory);
receiveMessage(connectionFactory);
pooledConnectionFactory.stop();
}
private static void
sendMessage(PooledConnectionFactory pooledConnectionFactory) throws JMSException {
// Establish a connection for the producer.
final Connection producerConnection = pooledConnectionFactory
.createConnection();
producerConnection.start();
// Create a session.
final Session producerSession = producerConnection
.createSession(false, Session.AUTO_ACKNOWLEDGE);
// Create a queue named "MyQueue".
final Destination producerDestination = producerSession
.createQueue("MyQueue");
// Create a producer from the session to the queue.
final MessageProducer producer = producerSession
.createProducer(producerDestination);
producer.setDeliveryMode(DeliveryMode.NON_PERSISTENT);
// Create a message.
final String text = "Hello from Amazon MQ!";
final TextMessage producerMessage = producerSession
.createTextMessage(text);
// Send the message.
producer.send(producerMessage);
System.out.println("Message sent.");
// Clean up the producer.
producer.close();
producerSession.close();
producerConnection.close();
}
private static void
receiveMessage(ActiveMQConnectionFactory connectionFactory) throws JMSException {
// Establish a connection for the consumer.
// Note: Consumers should not use PooledConnectionFactory.
final Connection consumerConnection = connectionFactory.createConnection();
consumerConnection.start();
// Create a session.
final Session consumerSession = consumerConnection
.createSession(false, Session.AUTO_ACKNOWLEDGE);
// Create a queue named "MyQueue".
final Destination consumerDestination = consumerSession
.createQueue("MyQueue");
// Create a message consumer from the session to the queue.
final MessageConsumer consumer = consumerSession
.createConsumer(consumerDestination);
// Begin to wait for messages.
final Message consumerMessage = consumer.receive(1000);
// Receive the message when it arrives.
final TextMessage consumerTextMessage = (TextMessage) consumerMessage;
System.out.println("Message received: " + consumerTextMessage.getText());
// Clean up the consumer.
consumer.close();
consumerSession.close();
consumerConnection.close();
}
private static PooledConnectionFactory
createPooledConnectionFactory(ActiveMQConnectionFactory connectionFactory) {
// Create a pooled connection factory.
final PooledConnectionFactory pooledConnectionFactory =
new PooledConnectionFactory();
pooledConnectionFactory.setConnectionFactory(connectionFactory);
pooledConnectionFactory.setMaxConnections(10);
return pooledConnectionFactory;
}
private static ActiveMQConnectionFactory createActiveMQConnectionFactory() {
// Create a connection factory.
final ActiveMQConnectionFactory connectionFactory =
new ActiveMQConnectionFactory(WIRE_LEVEL_ENDPOINT);
// Pass the sign-in credentials.
connectionFactory.setUserName(ACTIVE_MQ_USERNAME);
connectionFactory.setPassword(ACTIVE_MQ_PASSWORD);
return connectionFactory;
}
}
```
------
#### [ MQTT ]
```
/*
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* https://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*
*/
import org.eclipse.paho.client.mqttv3.*;
public class AmazonMQExampleMqtt implements MqttCallback {
// Specify the connection parameters.
private final static String WIRE_LEVEL_ENDPOINT =
"ssl://b-1234a5b6-78cd-901e-2fgh-3i45j6k178l9-1.mq.us-east-2.amazonaws.com:8883";
private final static String ACTIVE_MQ_USERNAME = "MyUsername123";
private final static String ACTIVE_MQ_PASSWORD = "MyPassword456";
public static void main(String[] args) throws Exception {
new AmazonMQExampleMqtt().run();
}
private void run() throws MqttException, InterruptedException {
// Specify the topic name and the message text.
final String topic = "myTopic";
final String text = "Hello from Amazon MQ!";
// Create the MQTT client and specify the connection options.
final String clientId = "abc123";
final MqttClient client = new MqttClient(WIRE_LEVEL_ENDPOINT, clientId);
final MqttConnectOptions connOpts = new MqttConnectOptions();
// Pass the sign-in credentials.
connOpts.setUserName(ACTIVE_MQ_USERNAME);
connOpts.setPassword(ACTIVE_MQ_PASSWORD.toCharArray());
// Create a session and subscribe to a topic filter.
client.connect(connOpts);
client.setCallback(this);
client.subscribe("+");
// Create a message.
final MqttMessage message = new MqttMessage(text.getBytes());
// Publish the message to a topic.
client.publish(topic, message);
System.out.println("Published message.");
// Wait for the message to be received.
Thread.sleep(3000L);
// Clean up the connection.
client.disconnect();
}
@Override
public void connectionLost(Throwable cause) {
System.out.println("Lost connection.");
}
@Override
public void messageArrived(String topic, MqttMessage message) throws MqttException {
System.out.println("Received message from topic " + topic + ": " + message);
}
@Override
public void deliveryComplete(IMqttDeliveryToken token) {
System.out.println("Delivered message.");
}
}
```
------
#### [ STOMP\$1WSS ]
```
/*
* Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* https://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*
*/
import org.springframework.messaging.converter.StringMessageConverter;
import org.springframework.messaging.simp.stomp.*;
import org.springframework.web.socket.WebSocketHttpHeaders;
import org.springframework.web.socket.client.WebSocketClient;
import org.springframework.web.socket.client.standard.StandardWebSocketClient;
import org.springframework.web.socket.messaging.WebSocketStompClient;
import java.lang.reflect.Type;
public class AmazonMQExampleStompWss {
// Specify the connection parameters.
private final static String DESTINATION = "/queue";
private final static String WIRE_LEVEL_ENDPOINT =
"wss://b-1234a5b6-78cd-901e-2fgh-3i45j6k178l9-1.mq.us-east-2.amazonaws.com:61619";
private final static String ACTIVE_MQ_USERNAME = "MyUsername123";
private final static String ACTIVE_MQ_PASSWORD = "MyPassword456";
public static void main(String[] args) throws Exception {
final AmazonMQExampleStompWss example = new AmazonMQExampleStompWss();
final StompSession stompSession = example.connect();
System.out.println("Subscribed to a destination using session.");
example.subscribeToDestination(stompSession);
System.out.println("Sent message to session.");
example.sendMessage(stompSession);
Thread.sleep(60000);
}
private StompSession connect() throws Exception {
// Create a client.
final WebSocketClient client = new StandardWebSocketClient();
final WebSocketStompClient stompClient = new WebSocketStompClient(client);
stompClient.setMessageConverter(new StringMessageConverter());
final WebSocketHttpHeaders headers = new WebSocketHttpHeaders();
// Create headers with authentication parameters.
final StompHeaders head = new StompHeaders();
head.add(StompHeaders.LOGIN, ACTIVE_MQ_USERNAME);
head.add(StompHeaders.PASSCODE, ACTIVE_MQ_PASSWORD);
final StompSessionHandler sessionHandler = new MySessionHandler();
// Create a connection.
return stompClient.connect(WIRE_LEVEL_ENDPOINT, headers, head,
sessionHandler).get();
}
private void subscribeToDestination(final StompSession stompSession) {
stompSession.subscribe(DESTINATION, new MyFrameHandler());
}
private void sendMessage(final StompSession stompSession) {
stompSession.send(DESTINATION, "Hello from Amazon MQ!".getBytes());
}
private static class MySessionHandler extends StompSessionHandlerAdapter {
public void afterConnected(final StompSession stompSession,
final StompHeaders stompHeaders) {
System.out.println("Connected to broker.");
}
}
private static class MyFrameHandler implements StompFrameHandler {
public Type getPayloadType(final StompHeaders headers) {
return String.class;
}
public void handleFrame(final StompHeaders stompHeaders,
final Object message) {
System.out.print("Received message from topic: " + message);
}
}
}
```
------