Connessione di un'applicazione Java alil broker Amazon MQ

Dopo aver creato un broker ActiveMQ di Amazon MQ, è possibile collegarvi l'applicazione. Di seguito sono riportati esempi che mostrano come è possibile utilizzare il servizio di messaggistica Java (JMS) per creare una connessione alil broker, creare una coda e inviare un messaggio. Per un esempio Java completo e funzionante, consultare Working Java Example.

Puoi connetterti ai broker ActiveMQ utilizzando vari client ActiveMQ. È consigliato l'uso del client ActiveMQ.

Prerequisiti

Abilitazione attributi VPC

Per garantire che il broker sia accessibile all'interno del VPC, è necessario abilitare gli attributi VPC enableDnsHostnames e enableDnsSupport. Per ulteriori informazioni, consultare Supporto del DNS nel VPC nella Guida per l'utente di Amazon VPC.

Abilitazione connessioni in entrata

1. Accedere alla console Amazon MQ.

2. Dall'elenco dei broker, scegli il nome del tuo broker (ad esempio, MyBroker).

3. Nella MyBrokerpagina, nella sezione Connessioni, annota gli indirizzi e le porte dell'URL della console web del broker e dei protocolli a livello di cavo.

4. Nella sezione Details (Dettagli), in Security and network (Sicurezza e rete), scegliere il nome del gruppo di sicurezza o .

   Viene visualizzata la pagina Security Groups (Gruppi di sicurezza) del pannello di controllo EC2.

5. Scegli il tuo gruppo di sicurezza dall'elenco.

6. Nella parte inferiore della pagina scegli Inbound (In entrata), quindi scegli Edit (Modifica).

7. Nella finestra di dialogo Edit inbound rules (Modifica le regole in entrata), aggiungere una regola per ogni URL o endpoint che si desidera rendere accessibile pubblicamente (nell'esempio seguente viene illustrato come eseguire questa operazione per una console Web del broker).

   1. Selezionare Add Rule (Aggiungi regola).

   2. Per Type (Tipo) seleziona Custom TCP (TCP personalizzato).

   3. Per Port Range (Intervallo porte), digitare la porta della console Web (8162).

   4. Per Source (Origine), lasciare selezionato Custom (Personalizzato), quindi inserire l'indirizzo IP del sistema a cui desideri poter accedere alla console Web (ad esempio, 192.0.2.1).

   5. Selezionare Salva.

      Il broker può ora accettare connessioni in entrata.

Aggiunta dipendenze Java

Aggiungere i pacchetti activemq-client.jar e activemq-pool.jar al percorso di classe Java. L'esempio seguente mostra queste dipendenze in un file pom.xml di progetto Maven.

<dependencies>
    <dependency>
        <groupId>org.apache.activemq</groupId>
        <artifactId>activemq-client</artifactId>
        <version>5.15.16</version>
    </dependency>
    <dependency>
        <groupId>org.apache.activemq</groupId>
        <artifactId>activemq-pool</artifactId>
        <version>5.15.16</version>
    </dependency>
</dependencies>

Per ulteriori informazioni su activemq-client.jar, consultare Configurazione iniziale nella documentazione di Apache ActiveMQ.

Importante

Nel codice di esempio seguente, produttori e consumatori vengono eseguiti in un singolo thread. Per i sistemi di produzione (o per testare il failover delle istanze del broker), assicurarsi che i produttori e i consumatori vengano eseguiti su host o thread separati.

Per creare un produttore del messaggio e inviare un messaggio

1. Creare un pool di connessioni di stabilimento JMS per il produttore di messaggi utilizzando l'endpoint del broker e quindi chiamare il metodo createConnection rispetto allo stabilimento.

   Nota

   Per un broker attivo/in standby, Amazon MQ fornisce due URL della console Web ActiveMQ, ma è attivo un solo URL alla volta. Allo stesso modo, Amazon MQ fornisce due endpoint per ogni protocollo a livello di connessione, ma è attivo un solo endpoint per ogni coppia alla volta. I suffissi -1 e -2 indicano una coppia ridondante. Per ulteriori informazioni, consulta Broker Architecture.

   Per gli endpoint del protocollo a livello di connessione, è possibile consentire all'applicazione di connettersi a entrambi gli endpoint utilizzando il trasporto di failover.

   // 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();

   Nota

   I produttori di messaggi devono sempre utilizzare la classe PooledConnectionFactory. Per ulteriori informazioni, consulta Usa sempre il pooling delle connessioni.

2. Creare una sessione, una coda denominata MyQueue e un produttore di messaggi.

   // 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);

3. Creare la stringa del messaggio "Hello from Amazon MQ!" e quindi inviare il messaggio.

   // 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.");

4. Eliminare il produttore.

   producer.close();
   producerSession.close();
   producerConnection.close();

Per creare un consumatore del messaggio e ricevere il messaggio

1. Creare una connessione di stabilimento JMS per il produttore di messaggi utilizzando l'endpoint del broker e quindi chiamare il metodo createConnection rispetto allo stabilimento.

   // 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();

   Nota

   I consumatori dei messaggi non dovrebbero mai utilizzare la classe PooledConnectionFactory. Per ulteriori informazioni, consulta Usa sempre il pooling delle connessioni.

2. Creare una sessione, una coda denominata MyQueue e un consumatore di messaggi.

   // 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);

3. Iniziare ad attendere i messaggi quindi riceverlo non appena arriva.

   // 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());

   Nota

   A differenza dei servizi di AWS messaggistica (come Amazon SQS), il consumatore è costantemente connesso al broker.

4. Chiudere il consumatore, la sessione e la connessione.

   consumer.close();
   consumerSession.close();
   consumerConnection.close();