Java如何获取方法参数具体名称？这是个好问题！

默认情况下，我们是无法获取方法中参数名称的。通过反射机制，也只能得到参数的顺序以及一些没有意义的变量：arg0、arg1等等。

公司主营业务：成都网站设计、做网站、移动网站开发等业务。帮助企业客户真正实现互联网宣传，提高企业的竞争能力。成都创新互联是一支青春激扬、勤奋敬业、活力青春激扬、勤奋敬业、活力澎湃、和谐高效的团队。公司秉承以“开放、自由、严谨、自律”为核心的企业文化，感谢他们对我们的高要求，感谢他们从不同领域给我们带来的挑战，让我们激情的团队有机会用头脑与智慧不断的给客户带来惊喜。成都创新互联推出鞍山免费做网站回馈大家。

但我们又确实需要这部分信息。比如IDE的自动提示，文档化服务接口的详细信息等。

这是因为，这些变量的名字，根本就没有编译进class文件中，它不可能凭空产生。

在JDK 8之后，可以通过在编译时指定-parameters选项，将方法的参数名记入class文件，并在运行时通过反射机制获取相关信息。

如果你的项目是实用maven构建，那么就可以加入几行配置，追加参数。

 
 
 
 
    
  
  
  
  
  1.   
    2. 
  
  
  
  
  2.     maven-compiler-plugin  
    3. 
  
  
  
  
  3.     3.8.0  
    4. 
  
  
  
  
  4.       
    5. 
  
  
  
  
  5.         1.8  
    6. 
  
  
  
  
  6.         1.8  
    7. 
  
  
  
  
  7.         utf8  
    8. 
  
  
  
  
  8.           
    9. 
  
  
  
  
  9.             -parameters  
    10. 
  
  
  
  
  10.           
    11. 
  
  
  
  
  11.       
    12. 
  
  
  
  
  12.   
    13.

如果是用的IDEA等编辑器，也可以通过设置界面进行配置。不过不推荐这样，因为你的这些配置不好进行共享。

在普通Java项目里，就可以通过下面的方式来获取反射数据。Method.getParameters这个方法是新加的。

 
 
 
 
    
  
  
  
  
  1. public class Test {
    2. 
  
  
  
  
  2.   
    3. 
  
  
  
  
  3.     public static void main(String[] args) throws Exception{
    4. 
  
  
  
  
  4.         Class clazz = Class.forName("com.test.MethodParameterTest");
    5. 
  
  
  
  
  5.         Method[] methods = clazz.getMethods();
    6. 
  
  
  
  
  6.         Constructor[] constructors = clazz.getConstructors();
    7. 
  
  
  
  
  7.         for (Constructor constructor : constructors) {
    8. 
  
  
  
  
  8.             System.out.println("+++" + constructor.getName());
    9. 
  
  
  
  
  9.             Parameter[] parameters = constructor.getParameters();
    10. 
  
  
  
  
  10.             for (Parameter parameter : parameters) {
    11. 
  
  
  
  
  11.                 printParameter(parameter);
    12. 
  
  
  
  
  12.             }
    13. 
  
  
  
  
  13.         }
    14. 
  
  
  
  
  14.   
    15. 
  
  
  
  
  15.         System.out.println("------------------");
    16. 
  
  
  
  
  16.         for (Method method : methods) {
    17. 
  
  
  
  
  17.             System.out.println(method.getName());
    18. 
  
  
  
  
  18.             Parameter[] parameters = method.getParameters();
    19. 
  
  
  
  
  19.             for (Parameter parameter : parameters) {
    20. 
  
  
  
  
  20.                 printParameter(parameter);
    21. 
  
  
  
  
  21.             }
    22. 
  
  
  
  
  22.         }
    23. 
  
  
  
  
  23.     }
    24. 
  
  
  
  
  24.   
    25. 
  
  
  
  
  25.     private static void printParameter(Parameter parameter) {
    26. 
  
  
  
  
  26.         //参数名
    27. 
  
  
  
  
  27.         System.out.println("\t\t" + parameter.getName());
    28. 
  
  
  
  
  28.         //是否在源码中隐式声明的参数名
    29. 
  
  
  
  
  29.         System.out.println("\t\t\t implicit:" + parameter.isImplicit());
    30. 
  
  
  
  
  30.         //类文件中，是否存在参数名
    31. 
  
  
  
  
  31.         System.out.println("\t\t\t namePresent:" + parameter.isNamePresent());
    32. 
  
  
  
  
  32.         //是否为虚构参数
    33. 
  
  
  
  
  33.         System.out.println("\t\t\t synthetic:" + parameter.isSynthetic());
    34. 
  
  
  
  
  34.         System.out.println("\t\t\t VarArgs:" + parameter.isVarArgs());
    35. 
  
  
  
  
  35.     }
    36. 
  
  
  
  
  36. }
    37.

下面介绍几个方法的意义：

isImplicit()

参数是否为隐式声明在源文件中，比如内部类，默认构造函数(无参)其实在编译成class时将会把包含它的主类引用作为首个参数，此参数即为隐式声明。

如果为true，即表示有JDK编译器隐式生成在class文件中的方法参数，而source文件中并不可见。常规的普通方法，此值为false。

isNamePresent()

此参数在class文件中是否有此参数名;受制于在编译时是否指定了“-parameter”，对于指定此参数的编译文件，通常为true;对于JDK 内部类、默认编译的类，通常为false;此时你会发现，它们的参数名通常为表意名称：arg0、arg1等等，此时为false。

isSynthetic()

