Better compile time reflection and refactoring

surajkumar · surajkumar · commit c21832c66aea · 2024-05-29T16:16:16.000+01:00
diff --git a/annotations/src/main/java/com/javadiscord/jdi/core/processor/loader/ComponentLoader.java b/annotations/src/main/java/com/javadiscord/jdi/core/processor/loader/ComponentLoader.java
@@ -20,15 +20,9 @@ public class ComponentLoader {
     private static final Map<Class<?>, Object> COMPONENTS = new HashMap<>();
     private final ComponentValidator componentValidator = new ComponentValidator();
 
-    public ComponentLoader() {
-        try {
-            loadComponents();
-        } catch (Exception e) {
-            LOGGER.error("An error occurred while loading components classes", e);
-        }
-    }
+    public ComponentLoader() {}
 
-    private void loadComponents() {
+    public void loadComponents() {
         List<File> classes = ClassFileUtil.getClassesInClassPath();
         for (File classFile : classes) {
             try {
diff --git a/core/src/main/java/com/javadiscord/jdi/core/Constants.java b/core/src/main/java/com/javadiscord/jdi/core/Constants.java
@@ -0,0 +1,13 @@
+package com.javadiscord.jdi.core;
+
+public class Constants {
+    public static final String COMMAND_OPTION_CHOICE_ANNOTATION =
+        "com.javadiscord.jdi.core.annotations.CommandOptionChoice";
+    public static final String LISTENER_LOADER_CLASS =
+        "com.javadiscord.jdi.core.processor.loader.ListenerLoader";
+    public static final String COMPONENT_LOADER_CLASS =
+        "com.javadiscord.jdi.core.processor.loader.ComponentLoader";
+    public static final String SLASH_COMMAND_LOADER_CLASS =
+        "com.javadiscord.jdi.core.processor.loader.SlashCommandLoader";
+
+}
diff --git a/core/src/main/java/com/javadiscord/jdi/core/Discord.java b/core/src/main/java/com/javadiscord/jdi/core/Discord.java
@@ -22,6 +22,9 @@
 import com.javadiscord.jdi.core.api.builders.command.CommandOptionType;
 import com.javadiscord.jdi.core.interaction.InteractionEventHandler;
 import com.javadiscord.jdi.core.models.ready.ReadyEvent;
+import com.javadiscord.jdi.internal.ReflectiveComponentLoader;
+import com.javadiscord.jdi.internal.ReflectiveLoader;
+import com.javadiscord.jdi.internal.ReflectiveSlashCommandClassMethod;
 import com.javadiscord.jdi.internal.api.DiscordRequest;
 import com.javadiscord.jdi.internal.api.DiscordRequestDispatcher;
 import com.javadiscord.jdi.internal.api.DiscordResponseFuture;
@@ -137,10 +140,11 @@ private void registerLoadedAnnotationsWithDiscord() {
         LOGGER.info("Registering slash commands with Discord");
         loadedSlashCommands.forEach((commandName, slashCommandClassInstance) -> {
             try {
-                Class<?> slashCommandClassInstanceClass = slashCommandClassInstance.getClass();
-                Method method =
-                    (Method) slashCommandClassInstanceClass.getMethod("method")
-                        .invoke(slashCommandClassInstance);
+                ReflectiveSlashCommandClassMethod slashCommandClassMethod =
+                    ReflectiveLoader
+                        .proxy(slashCommandClassInstance, ReflectiveSlashCommandClassMethod.class);
+
+                Method method = slashCommandClassMethod.method();
 
                 Annotation[] annotations = method.getAnnotations();
                 for (Annotation annotation : annotations) {
@@ -216,7 +220,7 @@ private void addCommandOptionChoice(
         Annotation annotation1 = (Annotation) choice;
         if (
             annotation1.annotationType().getName()
-                .equals("com.javadiscord.jdi.core.annotations.CommandOptionChoice")
+                .equals(Constants.COMMAND_OPTION_CHOICE_ANNOTATION)
         ) {
             Method nameMethod1 = annotation1.annotationType().getMethod("name");
             Method valueMethod1 = annotation1.annotationType().getMethod("value");
@@ -228,7 +232,7 @@ private void addCommandOptionChoice(
 
     private boolean annotationLibPresent() {
         try {
-            Class.forName("com.javadiscord.jdi.core.processor.loader.ListenerLoader");
+            Class.forName(Constants.LISTENER_LOADER_CLASS);
             return true;
         } catch (Exception e) {
             return false;
@@ -239,9 +243,19 @@ private void loadComponents() {
         LOGGER.info("Loading Components");
         try {
             Class<?> clazz =
-                Class.forName("com.javadiscord.jdi.core.processor.loader.ComponentLoader");
+                Class.forName(Constants.COMPONENT_LOADER_CLASS);
+            ReflectiveComponentLoader componentLoader = null;
             for (Constructor<?> constructor : clazz.getConstructors()) {
-                constructor.newInstance();
+                if (constructor.getParameterCount() == 0) {
+                    componentLoader =
+                        ReflectiveLoader
+                            .proxy(constructor.newInstance(), ReflectiveComponentLoader.class);
+                }
+            }
+            if (componentLoader != null) {
+                componentLoader.loadComponents();
+            } else {
+                throw new RuntimeException("Unable to create ComponentLoader instance");
             }
         } catch (Exception | Error e) {
             LOGGER.warn("Component loading failed", e);
@@ -252,7 +266,7 @@ private void loadAnnotations() {
         LOGGER.info("Loading EventListeners");
         try {
             Class<?> clazz =
-                Class.forName("com.javadiscord.jdi.core.processor.loader.ListenerLoader");
+                Class.forName(Constants.LISTENER_LOADER_CLASS);
             for (Constructor<?> constructor : clazz.getConstructors()) {
                 if (constructor.getParameterCount() == 1) {
                     Parameter parameters = constructor.getParameters()[0];
@@ -271,7 +285,7 @@ private void loadSlashCommands() {
         LOGGER.info("Loading SlashCommands");
         try {
             Class<?> clazz =
-                Class.forName("com.javadiscord.jdi.core.processor.loader.SlashCommandLoader");
+                Class.forName(Constants.SLASH_COMMAND_LOADER_CLASS);
             for (Constructor<?> constructor : clazz.getConstructors()) {
                 if (constructor.getParameterCount() == 1) {
                     Parameter parameters = constructor.getParameters()[0];
diff --git a/core/src/main/java/com/javadiscord/jdi/core/GatewayEventListenerAnnotations.java b/core/src/main/java/com/javadiscord/jdi/core/GatewayEventListenerAnnotations.java
@@ -212,56 +212,78 @@ public GatewayEventListenerAnnotations(Discord discord) {
         this.discord = discord;
     }
 
-    @SuppressWarnings("unchecked")
     @Override
     public void receive(EventType eventType, Object event) {
-        if (!EVENT_TYPE_ANNOTATIONS.containsKey(eventType)) {
+        if (!isEventTypeValid(eventType)) {
             return;
         }
-        Class<? extends Annotation> annotationClass;
-        try {
-            annotationClass =
-                (Class<? extends Annotation>) Class.forName(EVENT_TYPE_ANNOTATIONS.get(eventType));
-        } catch (ClassNotFoundException e) {
+
+        Class<? extends Annotation> annotationClass = getAnnotationClass(eventType);
+        if (annotationClass == null) {
             LOGGER.error("Could not find annotation binding for {}", eventType);
             return;
         }
+
+        invokeAnnotatedMethods(annotationClass, event);
+    }
+
+    private boolean isEventTypeValid(EventType eventType) {
+        return EVENT_TYPE_ANNOTATIONS.containsKey(eventType);
+    }
+
+    @SuppressWarnings("unchecked")
+    private Class<? extends Annotation> getAnnotationClass(EventType eventType) {
+        try {
+            return (Class<? extends Annotation>) Class
+                .forName(EVENT_TYPE_ANNOTATIONS.get(eventType));
+        } catch (ClassNotFoundException e) {
+            return null;
+        }
+    }
+
+    private void invokeAnnotatedMethods(Class<? extends Annotation> annotationClass, Object event) {
         for (Object listener : discord.getAnnotatedEventListeners()) {
             Method[] methods = listener.getClass().getMethods();
-            List<Object> paramOrder = new ArrayList<>();
             for (Method method : methods) {
-                if (!method.isAnnotationPresent(annotationClass)) {
-                    continue;
+                if (method.isAnnotationPresent(annotationClass)) {
+                    invokeMethod(listener, method, event);
                 }
-                Parameter[] parameters = method.getParameters();
-                for (Parameter parameter : parameters) {
-                    if (parameter.getParameterizedType() == event.getClass()) {
-                        paramOrder.add(event);
-                    } else if (parameter.getParameterizedType() == Discord.class) {
-                        paramOrder.add(discord);
-                    } else if (parameter.getParameterizedType() == Guild.class) {
-                        Guild guild = GatewayEventListener.getGuild(discord, event);
-                        paramOrder.add(guild);
-                    }
-                }
-                try {
-                    if (paramOrder.size() != method.getParameterCount()) {
-                        throw new RuntimeException(
-                            "Bound "
-                                + paramOrder.size()
-                                + " parameters but expected "
-                                + method.getParameterCount()
-                        );
-                    }
-                    LOGGER.trace("Invoking method {} with params {}", method.getName(), paramOrder);
+            }
+        }
+    }
 
-                    method.invoke(listener, paramOrder.toArray());
+    private void invokeMethod(Object listener, Method method, Object event) {
+        List<Object> paramOrder = getParamOrder(method, event);
+        if (paramOrder.size() != method.getParameterCount()) {
+            throw new RuntimeException(
+                "Bound " + paramOrder.size() + " parameters but expected "
+                    + method.getParameterCount()
+            );
+        }
 
-                } catch (Exception e) {
-                    LOGGER.error("Failed to invoke {}", method.getName(), e);
-                    throw new RuntimeException(e);
-                }
+        try {
+            LOGGER.trace("Invoking method {} with params {}", method.getName(), paramOrder);
+            method.invoke(listener, paramOrder.toArray());
+        } catch (Exception e) {
+            LOGGER.error("Failed to invoke {}", method.getName(), e);
+            throw new RuntimeException(e);
+        }
+    }
+
+    private List<Object> getParamOrder(Method method, Object event) {
+        List<Object> paramOrder = new ArrayList<>();
+        Parameter[] parameters = method.getParameters();
+        for (Parameter parameter : parameters) {
+            if (parameter.getParameterizedType() == event.getClass()) {
+                paramOrder.add(event);
+            } else if (parameter.getParameterizedType() == Discord.class) {
+                paramOrder.add(discord);
+            } else if (parameter.getParameterizedType() == Guild.class) {
+                Guild guild = GatewayEventListener.getGuild(discord, event);
+                paramOrder.add(guild);
             }
         }
+        return paramOrder;
     }
+
 }
diff --git a/core/src/main/java/com/javadiscord/jdi/core/interaction/InteractionEventHandler.java b/core/src/main/java/com/javadiscord/jdi/core/interaction/InteractionEventHandler.java
@@ -9,6 +9,9 @@
 import com.javadiscord.jdi.core.GatewayEventListener;
 import com.javadiscord.jdi.core.Guild;
 import com.javadiscord.jdi.core.models.guild.Interaction;
+import com.javadiscord.jdi.internal.ReflectiveLoader;
+import com.javadiscord.jdi.internal.ReflectiveSlashCommandClassMethod;
+import com.javadiscord.jdi.internal.ReflectiveSlashCommandLoader;
 
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
@@ -30,29 +33,21 @@ public void onInteractionCreate(Interaction interaction, Guild guild) {
         String command = interaction.data().name();
 
         try {
-            Class<?> slashCommandLoaderClass = slashCommandLoader.getClass();
+            ReflectiveSlashCommandLoader reflectiveSlashCommandLoader =
+                ReflectiveLoader.proxy(slashCommandLoader, ReflectiveSlashCommandLoader.class);
 
-            Method getSlashCommandClassMethod =
-                slashCommandLoaderClass.getMethod("getSlashCommandClassMethod", String.class);
-
-            Object commandClassMethodInstance =
-                getSlashCommandClassMethod.invoke(slashCommandLoader, command);
-
-            if (commandClassMethodInstance == null) {
-                LOGGER.warn("No handler found for /{} command", command);
-                return;
-            }
-
-            Class<?> handler =
-                (Class<?>) commandClassMethodInstance.getClass().getMethod("clazz")
-                    .invoke(commandClassMethodInstance);
+            ReflectiveSlashCommandClassMethod reflectiveSlashCommandClassMethod =
+                ReflectiveLoader.proxy(
+                    reflectiveSlashCommandLoader.getSlashCommandClassMethod(command),
+                    ReflectiveSlashCommandClassMethod.class
+                );
 
-            Method method =
-                (Method) commandClassMethodInstance.getClass().getMethod("method")
-                    .invoke(commandClassMethodInstance);
+            Class<?> handler = reflectiveSlashCommandClassMethod.clazz();
+            Method method = reflectiveSlashCommandClassMethod.method();
 
             List<Object> paramOrder = new ArrayList<>();
             Parameter[] parameters = method.getParameters();
+
             for (Parameter parameter : parameters) {
                 if (parameter.getParameterizedType() == interaction.getClass()) {
                     paramOrder.add(interaction);
@@ -88,13 +83,10 @@ public void onInteractionCreate(Interaction interaction, Guild guild) {
         }
     }
 
-    private void injectComponents(Object object) throws Exception {
-        Class<?> slashCommandLoaderClass = slashCommandLoader.getClass();
+    private void injectComponents(Object object) {
+        ReflectiveSlashCommandLoader reflectiveSlashCommandLoader =
+            ReflectiveLoader.proxy(slashCommandLoader, ReflectiveSlashCommandLoader.class);
 
-        Method injectComponentsMethod =
-            slashCommandLoaderClass.getMethod("injectComponents", Object.class);
-
-        injectComponentsMethod.invoke(slashCommandLoader, object);
+        reflectiveSlashCommandLoader.injectComponents(object);
     }
-
 }
diff --git a/core/src/main/java/com/javadiscord/jdi/internal/ReflectiveComponentLoader.java b/core/src/main/java/com/javadiscord/jdi/internal/ReflectiveComponentLoader.java
@@ -0,0 +1,7 @@
+package com.javadiscord.jdi.internal;
+
+public interface ReflectiveComponentLoader {
+    void loadComponents();
+
+    void injectComponents(Object component);
+}
diff --git a/core/src/main/java/com/javadiscord/jdi/internal/ReflectiveLoader.java b/core/src/main/java/com/javadiscord/jdi/internal/ReflectiveLoader.java
@@ -0,0 +1,22 @@
+package com.javadiscord.jdi.internal;
+
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Proxy;
+
+public class ReflectiveLoader {
+    public static <T> T proxy(Object object, Class<T> interfaceClass) {
+        InvocationHandler handler =
+            (proxy, method, methodArgs) -> object.getClass()
+                .getMethod(method.getName(), method.getParameterTypes())
+                .invoke(object, methodArgs);
+
+        @SuppressWarnings("unchecked") T proxyInstance =
+            (T) Proxy.newProxyInstance(
+                interfaceClass.getClassLoader(),
+                new Class[] {interfaceClass},
+                handler
+            );
+
+        return proxyInstance;
+    }
+}
diff --git a/core/src/main/java/com/javadiscord/jdi/internal/ReflectiveSlashCommandClassMethod.java b/core/src/main/java/com/javadiscord/jdi/internal/ReflectiveSlashCommandClassMethod.java
@@ -0,0 +1,9 @@
+package com.javadiscord.jdi.internal;
+
+import java.lang.reflect.Method;
+
+public interface ReflectiveSlashCommandClassMethod {
+    Class<?> clazz();
+
+    Method method();
+}
diff --git a/core/src/main/java/com/javadiscord/jdi/internal/ReflectiveSlashCommandLoader.java b/core/src/main/java/com/javadiscord/jdi/internal/ReflectiveSlashCommandLoader.java
@@ -0,0 +1,7 @@
+package com.javadiscord.jdi.internal;
+
+public interface ReflectiveSlashCommandLoader {
+    Object getSlashCommandClassMethod(String name);
+
+    void injectComponents(Object object);
+}
diff --git a/settings.gradle b/settings.gradle
@@ -9,4 +9,3 @@ include 'example:echo-bot'
 findProject(':example:echo-bot')?.name = 'echo-bot'
 include 'example:lj-discord-bot'
 findProject(':example:lj-discord-bot')?.name = 'lj-discord-bot'
-
