Allows customizing the ObjectMapper in REST Client Reactive Jackson

The REST Client Reactive supports adding a custom ObjectMapper to be used only the Client using the annotation `@ClientObjectMapper`. 

A simple example is to provide a custom ObjectMapper to the REST Client Reactive Jackson extension by doing:

```java
@path("/extensions")
@RegisterRestClient
public interface ExtensionsService {

    @get
    Set<Extension> getById(@QueryParam("id") String id);

    @ClientObjectMapper <1>
    static ObjectMapper objectMapper(ObjectMapper defaultObjectMapper) { <2>
        return defaultObjectMapper.copy()
                .disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES)
                .disable(DeserializationFeature.UNWRAP_ROOT_VALUE);
    }
}
```

<1> The method must be annotated with `@ClientObjectMapper`.
<2> It's must be a static method. Also, the parameter `defaultObjectMapper` will be resolved via CDI. If not found, it will throw an exception at runtime.

Fix #23979

docs/src/main/asciidoc/rest-client-reactive.adoc

@@ -1101,6 +1101,34 @@ public class TestClientRequestFilter implements ResteasyReactiveClientRequestFil
 }
 ----
 
+== Customizing the ObjectMapper in REST Client Reactive Jackson
+
+The REST Client Reactive supports adding a custom ObjectMapper to be used only the Client using the annotation `@ClientObjectMapper`. 
+
+A simple example is to provide a custom ObjectMapper to the REST Client Reactive Jackson extension by doing:
+
+[source, java]
+----
+@Path("/extensions")
+@RegisterRestClient
+public interface ExtensionsService {
+
+ @GET
+ Set<Extension> getById(@QueryParam("id") String id);
+
+ @ClientObjectMapper <1>
+ static ObjectMapper objectMapper(ObjectMapper defaultObjectMapper) { <2>
+ return defaultObjectMapper.copy() <3>
+ .disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES)
+ .disable(DeserializationFeature.UNWRAP_ROOT_VALUE);
+ }
+}
+----
+
+<1> The method must be annotated with `@ClientObjectMapper`.
+<2> It's must be a static method. Also, the parameter `defaultObjectMapper` will be resolved via CDI. If not found, it will throw an exception at runtime.
+<3> In this example, we're creating a copy of the default object mapper. You should *NEVER* modify the default object mapper, but create a copy instead. 
+
 == Exception handling
 
 The MicroProfile REST Client specification introduces the `org.eclipse.microprofile.rest.client.ext.ResponseExceptionMapper` whose purpose is to convert an HTTP response to an exception.

extensions/resteasy-reactive/rest-client-reactive-jackson/deployment/src/main/java/io/quarkus/rest/client/reactive/jackson/deployment/RestClientReactiveJacksonProcessor.java

@@ -10,10 +10,16 @@
 import jakarta.ws.rs.RuntimeType;
 import jakarta.ws.rs.core.MediaType;
 
+import org.jboss.jandex.DotName;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+
 import io.quarkus.arc.deployment.AdditionalBeanBuildItem;
 import io.quarkus.deployment.annotations.BuildProducer;
 import io.quarkus.deployment.annotations.BuildStep;
 import io.quarkus.deployment.builditem.FeatureBuildItem;
+import io.quarkus.rest.client.reactive.deployment.AnnotationToRegisterIntoClientContextBuildItem;
+import io.quarkus.rest.client.reactive.jackson.ClientObjectMapper;
 import io.quarkus.rest.client.reactive.jackson.runtime.serialisers.ClientJacksonMessageBodyReader;
 import io.quarkus.rest.client.reactive.jackson.runtime.serialisers.ClientJacksonMessageBodyWriter;
 import io.quarkus.resteasy.reactive.jackson.deployment.processor.ResteasyReactiveJacksonProviderDefinedBuildItem;
@@ -43,6 +49,12 @@ ReinitializeVertxJsonBuildItem vertxJson() {
  return new ReinitializeVertxJsonBuildItem();
  }
 
