非Java RS环境下Quarkus/MicroProfile动态Rest客户端线程安全Token注入

针对多RestClient实例下的线程安全问题，以下是几种实用的解决方案：

方案一：为每个RestClient实例绑定独立的Header工厂 #

将静态Token改为实例变量，让每个客户端实例拥有专属的ApiHeader对象，彻底避免实例间的Token干扰：

修改后的ApiHeader实现 #

public class ApiHeader implements ClientHeadersFactory {
    private String userToken;

    // 通过构造方法初始化Token
    public ApiHeader(String userToken) {
        this.userToken = userToken;
    }

    // 支持动态更新Token
    public void setUserToken(String userToken) {
        this.userToken = userToken;
    }

    @Override
    public MultivaluedMap<String, String> update(
            MultivaluedMap<String, String> incomingHeaders,
            MultivaluedMap<String, String> clientOutgoingHeaders
    ) {
        MultivaluedMap<String, String> map = new MultivaluedHashMap<>();
        if (userToken != null) {
            map.add("authorization", userToken);
        }
        return map;
    }
}

创建多实例RestClient #

// 客户端1：使用TokenA
ApiHeader headerA = new ApiHeader("Bearer tokenA");
MyApi apiClientA = RestClientBuilder.newBuilder()
        .baseUri(URI.create("https://api.example.com/v1"))
        .register(headerA)
        .build(MyApi.class);

// 客户端2：使用TokenB
ApiHeader headerB = new ApiHeader("Bearer tokenB");
MyApi apiClientB = RestClientBuilder.newBuilder()
        .baseUri(URI.create("https://api.example.com/v2"))
        .register(headerB)
        .build(MyApi.class);

这种方式逻辑简单，每个客户端实例的Token完全独立，天然线程安全，还支持动态更新对应实例的Token。

方案二：请求级别的Token传递（适合单客户端多用户场景） #

如果需要同一个RestClient实例处理不同请求的不同Token，可以结合ThreadLocal和请求过滤器实现，注意必须清理ThreadLocal避免线程池泄漏：

Token过滤器实现 #

public class TokenRequestFilter implements ClientRequestFilter {
    private static final ThreadLocal<String> tokenHolder = new ThreadLocal<>();

    // 设置当前请求的Token
    public static void setRequestToken(String token) {
        tokenHolder.set(token);
    }

    // 清理当前线程的Token，必须在请求结束后调用
    public static void clearRequestToken() {
        tokenHolder.remove();
    }

    @Override
    public void filter(ClientRequestContext requestContext) throws IOException {
        String token = tokenHolder.get();
        if (token != null) {
            requestContext.getHeaders().add("authorization", token);
        }
    }
}

客户端初始化与调用 #

// 初始化客户端并注册过滤器
MyApi apiClient = RestClientBuilder.newBuilder()
        .baseUri(URI.create("https://api.example.com"))
        .register(TokenRequestFilter.class)
        .build(MyApi.class);

// 调用时绑定请求专属Token
try {
    TokenRequestFilter.setRequestToken("Bearer user1Token");
    apiClient.getResource();
} finally {
    // 必须清理，防止线程池复用旧Token
    TokenRequestFilter.clearRequestToken();
}

方案三：直接在API接口方法中传递Token #

如果允许修改API接口定义，最直观的方式是将Token作为方法参数传递，完全规避线程安全问题：

定义带Token参数的API接口 #

public interface MyApi {
    @GET("/resource")
    Response getResource(@HeaderParam("authorization") String token);
}

调用时传入Token #

apiClient.getResource("Bearer userSpecificToken");

这种方式侵入性较强，但逻辑最清晰，适合简单场景。

内容的提问来源于stack exchange，提问作者Anand