Apache CXF这类JAX-RS Client实现与MicroProfile Rest Client的差异对比

Great question! Let's break down the core differences between these two tools for consuming REST APIs—they solve similar problems but approach them from distinct angles, with different strengths for different use cases.

1. Core Design & Scope #

• Apache CXF JAX-RS Client: This is a component of the full-featured Apache CXF framework, which supports both SOAP and REST services. It's a general-purpose implementation of the JAX-RS specification (JSR-311, JSR-339, etc.), designed to work either independently or alongside CXF's REST/SOAP server components. It prioritizes flexibility and broad feature coverage.
• MicroProfile Rest Client: This is part of the MicroProfile specification, focused specifically on simplifying REST client development for cloud-native and microservices environments. It builds on JAX-RS annotations but adds declarative, standards-based abstractions, and is tightly integrated with the broader MicroProfile ecosystem (like Config, Fault Tolerance, and Metrics).

2. Programming Model #

Apache CXF JAX-RS Client #

Offers two distinct approaches, balancing flexibility and convenience:

• Low-level API: Uses WebClient for manual request building and response handling—great for one-off or highly customized calls, but requires more boilerplate.

  // Example of low-level WebClient usage
  WebClient client = WebClient.create("http://example.com/api");
  String userJson = client.path("/users/123")
                          .accept(MediaType.APPLICATION_JSON)
                          .get(String.class);
  

• Proxy-based approach: Creates a proxy from a JAX-RS annotated interface, but requires explicit setup via JAXRSClientFactory.

  // Example of proxy creation with CXF
  UserApi userApi = JAXRSClientFactory.create("http://example.com/api", UserApi.class);
  User user = userApi.getUser(123);
  

MicroProfile Rest Client #

Strictly declarative and proxy-focused, with minimal boilerplate:

• Define a JAX-RS annotated interface, then inject or build a proxy instance—no manual factory setup needed.
• Supports configuration via MicroProfile Config (e.g., override base URI, timeouts via properties files or environment variables).

  // Declarative client interface
  @RegisterRestClient(baseUri = "http://example.com/api")
  public interface UserApi {
      @GET
      @Path("/users/{id}")
      User getUser(@PathParam("id") int id);
  }
  
  // Usage via CDI injection
  @Inject
  @RestClient
  private UserApi userApi;
  
  // Or manual builder setup
  UserApi api = RestClientBuilder.newBuilder()
                                 .baseUri(URI.create("http://example.com/api"))
                                 .build(UserApi.class);
  

3. Ecosystem Integration #

• Apache CXF JAX-RS Client: Integrates with Spring, Jakarta EE, and other enterprise frameworks, but doesn't have native support for MicroProfile features. To use things like fault tolerance or centralized config, you'll need to add extra extensions or manual wiring.
• MicroProfile Rest Client: Built for tight integration with MicroProfile specs:
  • Use @ConfigProperty or external config files to override client settings without code changes.
  • Add fault tolerance directly to client interfaces with annotations like @Retry or @CircuitBreaker (via MicroProfile Fault Tolerance).
  • Automatically collect metrics for client calls (via MicroProfile Metrics).
  • Propagate JWT tokens across services (via MicroProfile JWT Propagation).

4. Standardization & Portability #

• Apache CXF JAX-RS Client: Implements the JAX-RS standard but includes proprietary extensions (like WebClient's unique methods). Code using these extensions won't be portable to other JAX-RS clients (e.g., Jersey).
• MicroProfile Rest Client: Is a specification, not just an implementation. Multiple vendors (Quarkus, OpenLiberty, even Apache CXF itself) offer compliant implementations. If you stick to the standard API, you can migrate your client code between any MicroProfile-compatible runtime without modifications.

5. Feature Set & Footprint #

• Apache CXF JAX-RS Client: Offers a broader set of advanced features, including SOAP/REST hybrid support, WS-* protocol compatibility, custom interceptor chains, detailed message logging, and multiple OAuth2 integration options. It's a heavier-weight solution, ideal for complex enterprise scenarios.
• MicroProfile Rest Client: Focuses on lightweight, cloud-native features. It's simpler, has a smaller footprint, and prioritizes ease of use in microservices. While it supports interceptors and basic auth, it lacks some of CXF's more niche enterprise features.

Summary #

• Choose Apache CXF JAX-RS Client if you need a flexible, full-featured client with deep integration into CXF's ecosystem, or if you're working in a traditional enterprise environment with SOAP/REST hybrid needs.
• Choose MicroProfile Rest Client if you want a declarative, portable, cloud-native client that seamlessly integrates with MicroProfile's config, fault tolerance, and metrics tools—perfect for microservices and modern Java applications.

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