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.
# Verbinden einer Java-Anwendung mit Ihrem Amazon MQ-Broker
Nachdem Sie einen Amazon MQ ActiveMQ Broker erstellt haben, können Sie Ihre Anwendung mit ihm verbinden. Die folgenden Beispiele zeigen, wie Sie den Java Message Service (JMS) verwenden können, um eine Verbindung zum Broker zu erstellen, eine Warteschlange zu erstellen und eine Nachricht zu senden. Ein vollständiges, funktionierendes Java-Beispiel finden Sie unter[Funktionierende Beispiele für die Verwendung von Java Message Service (JMS) mit ActiveMQ](amazon-mq-working-java-example.md).
Sie können unter Verwendung [verschiedener ActiveMQ-Clients](http://activemq.apache.org/cross-language-clients.html) eine Verbindung zu ActiveMQ-Brokern einrichten. Wir empfehlen die Verwendung des [ActiveMQ-Clients](https://mvnrepository.com/artifact/org.apache.activemq/activemq-client).
**Topics**
+ [Voraussetzungen](#connect-application-prerequisites-tutorial)
+ [So erstellen Sie einen Nachrichtenproduzenten und senden eine Nachricht:](#create-producer-send-message-tutorial)
+ [So erstellen Sie einen Nachrichtenkonsumenten und empfangen die Nachricht:](#create-consumer-receive-message-tutorial)
## 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
Aktivieren Sie als Nächstes eingehende Verbindungen für Ihre Anwendung.
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 .
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
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.
**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.
## So erstellen Sie einen Nachrichtenproduzenten und senden eine Nachricht:
Verwenden Sie die folgende Anweisung, um einen Nachrichtengenerator zu erstellen und eine Nachricht zu empfangen.
1. Erstellen Sie eine JMS-Pool-Connection Factory für den Nachrichtenproduzenten mit dem Endpunkt Ihres Brokers und rufen Sie dann die`createConnection`Methode gegen die Fabrik.
**Anmerkung**
Für einen active/standby Broker bietet Amazon MQ zwei ActiveMQ-Web-Konsolen URLs, aber es ist jeweils nur eine URL aktiv. Ebenso stellt Amazon MQ zwei Endpunkte für jedes Wire-Level-Protokoll bereit, jedoch ist jeweils nur ein Endpunkt in jedem Paar aktiv. Die `-1`- und `-2`-Suffixe bezeichnen ein redundantes Paar. Weitere Informationen finden Sie unter [Bereitstellungsoptionen für Amazon MQ für ActiveMQ-Broker](amazon-mq-broker-architecture.md)).
[Bei Protokollendpunkten auf Wire-Level-Ebene sollten Sie Ihrer Anwendung ermöglichen, mithilfe des Failover-Transports eine Verbindung zu einem der beiden Endpunkte herzustellen.](http://activemq.apache.org/failover-transport-reference.html)
```
// Create a connection factory.
final ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory(wireLevelEndpoint);
// Pass the sign-in credentials.
connectionFactory.setUserName(activeMqUsername);
connectionFactory.setPassword(activeMqPassword);
// Create a pooled connection factory.
final PooledConnectionFactory pooledConnectionFactory = new PooledConnectionFactory();
pooledConnectionFactory.setConnectionFactory(connectionFactory);
pooledConnectionFactory.setMaxConnections(10);
// Establish a connection for the producer.
final Connection producerConnection = pooledConnectionFactory.createConnection();
producerConnection.start();
// Close all connections in the pool.
pooledConnectionFactory.clear();
```
**Anmerkung**
Nachrichtenproduzenten sollten immer die`PooledConnectionFactory`-Klasse. Weitere Informationen finden Sie unter [Verwenden Sie immer Verbindungspools](best-practices-activemq.md#always-use-connection-pooling).
1. Erstellen Sie eine Sitzung, eine Warteschlange namens`MyQueue`und einen Nachrichtenproduzenten.
```
// 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);
```
1. Erstellen der Nachrichtenzeichenfolge`"Hello from Amazon MQ!"`Dann senden Sie die Nachricht.
```
// Create a message.
final String text = "Hello from Amazon MQ!";
TextMessage producerMessage = producerSession.createTextMessage(text);
// Send the message.
producer.send(producerMessage);
System.out.println("Message sent.");
```
1. Bereinigen Sie den Produzenten.
```
producer.close();
producerSession.close();
producerConnection.close();
```
## So erstellen Sie einen Nachrichtenkonsumenten und empfangen die Nachricht:
Verwenden Sie die folgende Anweisung, um einen Nachrichtengenerator zu erstellen und eine Nachricht zu empfangen.
1. Erstellen Sie eine JMS-Connection Factory für den Nachrichtenproduzenten mit dem Endpunkt Ihres Brokers und rufen Sie dann die`createConnection`Methode gegen die Fabrik.
```
// Create a connection factory.
final ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory(wireLevelEndpoint);
// Pass the sign-in credentials.
connectionFactory.setUserName(activeMqUsername);
connectionFactory.setPassword(activeMqPassword);
// Establish a connection for the consumer.
final Connection consumerConnection = connectionFactory.createConnection();
consumerConnection.start();
```
**Anmerkung**
Die Nachrichtenkonsumenten sollten *nie* die `PooledConnectionFactory`-Klasse verwenden. Weitere Informationen finden Sie unter [Verwenden Sie immer Verbindungspools](best-practices-activemq.md#always-use-connection-pooling).
1. Erstellen Sie eine Sitzung, eine Warteschlange namens`MyQueue`und einem Nachrichtenverbraucher.
```
// 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);
```
1. Beginnen Sie, auf Nachrichten zu warten und die Nachricht zu erhalten, wenn sie eintrifft.
```
// 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());
```
**Anmerkung**
Im Gegensatz zu AWS Messaging-Diensten (wie Amazon SQS) ist der Verbraucher ständig mit dem Broker verbunden.
1. Schließen Sie den Verbraucher, die Sitzung und die Verbindung.
```
consumer.close();
consumerSession.close();
consumerConnection.close();
```