+ @BuildStep
+ void additionalProviders(BuildProducer<AnnotationToRegisterIntoClientContextBuildItem> annotation) {
+ annotation.produce(new AnnotationToRegisterIntoClientContextBuildItem(DotName.createSimple(ClientObjectMapper.class),
+ ObjectMapper.class));
+ }
+
  @BuildStep
  void additionalProviders(
  List<ResteasyReactiveJacksonProviderDefinedBuildItem> jacksonProviderDefined,

extensions/resteasy-reactive/rest-client-reactive-jackson/deployment/src/test/java/io/quarkus/rest/client/reactive/jackson/test/DifferentObjectMapperForClientAndServerTest.java

@@ -30,6 +30,7 @@
 
 import io.quarkus.jackson.ObjectMapperCustomizer;
 import io.quarkus.rest.client.reactive.QuarkusRestClientBuilder;
+import io.quarkus.rest.client.reactive.jackson.ClientObjectMapper;
 import io.quarkus.test.QuarkusUnitTest;
 import io.quarkus.test.common.http.TestHTTPResource;
 
@@ -76,15 +77,15 @@ void shouldClientUseCustomObjectMapperUnwrappingRootElement() {
  }
 
  /**
- * Because MyClientNotUnwrappingRootElement is using `@RegisterProvider(ClientObjectMapperNotUnwrappingRootElement.class)`
+ * Because MyClientNotUnwrappingRootElement uses `@ClientObjectMapper`
  * which is configured with: `.disable(DeserializationFeature.UNWRAP_ROOT_VALUE)`.
  */
  @Test
  void shouldClientUseCustomObjectMapperNotUnwrappingRootElement() {
- assertFalse(ClientObjectMapperNotUnwrappingRootElement.USED.get());
+ assertFalse(MyClientNotUnwrappingRootElement.CUSTOM_OBJECT_MAPPER_USED.get());
  Request request = clientNotUnwrappingRootElement.get();
  assertNull(request.value);
- assertTrue(ClientObjectMapperNotUnwrappingRootElement.USED.get());
+ assertTrue(MyClientNotUnwrappingRootElement.CUSTOM_OBJECT_MAPPER_USED.get());
  }
 
  @Path("/server")
@@ -106,10 +107,19 @@ public interface MyClientUnwrappingRootElement {
 
  @Path("/server")
  @Produces(MediaType.APPLICATION_JSON)
- @RegisterProvider(ClientObjectMapperNotUnwrappingRootElement.class)
  public interface MyClientNotUnwrappingRootElement {
+ AtomicBoolean CUSTOM_OBJECT_MAPPER_USED = new AtomicBoolean(false);
+
  @GET
  Request get();
+
+ @ClientObjectMapper
+ static ObjectMapper objectMapper(ObjectMapper defaultObjectMapper) {
+ CUSTOM_OBJECT_MAPPER_USED.set(true);
+ return defaultObjectMapper.copy()
+ .disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES)
+ .disable(DeserializationFeature.UNWRAP_ROOT_VALUE);
+ }
  }
 
  public static class Request {
@@ -157,19 +167,6 @@ public ObjectMapper getContext(Class<?> type) {
  }
  }
 
- public static class ClientObjectMapperNotUnwrappingRootElement implements ContextResolver<ObjectMapper> {
-
- static final AtomicBoolean USED = new AtomicBoolean(false);
-
- @Override
- public ObjectMapper getContext(Class<?> type) {
- USED.set(true);
- return new ObjectMapper()
- .disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES)
- .disable(DeserializationFeature.UNWRAP_ROOT_VALUE);
- }
- }
-
  @Singleton
  public static class ServerCustomObjectMapperDisallowUnknownProperties implements ObjectMapperCustomizer {
 

extensions/resteasy-reactive/rest-client-reactive-jackson/runtime/src/main/java/io/quarkus/rest/client/reactive/jackson/ClientObjectMapper.java

@@ -0,0 +1,48 @@
+package io.quarkus.rest.client.reactive.jackson;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Used to easily define a custom object mapper for the specific REST Client on which it's used.
+ *
+ * The annotation MUST be placed on a method of the REST Client interface that meets the following criteria:
+ * <ul>
+ * <li>Is a {@code static} method</li>
+ * </ul>
+ *
+ * An example method could look like the following:
+ *
+ * <pre>
+ * {@code
+ * &#64;ClientObjectMapper
+ * static ObjectMapper objectMapper() {
+ * return new ObjectMapper();
+ * }
+ *
+ * }
+ * </pre>
+ *
+ * Moreover, we can inject the default ObjectMapper instance to create a copy of it by doing:
+ *
+ * <pre>
+ * {@code
+ * &#64;ClientObjectMapper
+ * static ObjectMapper objectMapper(ObjectMapper defaultObjectMapper) {
+ * return defaultObjectMapper.copy() <3>
+ * .disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES)
+ * .disable(DeserializationFeature.UNWRAP_ROOT_VALUE);
+ * }
+ *
+ * }
+ * </pre>
+ *
+ * Remember that the default object mapper instance should NEVER be modified, but instead always use copy if they pan to
+ * inherit the default settings.
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.METHOD)
+public @interface ClientObjectMapper {
+}

extensions/resteasy-reactive/rest-client-reactive/deployment/src/main/java/io/quarkus/rest/client/reactive/deployment/AnnotationToRegisterIntoClientContextBuildItem.java

