反射取含数组的构造函数时的参数类型传递

今天在和瑾华讨论ASM的时候，通过将反射的method转换为asm的method时遇到反射时数组的问题。当时两个人都卡住了，现在实验通了，顺手记录下来。

原始类：

1. public class Person implements China { 
2.     protected String name; 
3.  
4.     public Person(String name) { 
5.         this.name = name; 
6.     } 
7.     public Person(String name1[],String name2) { 
8.     } 
9.  
10.     public String sayHello(String name) { 
11.         return "welcome " + name; 
12.     } 
13.  
14.     protected void protect() { 
15.         privatedMethod(); 
16.     } 
17.  
18.     private void privatedMethod() { 
19.  
20.     } 
21.  
22. } 

通过反射取得构造函数， 通常的方法为：

1. @Test 
2.     public void test04() { 
3.         try { 
4.             Class<?> clazz = (Class<?>) Class 
5.                     .forName("com.alibaba.demoeo.reflect.classes.Person"); 
6.             Constructor<?>[] constructs = clazz.getConstructors(); 
7.             for (Constructor<?> construct : constructs) { 
8.                 System.out.println(construct.getName()); 
9.             } 
10.         } catch (Exception e) { 
11.             e.printStackTrace(); 
12.         } 
13.     } 

如果要取得特定参数的构造函数，则为：

1. @Test 
2.     public void test07() { 
3.         try { 
4.             Class<?> clazz = (Class<?>) Class 
5.             .forName("com.alibaba.demoeo.reflect.classes.Person"); 
6.             Constructor<?> construct = clazz.getConstructor(String.class); 
7.             System.out.println(construct); 
8.         } catch (Exception e) { 
9.             e.printStackTrace(); 
10.         } 
11.     } 

问题引出：而要取得含有数组的参数的构造函数如何办呢？ 这也是我们卡住的原因，实验了clazz.getConstructor(String.class, String.class); clazz.getConstructor(Array.class, String.class);等都不行， 后来通过反射机制将参数类型输出进行查看，发现数组为：class [Ljava.lang.String;

1. @Test 
2. public void test05() { 
3.     try { 
4.         Class<?> clazz = (Class<?>) Class 
5.         .forName("com.alibaba.demoeo.reflect.classes.Person"); 
6.         Constructor<?>[] constructs = clazz.getConstructors(); 
7.          
8.         for (Constructor<?> construct : constructs) { 
9.             Class<?>[] types = construct.getParameterTypes(); 
10.             for(Class<?> type : types){ 
11.                 System.out.println(type); 
12.             } 
13.             System.out.println("-------------"); 
14.         } 
15.     } catch (Exception e) { 
16.         e.printStackTrace(); 
17.     } 
18. } 

输出为：

1. class java.lang.String 
2. ------------- 
3. class [Ljava.lang.String; 
4. class java.lang.String 
5. ------------- 

好的，现在知道是什么内容了，那就使用这种类型来构造：

1. @Test 
2.     public void test06() { 
3.         try { 
4.             Class<?> clazz = (Class<?>) Class 
5.             .forName("com.alibaba.demoeo.reflect.classes.Person"); 
6.             Constructor<?> construct = clazz.getConstructor(Class.forName(("[Ljava.lang.String;")), String.class); 
7.             System.out.println(construct); 
8.         } catch (Exception e) { 
9.             e.printStackTrace(); 
10.         } 
11.     } 

测试结果正确，输出如下：

1. public com.alibaba.demoeo.reflect.classes.Person(java.lang.String[],java.lang.String) 

考虑getConstructor的参数为可变数组，于是考虑通过传递数组类型给getConstructor方法，经测试后通过，具体如下：

1. @Test 
2.     public void test08() { 
3.         try { 
4.             Class<?> clazz = (Class<?>) Class 
5.             .forName("com.alibaba.demoeo.reflect.classes.Person"); 
6.             Constructor<?> construct = clazz.getConstructor(new Class[]{String[].class,String.class}); 
7.             System.out.println(construct); 
8.         } catch (Exception e) { 
9.             e.printStackTrace(); 
10.         } 
11.     } 

使用此方法测试ASM转换：

1. public class Demo { 
2.     public void test(String[] str){} 
3.     /** 
4.      * @param args 
5.      */ 
6.     public static void main(String[] args) throws Exception{ 
7.         java.lang.reflect.Method method = Demo.class.getMethod("test", Class.forName("[Ljava.lang.String;")); 
8.         //java.lang.reflect.Method method = Demo.class.getMethod("test", new Class[]{String[].class}); 
9.          
10.         com.alibaba.citrus.asm.commons.Method asmMethod = com.alibaba.citrus.asm.commons.Method.getMethod(method); 
11.         System.out.println(asmMethod.getDescriptor()); 
12.     } 
13. } 

或者

1. public class Demo { 
2.     public void test(String[] str){} 
3.     /** 
4.      * @param args 
5.      */ 
6.     public static void main(String[] args) throws Exception{ 
7.         //java.lang.reflect.Method method = Demo.class.getMethod("test", Class.forName("[Ljava.lang.String;")); 
8.         java.lang.reflect.Method method = Demo.class.getMethod("test", new Class[]{String[].class}); 
9.          
10.         com.alibaba.citrus.asm.commons.Method asmMethod = com.alibaba.citrus.asm.commons.Method.getMethod(method); 
11.         System.out.println(asmMethod.getDescriptor()); 
12.     } 
13. } 

测试结果：

1. ([Ljava/lang/String;)V 

【注意】

1、今天讨论之后，也可以使用String[].class表达字符串数组也是可以的

本文转自 tianya23 51CTO博客，原文链接：http://blog.51cto.com/tianya23/568119，如需转载请自行联系原作者