Using the Amazon SQS Java Messaging Library

Create a connection factory and call the createConnection method against the factory.

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

The SQSConnection class extends javax.jms.Connection. Together with the JMS standard connection methods, SQSConnection offers additional methods, such as getAmazonSQSClient and getWrappedAmazonSQSClient. Both methods let you perform administrative operations not included in the JMS specification, such as creating new queues. However, the getWrappedAmazonSQSClient method also provides a wrapped version of the Amazon SQS client used by the current connection. The wrapper transforms every exception from the client into an JMSException, allowing it to be more easily used by existing code that expects JMSException occurrences.

You can use the client objects returned from getAmazonSQSClient and getWrappedAmazonSQSClient to perform administrative operations not included in the JMS specification (for example, you can create an Amazon SQS queue).

If you have existing code that expects JMS exceptions, then you should use getWrappedAmazonSQSClient:

When the connection and the underlying Amazon SQS queue are ready, create a nontransacted JMS session with AUTO_ACKNOWLEDGE mode.

// Create the nontransacted session with AUTO_ACKNOWLEDGE mode
Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);

To send a text message to the queue, create a JMS queue identity and a message producer.

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

Create a text message and send it to the queue.

To receive messages, create a consumer for the same queue and invoke the start method.

You can call the start method on the connection at any time. However, the consumer doesn't begin to receive messages until you call it.

// Create a consumer for the 'MyQueue'
MessageConsumer consumer = session.createConsumer(queue);
// Start receiving incoming messages
connection.start();

Call the receive method on the consumer with a timeout set to 1 second, and then print the contents of the received message.

Close the connection and the session.

// Close the connection (and the session).
connection.close();

Implement the MessageListener interface.

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

The onMessage method of the MessageListener interface is called when you receive a message. In this listener implementation, the text stored in the message is printed.

Instead of explicitly calling the receive method on the consumer, set the message listener of the consumer to an instance of the MyListener implementation. The main thread waits for one second.

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

To explicitly acknowledge the messages after they're processed, you must create the session with CLIENT_ACKNOWLEDGE mode.

// Create the non-transacted session with CLIENT_ACKNOWLEDGE mode.
Session session = connection.createSession(false, Session.CLIENT_ACKNOWLEDGE);

When the message is received, display it and then explicitly acknowledge it.

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