如何在CXF（JAX-RS）中覆写HTTP响应头Connection

嘿，这个场景我太熟了——负载均衡后的长连接确实会让流量集中在少数连接上，导致负载不均。用CXF实现你要的「每N次请求返回Connection: close」需求，有两种靠谱的方案，我给你拆解清楚：

这是JAX-RS 2.0+的标准API，不仅在CXF里能用，换其他JAX-RS框架（比如Jersey）也不用改代码，通用性拉满。

步骤1：写一个带请求计数的过滤器 #

核心是用线程安全的计数器跟踪请求次数，达到阈值就修改响应头：

import javax.ws.rs.container.ContainerRequestContext;
import javax.ws.rs.container.ContainerResponseContext;
import javax.ws.rs.container.ContainerResponseFilter;
import javax.ws.rs.ext.Provider;
import java.util.concurrent.atomic.AtomicInteger;

@Provider
public class ConnectionHeaderFilter implements ContainerResponseFilter {
    // 你可以自己调整这个阈值，比如改成你需要的几百次
    private static final int REQUEST_THRESHOLD = 500;
    // 必须用AtomicInteger，不然多请求并发计数会乱
    private final AtomicInteger requestCounter = new AtomicInteger(0);

    @Override
    public void filter(ContainerRequestContext reqCtx, ContainerResponseContext respCtx) {
        int currentCount = requestCounter.incrementAndGet();
        
        if (currentCount >= REQUEST_THRESHOLD) {
            // 达到阈值，强制返回Connection: close，然后重置计数器
            respCtx.getHeaders().putSingle("Connection", "close");
            requestCounter.set(0);
        } else {
            // 没到阈值，保持长连接
            respCtx.getHeaders().putSingle("Connection", "Keep-Alive");
        }
    }
}

步骤2：把过滤器注册到CXF #

两种注册方式，选你常用的：

• 代码配置（用JAXRSServerFactoryBean）：

  JAXRSServerFactoryBean server = new JAXRSServerFactoryBean();
  // 先设置你的服务地址、实现类这些基础配置
  server.setAddress("/your-service-path");
  server.setServiceBeans(List.of(new YourServiceImplementation()));
  // 把过滤器加进去
  server.getProviders().add(new ConnectionHeaderFilter());
  server.create();
  

• Spring XML配置：

  <jaxrs:server id="yourService" address="/your-service-path">
      <jaxrs:serviceBeans>
          <bean class="com.your.package.YourServiceImplementation"/>
      </jaxrs:serviceBeans>
      <jaxrs:providers>
          <bean class="com.your.package.ConnectionHeaderFilter"/>
      </jaxrs:providers>
  </jaxrs:server>
  

如果你需要更深入CXF的处理流程，比如在响应头写入前做更多操作，可以用CXF的原生拦截器：

步骤1：实现自定义OutInterceptor #

import org.apache.cxf.interceptor.Fault;
import org.apache.cxf.message.Message;
import org.apache.cxf.phase.AbstractPhaseInterceptor;
import org.apache.cxf.phase.Phase;
import java.util.concurrent.atomic.AtomicInteger;

public class ConnectionHeaderInterceptor extends AbstractPhaseInterceptor<Message> {
    private static final int REQUEST_THRESHOLD = 500;
    private final AtomicInteger requestCounter = new AtomicInteger(0);

    public ConnectionHeaderInterceptor() {
        // 选WRITE_RESPONSE_HEADERS阶段，刚好在写响应头之前处理
        super(Phase.WRITE_RESPONSE_HEADERS);
    }

    @Override
    public void handleMessage(Message message) throws Fault {
        int currentCount = requestCounter.incrementAndGet();
        
        // 获取CXF的响应头Map
        @SuppressWarnings("unchecked")
        java.util.Map<String, Object> headers = (java.util.Map<String, Object>) message.get(Message.PROTOCOL_HEADERS);
        
        if (currentCount >= REQUEST_THRESHOLD) {
            headers.put("Connection", java.util.Collections.singletonList("close"));
            requestCounter.set(0);
        } else {
            headers.put("Connection", java.util.Collections.singletonList("Keep-Alive"));
        }
    }
}

步骤2：注册拦截器到CXF #

同样两种方式：

• 代码配置：

  JAXRSServerFactoryBean server = new JAXRSServerFactoryBean();
  // 基础配置先搞定
  server.setAddress("/your-service-path");
  server.setServiceBeans(List.of(new YourServiceImplementation()));
  // 添加输出拦截器
  server.getOutInterceptors().add(new ConnectionHeaderInterceptor());
  server.create();
  

• Spring XML配置：

  <jaxrs:server id="yourService" address="/your-service-path">
      <jaxrs:serviceBeans>
          <bean class="com.your.package.YourServiceImplementation"/>
      </jaxrs:serviceBeans>
      <jaxrs:outInterceptors>
          <bean class="com.your.package.ConnectionHeaderInterceptor"/>
      </jaxrs:outInterceptors>
  </jaxrs:server>
  

• 线程安全绝对不能忘：一定要用AtomicInteger或者其他线程安全的计数工具，不然多请求并发时计数会乱套，阈值判断完全失效。
• 阈值要按需调整：别死磕几百次，根据你的流量大小、负载均衡器的特性，测试出最适合的数值——比如流量大的服务可以设到几千，流量小的设几百就行。
• 测试验证：用curl或者Postman多测几次，看看响应头是不是每隔N次就出现一次Connection: close，确保容器没覆盖你的设置（有些Servlet容器会自己管理Connection头，需要确认你的过滤器/拦截器优先级更高）。
• 分布式场景要特殊处理：如果你的服务是多实例部署，每个实例的计数器是独立的。要是需要全局计数（比如整个集群每N次请求就返回一次close），那得换成分布式计数器，比如用Redis来存计数。

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