Kann ich den Methodenparameternamen mithilfe der Java-Reflektion erhalten?

In Java 8 können Sie Folgendes tun:

import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
import java.util.ArrayList;
import java.util.List;

public final class Methods {

    public static List<String> getParameterNames(Method method) {
        Parameter[] parameters = method.getParameters();
        List<String> parameterNames = new ArrayList<>();

        for (Parameter parameter : parameters) {
            if(!parameter.isNamePresent()) {
                throw new IllegalArgumentException("Parameter names are not present!");
            }

            String parameterName = parameter.getName();
            parameterNames.add(parameterName);
        }

        return parameterNames;
    }

    private Methods(){}
}

Also für Ihre Klasse Whatever können wir tun, ein manueller test:

import java.lang.reflect.Method;

public class ManualTest {
    public static void main(String[] args) {
        Method[] declaredMethods = Whatever.class.getDeclaredMethods();

        for (Method declaredMethod : declaredMethods) {
            if (declaredMethod.getName().equals("aMethod")) {
                System.out.println(Methods.getParameterNames(declaredMethod));
                break;
            }
        }
    }
}

dem drucken sollten [aParam] wenn Sie bestanden haben -parameters argument, um Ihre Java-8-compiler.

Für Maven Nutzer:

<properties>
    <!-- PLUGIN VERSIONS -->
    <maven-compiler-plugin.version>3.1</maven-compiler-plugin.version>

    <!-- OTHER PROPERTIES -->
    <java.version>1.8</java.version>
</properties>

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>${maven-compiler-plugin.version}</version>
            <configuration>
                <!-- Original answer -->
                <compilerArgument>-parameters</compilerArgument>
                <!-- Or, if you use the plugin version >= 3.6.2 -->
                <parameters>true</parameters>
                <testCompilerArgument>-parameters</testCompilerArgument>
                <source>${java.version}</source>
                <target>${java.version}</target>
            </configuration>
        </plugin>
    </plugins>
</build>

Weitere Informationen finden Sie unter folgenden links:

1. Offizielle Java-Tutorial: Die Namen der Parameter der Methode
2. JEP 118: Access to Parameter Names at Runtime
3. Javadoc für die Parameter-Klasse

InformationsquelleAutor der Antwort lpandzic

Ja.

Code kompiliert werden muss mit Java 8 kompatibel compiler mit der option zum speichern von formalen Parameternamen eingeschaltet (-Parameter option).

Dann dieser code sollte funktionieren:

Class<String> clz = String.class;
for (Method m : clz.getDeclaredMethods()) {
   System.err.println(m.getName());
   for (Parameter p : m.getParameters()) {
    System.err.println("  " + p.getName());
   }
}

InformationsquelleAutor der Antwort Karol Król

siehe org.springframework.core.DefaultParameterNameDiscoverer Klasse

DefaultParameterNameDiscoverer discoverer = new DefaultParameterNameDiscoverer();
String[] params = discoverer.getParameterNames(MathUtils.class.getMethod("isPrime", Integer.class));

InformationsquelleAutor der Antwort Denis Danilkovich

Zwar ist es nicht möglich (wie bereits dargestellt), Sie könnte Verwendung einer annotation zu führen über die parameter name, und erhalten, dass, obwohl die Reflexion.

Nicht die sauberste Lösung, aber es bekommt den job getan. Einige webservices, tatsächlich tun dies, um die Namen der parameter (sprich: der Bereitstellung von WSs mit glassfish).

InformationsquelleAutor der Antwort WhyNotHugo

So dass Sie sollten in der Lage sein zu tun:

Whatever.declaredMethods
        .find { it.name == 'aMethod' }
        .parameters
        .collect { "$it.type : $it.name" }

Aber Sie werden wahrscheinlich erhalten eine Liste, etwa so:

["int : arg0"]

Ich glaube, das wird behoben, in Groovy 2.5+

Also aktuell die Antwort ist:

• Wenn es eine Groovy-Klasse, dann Nein, Sie können nicht den Namen, aber Sie sollten in der Lage sein in der Zukunft.
• Wenn es eine Java-Klasse kompiliert, die unter Java 8 ist, sollten Sie in der Lage sein.

Siehe auch:

• http://openjdk.java.net/jeps/118
• https://docs.oracle.com/javase/tutorial/reflect/member/methodparameterreflection.html

Für jede Methode, dann so etwas wie:

Whatever.declaredMethods
        .findAll { !it.synthetic }
        .collect { method -> 
            println method
            method.name + " -> " + method.parameters.collect { "[$it.type : $it.name]" }.join(';')
        }
        .each {
            println it
        }

InformationsquelleAutor der Antwort tim_yates

