Merge pull request #358 from netgrif/NAE-2204

[NAE-2204] Plugin EntryPoint class cannot resolve annotation when proxyed by Spring

Author: machacjozef

application-engine/pom.xml

@@ -135,6 +135,11 @@
             <artifactId>nae-user-ce</artifactId>
             <version>${project.version}</version>
         </dependency>
+        <dependency>
+            <groupId>com.netgrif</groupId>
+            <artifactId>nae-spring-core-adapter</artifactId>
+            <version>${project.version}</version>
+        </dependency>
 
         <!-- Loader -->
         <dependency>

application-engine/src/main/groovy/com/netgrif/application/engine/integration/modules/ModuleServiceInjector.groovy

@@ -3,10 +3,12 @@ package com.netgrif.application.engine.integration.modules
 import com.netgrif.application.engine.configuration.ApplicationContextProvider
 import com.netgrif.application.engine.startup.ApplicationEngineFinishRunner
 import com.netgrif.application.engine.startup.annotation.RunnerOrder
+import com.netgrif.application.engine.adapter.spring.utils.NaeReflectionUtils
 import org.slf4j.Logger
 import org.slf4j.LoggerFactory
 import org.springframework.boot.ApplicationArguments
 import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty
+import org.springframework.core.annotation.AnnotatedElementUtils
 import org.springframework.stereotype.Component
 
 /**
@@ -75,7 +77,8 @@ class ModuleServiceInjector implements ApplicationEngineFinishRunner {
     private Map<String, Map<String, Object>> groupServicesByModule(Map<String, Object> services) {
         Map<String, Map<String, Object>> grouped = [(DEFAULT_KEY): [:]]
         services.each { entry ->
-            ModuleService[] annotations = entry.value.getClass().getAnnotationsByType(ModuleService.class)
+            Class serviceClass = NaeReflectionUtils.resolveClass(entry.value)
+            ModuleService[] annotations = serviceClass.getAnnotationsByType(ModuleService.class)
             if (annotations.length == 0) throw new IllegalStateException("Module Service bean must have @ModuleService annotations")
             ModuleService annotation = annotations[0]
             if (annotation.value().isBlank()) {

application-engine/src/main/java/com/netgrif/application/engine/startup/ApplicationRunnerExecutor.java

@@ -12,7 +12,7 @@
 
 import java.util.Map;
 
-import static com.netgrif.application.engine.startup.ApplicationRunnerOrderResolver.resolveClass;
+import static com.netgrif.application.engine.adapter.spring.utils.NaeReflectionUtils.resolveClass;
 
 @Slf4j
 @Component

application-engine/src/main/java/com/netgrif/application/engine/startup/ApplicationRunnerOrderResolver.java

@@ -8,13 +8,15 @@
 import lombok.Getter;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
-import org.springframework.aop.support.AopUtils;
 import org.springframework.stereotype.Component;
 
 import java.lang.annotation.Annotation;
 import java.util.*;
 import java.util.function.Function;
 
+import static com.netgrif.application.engine.adapter.spring.utils.NaeReflectionUtils.indexOfClass;
+import static com.netgrif.application.engine.adapter.spring.utils.NaeReflectionUtils.resolveClass;
+
 @Slf4j
 @Component
 @RequiredArgsConstructor
@@ -54,11 +56,6 @@ public <T> SortedRunners<T> sortByRunnerOrderAnnotation(Collection<T> runners) {
         return new SortedRunners<>(ordered.values().stream().flatMap(List::stream).toList(), unresolved);
     }
 
-    public static <T> Class<?> resolveClass(T object) {
-        if (object instanceof Class) return (Class<?>) object;
-        else return AopUtils.isAopProxy(object) ? AopUtils.getTargetClass(object) : object.getClass();
-    }
-
     @Getter
     public static class SortedRunners<T> {
         private final List<T> sorted;
@@ -91,7 +88,6 @@ public SortedRunners(List<T> sorted, List<T> unresolved) {
          * @return {@code true} if all unresolved runners have been successfully sorted and the unresolved list is empty;
          * {@code false} otherwise.
          */
-
         public boolean resolveAllRunners() {
             sortUnresolvedRunners();
             replaced.values().forEach(this::removeRunner);
@@ -171,29 +167,6 @@ protected boolean replaceRunner(T item) {
             return changed;
         }
 
-        /**
-         * Returns the index of the first occurrence of the specified class in the given list.
-         * If the list contains an element whose class matches the specified class, the index of that element is returned.
-         * If the specified class is {@code null}, the method returns the index of the first {@code null} element in the list.
-         * If the list is {@code null} or empty, or if the class is not found, the method returns {@code -1}.
-         *
-         * @param <I>   the type of elements in the list
-         * @param list  the list to search for the specified class
-         * @param clazz the class to search for in the list
-         * @return the index of the first occurrence of the specified class in the list, or {@code -1} if the class is not found
-         */
-        public static <I> int indexOfClass(List<I> list, Class<?> clazz) {
-            if (list == null) return -1;
-            if (list.isEmpty()) return -1;
-            if (clazz == null) return list.indexOf(null);
-            for (int i = 0; i < list.size(); i++) {
-                if (resolveClass(list.get(i)).equals(clazz)) {
-                    return i;
-                }
-            }
-            return -1;
-        }
-
     }
 
 }

nae-spring-core-adapter/src/main/java/com/netgrif/application/engine/adapter/spring/utils/NaeReflectionUtils.java

@@ -0,0 +1,57 @@
+package com.netgrif.application.engine.adapter.spring.utils;
+
+import org.springframework.aop.framework.AopProxyUtils;
+
+import java.util.List;
+import java.util.Objects;
+
+public final class NaeReflectionUtils {
+
+    private NaeReflectionUtils() {
+        throw new IllegalStateException("No instances. Utility class");
+    }
+
+    /**
+     * Resolves and returns the {@code Class} object for the given input object.
+     * If the input object is a {@code Class}, it is returned directly.
+     * If the input object is an AOP proxy, the target class of the proxy is returned.
+     * Otherwise, the class of the object is returned.
+     *
+     * @param <T>    the type of the input object
+     * @param object the object for which the {@code Class} needs to be resolved
+     * @return the {@code Class} object corresponding to the input object or null if null value provided
+     */
+    public static <T> Class<?> resolveClass(T object) {
+        if (object == null) return null;
+        if (object instanceof Class) return (Class<?>) object;
+        return AopProxyUtils.ultimateTargetClass(object);
+    }
+
+    /**
+     * Returns the index of the first occurrence of the specified class in the given list.
+     * If the list contains an element whose class matches the specified class, the index of that element is returned.
+     * If the specified class is {@code null}, the method returns the index of the first {@code null} element in the list.
+     * If the list is {@code null} or empty, or if the class is not found, the method returns {@code -1}.
+     *
+     * @param <I>   the type of elements in the list
+     * @param list  the list to search for the specified class
+     * @param clazz the class to search for in the list
+     * @return the index of the first occurrence of the specified class in the list, or {@code -1} if the class is not found
+     */
+    public static <I> int indexOfClass(List<I> list, Class<?> clazz) {
+        if (list == null) return -1;
+        if (list.isEmpty()) return -1;
+        if (clazz == null) return list.indexOf(null);
+        for (int i = 0; i < list.size(); i++) {
+            I item = list.get(i);
+            if (item == null) continue;
+            Class<?> itemClass = resolveClass(item);
+            if (Objects.equals(itemClass, clazz)) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+
+}