Javaのアノテーションを活用した非同期処理の制御方法を徹底解説

public class Example {

    @Override
    public String toString() {
        return "Example Object";
    }

    @Deprecated
    public void oldMethod() {
        // 古いメソッドで、将来削除される可能性があります
    }
}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MyAnnotation {
    String value();
}

import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

@Service
public class MyService {

    @Async
    public void performAsyncTask() {
        // 非同期で実行されるタスク
        System.out.println("Task executed asynchronously");
    }
}

import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;

@Configuration
@EnableAsync
public class AppConfig {
    // 非同期処理の設定
}

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;

@Service
public class MyService {

    @Scheduled(fixedRate = 5000)
    public void performScheduledTask() {
        // 5秒ごとに実行されるタスク
        System.out.println("Scheduled task executed");
    }
}

import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

@Service
public class AsyncService {

    @Async
    public void executeAsyncTask() {
        System.out.println("非同期タスクを実行中...");
        // 長時間実行されるタスクのシミュレーション
        try {
            Thread.sleep(5000); // 5秒間待機
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            System.out.println("タスクが中断されました。");
        }
        System.out.println("非同期タスクが完了しました。");
    }
}

import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import java.util.concurrent.CompletableFuture;

@Service
public class AsyncService {

    @Async
    public CompletableFuture<String> fetchAsyncData() {
        System.out.println("データの取得を非同期で開始...");
        try {
            Thread.sleep(3000); // データ取得のシミュレーション
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return CompletableFuture.completedFuture("タスクが中断されました。");
        }
        return CompletableFuture.completedFuture("データ取得完了");
    }
}

import java.util.concurrent.CompletableFuture;

public void executeMultipleTasks() {
    CompletableFuture<String> task1 = asyncService.fetchAsyncData();
    CompletableFuture<String> task2 = asyncService.fetchAsyncData();
    CompletableFuture<Void> combinedTasks = CompletableFuture.allOf(task1, task2);

    combinedTasks.thenRun(() -> {
        try {
            String result1 = task1.get();
            String result2 = task2.get();
            System.out.println("全タスク完了: " + result1 + ", " + result2);
        } catch (Exception e) {
            e.printStackTrace();
        }
    });
}

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>
</dependencies>

import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;

@Configuration
@EnableAsync
public class AppConfig {
    // ここに他の設定も追加可能です
}

import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

@Service
public class NotificationService {

    @Async
    public void sendEmailNotification(String email) {
        System.out.println("非同期でメール送信を開始: " + email);
        try {
            // メール送信のシミュレーション（5秒待機）
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            System.out.println("メール送信が中断されました。");
        }
        System.out.println("メール送信が完了しました: " + email);
    }
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class NotificationController {

    @Autowired
    private NotificationService notificationService;

    @GetMapping("/send-notification")
    public String sendNotification() {
        notificationService.sendEmailNotification("user@example.com");
        return "通知が非同期で送信されました";
    }
}

import org.springframework.aop.interceptor.AsyncUncaughtExceptionHandler;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.AsyncConfigurer;

import java.lang.reflect.Method;

@Configuration
public class CustomAsyncConfigurer implements AsyncConfigurer {

    @Override
    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
        return new AsyncUncaughtExceptionHandler() {
            @Override
            public void handleUncaughtException(Throwable throwable, Method method, Object... objects) {
                System.out.println("非同期エラーが発生しました: " + throwable.getMessage());
            }
        };
    }
}

import java.util.concurrent.CompletableFuture;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

@Service
public class AsyncService {

    @Async
    public CompletableFuture<String> fetchData() {
        return CompletableFuture.supplyAsync(() -> {
            if (true) {
                throw new RuntimeException("データ取得中にエラーが発生しました");
            }
            return "データ取得成功";
        }).exceptionally(ex -> {
            System.out.println("エラー: " + ex.getMessage());
            return "エラーが発生しました";
        });
    }
}

import org.springframework.aop.interceptor.AsyncUncaughtExceptionHandler;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.AsyncConfigurer;
import java.lang.reflect.Method;

@Configuration
public class CustomAsyncConfigurer implements AsyncConfigurer {

    @Override
    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
        return new AsyncUncaughtExceptionHandler() {
            @Override
            public void handleUncaughtException(Throwable throwable, Method method, Object... params) {
                System.out.println("非同期処理中に未処理の例外が発生しました: " + throwable.getMessage());
            }
        };
    }
}

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.concurrent.Executor;

@Configuration
public class AsyncConfig {

    @Bean(name = "taskExecutor")
    public Executor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5);
        executor.setMaxPoolSize(10);
        executor.setQueueCapacity(100);
        executor.setThreadNamePrefix("AsyncTask-");
        executor.initialize();
        return executor;
    }
}

@Async
@Order(1)
public void highPriorityTask() {
    // 優先度の高いタスクの処理
}

@Async
@Order(2)
public void lowPriorityTask() {
    // 優先度の低いタスクの処理
}

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;

@Service
public class ScheduledTaskService {

    @Scheduled(fixedRate = 5000)
    public void performTask() {
        System.out.println("5秒ごとに実行されるタスク: " + System.currentTimeMillis());
    }

    @Scheduled(cron = "0 0 12 * * ?")
    public void performDailyTask() {
        System.out.println("毎日正午に実行されるタスク");
    }
}

import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;

@Service
public class CombinedService {

    @Async
    @Scheduled(fixedRate = 10000)
    public void performAsyncScheduledTask() {
        System.out.println("10秒ごとに非同期で実行されるタスク: " + System.currentTimeMillis());
        // 長時間かかる処理のシミュレーション
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        System.out.println("非同期タスクが完了しました");
    }
}

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