Werden die Namen der Parameter sind nur nützlich, um den compiler. Wenn der compiler erzeugt eine class-Datei, die Namen der parameter sind nicht im Lieferumfang enthalten - eine Methode, die Argumentliste nur aus der Anzahl und den Typen Ihrer Argumente. So würde es unmöglich sein, die zum abrufen der parameter name mit Reflexion (als tagged in deiner Frage) - es existiert nicht überall.

Jedoch, wenn die Verwendung der Reflexion ist nicht eine harte Anforderung, können Sie diese Informationen abrufen direkt aus dem source-code (sofern Sie es haben).

InformationsquelleAutor der Antwort danben

Als @Bozho erwähnt, ist es möglich, es zu tun, wenn debug-Informationen enthalten, die während der Kompilierung.
Es gibt eine gute Antwort hier...

Wie man die Namen der parameter eines Objekts Konstruktoren (Reflexion)? durch
@AdamPaynter

...mit der ASM-Bibliothek. Ich habe ein Beispiel zeigt, wie Sie Ihr Ziel erreichen.

Starten Sie als erstes mit einem pom.xml mit diesen Abhängigkeiten.

<dependency>
    <groupId>org.ow2.asm</groupId>
    <artifactId>asm-all</artifactId>
    <version>5.2</version>
</dependency>
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
    <scope>test</scope>
</dependency>

Dann, diese Klasse soll das tun, was Sie wollen. Einfach aufrufen der statischen Methode getParameterNames().

import org.objectweb.asm.ClassReader;
import org.objectweb.asm.Type;
import org.objectweb.asm.tree.ClassNode;
import org.objectweb.asm.tree.LocalVariableNode;
import org.objectweb.asm.tree.MethodNode;

public class ArgumentReflection {
    /**
     * Returns a list containing one parameter name for each argument accepted
     * by the given constructor. If the class was compiled with debugging
     * symbols, the parameter names will match those provided in the Java source
     * code. Otherwise, a generic "arg" parameter name is generated ("arg0" for
     * the first argument, "arg1" for the second...).
     * 
     * This method relies on the constructor's class loader to locate the
     * bytecode resource that defined its class.
     * 
     * @param theMethod
     * @return
     * @throws IOException
     */
    public static List<String> getParameterNames(Method theMethod) throws IOException {
        Class<?> declaringClass = theMethod.getDeclaringClass();
        ClassLoader declaringClassLoader = declaringClass.getClassLoader();

        Type declaringType = Type.getType(declaringClass);
        String constructorDescriptor = Type.getMethodDescriptor(theMethod);
        String url = declaringType.getInternalName() + ".class";

        InputStream classFileInputStream = declaringClassLoader.getResourceAsStream(url);
        if (classFileInputStream == null) {
            throw new IllegalArgumentException(
                    "The constructor's class loader cannot find the bytecode that defined the constructor's class (URL: "
                            + url + ")");
        }

        ClassNode classNode;
        try {
            classNode = new ClassNode();
            ClassReader classReader = new ClassReader(classFileInputStream);
            classReader.accept(classNode, 0);
        } finally {
            classFileInputStream.close();
        }

        @SuppressWarnings("unchecked")
        List<MethodNode> methods = classNode.methods;
        for (MethodNode method : methods) {
            if (method.name.equals(theMethod.getName()) && method.desc.equals(constructorDescriptor)) {
                Type[] argumentTypes = Type.getArgumentTypes(method.desc);
                List<String> parameterNames = new ArrayList<String>(argumentTypes.length);

                @SuppressWarnings("unchecked")
                List<LocalVariableNode> localVariables = method.localVariables;
                for (int i = 1; i <= argumentTypes.length; i++) {
                    //The first local variable actually represents the "this"
                    //object if the method is not static!
                    parameterNames.add(localVariables.get(i).name);
                }

                return parameterNames;
            }
        }

        return null;
    }
}

Hier ist ein Beispiel mit einem unit-test.

public class ArgumentReflectionTest {

    @Test
    public void shouldExtractTheNamesOfTheParameters3() throws NoSuchMethodException, SecurityException, IOException {

        List<String> parameterNames = ArgumentReflection
                .getParameterNames(Clazz.class.getMethod("callMe", String.class, String.class));
        assertEquals("firstName", parameterNames.get(0));
        assertEquals("lastName", parameterNames.get(1));
        assertEquals(2, parameterNames.size());

    }

    public static final class Clazz {

        public void callMe(String firstName, String lastName) {
        }

    }
}

Können Sie finden das vollständige Beispiel auf GitHub

Vorsichtsmaßnahmen

• Ich leicht verändert die ursprüngliche Lösung von @AdamPaynter, damit es funktioniert für die Methoden. Wenn ich das richtig verstanden, seine Lösung funktioniert nur mit Konstruktoren.
• Diese Lösung funktioniert nicht mit static Methoden. Dies ist, weil in diesem Fall die Anzahl der Argumente zurück durch ASM ist anders, aber es ist etwas, das leicht behoben werden können.

InformationsquelleAutor der Antwort danidemi