Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Conexión de una aplicación Java con el agente Amazon MQ
<a name="amazon-mq-connecting-application"></a>

Después de crear un agente de ActiveMQ en Amazon MQ, puede conectar su aplicación a él. Los siguientes ejemplos muestran cómo puede utilizar Java Message Service (JMS) para crear una conexión con el agente, crear una cola y enviar un mensaje. Para ver un ejemplo de Java completo y en funcionamiento, consulte [Ejemplos prácticos del uso de Java Message Service (JMS) con ActiveMQ](amazon-mq-working-java-example.md).

Puede conectarse a los agentes de ActiveMQ mediante [distintos clientes de ActiveMQ](http://activemq.apache.org/cross-language-clients.html). Le recomendamos que utilice el [cliente de ActiveMQ](https://mvnrepository.com/artifact/org.apache.activemq/activemq-client).

**Topics**
+ [Requisitos previos](#connect-application-prerequisites-tutorial)
+ [Para crear un productor de mensajes y enviar un mensaje](#create-producer-send-message-tutorial)
+ [Para crear un consumidor de mensajes y recibir el mensaje](#create-consumer-receive-message-tutorial)

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

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

Para asegurarse de poder acceder a su agente dentro de su VPC, debe habilitar los atributos `enableDnsHostnames` y `enableDnsSupport` de VPC. Para obtener más información, consulte el tema sobre [soporte de DNS en su VPC](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-dns.html#vpc-dns-support) en la *Guía del usuario de Amazon VPC*.

### Habilitar las conexiones entrantes
<a name="connect-application-allow-inbound-connections-tutorial"></a>

A continuación, habilite las conexiones entrantes para su aplicación.

1. Inicie sesión en la [consola de Amazon MQ](https://console.aws.amazon.com/amazon-mq/).

1. En la lista de corredores, elija el nombre de su corredor (por ejemplo, **MyBroker**).

1. En la **{{MyBroker}}**página, en la sección **Conexiones**, anote las direcciones y los puertos de la URL de la consola web del bróker y de los protocolos a nivel de cable.

1. En la sección **Details** (Detalles), en **Security and network** (Seguridad y red), elija el nombre de su grupo de seguridad o ![](http://docs.aws.amazon.com/es_es/amazon-mq/latest/developer-guide/images/amazon-mq-tutorials-broker-details-link.png).

   Aparecerá la página **Security Groups** (Grupos de seguridad) del panel de EC2.

1. En la lista de grupos de seguridad, elija el grupo de seguridad.

1. En la parte inferior de la página, elija **Inbound (Entrante)** y, a continuación, **Edit (Editar)**.

1. En el cuadro de diálogo **Edit inbound rules** (Editar reglas entrantes), agregue una regla para cada URL o punto de enlace que desee que sea accesible públicamente (en el ejemplo a continuación se muestra cómo hacerlo para una consola web de agente).

   1. Seleccione **Add Rule (Agregar regla)**.

   1. En **Type (Tipo)**, seleccione **Custom TCP (TCP personalizada)**.

   1. Para **Port Range** (Rango de puertos), escriba el puerto de la consola web (`8162`).

   1. Para **Source** (Fuente), deje seleccionada la opción **Custom** (Personalizada) y, luego, escriba la dirección IP del sistema que desea que pueda acceder a la consola web (por ejemplo, `192.0.2.1`).

   1. Seleccione **Save**.

      El agente ahora puede aceptar las conexiones entrantes.

### Añadir dependencias de Java
<a name="connect-application-java-dependencies-tutorial"></a>

Agregue los paquetes `activemq-client.jar` y `activemq-pool.jar` a la ruta de clases de Java. Los siguientes ejemplos muestran estas dependencias en el archivo `pom.xml` de un proyecto 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 obtener más información acerca de `activemq-client.jar`, consulte el tema sobre la [configuración inicial](http://activemq.apache.org/initial-configuration.html) en la documentación de Apache ActiveMQ.

**importante**  
En el siguiente código de ejemplo, los productores y los consumidores se ejecutan en un único subproceso. Para sistemas de producción (o para probar la conmutación por error de instancias del agente), asegúrese de que sus productores y consumidores se ejecuten en anfitriones o subprocesos independientes.

## Para crear un productor de mensajes y enviar un mensaje
<a name="create-producer-send-message-tutorial"></a>

 Emplee las siguientes instrucciones para crear un productor de mensajes y recibir un mensaje.

1. Cree una fábrica de conexiones JMS agrupadas para el productor de mensajes utilizando el punto de enlace de su agente y, a continuación, ejecute el método `createConnection` contra la fábrica.
**nota**  
Para un active/standby bróker, Amazon MQ proporciona dos ActiveMQ Web Console URLs, pero solo hay una URL activa a la vez. Del mismo modo, Amazon MQ proporciona dos puntos de enlace para cada protocolo de nivel de cable, pero solo hay un punto de enlace activo en cada par a la vez. Los sufijos `-1` y `-2` denotan un par redundante. Para obtener más información, consulte [Opciones de implementación de Amazon MQ para agentes de ActiveMQ](amazon-mq-broker-architecture.md)).  
Para los puntos de conexión de protocolo de nivel de cable, debería permitir que la aplicación se conecte a cualquiera de los puntos de conexión mediante el [transporte de conmutación por error](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**  
Los productores de mensajes siempre deben usar la clase `PooledConnectionFactory`. Para obtener más información, consulte [Usar siempre el grupo de conexiones](best-practices-activemq.md#always-use-connection-pooling).

1. Cree una sesión, una cola con el nombre `MyQueue` y un productor de mensajes.

   ```
   // 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. Cree la cadena de mensaje `"Hello from Amazon MQ!"` y, a continuación, envíe el mensaje.

   ```
   // 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. Elimine al productor.

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

## Para crear un consumidor de mensajes y recibir el mensaje
<a name="create-consumer-receive-message-tutorial"></a>

 Emplee las siguientes instrucciones para crear un productor de mensajes y recibir un mensaje.

1. Cree una fábrica de conexiones JMS para el productor de mensajes a través del punto de enlace de su agente y, a continuación, ejecute el método `createConnection` contra la 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**  
Los consumidores de mensajes *nunca* usan la clase `PooledConnectionFactory`. Para obtener más información, consulte [Usar siempre el grupo de conexiones](best-practices-activemq.md#always-use-connection-pooling).

1. Cree una sesión, una cola con el nombre `MyQueue` y un consumidor de mensajes.

   ```
   // 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. Comience a esperar los mensajes y reciba el mensaje cuando llegue.

   ```
   // 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 diferencia AWS de los servicios de mensajería (como Amazon SQS), el consumidor está constantemente conectado con el intermediario.

1. Cierre el consumidor, la sesión y la conexión.

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