Causeway 3883

api/applib/src/main/java/org/apache/causeway/applib/services/wrapper/WrappingObject.java

@@ -59,6 +59,7 @@ public interface WrappingObject {
      */
     Object __causeway_wrapped();
 
+
     /**
      * The {@link ExecutionMode}(s) inferred from the
      * {@link SyncControl} with which this wrapper was

commons/src/main/java/module-info.java

@@ -79,8 +79,10 @@
     requires com.fasterxml.jackson.datatype.jsr310;
     requires com.fasterxml.jackson.dataformat.yaml;
     requires com.fasterxml.jackson.datatype.jdk8;
+    requires java.management;
 
     opens org.apache.causeway.commons.internal.resources to java.xml.bind, com.sun.xml.bind; // JUnit test
     opens org.apache.causeway.commons.io to java.xml.bind, com.sun.xml.bind;
+    exports org.apache.causeway.commons.memory;
 
 }

commons/src/main/java/org/apache/causeway/commons/internal/proxy/_ProxyFactoryService.java

@@ -26,6 +26,8 @@
  */
 public interface _ProxyFactoryService {
 
+    String WRAPPER_INVOCATION_CONTEXT_FIELD_NAME = "__causeway_wrapperInvocationContext";
+
     <T> _ProxyFactory<T> factory(
             Class<T> base,
             @Nullable Class<?>[] interfaces,

commons/src/main/java/org/apache/causeway/commons/memory/MemoryUsage.java

@@ -0,0 +1,67 @@
+package org.apache.causeway.commons.memory;
+
+import lombok.SneakyThrows;
+
+import java.lang.management.ManagementFactory;
+import java.lang.management.MemoryPoolMXBean;
+import java.util.concurrent.Callable;
+
+public class MemoryUsage {
+
+    private MemoryUsage(java.lang.management.MemoryUsage usage) {
+        this(usage.getUsed() / 1024);
+    }
+
+    private MemoryUsage(final long usedInKb) {
+        this.usedInKb = usedInKb;
+    }
+
+    final long usedInKb;
+
+    @Override
+    public String toString() {
+        return String.format("%,d KB", usedInKb);
+    }
+
+    public static void measureMetaspace(String desc, final Runnable runnable) {
+        MemoryUsage before = metaspace();
+        try {
+            runnable.run();
+        } finally {
+            MemoryUsage after = metaspace();
+            System.out.printf("%s : %s%n", after.minus(before), desc);
+        }
+    }
+
+    static int indent = 0;
+
+    @SneakyThrows
+    public static <T> T measureMetaspace(final String desc, final Callable<T> runnable) {
+        MemoryUsage before = metaspace();
+        try {
+            indent++;
+            return runnable.call();
+        } finally {
+            MemoryUsage after = metaspace();
+            System.out.printf("%s%s : %s%n", spaces(indent), after.minus(before), desc);
+            indent--;
+        }
+    }
+
+    private static String spaces(int indent) {
+        return " ".repeat(indent * 2);
+    }
+
+    private MemoryUsage minus(MemoryUsage before) {
+        return new MemoryUsage(this.usedInKb - before.usedInKb);
+    }
+
+    public static MemoryUsage metaspace() {
+        for (MemoryPoolMXBean pool : ManagementFactory.getMemoryPoolMXBeans()) {
+            if (pool.getName().contains("Metaspace")) {
+                return new MemoryUsage(pool.getUsage());
+            }
+        }
+        throw new RuntimeException("Metaspace Usage not found");
+    }
+}

core/codegen-bytebuddy/src/main/java/org/apache/causeway/core/codegen/bytebuddy/services/ProxyFactoryServiceByteBuddy.java

@@ -18,8 +18,12 @@
  */
 package org.apache.causeway.core.codegen.bytebuddy.services;
 
+import java.io.IOException;
+import java.io.UncheckedIOException;
 import java.lang.reflect.InvocationHandler;
 import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Modifier;
+import java.util.Map;
 import java.util.function.Function;
 
 import org.springframework.lang.Nullable;
@@ -29,6 +33,7 @@
 import org.apache.causeway.commons.internal._Constants;
 import org.apache.causeway.commons.internal.base._Casts;
 import org.apache.causeway.commons.internal.base._NullSafe;
+import org.apache.causeway.commons.internal.collections._Maps;
 import org.apache.causeway.commons.internal.context._Context;
 import org.apache.causeway.commons.internal.proxy._ProxyFactory;
 import org.apache.causeway.commons.internal.proxy._ProxyFactoryServiceAbstract;
@@ -44,7 +49,9 @@
 @Service
 public class ProxyFactoryServiceByteBuddy extends _ProxyFactoryServiceAbstract {
 
+
     private final ClassLoadingStrategyAdvisor strategyAdvisor = new ClassLoadingStrategyAdvisor();
+    private Map<InvocationHandler, Class<?>> proxyClassByInvocationHandler = _Maps.newConcurrentHashMap();
 
     @Override
     public <T> _ProxyFactory<T> factory(
@@ -54,21 +61,47 @@ public <T> _ProxyFactory<T> factory(
 
         val objenesis = new ObjenesisStd();
 
-        final Function<InvocationHandler, Class<? extends T>> proxyClassFactory = handler->
-        nextProxyDef(base, interfaces)
-        .intercept(InvocationHandlerAdapter.of(handler))
-        .make()
-        .load(_Context.getDefaultClassLoader(),
-                strategyAdvisor.getSuitableStrategy(base))
-        .getLoaded();
+        final Function<InvocationHandler, Class<? extends T>> proxyClassFactory = new Function<>() {
+
+            /**
+             * Cached proxy class by invocation handler.
+             *
+             * <p>
+             *     The only state held in invocation handler is the org.apache.causeway.core.metamodel.spec.ObjectSpecification,
+             *.    in effect the target class.
+             * </p>
+             *
+             * <p>
+             *     The remaining state (defined by WrapperInvocationContext) is held in the proxy object itself as a field.
+             * </p>
+             * @return
+             */
+            @Override
+            public Class<? extends T> apply(InvocationHandler handler) {
+                return (Class<? extends T>) proxyClassByInvocationHandler.computeIfAbsent(handler, this::createClass);
+            }
+
+            private Class<? extends T> createClass(InvocationHandler handler) {
+                try (final var unloaded = nextProxyDef(base, interfaces)
+                        .intercept(InvocationHandlerAdapter.of(handler))
+                        .defineField(WRAPPER_INVOCATION_CONTEXT_FIELD_NAME, Object.class, Modifier.PUBLIC)
+                        .make()
+                ) {
+                    return unloaded
+                            .load(_Context.getDefaultClassLoader(), strategyAdvisor.getSuitableStrategy(base))
+                            .getLoaded();
+                } catch (IOException e) {
+                    throw new UncheckedIOException("Failed to generate proxy class", e);
+                }
+            }
+        };
 
         return new _ProxyFactory<T>() {
 
             @Override
             public T createInstance(final InvocationHandler handler, final boolean initialize) {
 
                 try {
-
                     if(initialize) {
                         ensureSameSize(constructorArgTypes, null);
                         return _Casts.uncheckedCast( createUsingConstructor(handler, null) );
@@ -101,20 +134,18 @@ public T createInstance(final InvocationHandler handler, final Object[] construc
 
             private Object createNotUsingConstructor(final InvocationHandler invocationHandler) {
                 final Class<? extends T> proxyClass = proxyClassFactory.apply(invocationHandler);
-                final Object object = objenesis.newInstance(proxyClass);
-                return object;
+                return objenesis.newInstance(proxyClass);
             }
 
             // -- HELPER (create with initialize)
 
             private Object createUsingConstructor(final InvocationHandler invocationHandler, @Nullable final Object[] constructorArgs)
                     throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException {
-                final Class<? extends T> proxyClass = proxyClassFactory.apply(invocationHandler);
-                return proxyClass
-                        .getConstructor(constructorArgTypes==null ? _Constants.emptyClasses : constructorArgTypes)
-                        .newInstance(constructorArgs==null ? _Constants.emptyObjects : constructorArgs);
+                final var proxyClass = proxyClassFactory.apply(invocationHandler);  // creates or fetches from cache
+                final var constructor =
+                        proxyClass.getConstructor(constructorArgTypes == null ? _Constants.emptyClasses : constructorArgTypes);
+                return constructor.newInstance(constructorArgs == null ? _Constants.emptyObjects : constructorArgs);
             }
-
         };
 
     }

core/metamodel/src/main/java/org/apache/causeway/core/metamodel/context/HasMetaModelContext.java

@@ -22,6 +22,8 @@
 import java.util.function.Supplier;
 import java.util.stream.Stream;
 
+import org.apache.causeway.core.metamodel.services.command.CommandDtoFactory;
+
 import org.springframework.lang.Nullable;
 
 import org.apache.causeway.applib.locale.UserLocale;
@@ -150,6 +152,10 @@ default InteractionService getInteractionService() {
         return getMetaModelContext().getInteractionService();
     }
 
+    default CommandDtoFactory getCommandDtoFactory() {
+        return getMetaModelContext().getCommandDtoFactory();
+    }
+
     default Optional<UserLocale> currentUserLocale() {
         return getInteractionService().currentInteractionContext()
                 .map(InteractionContext::getLocale);

core/metamodel/src/main/java/org/apache/causeway/core/metamodel/context/MetaModelContext_usingSpring.java

@@ -48,6 +48,7 @@
 import org.apache.causeway.core.metamodel.facets.object.icon.ObjectIconService;
 import org.apache.causeway.core.metamodel.object.ManagedObject;
 import org.apache.causeway.core.metamodel.objectmanager.ObjectManager;
+import org.apache.causeway.core.metamodel.services.command.CommandDtoFactory;
 import org.apache.causeway.core.metamodel.specloader.SpecificationLoader;
 import org.apache.causeway.core.security.authentication.manager.AuthenticationManager;
 import org.apache.causeway.core.security.authorization.manager.AuthorizationManager;
@@ -160,6 +161,10 @@ void onDestroy() {
     private final InteractionService interactionService =
     getSingletonElseFail(InteractionService.class);
 
+    @Getter(lazy = true)
+    private final CommandDtoFactory commandDtoFactory =
+    getSingletonElseFail(CommandDtoFactory.class);
+
     @Override
     public final ManagedObject getHomePageAdapter() {
         final Object pojo = getHomePageResolverService().getHomePage();

core/metamodel/src/main/java/org/apache/causeway/core/metamodel/specloader/specimpl/ObjectMemberAbstract.java

@@ -322,10 +322,6 @@ protected InteractionProvider getInteractionContext() {
         return getServiceRegistry().lookupServiceElseFail(InteractionProvider.class);
     }
 
-    protected CommandDtoFactory getCommandDtoFactory() {
-        return getServiceRegistry().lookupServiceElseFail(CommandDtoFactory.class);
-    }
-
     @Override
     public String asciiId() {
         return getMetaModelContext().getAsciiIdentifierService().asciiIdFor(getId());

core/runtimeservices/src/main/java/module-info.java

@@ -79,6 +79,7 @@
     requires spring.tx;
     requires org.apache.causeway.core.codegen.bytebuddy;
     requires spring.aop;
+    requires java.management;
 
     opens org.apache.causeway.core.runtimeservices.wrapper;
     opens org.apache.causeway.core.runtimeservices.wrapper.proxy; //to org.apache.causeway.core.codegen.bytebuddy

core/runtimeservices/src/main/java/org/apache/causeway/core/runtimeservices/wrapper/InvocationHandlerForAsyncWrapMixin.java

@@ -0,0 +1,115 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you under the Apache License, Version 2.0 (the
+ *  "License"); you may not use this file except in compliance
+ *  with the License.  You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing,
+ *  software distributed under the License is distributed on an
+ *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ *  specific language governing permissions and limitations
+ *  under the License.
+ */
+package org.apache.causeway.core.runtimeservices.wrapper;
+
+import java.lang.reflect.Method;
+import java.util.concurrent.ExecutorService;
+
+import org.apache.causeway.applib.services.wrapper.control.AsyncControl;
+import org.apache.causeway.commons.internal.reflection._GenericResolver;
+import org.apache.causeway.core.metamodel.context.MetaModelContext;
+import org.apache.causeway.core.metamodel.spec.ObjectSpecification;
+import org.apache.causeway.core.metamodel.spec.feature.MixedIn;
+import org.apache.causeway.core.metamodel.spec.feature.MixedInMember;
+import org.apache.causeway.core.metamodel.spec.feature.ObjectAction;
+import org.apache.causeway.core.runtimeservices.session.InteractionIdGenerator;
+import org.apache.causeway.core.runtimeservices.wrapper.handlers.DomainObjectInvocationHandler;
+import org.apache.causeway.core.runtimeservices.wrapper.handlers.WrapperInvocationContext;
+
+import static org.apache.causeway.applib.services.wrapper.control.SyncControl.control;
+
+import lombok.NonNull;
+import lombok.val;
+
+class InvocationHandlerForAsyncWrapMixin<T, R> extends InvocationHandlerforAsyncAbstract<T,R> {
+
+    private final @NonNull Object mixeePojo;
+
+    public InvocationHandlerForAsyncWrapMixin(
+            final MetaModelContext metaModelContext,
+            final InteractionIdGenerator interactionIdGenerator,
+            final ExecutorService commonExecutorService,
+            final @NonNull AsyncControl<R> asyncControl,
+            final T targetPojo,
+            final ObjectSpecification targetSpecification,
+            final @NonNull Object mixeePojo) {
+        super(metaModelContext, interactionIdGenerator, commonExecutorService, asyncControl, targetPojo, targetSpecification);
+        this.mixeePojo = mixeePojo;
+    }
+
+    @Override
+    public Object invoke(Object proxyObject, Method method, Object[] args) throws Throwable {
+
+        val resolvedMethod = _GenericResolver.resolveMethod(method, targetPojo.getClass())
+                .orElseThrow(); // fail early on attempt to invoke method that is not part of the meta-model
+
+        if (isInheritedFromJavaLangObject(method)) {
+            return method.invoke(targetPojo, args);
+        }
+
+        if (shouldCheckRules(asyncControl)) {
+            val doih = new DomainObjectInvocationHandler<>(
+                    metaModelContext,
+                    null, targetSpecification
+            );
+
+            try {
+                doih.invoke(proxyObject, method, args);
+            } catch (Throwable e) {
+                throw new RuntimeException(e);
+            }
+        }
+
+        val memberAndTarget = locateMemberAndTarget(resolvedMethod, mixeePojo, targetSpecification);
+        if (!memberAndTarget.isMemberFound()) {
+            return method.invoke(targetPojo, args);
+        }
+
+        return submitAsync(memberAndTarget, args, asyncControl);
+    }
+
+    <Q> MemberAndTarget locateMemberAndTarget(
+            final _GenericResolver.ResolvedMethod method,
+            final Q mixeePojo,
+            final ObjectSpecification targetSpecification
+    ) {
+
+        final var mixinMember = targetSpecification.getMember(method).orElse(null);
+        if (mixinMember == null) {
+            return MemberAndTarget.notFound();
+        }
+
+        // find corresponding action of the mixee (this is the 'real' target, the target usable for invocation).
+        final var mixeeClass = mixeePojo.getClass();
+
+        // don't care about anything other than actions
+        // (contributed properties and collections are read-only).
+        final ObjectAction targetAction = metaModelContext.getSpecificationLoader().specForType(mixeeClass)
+                .flatMap(mixeeSpec->mixeeSpec.streamAnyActions(MixedIn.ONLY)
+                        .filter(act -> ((MixedInMember)act).hasMixinAction((ObjectAction) mixinMember))
+                        .findFirst()
+                )
+                .orElseThrow(()->new UnsupportedOperationException(String.format(
+                        "Could not locate objectAction delegating to mixinAction id='%s' on mixee class '%s'",
+                        mixinMember.getId(), mixeeClass.getName())));
+
+        return MemberAndTarget.foundAction(targetAction, metaModelContext.getObjectManager().adapt(mixeePojo), method.method());
+    }
+
+}