@Async注解导致请求头参数丢失

import org.apache.poi.ss.formula.functions.T;
import org.jetbrains.annotations.NotNull;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.AsyncConfigurer;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.util.concurrent.ListenableFuture;
import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.RequestContextHolder;

import java.util.concurrent.Callable;
import java.util.concurrent.Executor;
import java.util.concurrent.Future;

/**
 * @Author: hrd
 * @CreateTime: 2024/4/15 9:42
 * @Description:
 */
@Configuration
@EnableAsync
public class AsyncConfig implements AsyncConfigurer {
    // 实现 getAsyncExecutor 方法来配置任务执行器
    @Override
    public Executor getAsyncExecutor() {
        ContextAwarePoolExecutor executor = new ContextAwarePoolExecutor();
        // 配置线程池参数
        executor.setCorePoolSize(5);
        executor.setMaxPoolSize(10);
        executor.setQueueCapacity(100);
        executor.initialize();
        return executor;
    }

    public static class ContextAwareCallable<T> implements Callable<T> {
        private final Callable<T> task;
        private final RequestAttributes context;

        public ContextAwareCallable(Callable<T> task, RequestAttributes context) {
            this.task = task;
            this.context = context;
        }

        @Override
        public T call() throws Exception {
            if (context != null) {
                RequestContextHolder.setRequestAttributes(context);
            }
            try {
                return task.call();
            } finally {
                RequestContextHolder.resetRequestAttributes();
            }
        }

    }


    public static class ContextAwarePoolExecutor extends ThreadPoolTaskExecutor {
        static <T> ContextAwareCallable<T> of(Callable<T> task, RequestAttributes context) {
            return new ContextAwareCallable(task, context);

        }

        @NotNull
        @Override
        public <T> Future<T> submit(@NotNull Callable<T> task) {
            return super.submit(of(task, RequestContextHolder.currentRequestAttributes()));
        }

        @NotNull
        @Override
        public <T> ListenableFuture<T> submitListenable(@NotNull Callable<T> task) {
            return super.submitListenable(of(task, RequestContextHolder.currentRequestAttributes()));
        }
    }
}