RestAssured并行执行请求出现重复Authorization头如何解决？

问题根源 #

RestAssured 的 baseURI、requestSpecification、responseSpecification 均为静态类属性，全局共享无线程隔离。多线程并行执行场景时，不同线程的Before方法会同时修改这些全局属性，导致配置互相覆盖、头信息叠加，最终出现多个Authorization头的问题。

解决方案1：使用ThreadLocal隔离每个线程的配置（最稳妥，无副作用） #

完全放弃操作RestAssured全局静态配置，将每个场景的配置存到线程独立的ThreadLocal中，从根源避免配置串扰。

1. 定义线程上下文存储类：

public class RestSpecHolder {
    private static final ThreadLocal<RequestSpecification> REQ_SPEC = new ThreadLocal<>();
    private static final ThreadLocal<ResponseSpecification> RES_SPEC = new ThreadLocal<>();
    private static final ThreadLocal<String> BASE_URI = new ThreadLocal<>();

    public static void setReqSpec(RequestSpecification spec) {
        REQ_SPEC.set(spec);
    }

    public static RequestSpecification getReqSpec() {
        return REQ_SPEC.get();
    }

    public static void setResSpec(ResponseSpecification spec) {
        RES_SPEC.set(spec);
    }

    public static ResponseSpecification getResSpec() {
        return RES_SPEC.get();
    }

    public static void setBaseUri(String uri) {
        BASE_URI.set(uri);
    }

    public static String getBaseUri() {
        return BASE_URI.get();
    }

    // 场景执行结束后清理线程数据，避免内存泄漏和脏数据
    public static void clear() {
        REQ_SPEC.remove();
        RES_SPEC.remove();
        BASE_URI.remove();
    }
}

2. 调整Before/After逻辑：

@cucumber.api.java.Before
public void beforeScenario(Scenario scenario) {
    Specification spec = new Specification();
    RestSpecHolder.setBaseUri("https://test.net");
    RestSpecHolder.setReqSpec(spec.requestSpecificationWithAdminToken(token));
    RestSpecHolder.setResSpec(spec.responseSpecification());
}

@cucumber.api.java.After
public void afterScenario(Scenario scenario) {
    RestSpecHolder.clear();
}

3. 调整测试用例写法，显式传入当前线程的配置：

SomeBinding bindings = SerenityRest.
                given()
                .baseUri(RestSpecHolder.getBaseUri())
                .spec(RestSpecHolder.getReqSpec())
                .queryParams(params)
                .when().get("/api/some/GetEntities")
                .then()
                .spec(RestSpecHolder.getResSpec())
                .statusCode(HttpStatus.SC_OK)
                .extract().response().as(SomeBinding.class); 

解决方案2：添加全局请求过滤器（改造成本更低） #

如果测试用例数量多，不想批量修改所有请求写法，可以通过RestAssured全局过滤器在请求发送前统一清理重复头，配合ThreadLocal存储当前线程的认证信息。

1. 定义token存储类和请求过滤器：

public class TokenHolder {
    private static final ThreadLocal<String> CURRENT_TOKEN = new ThreadLocal<>();
    public static void setToken(String token) {
        CURRENT_TOKEN.set(token);
    }
    public static String getToken() {
        return CURRENT_TOKEN.get();
    }
    public static void clear() {
        CURRENT_TOKEN.remove();
    }
}

public class AuthHeaderFilter implements RequestFilter {
    @Override
    public Response filter(FilterableRequestSpecification requestSpec, FilterableResponseSpecification responseSpec, FilterContext ctx) {
        // 移除所有已存在的Authorization头，避免叠加
        requestSpec.removeHeader("Authorization");
        // 加入当前线程的认证头
        requestSpec.header("Authorization", "Bearer " + TokenHolder.getToken());
        return ctx.next(requestSpec, responseSpec, ctx);
    }
}

2. 项目启动时全局注册过滤器（只需要执行一次）：

static {
    RestAssured.filters(new AuthHeaderFilter());
    // 原有全局固定配置可以在这里一次性设置
    RestAssured.baseURI = "https://test.net";
    RestAssured.responseSpecification = new Specification().responseSpecification();
    RestAssured.config = RestAssuredConfig.config().decoderConfig(decoderConfig().noContentDecoders());
}

3. 调整Before/After逻辑：

@cucumber.api.java.Before
public void beforeScenario(Scenario scenario) {
    TokenHolder.setToken(token);
    RestAssured.requestSpecification = new Specification().requestSpecificationWithAdminToken(token);
}

@cucumber.api.java.After
public void afterScenario(Scenario scenario) {
    TokenHolder.clear();
}

补充优化点 #

原有requestSpecificationWithAdminToken方法中的addHeader可以替换为setHeader，避免同个spec内重复添加同名头，配合上述隔离方案可靠性更高。

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