Update JDK to 17.

Switch from javax.jms.* to jakarta.jms.* namespace.
Update testing libraries and maven plugins.

Author: armogur

pom.xml

@@ -25,19 +25,19 @@ public interface PrefetchManager {
      * messageQueue when user calls for receive or message listener onMessage is
      * called.
      */
-    public void messageDispatched();
+    void messageDispatched();
 
     /**
      * Notify the prefetchThread that the message listener has finished with any
      * previous message and is ready to accept another.
      */
-    public void messageListenerReady();
+    void messageListenerReady();
 
     /**
      * This is used to determine the state of the consumer, when the message
      * listener scheduler is processing the messages.
      * 
      * @return The message consumer, which owns the prefetchThread
      */
-    public SQSMessageConsumer getMessageConsumer();
+    SQSMessageConsumer getMessageConsumer();
 }

src/main/java/com/amazon/sqs/javamessaging/AmazonSQSMessagingClientWrapper.java

@@ -18,20 +18,20 @@
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 
-import javax.jms.IllegalStateException;
-import javax.jms.Connection;
-import javax.jms.ConnectionConsumer;
-import javax.jms.ConnectionMetaData;
-import javax.jms.Destination;
-import javax.jms.ExceptionListener;
-import javax.jms.InvalidClientIDException;
-import javax.jms.JMSException;
-import javax.jms.Queue;
-import javax.jms.QueueConnection;
-import javax.jms.QueueSession;
-import javax.jms.ServerSessionPool;
-import javax.jms.Session;
-import javax.jms.Topic;
+import jakarta.jms.IllegalStateException;
+import jakarta.jms.Connection;
+import jakarta.jms.ConnectionConsumer;
+import jakarta.jms.ConnectionMetaData;
+import jakarta.jms.Destination;
+import jakarta.jms.ExceptionListener;
+import jakarta.jms.InvalidClientIDException;
+import jakarta.jms.JMSException;
+import jakarta.jms.Queue;
+import jakarta.jms.QueueConnection;
+import jakarta.jms.QueueSession;
+import jakarta.jms.ServerSessionPool;
+import jakarta.jms.Session;
+import jakarta.jms.Topic;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -107,7 +107,7 @@ public class SQSConnection implements Connection, QueueConnection {
      */
     private volatile boolean actionOnConnectionTaken = false;
 
-    private final Set<Session> sessions = Collections.newSetFromMap(new ConcurrentHashMap<Session, Boolean>());
+    private final Set<Session> sessions = Collections.newSetFromMap(new ConcurrentHashMap<>());
 
     SQSConnection(AmazonSQSMessagingClientWrapper amazonSQSClientJMSWrapper, int numberOfMessagesToPrefetch) {
         amazonSQSClient = amazonSQSClientJMSWrapper;
@@ -167,7 +167,7 @@ public QueueSession createQueueSession(boolean transacted, int acknowledgeMode)
      * 
      * @param transacted
      *            Only false is supported.
-     * @param acknowledgeMode
+     * @param sessionMode
      *            Legal values are <code>Session.AUTO_ACKNOWLEDGE</code>,
      *            <code>Session.CLIENT_ACKNOWLEDGE</code>,
      *            <code>Session.DUPS_OK_ACKNOWLEDGE</code>, and
@@ -179,26 +179,26 @@ public QueueSession createQueueSession(boolean transacted, int acknowledgeMode)
      *             transaction and acknowledge mode.
      */
     @Override
-    public Session createSession(boolean transacted, int acknowledgeMode) throws JMSException {
+    public Session createSession(boolean transacted, int sessionMode) throws JMSException {
         checkClosed();
         actionOnConnectionTaken = true;
-        if (transacted || acknowledgeMode == Session.SESSION_TRANSACTED)
+        if (transacted || sessionMode == Session.SESSION_TRANSACTED)
             throw new JMSException("SQSSession does not support transacted");
 
         SQSSession sqsSession;
-        if (acknowledgeMode == Session.AUTO_ACKNOWLEDGE) {
-            sqsSession = new SQSSession(this, AcknowledgeMode.ACK_AUTO.withOriginalAcknowledgeMode(acknowledgeMode));
-        } else if (acknowledgeMode == Session.CLIENT_ACKNOWLEDGE || acknowledgeMode == Session.DUPS_OK_ACKNOWLEDGE) {
-            sqsSession = new SQSSession(this, AcknowledgeMode.ACK_RANGE.withOriginalAcknowledgeMode(acknowledgeMode));
-        } else if (acknowledgeMode == SQSSession.UNORDERED_ACKNOWLEDGE) {
-            sqsSession = new SQSSession(this, AcknowledgeMode.ACK_UNORDERED.withOriginalAcknowledgeMode(acknowledgeMode));
+        if (sessionMode == Session.AUTO_ACKNOWLEDGE) {
+            sqsSession = new SQSSession(this, AcknowledgeMode.ACK_AUTO.withOriginalAcknowledgeMode(sessionMode));
+        } else if (sessionMode == Session.CLIENT_ACKNOWLEDGE || sessionMode == Session.DUPS_OK_ACKNOWLEDGE) {
+            sqsSession = new SQSSession(this, AcknowledgeMode.ACK_RANGE.withOriginalAcknowledgeMode(sessionMode));
+        } else if (sessionMode == SQSSession.UNORDERED_ACKNOWLEDGE) {
+            sqsSession = new SQSSession(this, AcknowledgeMode.ACK_UNORDERED.withOriginalAcknowledgeMode(sessionMode));
         } else {
             LOG.error("Unrecognized acknowledgeMode. Cannot create Session.");
             throw new JMSException("Unrecognized acknowledgeMode. Cannot create Session.");
         }
         synchronized (stateLock) { 
             if (closing) {
-                /**
+                /*
                  * SQSSession's constructor has already started a SQSSessionCallbackScheduler which should be closed
                  * before leaving sqsSession object.
                  */
@@ -207,18 +207,27 @@ public Session createSession(boolean transacted, int acknowledgeMode) throws JMS
             }
             sessions.add(sqsSession);
 
-            /**
+            /*
              * Any new sessions created on a started connection should be
              * started on creation
              */
             if (running) {
                 sqsSession.start();
             }
         }
-               
         return sqsSession;
     }
 
+    @Override
+    public Session createSession(int sessionMode) throws JMSException {
+        return createSession(false, sessionMode);
+    }
+
+    @Override
+    public Session createSession() throws JMSException {
+        throw new JMSException(SQSMessagingClientConstants.UNSUPPORTED_METHOD);
+    }
+
     @Override
     public ExceptionListener getExceptionListener() throws JMSException {
         checkClosing();
@@ -303,7 +312,7 @@ public void start() throws JMSException {
      * This means that a client can rely on the fact that none of its message
      * listeners will be called and that all threads of control waiting for
      * receive calls to return will not return with a message until the
-     * connection is restarted. The receive timers for a stopped connection
+     * connection is restarted. The received timers for a stopped connection
      * continue to advance, so receives may time out while the connection is
      * stopped.
      * <P>
@@ -336,7 +345,7 @@ public void stop() throws JMSException {
                 try {
                     for (Session session : sessions) {
                         SQSSession sqsSession = (SQSSession) session;
-                        /**
+                        /*
                          * Session stop call blocks until receives and/or
                          * message listeners in progress have completed.
                          */
@@ -375,12 +384,11 @@ public void stop() throws JMSException {
      */
     @Override
     public void close() throws JMSException {
-
         if (closed) {
             return;
         }
 
-        /**
+        /*
          * A message listener must not attempt to close its own connection as
          * this would lead to deadlock.
          */
@@ -411,7 +419,7 @@ public void close() throws JMSException {
 
                 }
             }
-        }/** Blocks until closing of the connection completes */
+        }/* Blocks until closing of the connection completes */
         else {
             synchronized (stateLock) {
                 while (!closed) {
@@ -432,7 +440,7 @@ public void close() throws JMSException {
      * from list of Sessions.
      */
     void removeSession(Session session) throws JMSException {
-        /**
+        /*
          * No need to synchronize on stateLock assuming this can be only called
          * by session.close(), on which point connection will not be worried
          * about missing closing this session.
@@ -505,9 +513,22 @@ public ConnectionConsumer createConnectionConsumer(Destination destination, Stri
         throw new JMSException(SQSMessagingClientConstants.UNSUPPORTED_METHOD);
     }
 
+    @Override
+    public ConnectionConsumer createSharedConnectionConsumer(Topic topic, String subscriptionName, String messageSelector, ServerSessionPool sessionPool, int maxMessages) throws JMSException {
+        throw new JMSException(SQSMessagingClientConstants.UNSUPPORTED_METHOD);
+    }
+
     /** This method is not supported. */
     @Override
-    public ConnectionConsumer createDurableConnectionConsumer(Topic topic, String subscriptionName, String messageSelector,
+    public ConnectionConsumer createDurableConnectionConsumer(
+            Topic topic, String subscriptionName, String messageSelector,
+            ServerSessionPool sessionPool, int maxMessages) throws JMSException {
+        throw new JMSException(SQSMessagingClientConstants.UNSUPPORTED_METHOD);
+    }
+
+    @Override
+    public ConnectionConsumer createSharedDurableConnectionConsumer(
+            Topic topic, String subscriptionName, String messageSelector,
             ServerSessionPool sessionPool, int maxMessages) throws JMSException {
         throw new JMSException(SQSMessagingClientConstants.UNSUPPORTED_METHOD);
     }

src/main/java/com/amazon/sqs/javamessaging/PrefetchManager.java

@@ -14,34 +14,30 @@
  */
 package com.amazon.sqs.javamessaging;
 
-import java.util.function.Supplier;
-
-import javax.jms.ConnectionFactory;
-import javax.jms.JMSException;
-import javax.jms.QueueConnection;
-import javax.jms.QueueConnectionFactory;
-
+import jakarta.jms.*;
 import software.amazon.awssdk.auth.credentials.AwsBasicCredentials;
 import software.amazon.awssdk.auth.credentials.AwsCredentials;
 import software.amazon.awssdk.auth.credentials.AwsCredentialsProvider;
 import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider;
 import software.amazon.awssdk.services.sqs.SqsClient;
 import software.amazon.awssdk.services.sqs.SqsClientBuilder;
 
+import java.util.function.Supplier;
+
 /**
  * A ConnectionFactory object encapsulates a set of connection configuration
  * parameters for <code>SqsClient</code> as well as setting
  * <code>numberOfMessagesToPrefetch</code>.
- * <P>
+ * <p>
  * The <code>numberOfMessagesToPrefetch</code> parameter is used to size of the
  * prefetched messages, which can be tuned based on the application workload. It
  * helps in returning messages from internal buffers(if there is any) instead of
  * waiting for the SQS <code>receiveMessage</code> call to return.
- * <P>
+ * <p>
  * If more physical connections than the default maximum value (that is 50 as of
  * today) are needed on the connection pool,
  * {@link software.amazon.awssdk.core.client.config.ClientOverrideConfiguration} needs to be configured.
- * <P>
+ * <p>
  * None of the <code>createConnection</code> methods set-up the physical
  * connection to SQS, so validity of credentials are not checked with those
  * methods.
@@ -50,18 +46,16 @@
 public class SQSConnectionFactory implements ConnectionFactory, QueueConnectionFactory {
     private final ProviderConfiguration providerConfiguration;
     private final Supplier<SqsClient> amazonSQSClientSupplier;
-    
-    /*
 
-    /*
+    /**
      * Creates a SQSConnectionFactory that uses SqsClientBuilder.standard() for creating SqsClient connections.
      * Every SQSConnection will have its own copy of SqsClient.
      */
     public SQSConnectionFactory(ProviderConfiguration providerConfiguration) {
         this(providerConfiguration, SqsClient.create());
     }
-    
-    /*
+
+    /**
      * Creates a SQSConnectionFactory that uses the provided SqsClient connection.
      * Every SQSConnection will use the same provided SqsClient.
      */
@@ -73,15 +67,10 @@ public SQSConnectionFactory(ProviderConfiguration providerConfiguration, final S
             throw new IllegalArgumentException("AmazonSQS client cannot be null");
         }
         this.providerConfiguration = providerConfiguration;
-        this.amazonSQSClientSupplier = new Supplier<SqsClient>() {
-            @Override
-            public SqsClient get() {
-                return client;
-            }
-        };
+        this.amazonSQSClientSupplier = () -> client;
     }
-    
-    /*
+
+    /**
      * Creates a SQSConnectionFactory that uses the provided SqsClientBuilder for creating AmazonSQS client connections.
      * Every SQSConnection will have its own copy of AmazonSQS client created through the provided builder.
      */
@@ -93,19 +82,14 @@ public SQSConnectionFactory(ProviderConfiguration providerConfiguration, final S
             throw new IllegalArgumentException("AmazonSQS client builder cannot be null");
         }
         this.providerConfiguration = providerConfiguration;
-        this.amazonSQSClientSupplier = new Supplier<SqsClient>() {
-            @Override
-            public SqsClient get() {
-                return clientBuilder.build();
-            }
-        };
+        this.amazonSQSClientSupplier = clientBuilder::build;
     }
-    
+
 
     @Override
     public SQSConnection createConnection() throws JMSException {
         try {
-        	SqsClient amazonSQS = amazonSQSClientSupplier.get();
+            SqsClient amazonSQS = amazonSQSClientSupplier.get();
             return createConnection(amazonSQS, null);
         } catch (RuntimeException e) {
             throw (JMSException) new JMSException("Error creating SQS client: " + e.getMessage()).initCause(e);
@@ -118,36 +102,52 @@ public SQSConnection createConnection(String awsAccessKeyId, String awsSecretKey
         return createConnection(basicAWSCredentials);
     }
 
+    @Override
+    public JMSContext createContext() {
+        throw new JMSRuntimeException(SQSMessagingClientConstants.UNSUPPORTED_METHOD);
+    }
+
+    @Override
+    public JMSContext createContext(String userName, String password) {
+        throw new JMSRuntimeException(SQSMessagingClientConstants.UNSUPPORTED_METHOD);
+    }
+
+    @Override
+    public JMSContext createContext(String userName, String password, int sessionMode) {
+        throw new JMSRuntimeException(SQSMessagingClientConstants.UNSUPPORTED_METHOD);
+    }
+
+    @Override
+    public JMSContext createContext(int sessionMode) {
+        throw new JMSRuntimeException(SQSMessagingClientConstants.UNSUPPORTED_METHOD);
+    }
+
     public SQSConnection createConnection(AwsCredentials awsCredentials) throws JMSException {
         AwsCredentialsProvider awsCredentialsProvider = StaticCredentialsProvider.create(awsCredentials);
         return createConnection(awsCredentialsProvider);
     }
-    
+
     public SQSConnection createConnection(AwsCredentialsProvider awsCredentialsProvider) throws JMSException {
         try {
             SqsClient amazonSQS = amazonSQSClientSupplier.get();
             return createConnection(amazonSQS, awsCredentialsProvider);
-        } catch(Exception e) {
+        } catch (Exception e) {
             throw (JMSException) new JMSException("Error creating SQS client: " + e.getMessage()).initCause(e);
         }
     }
-    
+
     private SQSConnection createConnection(SqsClient amazonSQS, AwsCredentialsProvider awsCredentialsProvider) throws JMSException {
         AmazonSQSMessagingClientWrapper amazonSQSClientJMSWrapper = new AmazonSQSMessagingClientWrapper(amazonSQS, awsCredentialsProvider);
         return new SQSConnection(amazonSQSClientJMSWrapper, providerConfiguration.getNumberOfMessagesToPrefetch());
     }
-    
+
     @Override
     public QueueConnection createQueueConnection() throws JMSException {
-        return (QueueConnection) createConnection();
+        return createConnection();
     }
 
     @Override
     public QueueConnection createQueueConnection(String userName, String password) throws JMSException {
-        return (QueueConnection) createConnection(userName, password);
+        return createConnection(userName, password);
     }
-    
-
-   
-    
 }