@@ -0,0 +1,27 @@
+package io.quarkus.rest.client.reactive.deployment;
+
+import org.jboss.jandex.DotName;
+
+import io.quarkus.builder.item.MultiBuildItem;
+
+/**
+ * A Build Item that is used to register annotations that are used by the client to register services into the client context.
+ */
+public final class AnnotationToRegisterIntoClientContextBuildItem extends MultiBuildItem {
+
+ private final DotName annotation;
+ private final Class<?> expectedReturnType;
+
+ public AnnotationToRegisterIntoClientContextBuildItem(DotName annotation, Class<?> expectedReturnType) {
+ this.annotation = annotation;
+ this.expectedReturnType = expectedReturnType;
+ }
+
+ public DotName getAnnotation() {
+ return annotation;
+ }
+
+ public Class<?> getExpectedReturnType() {
+ return expectedReturnType;
+ }
+}

extensions/resteasy-reactive/rest-client-reactive/deployment/src/main/java/io/quarkus/rest/client/reactive/deployment/ClientContextResolverHandler.java

@@ -0,0 +1,183 @@
+package io.quarkus.rest.client.reactive.deployment;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.LinkedHashMap;
+
+import jakarta.ws.rs.Priorities;
+
+import org.jboss.jandex.AnnotationInstance;
+import org.jboss.jandex.AnnotationTarget;
+import org.jboss.jandex.AnnotationValue;
+import org.jboss.jandex.ClassInfo;
+import org.jboss.jandex.DotName;
+import org.jboss.jandex.MethodInfo;
+import org.jboss.jandex.Type;
+import org.jboss.resteasy.reactive.client.impl.RestClientRequestContext;
+
+import io.quarkus.arc.Arc;
+import io.quarkus.arc.ArcContainer;
+import io.quarkus.arc.InstanceHandle;
+import io.quarkus.gizmo.ClassCreator;
+import io.quarkus.gizmo.ClassOutput;
+import io.quarkus.gizmo.MethodCreator;
+import io.quarkus.gizmo.MethodDescriptor;
+import io.quarkus.gizmo.ResultHandle;
+import io.quarkus.gizmo.SignatureBuilder;
+import io.quarkus.rest.client.reactive.runtime.ResteasyReactiveContextResolver;
+import io.quarkus.runtime.util.HashUtil;
+
+/**
+ * Generates an implementation of {@link ResteasyReactiveContextResolver}
+ *
+ * The extension will search for methods annotated with a special annotation like `@ClientObjectMapper` (if the REST Client
+ * Jackson extension is present) and create the context resolver to register a custom object into the client context like the
+ * ObjectMapper instance.
+ */
+class ClientContextResolverHandler {
+
+ private static final String[] EMPTY_STRING_ARRAY = new String[0];
+ private static final ResultHandle[] EMPTY_RESULT_HANDLES_ARRAY = new ResultHandle[0];
+ private static final MethodDescriptor GET_INVOKED_METHOD =
+ MethodDescriptor.ofMethod(RestClientRequestContext.class, "getInvokedMethod", Method.class);
+
+ private final DotName annotation;
+ private final Class<?> expectedReturnType;
+ private final ClassOutput classOutput;
+
+ ClientContextResolverHandler(DotName annotation, Class<?> expectedReturnType, ClassOutput classOutput) {
+ this.annotation = annotation;
+ this.expectedReturnType = expectedReturnType;
+ this.classOutput = classOutput;
+ }
+
+ /**
+ * Generates an implementation of {@link ResteasyReactiveContextResolver} that looks something like:
+ *
+ * <pre>
+ * {@code
+ * public class SomeService_map_ContextResolver_a8fb70beeef2a54b80151484d109618eed381626
+ * implements ResteasyReactiveContextResolver<T> {
+ *
+ * public T getContext(Class<?> type) {
+ * // simply call the static method of interface
+ * return SomeService.map(var1);
+ * }
+ *
+ * }
+ * </pre>
+ */
+ GeneratedClassResult generateContextResolver(AnnotationInstance instance) {
+ if (!annotation.equals(instance.name())) {
+ throw new IllegalArgumentException(
+ "'clientContextResolverInstance' must be an instance of " + annotation);
+ }
+ MethodInfo targetMethod = findTargetMethod(instance);
+ if (targetMethod == null) {
+ return null;
+ }
+
+ int priority = Priorities.USER;
+ AnnotationValue priorityAnnotationValue = instance.value("priority");
+ if (priorityAnnotationValue != null) {
+ priority = priorityAnnotationValue.asInt();
+ }
+
+ Class<?> returnTypeClassName = lookupReturnClass(targetMethod);
+ if (!expectedReturnType.isAssignableFrom(returnTypeClassName)) {
+ throw new IllegalStateException(annotation
+ + " is only supported on static methods of REST Client interfaces that return '" + expectedReturnType + "'."
+ + " Offending instance is '" + targetMethod.declaringClass().name().toString() + "#"
+ + targetMethod.name() + "'");
+ }
+
+ ClassInfo restClientInterfaceClassInfo = targetMethod.declaringClass();
+ String generatedClassName = getGeneratedClassName(targetMethod);
+ try (ClassCreator cc = ClassCreator.builder().classOutput(classOutput).className(generatedClassName)
+ .signature(SignatureBuilder.forClass().addInterface(io.quarkus.gizmo.Type.parameterizedType(io.quarkus.gizmo.Type.classType(ResteasyReactiveContextResolver.class), io.quarkus.gizmo.Type.classType(returnTypeClassName))))
+ .build()) {
+ MethodCreator getContext = cc.getMethodCreator("getContext", Object.class, Class.class);
+ LinkedHashMap<String, ResultHandle> targetMethodParams = new LinkedHashMap<>();
+ for (Type paramType : targetMethod.parameterTypes()) {
+ ResultHandle targetMethodParamHandle;
+ if (paramType.name().equals(DotNames.METHOD)) {
+ targetMethodParamHandle = getContext.invokeVirtualMethod(GET_INVOKED_METHOD, getContext.getMethodParam(1));
+ } else {
+ targetMethodParamHandle = getFromCDI(getContext, targetMethod.returnType().name().toString());
+ }
+
+ targetMethodParams.put(paramType.name().toString(), targetMethodParamHandle);
+ }
+
+ ResultHandle resultHandle = getContext.invokeStaticInterfaceMethod(
+ MethodDescriptor.ofMethod(
+ restClientInterfaceClassInfo.name().toString(),
+ targetMethod.name(),
+ targetMethod.returnType().name().toString(),
+ targetMethodParams.keySet().toArray(EMPTY_STRING_ARRAY)),
+ targetMethodParams.values().toArray(EMPTY_RESULT_HANDLES_ARRAY));
+ getContext.returnValue(resultHandle);
+ }
+
+ return new GeneratedClassResult(restClientInterfaceClassInfo.name().toString(), generatedClassName, priority);
+ }
+
+ private MethodInfo findTargetMethod(AnnotationInstance instance) {
+ MethodInfo targetMethod = null;
+ if (instance.target().kind() == AnnotationTarget.Kind.METHOD) {
+ targetMethod = instance.target().asMethod();
+ if (ignoreAnnotation(targetMethod)) {
+ return null;
+ }
+ if ((targetMethod.flags() & Modifier.STATIC) != 0) {
+ if (targetMethod.returnType().kind() == Type.Kind.VOID) {
+ throw new IllegalStateException(annotation
+ + " is only supported on static methods of REST Client interfaces that return an object."
+ + " Offending instance is '" + targetMethod.declaringClass().name().toString() + "#"
+ + targetMethod.name() + "'");
+ }
+
+
+ }
+ }
+
+ return targetMethod;
+ }
+
+ private static Class<?> lookupReturnClass(MethodInfo targetMethod) {
+ Class<?> returnTypeClassName = null;
+ try {
+ returnTypeClassName = Class.forName(targetMethod.returnType().name().toString(), false, Thread.currentThread().getContextClassLoader());
+ } catch (ClassNotFoundException ignored) {
+
+ }
+ return returnTypeClassName;
+ }
+
+ private static ResultHandle getFromCDI(MethodCreator getContext, String className) {
+ ResultHandle containerHandle = getContext
+ .invokeStaticMethod(MethodDescriptor.ofMethod(Arc.class, "container", ArcContainer.class));
+ ResultHandle instanceHandle = getContext.invokeInterfaceMethod(MethodDescriptor.ofMethod(ArcContainer.class, "instance", InstanceHandle.class, Class.class, Annotation[].class),
+ containerHandle, getContext.loadClassFromTCCL(className),
+ getContext.newArray(Annotation.class, 0));
+ return getContext.invokeInterfaceMethod(MethodDescriptor.ofMethod(InstanceHandle.class, "get", Object.class), instanceHandle);
+ }
+
+ public static String getGeneratedClassName(MethodInfo methodInfo) {
+ StringBuilder sigBuilder = new StringBuilder();
+ sigBuilder.append(methodInfo.name()).append("_").append(methodInfo.returnType().name().toString());
+ for (Type i : methodInfo.parameterTypes()) {
+ sigBuilder.append(i.name().toString());
+ }
+
+ return methodInfo.declaringClass().name().toString() + "_" + methodInfo.name() + "_"
+ + "ContextResolver" + "_" + HashUtil.sha1(sigBuilder.toString());
+ }
+
+ private static boolean ignoreAnnotation(MethodInfo methodInfo) {
+ // ignore the annotation if it's placed on a Kotlin companion class
+ // this is not a problem since the Kotlin compiler will also place the annotation the static method interface method
+ return methodInfo.declaringClass().name().toString().contains("$Companion");
+ }
+}