Bael 9487 bael 9552 (#18995)

* Update MyServiceImpl.java

* Update AppConfig.java

* Update MyService.java

* Update LogAppender.java

* Update SpringRetryIntegrationTest.java

* Update SpringAsyncConfig.java

* Update AsyncComponent.java

* Update AsyncService.java

* Update CustomAsyncExceptionHandler.java

* Update FirstAsyncService.java

* Update SecondAsyncService.java

* Update AsyncAnnotationExampleIntegrationTest.java

* Update AsyncWithXMLIntegrationTest.java

* Update SpringRetryIntegrationTest.java

* Update AsyncServiceUnitTest.java

Author: Deepak-Vohra

spring-scheduling/src/main/java/com/baeldung/async/AsyncComponent.java

@@ -1,37 +1,39 @@
 package com.baeldung.async;
 
 import org.springframework.scheduling.annotation.Async;
-import org.springframework.scheduling.annotation.AsyncResult;
 import org.springframework.stereotype.Component;
-
-import java.util.concurrent.Future;
+import java.util.concurrent.CompletableFuture;
 
 @Component
 public class AsyncComponent {
 
     @Async
     public void asyncMethodWithVoidReturnType() {
+        System.out.println("Execute method asynchronously. " 
+          + Thread.currentThread().getName());
     }
 
     @Async
-    public Future<String> asyncMethodWithReturnType() {
-        try {
-            Thread.sleep(5000);
-            return new AsyncResult<>("hello world !!!!");
-        } catch (final InterruptedException e) {
-
-        }
+    public CompletableFuture<String> asyncMethodWithReturnType() {
+        System.out.println("Execute method asynchronously - " 
+          + Thread.currentThread().getName());
 
-        return null;
+        try {
+                Thread.sleep(5000);
+                return CompletableFuture.completedFuture("hello world !!!!");
+        } catch (InterruptedException e) {
+              return CompletableFuture.failedFuture(e);
+          }
     }
 
     @Async("threadPoolTaskExecutor")
     public void asyncMethodWithConfiguredExecutor() {
+        System.out.println("Execute method with configured executor - "
+          + Thread.currentThread().getName());
     }
 
     @Async
     public void asyncMethodWithExceptions() throws Exception {
         throw new Exception("Throw message from asynchronous method. ");
     }
-
 }

spring-scheduling/src/main/java/com/baeldung/async/AsyncService.java

@@ -9,15 +9,15 @@
 public class AsyncService {
 
     @Autowired
-    private FirstAsyncService fisrtService;
+    private FirstAsyncService firstService;
     @Autowired
     private SecondAsyncService secondService;
 
     public CompletableFuture<String> asyncMergeServicesResponse() throws InterruptedException {
-        CompletableFuture<String> fisrtServiceResponse = fisrtService.asyncGetData();
+        CompletableFuture<String> firstServiceResponse = firstService.asyncGetData();
         CompletableFuture<String> secondServiceResponse = secondService.asyncGetData();
 
         // Merge responses from FirstAsyncService and SecondAsyncService
-        return fisrtServiceResponse.thenCompose(fisrtServiceValue -> secondServiceResponse.thenApply(secondServiceValue -> fisrtServiceValue + secondServiceValue));
+        return firstServiceResponse.thenCompose(firstServiceValue -> secondServiceResponse.thenApply(secondServiceValue -> firstServiceValue + secondServiceValue));
     }
 }

spring-scheduling/src/main/java/com/baeldung/async/CustomAsyncExceptionHandler.java

@@ -8,10 +8,12 @@ public class CustomAsyncExceptionHandler implements AsyncUncaughtExceptionHandle
 
     @Override
     public void handleUncaughtException(final Throwable throwable, final Method method, final Object... obj) {
-        System.out.println("Exception message - " + throwable.getMessage());
-        for (final Object param : obj) {
-            System.out.println("Param - " + param);
+        System.err.println("Async Exception Detected!");
+        System.err.println("Exception message - " + throwable.getMessage());
+        System.err.println("Method name - " + method.getName());
+        for (Object param : obj) {
+            System.err.println("Parameter value - " + param);
         }
     }
-
 }
+

spring-scheduling/src/main/java/com/baeldung/async/FirstAsyncService.java

@@ -3,16 +3,25 @@
 import java.util.concurrent.CompletableFuture;
 
 import org.springframework.scheduling.annotation.Async;
-import org.springframework.scheduling.annotation.AsyncResult;
 import org.springframework.stereotype.Service;
 
 @Service
 public class FirstAsyncService {
 
+    /**
+     * Executes asynchronously and returns a CompletableFuture holding the result.
+     * The method directly uses CompletableFuture, avoiding the deprecated AsyncResult.
+     * * @return A CompletableFuture containing the result string.
+     * @throws InterruptedException if the sleep is interrupted.
+     */
     @Async
     public CompletableFuture<String> asyncGetData() throws InterruptedException {
+        // Simulate a long-running task
         Thread.sleep(4000);
-        return new AsyncResult<>(super.getClass().getSimpleName() + " response !!! ").completable();
+        
+        // Return the result wrapped in a completed CompletableFuture
+        return CompletableFuture.completedFuture(
+            super.getClass().getSimpleName() + " response !!! "
+        );
     }
-
 }

spring-scheduling/src/main/java/com/baeldung/async/SecondAsyncService.java

@@ -3,16 +3,25 @@
 import java.util.concurrent.CompletableFuture;
 
 import org.springframework.scheduling.annotation.Async;
-import org.springframework.scheduling.annotation.AsyncResult;
 import org.springframework.stereotype.Service;
 
 @Service
 public class SecondAsyncService {
 
+    /**
+     * Executes asynchronously and returns a CompletableFuture holding the result.
+     * The method directly uses CompletableFuture, avoiding the deprecated AsyncResult.
+     * * @return A CompletableFuture containing the result string.
+     * @throws InterruptedException if the sleep is interrupted.
+     */
     @Async
     public CompletableFuture<String> asyncGetData() throws InterruptedException {
+        // Simulate a long-running task
         Thread.sleep(4000);
-        return new AsyncResult<>(super.getClass().getSimpleName() + " response !!! ").completable();
+        
+        // Return the result wrapped in a completed CompletableFuture
+        return CompletableFuture.completedFuture(
+            super.getClass().getSimpleName() + " response !!! "
+        );
     }
-
 }

spring-scheduling/src/main/java/com/baeldung/async/config/SpringAsyncConfig.java

@@ -12,24 +12,44 @@
 import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
 
 @Configuration
-@EnableAsync()
+@EnableAsync
 @ComponentScan("com.baeldung.async")
 public class SpringAsyncConfig implements AsyncConfigurer {
 
+    /**
+     * Defines a custom Executor used by @Async("threadPoolTaskExecutor") calls.
+     */
     @Bean(name = "threadPoolTaskExecutor")
     public Executor threadPoolTaskExecutor() {
-        return new ThreadPoolTaskExecutor();
+        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
+        executor.setCorePoolSize(5);
+        executor.setMaxPoolSize(10);
+        executor.setQueueCapacity(25);
+        executor.setThreadNamePrefix("CustomPool-");
+        executor.initialize();
+        return executor;
     }
 
+    /**
+     * Defines the default Executor used by un-named @Async calls.
+     */
     @Override
     public Executor getAsyncExecutor() {
-        ThreadPoolTaskExecutor threadPoolTaskExecutor = new ThreadPoolTaskExecutor();
-        threadPoolTaskExecutor.initialize();
-        return threadPoolTaskExecutor;
+        // You could return the named bean here, or create a new one.
+        // Creating a new one for demonstration purposes.
+        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
+        executor.setCorePoolSize(2);
+        executor.setMaxPoolSize(4);
+        executor.setThreadNamePrefix("DefaultAsync-");
+        executor.initialize();
+        return executor;
     }
 
+    /**
+     * Defines the exception handler for asynchronous method calls.
+     */
     @Override
     public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
         return new CustomAsyncExceptionHandler();
     }
-}
+}

