As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Conectar uma aplicação Java ao agente do Amazon MQ
<a name="amazon-mq-connecting-application"></a>

Depois de criar um agente do Amazon MQ ActiveMQ, você pode conectar sua aplicação a ele. Os exemplos a seguir mostram como você pode usar o JMS (Java Message Service) para criar uma conexão com o agente, criar uma fila e enviar uma mensagem. Para obter um exemplo completo e funcional do Java, consulte [Exemplos funcionais de Como usar o Java Message Service (JMS) com o ActiveMQ](amazon-mq-working-java-example.md).

Você pode se conectar a agentes do ActiveMQ usando [vários clientes de ActiveMQ](http://activemq.apache.org/cross-language-clients.html). Recomendamos usar o [Cliente ActiveMQ](https://mvnrepository.com/artifact/org.apache.activemq/activemq-client).

**Topics**
+ [Pré-requisitos](#connect-application-prerequisites-tutorial)
+ [Para criar um produtor de mensagens e enviar uma mensagem](#create-producer-send-message-tutorial)
+ [Para criar um consumidor de mensagens e receber a mensagem](#create-consumer-receive-message-tutorial)

## Pré-requisitos
<a name="connect-application-prerequisites-tutorial"></a>

### Habilitar atributos da VPC
<a name="connect-application-enable-vpc-attributes-tutorial"></a>

Para garantir que seu agente esteja acessível dentro da sua VPC, você deve habilitar os atributos VPC `enableDnsHostnames` e `enableDnsSupport`. Para obter mais informações, consulte [Compatibilidade com DNS para a sua VPC](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-dns.html#vpc-dns-support) no *Manual do usuário da Amazon VPC*.

### Habilitar conexões de entrada
<a name="connect-application-allow-inbound-connections-tutorial"></a>

Em seguida, habilite as conexões de entrada para sua aplicação.

1. Faça login no [console do Amazon MQ](https://console.aws.amazon.com/amazon-mq/).

1. Na lista de corretores, escolha o nome do seu corretor (por exemplo, **MyBroker**).

1. Na **{{MyBroker}}**página, na seção **Conexões**, observe os endereços e portas do URL do console web e dos protocolos de nível de fio do broker.

1. Na seção **Details** (Detalhes), em **Security and network** (Segurança e rede), escolha o nome do seu grupo de segurança ou ![](http://docs.aws.amazon.com/pt_br/amazon-mq/latest/developer-guide/images/amazon-mq-tutorials-broker-details-link.png).

   A página **Grupos de segurança** do painel do EC2 é exibida.

1. Na lista de security group, escolha seu security group.

1. Na parte inferior da página, escolha **Inbound (Entrada)** e a seguir selecione **Edit (Editar)**.

1. Na caixa de diálogo **Edit inbound rules** (Editar regras de entrada), adicione uma regra para cada URL ou endpoint que você deseja que seja acessível publicamente (o exemplo a seguir mostra como fazer isso para um console da Web do agente).

   1. Escolha **Add Rule (Adicionar regra)**.

   1. Em **Type (Tipo)**, selecione **Custom TCP (TCP personalizado)**.

   1. Para o **Intervalo de Portas**, digite a porta do console da Web (`8162`).

   1. Para **Source **(Origem), deixe **Custom **(Personalizado) selecionado e, depois, digite o endereço IP do sistema ao qual deseja ser capaz de acessar o console da Web (por exemplo, `192.0.2.1`).

   1. Escolha **Salvar**.

      Agora seu agente pode aceitar conexões de entrada.

### Adicionar dependências de Java
<a name="connect-application-java-dependencies-tutorial"></a>

Adicione os pacotes `activemq-client.jar` e `activemq-pool.jar` ao caminho da classe Java. O exemplo a seguir mostra essas dependências em um arquivo `pom.xml` do projeto 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>
```

Para obter mais informações sobre `activemq-client.jar`, consulte [Initial Configuration](http://activemq.apache.org/initial-configuration.html) (Configuração inicial) na documentação do Apache ActiveMQ.

**Importante**  
No código de exemplo a seguir, os produtores e consumidores são executados em um único thread. Para sistemas de produção (ou para testar o failover de instância do agente), certifique-se de que seus produtores e consumidores sejam executados em hosts ou threads separados.

## Para criar um produtor de mensagens e enviar uma mensagem
<a name="create-producer-send-message-tutorial"></a>

 Use a instrução a seguir para criar um produtor de mensagens e receber uma mensagem.

1. Crie uma fábrica de conexão em grupo JMS para o produtor da mensagem usando o endpoint do seu agente e, em seguida, chame o método `createConnection` contra a fábrica.
**nota**  
Para um active/standby corretor, o Amazon MQ fornece dois ActiveMQ Web Console URLs, mas somente um URL está ativo por vez. Da mesma forma, o Amazon MQ fornece dois endpoints para cada protocolo de nível de conexão, mas apenas um endpoint está ativo em cada par de cada vez. Os sufixos `-1` e `-2` denotam um par redundante. Para obter mais informações, consulte [Opções de implantação de agentes do Amazon MQ para ActiveMQ](amazon-mq-broker-architecture.md)).  
Para endpoints de protocolo no nível da conexão, você pode permitir que sua aplicação se conecte a qualquer endpoint usando o [Transporte de failover](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**  
Os produtores de mensagens devem sempre usar a classe `PooledConnectionFactory`. Para obter mais informações, consulte [Sempre usar pooling de conexão](best-practices-activemq.md#always-use-connection-pooling).

1. Crie uma sessão, uma fila chamada `MyQueue` e um produtor de mensagens.

   ```
   // 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. Crie a string da mensagem `"Hello from Amazon MQ!"` e, em seguida, envie a mensagem.

   ```
   // 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. Limpe o produtor.

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

## Para criar um consumidor de mensagens e receber a mensagem
<a name="create-consumer-receive-message-tutorial"></a>

 Use a instrução a seguir para criar um produtor de mensagens e receber uma mensagem.

1. Crie uma fábrica de conexão JMS para o produtor da mensagem usando o endpoint do seu agente e, em seguida, chame o método `createConnection` contra a fábrica.

   ```
   // 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**  
Os consumidores de mensagens *nunca* devem usar a classe `PooledConnectionFactory`. Para obter mais informações, consulte [Sempre usar pooling de conexão](best-practices-activemq.md#always-use-connection-pooling).

1. Crie uma sessão, uma fila chamada `MyQueue` e um consumidor de mensagens.

   ```
   // 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. Comece a aguardar mensagens e receba a mensagem quando ela chegar.

   ```
   // 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**  
Diferentemente dos serviços de AWS mensagens (como o Amazon SQS), o consumidor está constantemente conectado ao agente.

1. Feche o consumidor, a sessão e a conexão.

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