Merge pull request #31782 from mkouba/synthetic-bean-build-item-proxy

Synthetic beans - make it possible to use a recorded proxy directly

Author: Ladicek

docs/src/main/asciidoc/cdi-integration.adoc

@@ -286,7 +286,7 @@ You can:
 
 1. Generate the bytecode of the `Contextual#create(CreationalContext<T>)` method directly via `ExtendedBeanConfigurator.creator(Consumer<MethodCreator>)`.
 2. Pass a subclass of `io.quarkus.arc.BeanCreator` via `ExtendedBeanConfigurator#creator(Class<? extends BeanCreator<U>>)`, and possibly specify some build-time parameters via `ExtendedBeanConfigurator#param()` and synthetic injection points via `ExtendedBeanConfigurator#addInjectionPoint()`.
-3. Produce the runtime instance through a proxy returned from a <<writing-extensions.adoc#bytecode-recording,`@Recorder` method>> and set it via `ExtendedBeanConfigurator#runtimeValue(RuntimeValue<?>)`, `ExtendedBeanConfigurator#supplier(Supplier<?>)` or `ExtendedBeanConfigurator#createWith(Function<SyntheticCreationalContext<?>, <?>)`.
+3. Produce the runtime instance through a proxy returned from a <<writing-extensions.adoc#bytecode-recording,`@Recorder` method>> and set it via `ExtendedBeanConfigurator#runtimeValue(RuntimeValue<?>)`, `ExtendedBeanConfigurator#runtimeProxy(Object)`,  `ExtendedBeanConfigurator#supplier(Supplier<?>)` or `ExtendedBeanConfigurator#createWith(Function<SyntheticCreationalContext<?>, <?>)`.
 
 .`SyntheticBeanBuildItem` Example 2
 [source,java]

extensions/arc/deployment/src/main/java/io/quarkus/arc/deployment/SyntheticBeanBuildItem.java

@@ -7,19 +7,22 @@
 
 import org.jboss.jandex.AnnotationInstance;
 import org.jboss.jandex.DotName;
+import org.jboss.jandex.Type;
 
 import io.quarkus.arc.SyntheticCreationalContext;
 import io.quarkus.arc.processor.BeanConfiguratorBase;
 import io.quarkus.arc.processor.BeanRegistrar;
 import io.quarkus.builder.item.MultiBuildItem;
 import io.quarkus.deployment.annotations.ExecutionTime;