@Service
public class FutureService {

    @Async
    public CompletableFuture<String> processAsync() {
        return CompletableFuture.supplyAsync(() -> {
            // 非同期処理
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            return "非同期処理完了";
        });
    }

    public void execute() {
        try {
            CompletableFuture<String> future = processAsync();
            String result = future.get();  // 非同期処理の結果を取得
            System.out.println("結果: " + result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
}

import reactor.core.publisher.Mono;
import org.springframework.stereotype.Service;

@Service
public class ReactiveService {

    public Mono<String> fetchData() {
        return Mono.fromSupplier(() -> {
            try {
                Thread.sleep(2000);  // I/O操作のシミュレーション
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            return "データ取得完了";
        });
    }
}

import javax.annotation.PostConstruct;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

@Service
public class StartupService {

    @PostConstruct
    @Async
    public void initAsyncTask() {
        System.out.println("アプリケーション起動後に非同期処理を開始します...");
        // 起動時の非同期処理
    }
}

import static org.junit.jupiter.api.Assertions.assertEquals;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
public class AsyncServiceTest {

    @Autowired
    private AsyncService asyncService;

    @Test
    public void testAsyncMethod() throws ExecutionException, InterruptedException {
        CompletableFuture<String> future = asyncService.fetchData();
        // 非同期処理の結果を待機
        String result = future.get();
        assertEquals("データ取得完了", result);
    }
}

import static org.awaitility.Awaitility.await;
import static java.util.concurrent.TimeUnit.SECONDS;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
public class AsyncServiceAwaitilityTest {

    @Autowired
    private AsyncService asyncService;

    @Test
    public void testAsyncMethodWithAwaitility() {
        asyncService.executeAsyncTask();

        await().atMost(5, SECONDS).untilAsserted(() -> {
            // 期待する結果が得られたかどうかを確認
            assertEquals("期待される状態", getCurrentState());
        });
    }

    private String getCurrentState() {
        // 非同期処理によって変更される状態を取得
        return "期待される状態";
    }
}

import static org.mockito.Mockito.when;
import static org.junit.jupiter.api.Assertions.assertEquals;
import java.util.concurrent.CompletableFuture;
import org.junit.jupiter.api.Test;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
public class AsyncServiceMockitoTest {

    @Mock
    private DependencyService dependencyService;

    @InjectMocks
    private AsyncService asyncService;

    @Test
    public void testAsyncMethodWithMockito() throws Exception {
        MockitoAnnotations.openMocks(this);

        // モックの動作を定義
        when(dependencyService.getData()).thenReturn(CompletableFuture.completedFuture("モックデータ"));

        // 非同期処理のテスト
        CompletableFuture<String> future = asyncService.fetchDataFromDependency();
        String result = future.get();
        assertEquals("モックデータ", result);
    }
}

import static org.junit.jupiter.api.Assertions.assertThrows;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
public class AsyncServiceTimeoutTest {

    @Autowired
    private AsyncService asyncService;

    @Test
    public void testAsyncMethodTimeout() {
        CompletableFuture<String> future = asyncService.slowTask();

        // タイムアウトを設定して非同期処理をテスト
        assertThrows(TimeoutException.class, () -> {
            future.get(1, TimeUnit.SECONDS);
        });
    }
}

import static org.junit.jupiter.api.Assertions.assertTrue;
import org.junit.jupiter.api.Test;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.test.context.junit.jupiter.SpringJUnitConfig;

@SpringJUnitConfig
public class AsyncExecutorTest {

    @Test
    public void testImmediateCompletion() {
        ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
        taskExecutor.setCorePoolSize(1);
        taskExecutor.setMaxPoolSize(1);
        taskExecutor.initialize();

        // タスクが即座に実行されることをシミュレート
        taskExecutor.execute(() -> assertTrue(true));
    }
}

import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.stereotype.Service;

@Service
public class NotificationService {

    private final KafkaTemplate<String, String> kafkaTemplate;

    public NotificationService(KafkaTemplate<String, String> kafkaTemplate) {
        this.kafkaTemplate = kafkaTemplate;
    }

    public void sendNotification(String message) {
        kafkaTemplate.send("notification-topic", message);
        System.out.println("非同期で通知メッセージを送信しました: " + message);
    }
}

import org.springframework.batch.core.StepContribution;
import org.springframework.batch.core.scope.context.ChunkContext;
import org.springframework.batch.core.step.tasklet.Tasklet;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;

@Component
public class AsyncTasklet implements Tasklet {

    @Async
    @Override
    public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) throws Exception {
        // 非同期で実行されるバッチ処理
        processLargeData();
        return RepeatStatus.FINISHED;
    }

    private void processLargeData() {
        // データ処理のロジック
    }
}

import io.github.resilience4j.circuitbreaker.annotation.CircuitBreaker;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

@Service
public class ResilientService {

    @Async
    @CircuitBreaker(name = "backendService", fallbackMethod = "fallback")
    public void callExternalService() {
        // 外部サービスの呼び出し
    }

    public void fallback(Throwable t) {
        // フォールバック処理
        System.out.println("フォールバック処理が実行されました: " + t.getMessage());
    }
}

apiVersion: apps/v1
kind: Deployment
metadata:
  name: async-task-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: async-task
  template:
    metadata:
      labels:
        app: async-task
    spec:
      containers:
      - name: async-task-container
        image: async-task-image
        resources:
          limits:
            cpu: "500m"
            memory: "512Mi"