使用Reflections动态加载func_commands包中类的技术问询

Hey there! Let's tackle this problem step by step—auto-loading classes from your func_commands package without hardcoding class names is totally doable with Reflections, and I'll walk you through a practical implementation tailored to your scenario.

Since you mentioned building with interfaces, first let's formalize the contract your command classes must follow. This ensures Reflections can reliably find all relevant classes and you can interact with them consistently.

// Define this in a shared package (you can put it inside func_commands too if preferred)
public interface Command {
    // Required method for executing the command
    void cmd();
    // Required method for showing manual/help text
    String man();
}

Every class in func_commands should implement this interface—here's an example:

package com.yourproject.func_commands;

public class GreetCommand implements Command {
    @Override
    public void cmd() {
        System.out.println("Hello, this is the greet command!");
    }

    @Override
    public String man() {
        return "Usage: greet - Displays a friendly greeting message";
    }
}

First, make sure you have the Reflections library in your project.

If using Maven, add this to your pom.xml:

<dependency>
    <groupId>org.reflections</groupId>
    <artifactId>reflections</artifactId>
    <version>0.10.2</version> <!-- Use the latest stable version -->
</dependency>

For Gradle, add this to your build.gradle:

implementation 'org.reflections:reflections:0.10.2'

Now write the code that scans your func_commands package, finds all Command implementations, and loads them on program startup.

import org.reflections.Reflections;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class CommandManager {
    // Store loaded commands (key can be class name or a custom identifier)
    private static final Map<String, Command> loadedCommands = new HashMap<>();

    public static void initializeCommands() {
        // Initialize Reflections with the exact package path to scan
        Reflections reflections = new Reflections("com.yourproject.func_commands");

        // Fetch all classes that implement the Command interface
        Set<Class<? extends Command>> commandClasses = reflections.getSubTypesOf(Command.class);

        // Iterate through each class, instantiate it, and store it for later use
        for (Class<? extends Command> cmdClass : commandClasses) {
            try {
                // Create an instance (ensure your command classes have a no-arg constructor!)
                Command command = cmdClass.getDeclaredConstructor().newInstance();
                // Use the class's simple name as the key (we'll cover custom names later)
                loadedCommands.put(cmdClass.getSimpleName(), command);
                System.out.println("Successfully loaded command: " + cmdClass.getSimpleName());
            } catch (Exception e) {
                System.err.println("Failed to load command class: " + cmdClass.getName());
                e.printStackTrace();
            }
        }
    }

    // Example method to execute a command by name
    public static void executeCommand(String commandName) {
        Command command = loadedCommands.get(commandName);
        if (command != null) {
            command.cmd();
        } else {
            System.out.println("Command not found: " + commandName);
        }
    }

    // Example method to retrieve command documentation
    public static String getCommandManual(String commandName) {
        Command command = loadedCommands.get(commandName);
        return command != null ? command.man() : "No manual available for command: " + commandName;
    }

    public static void main(String[] args) {
        // Run initialization on program startup
        initializeCommands();

        // Test executing a command
        executeCommand("GreetCommand");
        // Test fetching the manual
        System.out.println(getCommandManual("GreetCommand"));
    }
}

• No-Arg Constructors: All your Command classes must have a public no-argument constructor (or accessible one) for newInstance() to work. If you need constructor parameters, adjust the instantiation logic (e.g., use dependency injection if you're using a framework).
• Package Path Accuracy: Double-check the package string passed to Reflections—it must match the actual package where your command classes live (e.g., com.yourproject.func_commands, not just func_commands).
• Unloading on Restart: You don't need extra code for unloading when restarting. When your program restarts, the JVM reloads classes from scratch—any classes removed from func_commands won't be scanned, so they won't be loaded into the new runtime.
• Scanning Edge Cases: If you're using code obfuscation (like ProGuard) or packaging as a fat JAR, ensure Reflections can access class files. Latest Reflections versions handle fat JARs well, but if you run into missing classes, verify your build configuration.

If you don't want to use class names as command identifiers, add a custom annotation:

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

@Retention(RetentionPolicy.RUNTIME)
public @interface CommandName {
    String value();
}

Annotate your command class:

@CommandName("greet")
public class GreetCommand implements Command {
    // ... existing code ...
}

Modify the loader to read the annotation:

// Inside the loop in initializeCommands()
CommandName cmdAnnotation = cmdClass.getAnnotation(CommandName.class);
String commandKey = cmdAnnotation != null ? cmdAnnotation.value() : cmdClass.getSimpleName();
loadedCommands.put(commandKey, command);

Now you can execute commands using friendly names: executeCommand("greet")

内容的提问来源于stack exchange，提问作者Naltan