好问题！确实，JAX-RS原生的Response或者Resteasy的@ResponseObject都没法同时满足服务端实现和客户端代理的类型安全需求。不过你可以通过自定义一个通用的类型安全响应包装类来解决这个问题，下面是具体的实现方案：

1. 定义通用响应包装类 #

首先创建一个普通POJO，用来封装HTTP状态码、响应头和业务数据。这个类可以灵活扩展，覆盖你需要的所有HTTP元数据：

import javax.ws.rs.core.MultivaluedHashMap;
import javax.ws.rs.core.MultivaluedMap;
import javax.ws.rs.core.Response;

public class TypedResponse<T> {
    private int status;
    private MultivaluedMap<String, String> headers;
    private T body;

    // 全参数构造方法
    public TypedResponse(int status, MultivaluedMap<String, String> headers, T body) {
        this.status = status;
        this.headers = headers;
        this.body = body;
    }

    // 便捷构造方法：快速返回成功响应
    public static <T> TypedResponse<T> ok(T body) {
        return new TypedResponse<>(Response.Status.OK.getStatusCode(), new MultivaluedHashMap<>(), body);
    }

    // 便捷构造方法：快速返回错误响应
    public static <T> TypedResponse<T> badRequest(String message) {
        return new TypedResponse<>(Response.Status.BAD_REQUEST.getStatusCode(), new MultivaluedHashMap<>(), (T) message);
    }

    // Getter方法
    public int getStatus() {
        return status;
    }

    public MultivaluedMap<String, String> getHeaders() {
        return headers;
    }

    public T getBody() {
        return body;
    }
}

2. 修改JAX-RS接口使用自定义响应类 #

把接口的返回类型替换为TypedResponse<T>，保留原有JAX-RS注解即可：

import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;
import java.util.List;

@Path("/foo")
public interface FooRestService {
    // DTO类保持不变
    class Foo {
        private String id;
        private String name;

        public Foo() {}
        public Foo(String id, String name) {
            this.id = id;
            this.name = name;
        }

        // Getter/Setter
        public String getId() { return id; }
        public void setId(String id) { this.id = id; }
        public String getName() { return name; }
        public void setName(String name) { this.name = name; }
    }

    @GET
    @Produces(MediaType.APPLICATION_JSON)
    @Path("/list")
    TypedResponse<List<Foo>> list();
}

3. 服务端实现：轻松返回带元数据的响应 #

服务端实现接口时，直接返回TypedResponse，可以自由设置状态码、响应头和业务数据，完全符合类型安全要求：

import javax.ws.rs.core.HttpHeaders;
import javax.ws.rs.core.MultivaluedHashMap;
import javax.ws.rs.core.MultivaluedMap;
import javax.ws.rs.core.Context;
import java.util.Arrays;
import java.util.List;

public class FooRestServiceImpl implements FooRestService {
    @Context
    private HttpHeaders requestHeaders; // 可选：获取请求头信息

    @Override
    public TypedResponse<List<Foo>> list() {
        // 模拟业务逻辑获取数据
        List<Foo> fooList = Arrays.asList(new Foo("1", "Foo1"), new Foo("2", "Foo2"));

        // 设置自定义响应头
        MultivaluedMap<String, String> responseHeaders = new MultivaluedHashMap<>();
        responseHeaders.add("X-Total-Count", String.valueOf(fooList.size()));

        // 返回完整响应
        return new TypedResponse<>(200, responseHeaders, fooList);
        // 异常场景示例：return TypedResponse.badRequest("Invalid parameters");
    }
}

4. 客户端代理：类型安全获取所有响应信息 #

客户端使用Resteasy代理时，直接接收TypedResponse，不需要手动解析Response或使用GenericType，全程类型安全：

import org.jboss.resteasy.client.jaxrs.ResteasyClientBuilder;
import java.util.List;

public class FooClient {
    public static void main(String[] args) {
        FooRestService service = new ResteasyClientBuilder().build()
                .proxy(FooRestService.class, "http://localhost:8080");

        // 直接获取类型安全的响应
        TypedResponse<List<FooRestService.Foo>> response = service.list();

        // 读取所有信息，无需类型转换
        int statusCode = response.getStatus();
        String totalCount = response.getHeaders().getFirst("X-Total-Count");
        List<FooRestService.Foo> foos = response.getBody();

        System.out.println("Status Code: " + statusCode);
        System.out.println("Total Items: " + totalCount);
        System.out.println("Fetched Foos: " + foos);
    }
}

方案优势 #

• 双向兼容：既可以在服务端作为返回类型实现，也能在客户端代理中类型安全使用。
• 灵活性：可以根据需求扩展TypedResponse，比如添加Cookie、响应时间等更多元数据。
• 无额外依赖：基于JAX-RS标准API实现，不需要依赖特定框架的私有注解（比如@ResponseObject）。

注意事项 #

• 确保你的JSON序列化库（比如Jackson）支持MultivaluedMap的序列化/反序列化，主流库都能完美支持。
• 如果需要更底层的Response控制（比如设置响应流），可以配合WriterInterceptor将TypedResponse转换为标准Response，但普通场景下不需要这么复杂。

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