Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Connessione di un'applicazione Java alil broker Amazon MQ
<a name="amazon-mq-connecting-application"></a>

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 [Esempi funzionanti di utilizzo di Java Message Service (JMS) con ActiveMQ](amazon-mq-working-java-example.md).

Puoi connetterti ai broker ActiveMQ utilizzando [vari client ActiveMQ](http://activemq.apache.org/cross-language-clients.html). È consigliato l'uso del [client ActiveMQ](https://mvnrepository.com/artifact/org.apache.activemq/activemq-client).

**Topics**
+ [Prerequisiti](#connect-application-prerequisites-tutorial)
+ [Per creare un produttore del messaggio e inviare un messaggio](#create-producer-send-message-tutorial)
+ [Per creare un consumatore del messaggio e ricevere il messaggio](#create-consumer-receive-message-tutorial)

## Prerequisiti
<a name="connect-application-prerequisites-tutorial"></a>

### Abilitazione attributi VPC
<a name="connect-application-enable-vpc-attributes-tutorial"></a>

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](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-dns.html#vpc-dns-support) nella *Guida per l'utente di Amazon VPC*.

### Abilitazione connessioni in entrata
<a name="connect-application-allow-inbound-connections-tutorial"></a>

Quindi, abilita le connessioni in entrata per la tua applicazione.

1. Accedere alla [console Amazon MQ](https://console.aws.amazon.com/amazon-mq/).

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

1. Nella **{{MyBroker}}**pagina, nella sezione **Connessioni**, annota gli indirizzi e le porte dell'URL della console web del broker e dei protocolli a livello di cavo.

1. Nella sezione **Details** (Dettagli), in **Security and network** (Sicurezza e rete), scegliere il nome del gruppo di sicurezza o ![](http://docs.aws.amazon.com/it_it/amazon-mq/latest/developer-guide/images/amazon-mq-tutorials-broker-details-link.png).

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

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

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

1. 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)**.

   1. Per **Type (Tipo)** seleziona **Custom TCP (TCP personalizzato)**.

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

   1. 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`).

   1. Scegli **Save** (Salva).

      Il broker può ora accettare connessioni in entrata.

### Aggiunta dipendenze Java
<a name="connect-application-java-dependencies-tutorial"></a>

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](http://activemq.apache.org/initial-configuration.html) 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
<a name="create-producer-send-message-tutorial"></a>

 Usa le seguenti istruzioni per creare un produttore di messaggi e ricevere 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 active/standby broker, Amazon MQ offre due URLs 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, vedere [Opzioni di implementazione per i broker Amazon MQ for ActiveMQ](amazon-mq-broker-architecture.md)).  
[Per gli endpoint con protocollo a livello di cavo, è necessario consentire all'applicazione di connettersi a entrambi gli endpoint utilizzando il Failover Transport.](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();
   ```
**Nota**  
I produttori di messaggi devono sempre utilizzare la classe `PooledConnectionFactory`. Per ulteriori informazioni, consulta [Usa sempre il pooling delle connessioni](best-practices-activemq.md#always-use-connection-pooling).

1. 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);
   ```

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

1. Eliminare il produttore.

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

## Per creare un consumatore del messaggio e ricevere il messaggio
<a name="create-consumer-receive-message-tutorial"></a>

 Utilizzate le seguenti istruzioni per creare un produttore di messaggi e ricevere un 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](best-practices-activemq.md#always-use-connection-pooling).

1. 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);
   ```

1. 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.

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

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