fixed:

Refactor Thread-Specific Storage pattern implementation to address Sonar issues: remove unnecessary instantiation, add private constructor, use diamond operator, and update tests.

Author: CMD137

thread-specific-storage/pom.xml

@@ -59,6 +59,12 @@
             <artifactId>mockito-core</artifactId>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>org.awaitility</groupId>
+            <artifactId>awaitility</artifactId>
+            <version>4.2.1</version>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
 
     <build>

thread-specific-storage/src/main/java/com/iluwatar/threadspecificstorage/App.java

@@ -17,9 +17,6 @@ public class App {
    * @param args command-line arguments (not used)
    */
   public static void main(String[] args) {
-    // Initialize components
-    UserContextProxy proxy = new UserContextProxy();
-
     // Simulate concurrent requests from multiple users
     for (int i = 1; i <= 5; i++) {
       // Simulate tokens for different users
@@ -28,7 +25,7 @@ public static void main(String[] args) {
       new Thread(
               () -> {
                 // Simulate request processing flow
-                RequestHandler handler = new RequestHandler(proxy, token);
+                RequestHandler handler = new RequestHandler(token);
                 handler.process();
               })
           .start();
@@ -37,6 +34,7 @@ public static void main(String[] args) {
       try {
         Thread.sleep(50);
       } catch (InterruptedException e) {
+        Thread.currentThread().interrupt();
         LOGGER.warn("Sleep interrupted", e);
       }
     }

thread-specific-storage/src/main/java/com/iluwatar/threadspecificstorage/RequestHandler.java

@@ -1,7 +1,6 @@
 package com.iluwatar.threadspecificstorage;
 
 import java.security.SecureRandom;
-import lombok.AllArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 
 /**
@@ -10,12 +9,14 @@
  * <p>Each instance simulates a request-processing thread that uses the Thread-Specific Object Proxy
  * to access Thread-Specific Object.
  */
-@AllArgsConstructor
 @Slf4j
 public class RequestHandler {
-  private final UserContextProxy contextProxy;
   private final String token;
 
+  public RequestHandler(String token) {
+    this.token = token;
+  }
+
   /**
    * Simulated business process: 1. Parse userId from token ("Token::userId"). 2. Store userId in
    * thread-local storage. 3. Later, retrieve userId and use it for business logic. 4. Finally,
@@ -29,13 +30,13 @@ public void process() {
       Long userId = parseToken(token);
 
       // Step 2: Save userId in ThreadLocal storage
-      contextProxy.set(new UserContext(userId));
+      UserContextProxy.set(new UserContext(userId));
 
       // Simulate delay between stages of request handling
       Thread.sleep(200);
 
       // Step 3: Retrieve userId later in the request flow
-      Long retrievedId = contextProxy.get().getUserId();
+      Long retrievedId = UserContextProxy.get().getUserId();
       SecureRandom random = new SecureRandom();
       String accountInfo = retrievedId + "'s account: " + random.nextInt(400);
       LOGGER.info(accountInfo);
@@ -44,7 +45,7 @@ public void process() {
       Thread.currentThread().interrupt();
     } finally {
       // Step 4: Clear ThreadLocal to avoid potential memory leaks
-      contextProxy.clear();
+      UserContextProxy.clear();
     }
   }
 

thread-specific-storage/src/main/java/com/iluwatar/threadspecificstorage/UserContextProxy.java

@@ -11,7 +11,10 @@ public class UserContextProxy {
    * Underlying TSObjectCollection (ThreadLocalMap) managed by JVM.This ThreadLocal acts as the Key
    * for the map.So That there is also no key factory.
    */
-  private static final ThreadLocal<UserContext> userContextHolder = new ThreadLocal<UserContext>();
+  private static final ThreadLocal<UserContext> userContextHolder = new ThreadLocal<>();
+
+  /** Private constructor to prevent instantiation of this utility class. */
+  private UserContextProxy() {}
 
   /** Set UserContext for the current thread. */
   public static void set(UserContext context) {

thread-specific-storage/src/test/java/com/iluwatar/threadspecificstorage/AppTest.java

@@ -1,5 +1,8 @@
 package com.iluwatar.threadspecificstorage;
 
+import static java.util.concurrent.TimeUnit.MILLISECONDS;
+import static java.util.concurrent.TimeUnit.SECONDS;
+import static org.awaitility.Awaitility.await;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import java.io.ByteArrayOutputStream;
@@ -18,11 +21,10 @@ void testMainMethod() {
     App.main(new String[] {});
 
     // Give some time for threads to execute
-    try {
-      Thread.sleep(2000);
-    } catch (InterruptedException e) {
-      Thread.currentThread().interrupt();
-    }
+    await()
+        .atMost(5, SECONDS)
+        .pollInterval(100, MILLISECONDS)
+        .until(() -> outContent.toString().contains("Start handling request with token"));
 
     // Verify output contains expected log messages
     String output = outContent.toString();

thread-specific-storage/src/test/java/com/iluwatar/threadspecificstorage/RequestHandlerTest.java

@@ -8,27 +8,25 @@ class RequestHandlerTest {
 
   @Test
   void process_shouldStoreAndClearUserContext() {
-    // Given - a real UserContextProxy
-    UserContextProxy proxy = new UserContextProxy();
-    RequestHandler handler = new RequestHandler(proxy, "token::123");
+    // Given - a request handler without proxy parameter
+    RequestHandler handler = new RequestHandler("token::123");
 
     // When - process the request
     handler.process();
 
     // Then - after processing, ThreadLocal should be cleared
-    assertNull(proxy.get(), "ThreadLocal should be cleared after process()");
+    assertNull(UserContextProxy.get(), "ThreadLocal should be cleared after process()");
   }
 
   @Test
   void process_withInvalidToken_shouldSetUserIdToMinusOne() {
-    // Given - a real UserContextProxy
-    UserContextProxy proxy = new UserContextProxy();
-    RequestHandler handler = new RequestHandler(proxy, "invalid-token");
+    // Given - a request handler without proxy parameter
+    RequestHandler handler = new RequestHandler("invalid-token");
 
     // When - process the request
     handler.process();
 
     // Then - after processing, ThreadLocal should be cleared
-    assertNull(proxy.get(), "ThreadLocal should be cleared even for invalid token");
+    assertNull(UserContextProxy.get(), "ThreadLocal should be cleared even for invalid token");
   }
 }