spring-scheduling/src/main/java/com/baeldung/springretry/AppConfig.java

@@ -7,11 +7,12 @@
 import org.springframework.retry.annotation.EnableRetry;
 import org.springframework.retry.backoff.FixedBackOffPolicy;
 import org.springframework.retry.support.RetryTemplate;
- 
+import org.springframework.resilience.annotation.EnableResilientMethods;
 
 @Configuration
 @ComponentScan(basePackages = "com.baeldung.springretry")
 @EnableRetry
+@EnableResilientMethods 
 @PropertySource("classpath:retryConfig.properties")
 public class AppConfig {
 

spring-scheduling/src/main/java/com/baeldung/springretry/MyService.java

@@ -5,7 +5,7 @@
 import org.springframework.retry.annotation.Backoff;
 import org.springframework.retry.annotation.Recover;
 import org.springframework.retry.annotation.Retryable;
-
+import org.springframework.resilience.annotation.ConcurrencyLimit;
 
 public interface MyService {
 
@@ -26,4 +26,8 @@ public interface MyService {
     void recover(SQLException e, String sql);
 
     void templateRetryService();
+
+    // **NEW Method with Concurrency Limit**
+    @ConcurrencyLimit(5)
+    void concurrentLimitService();
 }

spring-scheduling/src/main/java/com/baeldung/springretry/MyServiceImpl.java

@@ -7,17 +7,19 @@
 import org.springframework.retry.support.RetrySynchronizationManager;
 import org.springframework.stereotype.Service;
 import org.apache.commons.lang3.StringUtils;
-
+import org.springframework.resilience.annotation.ConcurrencyLimit;
 @Service
 public class MyServiceImpl implements MyService {
 
     private static final Logger logger = LoggerFactory.getLogger(MyServiceImpl.class);
 
     @Override
     public void retryService() {
+        // This is correct for logging the retry count (0 on first attempt, 1 on first retry, etc.)
         logger.info("Retry Number: " + RetrySynchronizationManager.getContext()
             .getRetryCount());
         logger.info("throw RuntimeException in method retryService()");
+        // Always throws the exception to force the retry aspect to kick in
         throw new RuntimeException();
     }
 
@@ -33,6 +35,7 @@ public void retryServiceWithRecovery(String sql) throws SQLException {
     public void retryServiceWithCustomization(String sql) throws SQLException {
         if (StringUtils.isEmpty(sql)) {
             logger.info("throw SQLException in method retryServiceWithCustomization()");
+            // Correctly throws SQLException to trigger the 2 retry attempts
             throw new SQLException();
         }
     }
@@ -55,4 +58,19 @@ public void templateRetryService() {
         logger.info("throw RuntimeException in method templateRetryService()");
         throw new RuntimeException();
     }
+
+    // **NEW Implementation for Concurrency Limit**
+    @Override
+    @ConcurrencyLimit(5)
+    public void concurrentLimitService() {
+        // The ConcurrencyLimit aspect will wrap this method.
+        logger.info("Concurrency Limit Active. Current Thread: " + Thread.currentThread().getName());
+        // Simulate a time-consuming task to observe throttling
+        try {
+            Thread.sleep(1000); // Correctly blocks to hold the lock
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+        }
+        logger.info("Concurrency Limit Released. Current Thread: " + Thread.currentThread().getName());
+    }
 }

spring-scheduling/src/main/java/com/baeldung/springretry/logging/LogAppender.java

@@ -5,10 +5,10 @@
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-
+import ch.qos.logback.classic.spi.ILoggingEvent;
 import ch.qos.logback.core.AppenderBase;
 
-public class LogAppender extends AppenderBase<ch.qos.logback.classic.spi.ILoggingEvent> {
+public class LogAppender extends AppenderBase<ILoggingEvent> {
 
     private static final Logger logger = LoggerFactory.getLogger(LogAppender.class);
     private static final List<String> logMessages = new ArrayList<>();
@@ -22,4 +22,12 @@ protected void append(ch.qos.logback.classic.spi.ILoggingEvent eventObject) {
     public static List<String> getLogMessages() {
         return logMessages;
     }
+
+    /**
+     * Clears the static list of captured log messages.
+     * Used in test setup (@Before) to ensure a clean slate for each test case.
+     */
+    public static void clearLogMessages() {
+        logMessages.clear();
+    }
 }