+import io.quarkus.deployment.recording.BytecodeRecorderImpl.ReturnedProxy;
 import io.quarkus.runtime.RuntimeValue;
 
 /**
  * Makes it possible to register a synthetic bean.
  * <p>
  * Bean instances can be easily produced through a recorder and set via {@link ExtendedBeanConfigurator#supplier(Supplier)},
- * {@link ExtendedBeanConfigurator#runtimeValue(RuntimeValue)} and {@link ExtendedBeanConfigurator#createWith(Function)}.
+ * {@link ExtendedBeanConfigurator#runtimeValue(RuntimeValue)}, {@link ExtendedBeanConfigurator#createWith(Function)} and
+ * {@link ExtendedBeanConfigurator#runtimeProxy(Object)}.
  *
  * @see ExtendedBeanConfigurator
  * @see BeanRegistrar
@@ -61,14 +64,16 @@ boolean isStaticInit() {
     }
 
     boolean hasRecorderInstance() {
-        return configurator.supplier != null || configurator.runtimeValue != null || configurator.fun != null;
+        return configurator.supplier != null || configurator.runtimeValue != null || configurator.fun != null
+                || configurator.runtimeProxy != null;
     }
 
     /**
      * This construct is not thread-safe and should not be reused.
      */
     public static class ExtendedBeanConfigurator extends BeanConfiguratorBase<ExtendedBeanConfigurator, Object> {
 
+        private Object runtimeProxy;
         private Supplier<?> supplier;
         private RuntimeValue<?> runtimeValue;
         private Function<SyntheticCreationalContext<?>, ?> fun;
@@ -85,53 +90,75 @@ public static class ExtendedBeanConfigurator extends BeanConfiguratorBase<Extend
          * @return a new build item
          */
         public SyntheticBeanBuildItem done() {
-            if (supplier == null && runtimeValue == null && fun == null && creatorConsumer == null) {
+            if (supplier == null && runtimeValue == null && fun == null && runtimeProxy == null && creatorConsumer == null) {
                 throw new IllegalStateException(
                         "Synthetic bean does not provide a creation method, use ExtendedBeanConfigurator#creator(), ExtendedBeanConfigurator#supplier(), ExtendedBeanConfigurator#createWith()  or ExtendedBeanConfigurator#runtimeValue()");
             }
             return new SyntheticBeanBuildItem(this);
         }
 
         /**
+         * The contextual bean instance is supplied by a proxy returned from a recorder method.
+         * <p>
          * Use {@link #createWith(Function)} if you want to leverage build-time parameters or synthetic injection points.
          *
-         * @param supplier A supplier returned from a recorder
+         * @param supplier A supplier returned from a recorder method
          * @return self
+         * @throws IllegalArgumentException If the supplier argument is not a proxy returned from a recorder method
          */
         public ExtendedBeanConfigurator supplier(Supplier<?> supplier) {
-            if (runtimeValue != null || fun != null) {
-                throw multipleCreationMethods();
-            }
+            checkReturnedProxy(supplier);
+            checkMultipleCreationMethods();
             this.supplier = Objects.requireNonNull(supplier);
             return this;
         }
 
         /**
+         * The contextual bean instance is a proxy returned from a recorder method.
+         * <p>
          * Use {@link #createWith(Function)} if you want to leverage build-time parameters or synthetic injection points.
          *
-         * @param runtimeValue A runtime value returned from a recorder
+         * @param runtimeValue A runtime value returned from a recorder method
          * @return self
+         * @throws IllegalArgumentException If the runtimeValue argument is not a proxy returned from a recorder method
          */
         public ExtendedBeanConfigurator runtimeValue(RuntimeValue<?> runtimeValue) {
-            if (supplier != null || fun != null) {
-                throw multipleCreationMethods();
-            }
+            checkReturnedProxy(runtimeValue);
+            checkMultipleCreationMethods();
             this.runtimeValue = Objects.requireNonNull(runtimeValue);
             return this;
         }
 
         /**
+         * The contextual bean instance is created by a proxy returned from a recorder method.
+         * <p>
          * This method is useful if you need to use build-time parameters or synthetic injection points during creation of a
          * bean instance.
          *
-         * @param fun A function returned from a recorder
+         * @param function A function returned from a recorder method
          * @return self
+         * @throws IllegalArgumentException If the function argument is not a proxy returned from a recorder method
          */
-        public <B> ExtendedBeanConfigurator createWith(Function<SyntheticCreationalContext<B>, B> fun) {
-            if (supplier != null || runtimeValue != null) {
-                throw multipleCreationMethods();
-            }
-            this.fun = cast(Objects.requireNonNull(fun));
+        public <B> ExtendedBeanConfigurator createWith(Function<SyntheticCreationalContext<B>, B> function) {
+            checkReturnedProxy(function);
+            checkMultipleCreationMethods();
+            this.fun = cast(Objects.requireNonNull(function));
+            return this;
+        }
+
+        /**
+         * The contextual bean instance is a proxy returned from a recorder method.
+         * <p>
+         * Use {@link #createWith(Function)} if you want to leverage build-time parameters or synthetic injection points.
+         *
+         * @param proxy A proxy returned from a recorder method
+         * @return self
+         * @throws IllegalArgumentException If the proxy argument is not a proxy returned from a recorder method
+         */
+        public ExtendedBeanConfigurator runtimeProxy(Object proxy) {
+            checkReturnedProxy(proxy);
+            checkMultipleCreationMethods();
+            this.runtimeProxy = Objects.requireNonNull(proxy);
             return this;
         }
 
@@ -158,6 +185,10 @@ DotName getImplClazz() {
             return implClazz;
         }
 
+        Set<Type> getTypes() {
+            return types;
+        }
+
         Set<AnnotationInstance> getQualifiers() {
             return qualifiers;
         }
@@ -174,8 +205,23 @@ RuntimeValue<?> getRuntimeValue() {
             return fun;
         }
 
-        private IllegalStateException multipleCreationMethods() {
-            return new IllegalStateException("It is not possible to specify multiple creation methods");
+        Object getRuntimeProxy() {
+            return runtimeProxy;
+        }
+
+        private void checkMultipleCreationMethods() {
+            if (runtimeProxy == null && runtimeValue == null && supplier == null && fun == null) {
+                return;
+            }
+            throw new IllegalStateException("It is not possible to specify multiple creation methods");
+        }
+
+        private void checkReturnedProxy(Object object) {
+            if (object instanceof ReturnedProxy) {
+                return;
+            }
+            throw new IllegalArgumentException(
+                    "The object is not a proxy returned from a recorder method: " + object.toString());
         }
 
     }

extensions/arc/deployment/src/main/java/io/quarkus/arc/deployment/SyntheticBeansProcessor.java

@@ -8,10 +8,9 @@
 
 import jakarta.enterprise.inject.CreationException;
 
-import org.jboss.jandex.DotName;
-
 import io.quarkus.arc.SyntheticCreationalContext;
 import io.quarkus.arc.deployment.BeanRegistrationPhaseBuildItem.BeanConfiguratorBuildItem;
+import io.quarkus.arc.deployment.SyntheticBeanBuildItem.ExtendedBeanConfigurator;
 import io.quarkus.arc.processor.BeanConfigurator;
 import io.quarkus.arc.runtime.ArcRecorder;
 import io.quarkus.deployment.annotations.BuildProducer;
@@ -75,26 +74,27 @@ void initRegular(List<SyntheticBeanBuildItem> syntheticBeans,
     private void configureSyntheticBean(ArcRecorder recorder,
             Map<String, Function<SyntheticCreationalContext<?>, ?>> functionsMap,
             BeanRegistrationPhaseBuildItem beanRegistration, SyntheticBeanBuildItem bean) {
-        DotName implClazz = bean.configurator().getImplClazz();
-        String name = createName(implClazz.toString(), bean.configurator().getQualifiers().toString());
+        String name = createName(bean.configurator());
         if (bean.configurator().getRuntimeValue() != null) {
             functionsMap.put(name, recorder.createFunction(bean.configurator().getRuntimeValue()));
         } else if (bean.configurator().getSupplier() != null) {
             functionsMap.put(name, recorder.createFunction(bean.configurator().getSupplier()));
         } else if (bean.configurator().getFunction() != null) {
             functionsMap.put(name, bean.configurator().getFunction());
+        } else if (bean.configurator().getRuntimeProxy() != null) {
+            functionsMap.put(name, recorder.createFunction(bean.configurator().getRuntimeProxy()));
         }
-        BeanConfigurator<?> configurator = beanRegistration.getContext().configure(implClazz)
+        BeanConfigurator<?> configurator = beanRegistration.getContext().configure(bean.configurator().getImplClazz())
                 .read(bean.configurator());
         if (bean.hasRecorderInstance()) {
             configurator.creator(creator(name, bean));
         }
         configurator.done();
     }
 
-    private String createName(String beanClass, String qualifiers) {
-        return beanClass.replace(".", "_") + "_"
-                + HashUtil.sha1(qualifiers);
+    private String createName(ExtendedBeanConfigurator configurator) {
+        return configurator.getImplClazz().toString().replace(".", "_") + "_"
+                + HashUtil.sha1(configurator.getTypes().toString() + configurator.getQualifiers().toString());
     }
 
     private Consumer<MethodCreator> creator(String name, SyntheticBeanBuildItem bean) {

extensions/arc/deployment/src/test/java/io/quarkus/arc/test/synthetic/SyntheticBeanBuildItemProxyTest.java

@@ -0,0 +1,108 @@
+package io.quarkus.arc.test.synthetic;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import java.lang.reflect.Method;
+import java.util.function.Consumer;
+
+import jakarta.enterprise.context.ApplicationScoped;
+import jakarta.enterprise.inject.Vetoed;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
+
+import io.quarkus.arc.Arc;
+import io.quarkus.arc.deployment.SyntheticBeanBuildItem;
+import io.quarkus.arc.deployment.SyntheticBeanBuildItem.ExtendedBeanConfigurator;
+import io.quarkus.builder.BuildChainBuilder;
+import io.quarkus.builder.BuildContext;
+import io.quarkus.builder.BuildStep;
+import io.quarkus.deployment.builditem.StaticBytecodeRecorderBuildItem;
+import io.quarkus.deployment.recording.BytecodeRecorderImpl;
+import io.quarkus.runtime.annotations.Recorder;
+import io.quarkus.test.QuarkusUnitTest;
+
+public class SyntheticBeanBuildItemProxyTest {
+
+    @RegisterExtension
+    static final QuarkusUnitTest config = new QuarkusUnitTest()
+            .withApplicationRoot(root -> root.addClasses(SyntheticBeanBuildItemProxyTest.class, SynthBean.class))
+            .addBuildChainCustomizer(buildCustomizer());
+
+    static Consumer<BuildChainBuilder> buildCustomizer() {
+        return new Consumer<BuildChainBuilder>() {
+
+            @Override
+            public void accept(BuildChainBuilder builder) {
+                builder.addBuildStep(new BuildStep() {
+
+                    @Override
+                    public void execute(BuildContext context) {
+                        BytecodeRecorderImpl bytecodeRecorder = new BytecodeRecorderImpl(true,
+                                TestRecorder.class.getSimpleName(),
+                                "test", "" + TestRecorder.class.hashCode(), true, s -> null);
+                        // We need to use reflection due to some class loading problems
+                        Object recorderProxy = bytecodeRecorder.getRecordingProxy(TestRecorder.class);
+                        try {
+                            Method test = recorderProxy.getClass().getDeclaredMethod("test");
+                            Object proxy = test.invoke(recorderProxy);
+                            ExtendedBeanConfigurator configurator = SyntheticBeanBuildItem.configure(SynthBean.class)
+                                    .scope(ApplicationScoped.class)
+                                    .unremovable();
+                            // No creator
+                            assertThrows(IllegalStateException.class,
+                                    () -> configurator.done());
+                            // Not a returned proxy
+                            assertThrows(IllegalArgumentException.class,
+                                    () -> configurator.runtimeProxy(new SynthBean()));
+                            context.produce(configurator
+                                    .runtimeProxy(proxy)
+                                    .done());
+                        } catch (Exception e) {
+                            throw new RuntimeException(e);
+                        }
+                        context.produce(new StaticBytecodeRecorderBuildItem(bytecodeRecorder));
+                    }
+                }).produces(StaticBytecodeRecorderBuildItem.class).produces(SyntheticBeanBuildItem.class).build();
+            }
+        };
+    }
+
+    @Recorder
+    public static class TestRecorder {
+
+        public SynthBean test() {
+            SynthBean bean = new SynthBean();
+            bean.setValue("ok");
+            return bean;
+        }
+
+    }
+
+    @Test
+    public void testBeans() {
+        SynthBean bean = Arc.container().instance(SynthBean.class).get();
+        assertNotNull(bean);
+        assertEquals("ok", bean.getValue());
+    }
+
+    @Vetoed
+    public static class SynthBean {
+
+        private String value;
+
+        public SynthBean() {
+        }
+
+        public String getValue() {
+            return value;
+        }
+
+        public void setValue(String value) {
+            this.value = value;
+        }
+
+    }
+}

extensions/arc/runtime/src/main/java/io/quarkus/arc/runtime/ArcRecorder.java

@@ -127,6 +127,15 @@ public Object apply(SyntheticCreationalContext<?> t) {
         };
     }
 
+    public Function<SyntheticCreationalContext<?>, Object> createFunction(Object returnedProxy) {
+        return new Function<SyntheticCreationalContext<?>, Object>() {
+            @Override
+            public Object apply(SyntheticCreationalContext<?> t) {
+                return returnedProxy;
+            }
+        };
+    }
+
     public void initTestApplicationClassPredicate(Set<String> applicationBeanClasses) {
         PreloadedTestApplicationClassPredicate predicate = Arc.container()
                 .instance(PreloadedTestApplicationClassPredicate.class).get();