是否为“虚构”参数，如果为true，表示既不是“显式”声明、也不是隐式声明在源文件中的参数，比如enum类的“values()”、“valueOf(String)”这是编译器“虚构”的系统方法。

在Spring环境中，由于有工具类的支持，会更加方便一些。

 
 
 
 
    
  
  
  
  
  1. public class SpringTest {
    2. 
  
  
  
  
  2.   
    3. 
  
  
  
  
  3.     private static final ParameterNameDiscoverer parameterNameDiscoverer = new DefaultParameterNameDiscoverer();
    4. 
  
  
  
  
  4.   
    5. 
  
  
  
  
  5.   
    6. 
  
  
  
  
  6.     public static void main(String[] args) throws Exception{
    7. 
  
  
  
  
  7.         Class clazz = Class.forName("com.test.MethodParameterTest");
    8. 
  
  
  
  
  8.         Method[] methods = clazz.getMethods();
    9. 
  
  
  
  
  9.         for (Method method : methods) {
    10. 
  
  
  
  
  10.             System.out.println(method.getName());
    11. 
  
  
  
  
  11.             //JDK 1.8 + is better.
    12. 
  
  
  
  
  12.             String[] parameterNames = parameterNameDiscoverer.getParameterNames(method);
    13. 
  
  
  
  
  13.             if (parameterNames == null) {
    14. 
  
  
  
  
  14.                 continue;
    15. 
  
  
  
  
  15.             }
    16. 
  
  
  
  
  16.             for (String pn : parameterNames) {
    17. 
  
  
  
  
  17.                 System.out.println("\t\t" + pn);
    18. 
  
  
  
  
  18.             }
    19. 
  
  
  
  
  19.         }
    20. 
  
  
  
  
  20.     }
    21. 
  
  
  
  
  21. }
    22.

那Java版本低于1.8的时候，又是怎么获取的呢?我们可以参考Spring的LocalVariableTableParameterNameDiscoverer类。

 
 
 
 
    
  
  
  
  
  1. public String[] getParameterNames(Method method) {
    2. 
  
  
  
  
  2.         Method originalMethod = BridgeMethodResolver.findBridgedMethod(method);
    3. 
  
  
  
  
  3.         return doGetParameterNames(originalMethod);
    4. 
  
  
  
  
  4. }
    5. 
  
  
  
  
  5. @Nullable
    6. 
  
  
  
  
  6. private String[] doGetParameterNames(Executable executable) {
    7. 
  
  
  
  
  7.         Class declaringClass = executable.getDeclaringClass();
    8. 
  
  
  
  
  8.         Map map = this.parameterNamesCache.computeIfAbsent(declaringClass, this::inspectClass);
    9. 
  
  
  
  
  9.         return (map != NO_DEBUG_INFO_MAP ? map.get(executable) : null);
    10. 
  
  
  
  
  10. }
    11.

最后就走到了inspectClass方法中。

 
 
 
 
    
  
  
  
  
  1. private Map inspectClass(Class clazz) {
    2. 
  
  
  
  
  2.         InputStream is = clazz.getResourceAsStream(ClassUtils.getClassFileName(clazz));
    3. 
  
  
  
  
  3.         if (is == null) {
    4. 
  
  
  
  
  4.             // We couldn't load the class file, which is not fatal as it
    5. 
  
  
  
  
  5.             // simply means this method of discovering parameter names won't work.
    6. 
  
  
  
  
  6.             if (logger.isDebugEnabled()) {
    7. 
  
  
  
  
  7.                 logger.debug("Cannot find '.class' file for class [" + clazz +
    8. 
  
  
  
  
  8.                         "] - unable to determine constructor/method parameter names");
    9. 
  
  
  
  
  9.             }
    10. 
  
  
  
  
  10.             return NO_DEBUG_INFO_MAP;
    11. 
  
  
  
  
  11.         }
    12. 
  
  
  
  
  12.         try {
    13. 
  
  
  
  
  13.             ClassReader classReader = new ClassReader(is);
    14. 
  
  
  
  
  14.             Map map = new ConcurrentHashMap<>(32);
    15. 
  
  
  
  
  15.             classReader.accept(new ParameterNameDiscoveringVisitor(clazz, map), 0);
    16. 
  
  
  
  
  16.             return map;
    17. 
  
  
  
  
  17.         }
    18. 
  
  
  
  
  18.         ...
    19.

可以看到，这种情况下，Spring是通过直接读取class文件进行解析的。实际上是通过读取LocalVariableTable中的数据进行获取的。如果你编译的时候没有加入这些debug选项，同样也拿不到方法参数的具体名称。

总结一下

  • Java8以前，读取Class中的LocalVariableTable属性表，需要编译时加入参数-g或者-g:vars 获取方法局部变量调试信息；
  • Java8及其以后，通过java.lang.reflect.Parameter#getName即可获取，但需要编译时加入参数-parameters参数。

网页名称：Java如何获取方法参数具体名称？这是个好问题！
转载来源：http://www.shufengxianlan.com/qtweb/news7/220307.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

企业网站制作知识

行业网站建设

成都小程序开发　　 　东方电机技改　　 　江油做网站　　 　微官网开发　　 　四川电信机房托管　　 　南充服务器托管　　 　青年旅行社　　 　西云服务器托管　　 　成都网站建设　　 　网站排名　　 　成都租用服务器　　 　成都微信开发　　 　边坡防护网　　 　网站改版　　 　成都定制网站建设　　 　成都网站建设　　 　网站seo优化　　 　四川德阳主机托管　　 　微信小程序　　 　成都App定制