我可以使用Java反射获取方法参数名吗？

时间：2010-02-10 15:10:35

标签： java reflection

如果我有这样的课程：

public class Whatever
{
  public void aMethod(int aParam);
}

有没有办法知道aMethod使用名为aParam的参数，类型为int？

15 个答案:

答案 0 :(得分：89)

在Java 8中，您可以执行以下操作：

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(){}
}

因此，对于您的班级Whatever，我们可以进行手动测试：

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;
            }
        }
    }
}

如果已将[aParam]参数传递给Java 8编译器，则应打印-parameters。

对于Maven用户：

<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>

有关详细信息，请参阅以下链接：

  1. Official Java Tutorial: Obtaining Names of Method Parameters
  2. JEP 118: Access to Parameter Names at Runtime
  3. Javadoc for Parameter class

答案 1 :(得分：78)

总结：

    如果在编译期间包含调试信息，则
  • 获取参数名称​​是。有关详细信息，请参阅this answer
  • 否则获取参数名称​​不可能
  • 可以使用method.getParameterTypes()
    • 获取参数类型

为编写编辑器的自动完成功能（正如您在其中一条评论中所述），有几个选项：

  • 使用arg0，arg1，arg2等
  • 使用intParam，stringParam，objectTypeParam等
  • 使用上述的组合 - 前者用于非基本类型，后者用于基本类型。
  • 根本不显示参数名称 - 只显示类型。

答案 2 :(得分：14)

创建Paranamer库是为了解决同样的问题。

它尝试以几种不同的方式确定方法名称。如果使用调试编译类，则可以通过读取类的字节码来提取信息。

另一种方法是在编译之后，在将它放入jar之前，将私有静态成员注入到类的字节码中。然后它使用反射在运行时从类中提取此信息。

https://github.com/paul-hammant/paranamer

我在使用这个库时遇到了问题，但最终确实让它工作了。我希望向维护者报告这些问题。

答案 3 :(得分：9)

是。
代码必须使用符合Java 8标准的编译器进行编译，并且可以选择打开正式参数名称（ - 参数选项）。
然后，此代码段应该有效：

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());
   }
}

答案 4 :(得分：7)

请参阅org.springframework.core.DefaultParameterNameDiscoverer类

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

答案 5 :(得分：5)

您可以使用反射检索方法并检测它的参数类型。查看http://java.sun.com/j2se/1.4.2/docs/api/java/lang/reflect/Method.html#getParameterTypes%28%29

但是，你不能告诉所用参数的名称。

答案 6 :(得分：3)

有可能而且Spring MVC 3可以做到，但我没有花时间仔细查看具体方法。

  

方法参数名称的匹配   到URI模板变量名称可以   只有在编译代码时才能完成   启用调试。如果你有的话   没有调试启用，你必须   指定URI模板的名称   @PathVariable中的变量名   注释以绑定   已解析变量名称的值   方法参数。例如：

取自spring documentation

答案 7 :(得分：3)

虽然不可能（正如其他人所说），但可以使用注释来继承参数名称，并通过反射获得它。

不是最干净的解决方案，但它完成了工作。一些web服务实际上是为了保留参数名称（即：使用glassfish部署WS）。

答案 8 :(得分：3)

请参阅java.beans.ConstructorProperties，这是一个专门用于完成此操作的注释。

答案 9 :(得分：2)

所以你应该能够做到：

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

但是你可能会得到一个这样的列表：

["int : arg0"]

I believe this will be fixed in Groovy 2.5+

目前，答案是：

  • 如果它是一个Groovy类，那么不，你不能得到这个名字，但你将来应该能够。
  • 如果它是在Java 8下编译的Java类，您应该能够。

另见：

对于每种方法，然后是：

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

答案 10 :(得分：2)

如果您使用eclipse，请参阅下面的图像以允许编译器存储有关方法参数的信息

enter image description here

答案 11 :(得分：0)

参数名称仅对编译器有用。当编译器生成类文件时，不包括参数名称 - 方法的参数列表仅包含其参数的数量和类型。所以不可能使用反射检索参数名称（在你的问题中标记） - 它在任何地方都不存在。

但是，如果使用反射并不是一项硬性要求，您可以直接从源代码中检索此信息（假设您拥有它）。

答案 12 :(得分：0)

加我2美分;当您使用javac -g编译源时，参数信息在类文件“for debugging”中可用。它可供APT使用，但您需要一个注释，因此对您没用。 （有人在4 - 5年前讨论了类似的问题：http://forums.java.net/jive/thread.jspa?messageID=13467&tstart=0）

除非您直接处理源文件（类似于APT在编译时所做的事情），否则除非直接处理源文件，否则无法获取它。

答案 13 :(得分：0)

正如@Bozho所说，如果在编译期间包含调试信息，则可以这样做。 这里有一个很好的答案......

How to get the parameter names of an object's constructors (reflection)? by @AdamPaynter

...使用ASM库。我汇总了一个展示如何实现目标的例子。

首先，从带有这些依赖项的pom.xml开始。

<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>

然后，这个课应该做你想要的。只需调用静态方法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;
    }
}

以下是单元测试的示例。

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) {
        }

    }
}

您可以在GitHub

上找到完整的示例

注意事项

  • 我稍微改变了@AdamPaynter的原始解决方案，使其适用于方法。如果我理解正确，他的解决方案只适用于构造函数。
  • 此解决方案不适用于static方法。这是因为在这种情况下，ASM返回的参数数量不同，但它可以很容易地修复。

答案 14 :(得分：0)

从 Java 字节码中读取附加符号信息的一种简单方法是：

Reflector reflector = new Reflector();
JavaMethod method = reflector.reflect(Whatever.class)
    .getMethods()
    .stream()
    .filter(m -> "aMethod".equals(m.getName()))
    .findFirst()
    .get();
String paramName = method.getParameters().getVariables().get(0).getName();
System.out.println(paramName);

来自 Maven Central 工件：

<dependency>
    <groupId>com.intersult</groupId>
    <artifactId>coder</artifactId>
    <version>1.5</version>
</dependency>
相关问题
最新问题