Redefine Jakarta module.

Author: arturobernalg

httpclient5-jakarta-rest-client/pom.xml

@@ -50,6 +50,14 @@
       <groupId>jakarta.ws.rs</groupId>
       <artifactId>jakarta.ws.rs-api</artifactId>
     </dependency>
+    <dependency>
+      <groupId>org.apache.httpcomponents.core5</groupId>
+      <artifactId>httpcore5-jackson2</artifactId>
+    </dependency>
+    <dependency>
+      <groupId>com.fasterxml.jackson.core</groupId>
+      <artifactId>jackson-databind</artifactId>
+    </dependency>
     <dependency>
       <groupId>org.junit.jupiter</groupId>
       <artifactId>junit-jupiter</artifactId>

httpclient5-jakarta-rest-client/src/main/java/org/apache/hc/client5/http/rest/ClientResourceMethod.java

@@ -59,14 +59,12 @@ static final class ParamInfo {
 
         private final ParamSource source;
         private final String name;
-        private final Class<?> type;
         private final String defaultValue;
 
         ParamInfo(final ParamSource paramSource, final String paramName,
-                  final Class<?> paramType, final String defValue) {
+                  final String defValue) {
             this.source = paramSource;
             this.name = paramName;
-            this.type = paramType;
             this.defaultValue = defValue;
         }
 
@@ -78,10 +76,6 @@ String getName() {
             return name;
         }
 
-        Class<?> getType() {
-            return type;
-        }
-
         String getDefaultValue() {
             return defaultValue;
         }
@@ -196,8 +190,7 @@ static List<ClientResourceMethod> scan(final Class<?> iface) {
 
             final ParamInfo[] params = scanParameters(m);
             validatePathParams(m, combinedPath, params);
-            validateReturnType(m);
-            validateBodyTypes(m, params);
+            validateConsumes(m, cons, params);
             final String strippedPath = stripRegex(combinedPath);
             result.add(new ClientResourceMethod(m, verb, strippedPath, prod, cons, params));
         }
@@ -215,12 +208,11 @@ private static String resolveHttpMethod(final Method m) {
     }
 
     private static ParamInfo[] scanParameters(final Method m) {
-        final Class<?>[] types = m.getParameterTypes();
         final Annotation[][] annotations = m.getParameterAnnotations();
-        final ParamInfo[] result = new ParamInfo[types.length];
+        final ParamInfo[] result = new ParamInfo[annotations.length];
         int bodyCount = 0;
-        for (int i = 0; i < types.length; i++) {
-            result[i] = resolveParam(types[i], annotations[i]);
+        for (int i = 0; i < annotations.length; i++) {
+            result[i] = resolveParam(annotations[i]);
             if (result[i].getSource() == ParamSource.BODY) {
                 bodyCount++;
             }
@@ -233,8 +225,7 @@ private static ParamInfo[] scanParameters(final Method m) {
         return result;
     }
 
-    private static ParamInfo resolveParam(final Class<?> type,
-                                          final Annotation[] annotations) {
+    private static ParamInfo resolveParam(final Annotation[] annotations) {
         String defVal = null;
         for (final Annotation a : annotations) {
             if (a instanceof DefaultValue) {
@@ -243,16 +234,16 @@ private static ParamInfo resolveParam(final Class<?> type,
         }
         for (final Annotation a : annotations) {
             if (a instanceof PathParam) {
-                return new ParamInfo(ParamSource.PATH, ((PathParam) a).value(), type, defVal);
+                return new ParamInfo(ParamSource.PATH, ((PathParam) a).value(), defVal);
             }
             if (a instanceof QueryParam) {
-                return new ParamInfo(ParamSource.QUERY, ((QueryParam) a).value(), type, defVal);
+                return new ParamInfo(ParamSource.QUERY, ((QueryParam) a).value(), defVal);
             }
             if (a instanceof HeaderParam) {
-                return new ParamInfo(ParamSource.HEADER, ((HeaderParam) a).value(), type, defVal);
+                return new ParamInfo(ParamSource.HEADER, ((HeaderParam) a).value(), defVal);
             }
         }
-        return new ParamInfo(ParamSource.BODY, null, type, null);
+        return new ParamInfo(ParamSource.BODY, null, null);
     }
 
     private static void validatePathParams(final Method m, final String path,
@@ -280,27 +271,17 @@ private static void validatePathParams(final Method m, final String path,
         }
     }
 
-    private static void validateReturnType(final Method m) {
-        final Class<?> rt = m.getReturnType();
-        if (rt != void.class && rt != Void.class
-                && rt != String.class && rt != byte[].class) {
-            throw new IllegalStateException("Method " + m.getName()
-                    + ": return type " + rt.getName() + " is not supported;"
-                    + " only void, String and byte[] are allowed");
+    private static void validateConsumes(final Method m,
+                                            final String[] consumes,
+                                            final ParamInfo[] params) {
+        if (consumes.length <= 1) {
+            return;
         }
-    }
-
-    private static void validateBodyTypes(final Method m,
-                                          final ParamInfo[] params) {
         for (final ParamInfo pi : params) {
             if (pi.getSource() == ParamSource.BODY) {
-                final Class<?> bt = pi.getType();
-                if (bt != String.class && bt != byte[].class) {
-                    throw new IllegalStateException("Method " + m.getName()
-                            + ": body parameter type " + bt.getName()
-                            + " is not supported;"
-                            + " only String and byte[] are allowed");
-                }
+                throw new IllegalStateException("Method " + m.getName()
+                        + " has a request body and multiple @Consumes"
+                        + " values; exactly one is required");
             }
         }
     }

httpclient5-jakarta-rest-client/src/main/java/org/apache/hc/client5/http/rest/RestClientBuilder.java

@@ -33,37 +33,43 @@
 import java.util.List;
 import java.util.Map;
 
-import org.apache.hc.client5.http.classic.HttpClient;
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient;
 import org.apache.hc.core5.util.Args;
 
 /**
  * Builds type-safe REST client proxies from Jakarta REST annotated interfaces. The proxy
- * translates each method call into an HTTP request executed through the classic
- * {@link HttpClient} transport.
+ * translates each method call into an HTTP request executed through the async
+ * {@link CloseableHttpAsyncClient} transport, which supports both HTTP/1.1 and HTTP/2.
  *
  * <p>Minimal usage:</p>
  * <pre>
- * try (CloseableHttpClient client = HttpClients.createDefault()) {
+ * try (CloseableHttpAsyncClient client = HttpAsyncClients.createDefault()) {
+ *     client.start();
  *     UserApi api = RestClientBuilder.newBuilder()
- *             .baseUri("http://api.example.com")
+ *             .baseUri("<a href="http://api.example.com">...</a>")
  *             .httpClient(client)
  *             .build(UserApi.class);
  *     String json = api.getUser(42);
  * }
  * </pre>
  *
  * <p>Both {@code baseUri} and {@code httpClient} are required. The caller owns the
- * client lifecycle.</p>
+ * client lifecycle, including the call to {@code start()} before use.</p>
  *
- * <p>Methods may return {@code String}, {@code byte[]}, or {@code void}. Non-2xx
- * responses throw {@link RestClientResponseException}.</p>
+ * <p>Methods may return {@code String}, {@code byte[]}, {@code void}, or any type
+ * deserializable by the configured Jackson {@link ObjectMapper}. Request bodies may be
+ * {@code String}, {@code byte[]}, or any type serializable by the ObjectMapper.
+ * Non-2xx responses throw {@link RestClientResponseException}.</p>
  *
  * @since 5.7
  */
 public final class RestClientBuilder {
 
     private URI baseUri;
-    private HttpClient httpClient;
+    private CloseableHttpAsyncClient httpClient;
+    private ObjectMapper objectMapper;
 
     private RestClientBuilder() {
     }
@@ -102,21 +108,36 @@ public RestClientBuilder baseUri(final URI uri) {
     }
 
     /**
-     * Sets the {@link HttpClient} to use for requests. The caller owns the client
-     * lifecycle.
+     * Sets the async HTTP client to use for requests. The caller owns the client
+     * lifecycle, including the call to {@link CloseableHttpAsyncClient#start()}.
      *
-     * @param client the HTTP client, must not be {@code null}.
+     * @param client the async HTTP client, must not be {@code null}.
      * @return this builder for chaining.
+     * @since 5.7
      */
-    public RestClientBuilder httpClient(final HttpClient client) {
+    public RestClientBuilder httpClient(final CloseableHttpAsyncClient client) {
         Args.notNull(client, "HTTP client");
         this.httpClient = client;
         return this;
     }
 
+    /**
+     * Sets the Jackson {@link ObjectMapper} for JSON serialization and deserialization.
+     * If not set, a default ObjectMapper is used.
+     *
+     * @param mapper the object mapper, must not be {@code null}.
+     * @return this builder for chaining.
+     * @since 5.7
+     */
+    public RestClientBuilder objectMapper(final ObjectMapper mapper) {
+        Args.notNull(mapper, "Object mapper");
+        this.objectMapper = mapper;
+        return this;
+    }
+
     /**
      * Scans the given interface for Jakarta REST annotations and creates a proxy that
-     * implements it by dispatching HTTP requests through the configured client.
+     * implements it by dispatching HTTP requests through the configured async client.
      *
      * @param <T>   the interface type.
      * @param iface the Jakarta REST annotated interface class.
@@ -140,18 +161,22 @@ public <T> T build(final Class<T> iface) {
 
         final List<ClientResourceMethod> methods = ClientResourceMethod.scan(iface);
         if (methods.isEmpty()) {
-            throw new IllegalStateException("No Jakarta REST methods found on " + iface.getName());
+            throw new IllegalStateException(
+                    "No Jakarta REST methods found on " + iface.getName());
         }
         final Map<Method, ClientResourceMethod> methodMap =
                 new HashMap<>(methods.size());
         for (final ClientResourceMethod rm : methods) {
             methodMap.put(rm.getMethod(), rm);
         }
 
+        final ObjectMapper mapper = objectMapper != null
+                ? objectMapper : new ObjectMapper();
+
         return (T) Proxy.newProxyInstance(
                 iface.getClassLoader(),
                 new Class<?>[]{iface},
-                new RestInvocationHandler(httpClient, baseUri, methodMap));
+                new RestInvocationHandler(httpClient, baseUri, methodMap, mapper));
     }
 
 }