自定义异步注解（AsyncConfigurer）

在Java Spring框架中，@Async注解用于支持异步方法执行，它允许方法在单独的线程中运行，从而提高应用程序的响应速度和性能。然而，默认的@Async可能不完全满足所有定制需求，比如特定的线程池配置、异步方法执行前后的自定义逻辑等。这时候，自定义注解结合Spring AOP（面向切面编程）就可以派上用场，以实现更精细的控制。下面是如何创建一个自定义异步注解并结合Spring异步处理的例子。

步骤一：定义自定义异步注解

首先，我们需要定义一个新的注解，这个注解将作为我们自定义异步处理的标记。

1import java.lang.annotation.ElementType;
2import java.lang.annotation.Retention;
3import java.lang.annotation.RetentionPolicy;
4import java.lang.annotation.Target;
5
6@Target(ElementType.METHOD) // 该注解只能用于方法
7@Retention(RetentionPolicy.RUNTIME) // 运行时保留注解，这样可以在运行时通过反射获取到
8public @interface CustomAsync {
9    // 可以添加自定义属性，这里为了简化未添加
10}

步骤二：配置异步方法执行器（AsyncConfigurer）

接下来，需要配置一个自定义的线程池来处理我们的异步任务，以及指定使用哪个线程池来执行带有我们自定义注解的方法

1import org.springframework.aop.interceptor.AsyncUncaughtExceptionHandler;
2import org.springframework.context.annotation.Configuration;
3import org.springframework.scheduling.annotation.AsyncConfigurer;
4import org.springframework.scheduling.annotation.EnableAsync;
5import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
6
7import java.util.concurrent.Executor;
8
9@Configuration
10@EnableAsync // 启用异步支持
11public class AsyncConfig implements AsyncConfigurer {
12
13    @Override
14    public Executor getAsyncExecutor() {
15        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
16        executor.setCorePoolSize(2); // 核心线程数
17        executor.setMaxPoolSize(5); // 最大线程数
18        executor.setQueueCapacity(100); // 队列大小
19        executor.initialize();
20        return executor;
21    }
22
23    @Override
24    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
25        // 自定义异常处理器，处理异步方法中未捕获的异常
26        return new CustomAsyncExceptionHandler();
27    }
28}
29
30// 自定义异常处理器示例
31class CustomAsyncExceptionHandler implements AsyncUncaughtExceptionHandler {
32    @Override
33    public void handleUncaughtException(Throwable throwable, Method method, Object... params) {
34        // 处理逻辑
35    }
36}

步骤三：自定义切面处理自定义注解

为了使自定义注解像@Async一样工作，我们需要编写一个切面（Aspect）来拦截带有@CustomAsync注解的方法，并在切面内实现异步调用逻辑。

1import org.aspectj.lang.ProceedingJoinPoint;
2import org.aspectj.lang.annotation.Around;
3import org.aspectj.lang.annotation.Aspect;
4import org.springframework.beans.factory.annotation.Autowired;
5import org.springframework.core.task.TaskExecutor;
6import org.springframework.stereotype.Component;
7
8@Aspect
9@Component
10public class CustomAsyncAspect {
11
12    @Autowired
13    private TaskExecutor taskExecutor;
14
15    @Around("@annotation(com.example.yourpackage.CustomAsync)")
16    public Object handleCustomAsyncMethod(ProceedingJoinPoint joinPoint) throws Throwable {
17        // 使用自定义线程池执行方法
18        return taskExecutor.execute(new Runnable() {
19            @Override
20            public void run() {
21                try {
22                    joinPoint.proceed();
23                } catch (Throwable throwable) {
24                    throw new RuntimeException("Async method execution failed", throwable);
25                }
26            }
27        });
28    }
29}

步骤四：在业务代码中使用自定义注解

最后，在需要异步执行的方法上使用我们自定义的@CustomAsync注解。

1@Service
2public class SomeService {
3
4    @CustomAsync
5    public void asyncMethod() {
6        // 异步执行的逻辑
7    }
8}

通过以上步骤，我们就实现了使用自定义注解@CustomAsync来进行异步方法调用的功能，这不仅允许我们灵活地配置异步任务的执行策略，还能在异步执行前后添加自定义逻辑，提高了应用的可维护性和扩展性。