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.
# Uso de la Biblioteca de mensajes Java de Amazon SQS
Para comenzar a utilizar el Servicio de mensajes de Java (JMS) con Amazon SQS, utilice los ejemplos de código de esta sección. En las próximas secciones se muestra cómo crear una conexión JMS y una sesión y cómo enviar y recibir un mensaje.
El objeto cliente de Amazon SQS encapsulado incluido en la Biblioteca de mensajes Java de Amazon SQS comprueba si existe una cola de Amazon SQS. Si la cola no existe, el cliente la crea.
## Creación de una conexión JMS
Antes de comenzar, consulte los requisitos previos de [Requisitos previos para trabajar con JMS y Amazon SQS](prerequisites.md).
1. Cree una fábrica de conexiones y llame al método `createConnection` de la fábrica.
```
// Create a new connection factory with all defaults (credentials and region) set automatically
SQSConnectionFactory connectionFactory = new SQSConnectionFactory(
new ProviderConfiguration(),
AmazonSQSClientBuilder.defaultClient()
);
// Create the connection.
SQSConnection connection = connectionFactory.createConnection();
```
La clase `SQSConnection` amplía `javax.jms.Connection`. Junto con los métodos de conexión estándar de JMS, `SQSConnection` ofrece métodos adicionales como, por ejemplo, `getAmazonSQSClient` y `getWrappedAmazonSQSClient`. Ambos métodos le permiten llevar a cabo operaciones administrativas no incluidas en la especificación JMS, como la creación de nuevas colas. Sin embargo, el método `getWrappedAmazonSQSClient` también ofrece una versión encapsulada del cliente de Amazon SQS que utiliza la conexión actual. El contenedor transforma cada excepción del cliente en una `JMSException`, por lo que es más fácil que la utilice el código existente, que espera encontrar `JMSException`.
1. Puede utilizar los objetos de cliente devueltos por `getAmazonSQSClient` y `getWrappedAmazonSQSClient` para realizar operaciones administrativas que no están incluidas en la especificación JMS (por ejemplo, puede crear una cola de Amazon SQS).
Si dispone de código que espera encontrar excepciones de JMS, debería utilizar `getWrappedAmazonSQSClient`:
+ Si utiliza `getWrappedAmazonSQSClient`, el objeto de cliente devuelto transforma todas las excepciones en las excepciones de JMS.
+ Si utiliza `getAmazonSQSClient`, todas las excepciones serán excepciones de Amazon SQS.
## Creación de una cola de Amazon SQS
El objeto de cliente encapsulado comprueba si existe una cola de Amazon SQS.
Si no existe una cola, el cliente la crea. Si la cola existe, la función no devuelve nada. Para obtener más información, consulte la sección "Create the queue if needed" en el ejemplo [TextMessageSender.java](sqs-jms-code-examples.md#example-sender).
### Para crear una cola estándar
```
// Get the wrapped client
AmazonSQSMessagingClientWrapper client = connection.getWrappedAmazonSQSClient();
// Create an SQS queue named MyQueue, if it doesn't already exist
if (!client.queueExists("MyQueue")) {
client.createQueue("MyQueue");
}
```
### Creación de una cola FIFO
```
// Get the wrapped client
AmazonSQSMessagingClientWrapper client = connection.getWrappedAmazonSQSClient();
// Create an Amazon SQS FIFO queue named MyQueue.fifo, if it doesn't already exist
if (!client.queueExists("MyQueue.fifo")) {
Map attributes = new HashMap();
attributes.put("FifoQueue", "true");
attributes.put("ContentBasedDeduplication", "true");
client.createQueue(new CreateQueueRequest().withQueueName("MyQueue.fifo").withAttributes(attributes));
}
```
**nota**
La cola FIFO debe finalizar con el sufijo `.fifo`.
Para obtener más información acerca del atributo `ContentBasedDeduplication`, consulte [Procesamiento una sola vez en Amazon SQS](FIFO-queues-exactly-once-processing.md).
## Envío de mensajes de forma sincrónica
1. Cuando la conexión y la cola de Amazon SQS subyacente estén listas, cree una sesión de JMS sin transacciones con el modo `AUTO_ACKNOWLEDGE`.
```
// Create the nontransacted session with AUTO_ACKNOWLEDGE mode
Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
```
1. Para enviar un mensaje de texto a la cola, cree una identidad de cola de JMS y un productor de mensajes.
```
// Create a queue identity and specify the queue name to the session
Queue queue = session.createQueue("MyQueue");
// Create a producer for the 'MyQueue'
MessageProducer producer = session.createProducer(queue);
```
1. Cree un mensaje de texto y envíelo a la cola.
+ Para enviar un mensaje a una cola estándar, no es necesario configurar ningún parámetro adicional.
```
// Create the text message
TextMessage message = session.createTextMessage("Hello World!");
// Send the message
producer.send(message);
System.out.println("JMS Message " + message.getJMSMessageID());
```
+ Para enviar un mensaje a una cola FIFO, debe establecer el ID de grupo de mensajes. También puede establecer un ID de desduplicación de mensajes. Para obtener más información, consulte [Términos clave de cola FIFO de Amazon SQS](FIFO-key-terms.md).
```
// Create the text message
TextMessage message = session.createTextMessage("Hello World!");
// Set the message group ID
message.setStringProperty("JMSXGroupID", "Default");
// You can also set a custom message deduplication ID
// message.setStringProperty("JMS_SQS_DeduplicationId", "hello");
// Here, it's not needed because content-based deduplication is enabled for the queue
// Send the message
producer.send(message);
System.out.println("JMS Message " + message.getJMSMessageID());
System.out.println("JMS Message Sequence Number " + message.getStringProperty("JMS_SQS_SequenceNumber"));
```
## Recepción de mensajes de forma sincrónica
1. Para recibir mensajes, cree un consumidor para la misma cola e invoque el método `start`.
Puede llamar al método `start` de la conexión en cualquier momento. Sin embargo, el consumidor no empieza a recibir mensajes hasta que no se le llama.
```
// Create a consumer for the 'MyQueue'
MessageConsumer consumer = session.createConsumer(queue);
// Start receiving incoming messages
connection.start();
```
1. Llame al método `receive` del consumidor con un tiempo de espera establecido en 1 segundo y, a continuación, imprima el contenido del mensaje recibido.
+ Cuando se recibe un mensaje de una cola estándar, se puede obtener acceso al contenido del mensaje.
```
// Receive a message from 'MyQueue' and wait up to 1 second
Message receivedMessage = consumer.receive(1000);
// Cast the received message as TextMessage and display the text
if (receivedMessage != null) {
System.out.println("Received: " + ((TextMessage) receivedMessage).getText());
}
```
+ Tras recibir un mensaje de una cola FIFO, puede obtener acceso al contenido del mensaje y otros atributos del mensaje específicos de FIFO, como el ID del grupo de mensajes, el ID de desduplicación de mensajes y el número de secuencia. Para obtener más información, consulte [Términos clave de cola FIFO de Amazon SQS](FIFO-key-terms.md).
```
// Receive a message from 'MyQueue' and wait up to 1 second
Message receivedMessage = consumer.receive(1000);
// Cast the received message as TextMessage and display the text
if (receivedMessage != null) {
System.out.println("Received: " + ((TextMessage) receivedMessage).getText());
System.out.println("Group id: " + receivedMessage.getStringProperty("JMSXGroupID"));
System.out.println("Message deduplication id: " + receivedMessage.getStringProperty("JMS_SQS_DeduplicationId"));
System.out.println("Message sequence number: " + receivedMessage.getStringProperty("JMS_SQS_SequenceNumber"));
}
```
1. Cierre la conexión y la sesión.
```
// Close the connection (and the session).
connection.close();
```
El resultado tiene un aspecto similar al siguiente:
```
JMS Message ID:8example-588b-44e5-bbcf-d816example2
Received: Hello World!
```
**nota**
Puede utilizar el marco Spring para inicializar estos objetos.
Para obtener más información, consulte `SpringExampleConfiguration.xml`, `SpringExample.java` y el resto de clases auxiliares en `ExampleConfiguration.java` y `ExampleCommon.java` en la sección [Ejemplos funcionales en Java del uso de JMS con colas estándar de Amazon SQS](sqs-jms-code-examples.md).
Para obtener ejemplos completos del envío y la recepción de objetos, consulte [TextMessageSender.java](sqs-jms-code-examples.md#example-sender) y [SyncMessageReceiver.java](sqs-jms-code-examples.md#example-synchronous-message-receiver).
## Recepción de mensajes de forma asincrónica
En el ejemplo de [Uso de la Biblioteca de mensajes Java de Amazon SQS](#getting-started), se envía un mensaje a `MyQueue` y se recibe de forma sincrónica.
El siguiente ejemplo muestra cómo recibir los mensajes de forma asíncrona a través de un agente de escucha.
1. Implemente la interfaz `MessageListener`.
```
class MyListener implements MessageListener {
@Override
public void onMessage(Message message) {
try {
// Cast the received message as TextMessage and print the text to screen.
System.out.println("Received: " + ((TextMessage) message).getText());
} catch (JMSException e) {
e.printStackTrace();
}
}
}
```
Se llama al método `onMessage` de la interfaz `MessageListener` cuando recibe un mensaje. En esta implementación del agente de escucha, se imprime el texto almacenados en el mensaje.
1. En lugar de llamar explícitamente al método `receive` del consumidor, establezca el agente de escucha de mensajes del consumidor en una instancia de la implementación de `MyListener`. El subproceso principal espera un segundo.
```
// Create a consumer for the 'MyQueue'.
MessageConsumer consumer = session.createConsumer(queue);
// Instantiate and set the message listener for the consumer.
consumer.setMessageListener(new MyListener());
// Start receiving incoming messages.
connection.start();
// Wait for 1 second. The listener onMessage() method is invoked when a message is received.
Thread.sleep(1000);
```
Los pasos restantes son idénticos a los del ejemplo [Uso de la Biblioteca de mensajes Java de Amazon SQS](#getting-started). Para obtener un ejemplo completo de un consumidor asíncrono, consulte `AsyncMessageReceiver.java` [Ejemplos funcionales en Java del uso de JMS con colas estándar de Amazon SQS](sqs-jms-code-examples.md).
El resultado de este ejemplo tiene un aspecto similar al siguiente:
```
JMS Message ID:8example-588b-44e5-bbcf-d816example2
Received: Hello World!
```
## Uso del modo de reconocimiento del cliente
En el ejemplo de [Uso de la Biblioteca de mensajes Java de Amazon SQS](#getting-started), se utiliza el modo `AUTO_ACKNOWLEDGE`, en el que cada mensaje recibido se confirma automáticamente (y, por tanto, se elimina de la cola subyacente de Amazon SQS).
1. Para reconocer explícitamente los mensajes una vez procesados, debe crear la sesión con el modo `CLIENT_ACKNOWLEDGE`.
```
// Create the non-transacted session with CLIENT_ACKNOWLEDGE mode.
Session session = connection.createSession(false, Session.CLIENT_ACKNOWLEDGE);
```
1. Cuando se reciba el mensaje, muéstrelo y acéptelo explícitamente.
```
// Cast the received message as TextMessage and print the text to screen. Also acknowledge the message.
if (receivedMessage != null) {
System.out.println("Received: " + ((TextMessage) receivedMessage).getText());
receivedMessage.acknowledge();
System.out.println("Acknowledged: " + message.getJMSMessageID());
}
```
**nota**
En este modo, cuando un mensaje se reconoce, todos los mensajes recibidos antes que este mensaje también se reconocen implícitamente. Por ejemplo, si se reciben 10 mensajes y solo se reconoce el décimo mensaje (en el orden en que los mensajes se reciben), los nueve mensajes anteriores también se reconocen.
Los pasos restantes son idénticos a los del ejemplo [Uso de la Biblioteca de mensajes Java de Amazon SQS](#getting-started). Para ver un ejemplo completo de un consumidor sincrónico con el modo de reconocimiento del cliente, consulte `SyncMessageReceiverClientAcknowledge.java` en [Ejemplos funcionales en Java del uso de JMS con colas estándar de Amazon SQS](sqs-jms-code-examples.md).
El resultado de este ejemplo tiene un aspecto similar al siguiente:
```
JMS Message ID:4example-aa0e-403f-b6df-5e02example5
Received: Hello World!
Acknowledged: ID:4example-aa0e-403f-b6df-5e02example5
```
## Uso del modo de reconocimiento sin orden
Cuando se utiliza el modo `CLIENT_ACKNOWLEDGE`, todos los mensajes recibidos antes que un mensaje reconocido explícitamente se reconocen automáticamente. Para obtener más información, consulte [Uso del modo de reconocimiento del cliente](#using-client-acknowledge-mode).
La Biblioteca de mensajes Java de Amazon SQS proporciona otro modo de confirmación. Cuando se utiliza el modo `UNORDERED_ACKNOWLEDGE`, el cliente debe reconocer individualmente y de forma explícita todos los mensajes recibidos, independientemente del orden de recepción. Para ello, cree una sesión con el modo `UNORDERED_ACKNOWLEDGE`.
```
// Create the non-transacted session with UNORDERED_ACKNOWLEDGE mode.
Session session = connection.createSession(false, SQSSession.UNORDERED_ACKNOWLEDGE);
```
Los pasos restantes son idénticos a los del ejemplo [Uso del modo de reconocimiento del cliente](#using-client-acknowledge-mode). Para obtener un ejemplo completo de un consumidor síncrono con el modo `UNORDERED_ACKNOWLEDGE`, consulte `SyncMessageReceiverUnorderedAcknowledge.java`.
En este ejemplo, el resultado tiene un aspecto similar al siguiente:
```
JMS Message ID:dexample-73ad-4adb-bc6c-4357example7
Received: Hello World!
Acknowledged: ID:dexample-73ad-4adb-bc6c-4357example7
```