java反射的一些调试

额，研究过这个的人很多很多，但是我没有很深入的研究过，所以谁也拦不住我去研究研究，然后记录下来······如有雷同··那就雷同了···请多多包涵。

首先是整个项目的结构：

使用到的类：

[java] view plain copy

1. package reflect.demo;  
2.   
3. public class Demo {  
4.   
5. }  

[java] view plain copy

1. package reflect.person;  
2.   
3. import lombok.AllArgsConstructor;  
4. import lombok.Data;  
5. import lombok.NoArgsConstructor;  
6.   
7. @AllArgsConstructor  
8. @NoArgsConstructor  
9. public @Data class Person {  
10.   
11.     private String name;  
12.     private int age;  
13.   
14.     public Person(int age) {  
15.         super();  
16.         this.age = age;  
17.     }  
18.   
19.     public Person(String name) {  
20.         super();  
21.         this.name = name;  
22.     }  
23.   
24. }  

[java] view plain copy

1. package reflect.person1;  
2.   
3. public interface China {  
4.     public static final String name = "xxxxx";  
5.     public static int age = 12;  
6.   
7.     public void sayChina();  
8.   
9.     public void sayHello(String name, int age);  
10. }  

[java] view plain copy

1. package reflect.person1;  
2.   
3. import lombok.AllArgsConstructor;  
4. import lombok.Data;  
5. import lombok.NoArgsConstructor;  
6.   
7. @Data  
8. @NoArgsConstructor  
9. @AllArgsConstructor  
10. public class Person1 implements China {  
11.     private String sex;  
12.   
13.     @Override  
14.     public void sayChina() {  
15.         System.out.println("hello,china");  
16.     }  
17.   
18.     @Override  
19.     public void sayHello(String name, int age) {  
20.         System.out.println(name + "---" + age);  
21.     }  
22.   
23. }  

[java] view plain copy

1. package reflect;  
2.   
3. import lombok.Getter;  
4. import lombok.Setter;  
5.   
6. public class HelloOriginal {  
7.     @Getter  
8.     @Setter  
9.     private static Class<?> demo;  
10.   
11.     static {  
12.         try {  
13.             demo = Class.forName("reflect.person1.Person1");  
14.         } catch (ClassNotFoundException e) {  
15.             // TODO Auto-generated catch block  
16.             e.printStackTrace();  
17.         }  
18.     }  
19. }  

1.凡是程序，都以HELLOWORLD来开始，貌似谁也避免不了哩。

[java] view plain copy

1. package reflect.test1;  
2.   
3. import reflect.demo.Demo;  
4.   
5. /** 
6.  * @author Administrator 通过一个对象获得完整的包名和类名 
7.  */  
8. public class Hello {  
9.     public static void main(String[] args) {  
10.         Demo demo = new Demo();  
11.         System.out.println(demo.getClass().getName());  
12.     }  
13. }  

这是反射的最最基础的东西了吧，我新建了一个对象，并且通过这个对象来获得它的class，有了class以后，我就可以操作class的相关信息了，这里我打印出了这个class的name属性。

这里就很容易的理解了反射，反射反射就是反过来搞。我们总是通过类来创建对象，而现在我们通过一个特定的对象（有时候我们不知道这个对象所属什么类）获得了它所归属的类的相关信息。

运行结果：

2.创建class对象的三种方式

[java] view plain copy

1. package reflect.test2;  
2.   
3. import reflect.demo.Demo;  
4.   
5. /** 
6.  * @author Administrator 实例化Class类对象 
7.  * 
8.  */  
9. public class Hello {  
10.     public static void main(String[] args) {  
11.         Class<?> demo1 = null;  
12.         // Class<?>是一种泛型的表达，意思是Object类及其子类都可以放  
13.         Class<?> demo2 = null;  
14.         Class<?> demo3 = null;  
15.   
16.         try {  
17.             // 一般使用的方式,通过指定特定的名称来创建class  
18.             demo1 = Class.forName("reflect.demo.Demo");  
19.         } catch (Exception e) {  
20.             e.printStackTrace();  
21.         }  
22.   
23.         demo2 = new Demo().getClass();//通过一个对象来获得class  
24.         demo3 = Demo.class;//通过类来获得class  
25.   
26.         System.out.println("类名称   " + demo1.getName());  
27.         System.out.println("类名称   " + demo2.getName());  
28.         System.out.println("类名称   " + demo3.getName());  
29.     }  
30.   
31. }  

运行结果：

3.通过反射来创建(实例化)一个对象，使用的是无参构造方法。

[java] view plain copy

1. package reflect.test3;  
2.   
3. import reflect.person.Person;  
4.   
5. /** 
6.  * @author Administrator 通过Class实例化其他类的对象 
7.  *  
8.  *         通过无参构造实例化对象 
9.  */  
10. public class Hello {  
11.     public static void main(String[] args) {  
12.         Class<?> demo = null;  
13.         try {  
14.             demo = Class.forName("reflect.person.Person");//获得了特定名称的类的class对象  
15.         } catch (ClassNotFoundException e) {  
16.             e.printStackTrace();  
17.         }  
18.         Person person = null;  
19.   
20.         try {  
21.             person = (Person) demo.newInstance();//使用class对象的newInstance()方法就可以创建一个对象了。  
22.             /** 
23.              *  
24.              *  
25.              * */  
26.         } catch (InstantiationException e) {  
27.             // TODO Auto-generated catch block  
28.             e.printStackTrace();  
29.         } catch (IllegalAccessException e) {  
30.             // TODO Auto-generated catch block  
31.             e.printStackTrace();  
32.         }  
33.   
34.         person.setName("ri");  
35.         person.setAge(1);  
36.   
37.         System.out.println(person);  
38.     }  
39. }  

4.通过有参的构造方法来构造对象

[java] view plain copy

1. package reflect.test4;  
2.   
3. import java.lang.reflect.Constructor;  
4.   
5. import reflect.person.Person;  
6.   
7. /** 
8.  * @author Administrator 
9.  * 
10.  *         通过Class调用其他类中的构造函数 （也可以通过这种方式通过Class创建其他类的对象） 
11.  */  
12. public class Hello {  
13.   
14.     public static void main(String[] args) {  
15.         Class<?> demo = null;  
16.         try {  
17.             demo = Class.forName("reflect.person.Person");  
18.         } catch (ClassNotFoundException e) {  
19.             // TODO Auto-generated catch block  
20.             e.printStackTrace();  
21.         }  
22.         Person per1 = null;  
23.         Person per2 = null;  
24.         Person per3 = null;  
25.         Person per4 = null;  
26.   
27.         Constructor<?> cons[] = demo.getConstructors();  
28.         try {  
29.             per4 = (Person) cons[0].newInstance();  
30.             per3 = (Person) cons[1].newInstance("ri", 12);  
31.             per1 = (Person) cons[2].newInstance("dd");  
32.             per2 = (Person) cons[3].newInstance(12);  
33.         } catch (Exception e) {  
34.             e.printStackTrace();  
35.         }  
36.   
37.         System.out.println(per1);  
38.         System.out.println(per2);  
39.         System.out.println(per3);  
40.         System.out.println(per4);  
41.   
42.     }  
43. }  

5.通过反射来获得一个类所实现的接口

[java] view plain copy

1. package reflect.test5;  
2.   
3. /** 
4.  * @author Administrator 返回一个类实现的接口 
5.  */  
6. public class Hello {  
7.     public static void main(String[] args) {  
8.         Class<?> demo = null;  
9.         try {  
10.             demo = Class.forName("reflect.person1.Person1");  
11.         } catch (ClassNotFoundException e) {  
12.             e.printStackTrace();  
13.         }  
14.   
15.         // 获得所有的接口  
16.         Class<?> intes[] = demo.getInterfaces();  
17.         for (int i = 0; i < intes.length; i++) {  
18.             System.out.println("Person1实现的接口:" + intes[i].getName());  
19.         }  
20.     }  
21. }  

运行结果：

6.通过反射来获得指定类的父类

[java] view plain copy

1. package reflect.test6;  
2.   
3.   
4. /** 
5.  * @author Administrator 取得其他类中的父类 
6.  */  
7. public class Hello {  
8.     public static void main(String[] args) {  
9.         Class<?> demo = null;  
10.         try {  
11.             demo = Class.forName("reflect.person1.Person1");  
12.         } catch (ClassNotFoundException e) {  
13.             // TODO Auto-generated catch block  
14.             e.printStackTrace();  
15.         }  
16.         Class<?> superClass = demo.getSuperclass();  
17.         System.out.println("继承的父类为" + superClass.getName());  
18.     }  
19. }  

运行结果：

7.通过反射来获得指定类中的构造方法

[java] view plain copy

1. package reflect.test7;  
2.   
3. import java.lang.reflect.Constructor;  
4.   
5. /** 
6.  * @author Administrator获得其他类中的全部构造函数 
7.  * 
8.  */  
9. public class Hello {  
10.   
11.     public static void main(String[] args) {  
12.         Class<?> demo = null;  
13.         try {  
14.             demo = Class.forName("reflect.person1.Person1");  
15.         } catch (ClassNotFoundException e) {  
16.             // TODO Auto-generated catch block  
17.             e.printStackTrace();  
18.         }  
19.         Constructor<?> cons[] = demo.getConstructors();  
20.         for (Constructor<?> con : cons) {  
21.             System.out.println(con);  
22.         }  
23.     }  
24. }  

8.通过拼装的方式来获得构造方法（本质是获得构造方法的各种信息，我们也可以用在类的各种方法上）

[java] view plain copy

1. package reflect.test8;  
2.   
3. import java.lang.reflect.Constructor;  
4. import java.lang.reflect.Modifier;  
5.   
6. import reflect.HelloOriginal;  
7.   
8. /** 
9.  * @author Administrator 拼装获得构造方法的全部内容 
10.  */  
11. public class Hello extends HelloOriginal {  
12.     public static void main(String[] args) {  
13.         Constructor<?>[] cons = getDemo().getConstructors();  
14.         for (Constructor<?> con : cons) {  
15.             Class<?>[] pts = con.getParameterTypes();  
16.             System.out.print("构造方法:  ");  
17.             int mo = con.getModifiers();  
18.             System.out.print(Modifier.toString(mo) + " ");  
19.             System.out.print(con.getName());  
20.             System.out.print("(");  
21.             for (int i = 0; i < pts.length; i++) {  
22.                 System.out.print(pts[i].getName() + " arg" + i);  
23.                 if (i < pts.length - 1) {  
24.                     System.out.print(",");  
25.                 }  
26.             }  
27.             System.out.println("){}");  
28.         }  
29.     }  
30. }  

9.拼装类中的所有方法的签名

[java] view plain copy

1. package reflect.test9;  
2.   
3. import java.lang.reflect.Method;  
4. import java.lang.reflect.Modifier;  
5.   
6. import reflect.HelloOriginal;  
7.   
8. /** 
9.  * @author Administrator拼接获得类中普通方法的所有内容（方法签名） 
10.  * 
11.  */  
12. public class Hello9 extends HelloOriginal {  
13.     public static void main(String[] args) {  
14.         /*获得类中的所有方法*/  
15.         Method[] methods = getDemo().getMethods();  
16.         for (Method method : methods) {  
17.             Class<?> returnType = method.getReturnType();/*获得方法的返回类型的class实例*/  
18.             Class<?>[] pts = method.getParameterTypes();/*获得方法参数的class实例的数组*/  
19.             int tem = method.getModifiers();/*获得方法的修饰符*/  
20.             System.out.print(Modifier.toString(tem) + " ");  
21.             System.out.print(returnType.getName() + " ");  
22.             System.out.print(method.getName() + "(");  
23.             for (int i = 0; i < pts.length; i++) {  
24.                 System.out.print(pts[i].getName() + "arg" + i);  
25.                 if (i < pts.length - 1) {  
26.                     System.out.print(",");  
27.                 }  
28.             }  
29.   
30.             Class<?>[] execs = method.getExceptionTypes();/*获得方法抛出的异常*/  
31.             if (execs.length > 0) {  
32.                 System.out.print(") throws ");  
33.                 for (int j = 0; j < execs.length; j++) {  
34.                     System.out.print(execs[j].getName() + " ");  
35.                     if (j < execs.length - 1) {  
36.                         System.out.print(",");  
37.                     }  
38.                 }  
39.   
40.             } else {  
41.                 System.out.print(")");  
42.             }  
43.             System.out.println("{}");  
44.         }  
45.     }  
46. }  

10.通过反射获得本类以及继承的属性

[java] view plain copy

1. package reflect.test10;  
2.   
3. import java.lang.reflect.Field;  
4. import java.lang.reflect.Modifier;  
5.   
6. import reflect.HelloOriginal;  
7.   
8. /** 
9.  * @author Administrator取得其他类的全部属性吧 
10.  * 
11.  */  
12. public class Hello extends HelloOriginal {  
13.   
14.     public static void main(String[] args) {  
15.         System.out.println("=================本类全部属性=====================");  
16.         Field[] fields = getDemo().getDeclaredFields();  
17.         for (int i = 0; i < fields.length; i++) {  
18.             // 权限修饰符  
19.             int mo = fields[i].getModifiers();  
20.             String priv = Modifier.toString(mo);  
21.             // 属性类型  
22.             Class<?> type = fields[i].getType();  
23.             System.out.println(priv + " " + type.getName() + " "  
24.                     + fields[i].getName() + ";");  
25.         }  
26.   
27.         System.out  
28.                 .println("===============实现的接口或者父类的属性========================");  
29.         Field[] fields1 = getDemo().getFields();  
30.         for (Field filed : fields1) {  
31.             // 权限修饰符  
32.             int mo = filed.getModifiers();  
33.             String priv = Modifier.toString(mo);  
34.             // 属性类型  
35.             Class<?> type = filed.getType();  
36.             System.out.println(priv + " " + type.getName() + " "  
37.                     + filed.getName() + ";");  
38.         }  
39.     }  
40. }  

11.通过反射来调用其他类中的方法

[java] view plain copy

1. package reflect.test11;  
2.   
3. import java.lang.reflect.InvocationTargetException;  
4. import java.lang.reflect.Method;  
5.   
6. import reflect.HelloOriginal;  
7.   
8. /** 
9.  * @author Administrator 通过反射调用其他类中的方法 
10.  */  
11. public class Hello extends HelloOriginal {  
12.     public static void main(String[] args) {  
13.         try {  
14.             Method method = getDemo().getMethod("sayChina");  
15.             method.invoke(getDemo().newInstance());  
16.   
17.             method = getDemo().getMethod("sayHello", String.class, int.class);  
18.             method.invoke(getDemo().newInstance(), "34324", 33);  
19.         } catch (NoSuchMethodException e) {  
20.             // TODO Auto-generated catch block  
21.             e.printStackTrace();  
22.         } catch (SecurityException e) {  
23.             // TODO Auto-generated catch block  
24.             e.printStackTrace();  
25.         } catch (IllegalAccessException e) {  
26.             // TODO Auto-generated catch block  
27.             e.printStackTrace();  
28.         } catch (IllegalArgumentException e) {  
29.             // TODO Auto-generated catch block  
30.             e.printStackTrace();  
31.         } catch (InvocationTargetException e) {  
32.             // TODO Auto-generated catch block  
33.             e.printStackTrace();  
34.         } catch (InstantiationException e) {  
35.             // TODO Auto-generated catch block  
36.             e.printStackTrace();  
37.         }  
38.     }  
39. }  

12.通过反射调用其他类的get和set方法

[java] view plain copy

1. package reflect.test12;  
2.   
3. import java.lang.reflect.Method;  
4.   
5. import reflect.HelloOriginal;  
6.   
7. /** 
8.  * @author Administrator 调用其他类的set和get方法 
9.  */  
10. public class Hello extends HelloOriginal {  
11.     public static void main(String[] args) throws Exception {  
12.         Object obj = getDemo().newInstance();  
13.         setter(obj, "Sex", "男", String.class);  
14.         getter(obj, "Sex");  
15.     }  
16.   
17.     public static void getter(Object obj, String att) throws Exception {  
18.         Method method = obj.getClass().getMethod("get" + att);  
19.         System.out.println(method.invoke(obj));  
20.     }  
21.   
22.     public static void setter(Object obj, String att, Object value,  
23.             Class<?> type) throws Exception {  
24.         Method method = obj.getClass().getMethod("set" + att, type);  
25.         method.invoke(obj, value);  
26.   
27.     }  
28. }  

13.通过反射操作其他类的属性

[java] view plain copy

1. package reflect.test13;  
2.   
3. import java.lang.reflect.Field;  
4.   
5. import reflect.HelloOriginal;  
6. import reflect.person1.Person1;  
7.   
8. /** 
9.  * @author Administrator 通过反射操作属性 
10.  */  
11. public class Hello extends HelloOriginal {  
12.     public static void main(String[] args) throws Exception {  
13.         Object obj = getDemo().newInstance();  
14.   
15.         Field field = getDemo().getDeclaredField("sex");  
16.         field.setAccessible(true);  
17.         field.set(obj, "女");  
18.         System.out.println(((Person1) obj).getSex());  
19.   
20.     }  
21. }  

14.通过反射获取并修改数组的信息

[java] view plain copy

1. package reflect.test14;  
2.   
3. import java.lang.reflect.Array;  
4.   
5. import reflect.HelloOriginal;  
6.   
7. /** 
8.  * @author Administrator 通过反射获取并修改数组的信息 
9.  */  
10. public class Hello extends HelloOriginal {  
11.     public static void main(String[] args) {  
12.         int[] tem = { 1, 2, 3, 4, 5 };  
13.         Class<?> test = tem.getClass().getComponentType();  
14.         System.out.println("数组类型" + test.getName());  
15.         System.out.println("数组长度  " + Array.getLength(tem));  
16.         System.out.println("数组的第一个元素: " + Array.get(tem, 0));  
17.         Array.set(tem, 0, 100);  
18.         System.out.println("修改之后数组第一个元素为： " + Array.get(tem, 0));  
19.     }  
20. }  

15.通过反射修改数组的大小

[java] view plain copy

1. package reflect.test15;  
2.   
3. import java.lang.reflect.Array;  
4.   
5. /** 
6.  * @author Administrator 通过反射修改数组大小 
7.  */  
8. public class Hello {  
9.     public static void main(String[] args) {  
10.         int[] temp = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };  
11.         int[] newTmep = (int[]) arrayInc(temp, 15);  
12.         print(newTmep);  
13.         String[] atr = { "a", "b", "c" };  
14.         String[] str1 = (String[]) arrayInc(atr, 8);  
15.         print(str1);  
16.     }  
17.   
18.     public static Object arrayInc(Object obj, int len) {  
19.         Class<?> tem = obj.getClass().getComponentType();  
20.         Object newArr = Array.newInstance(tem, len);  
21.         int co = Array.getLength(obj);  
22.         System.arraycopy(obj, 0, newArr, 0, co);  
23.         return newArr;  
24.     }  
25.   
26.     public static void print(Object obj) {  
27.         Class<?> clazz = obj.getClass();  
28.         if (!clazz.isArray()) {  
29.             return;  
30.         }  
31.         System.out.println("数组长度为----" + Array.getLength(obj));  
32.         for (int i = 0; i < Array.getLength(obj); i++) {  
33.             System.out.println(Array.get(obj, i));  
34.         }  
35.     }  
36. }  

16.通过反射获得类加载器

[java] view plain copy

1. package reflect.test16;  
2.   
3. import reflect.person.Person;  
4.   
5. /** 
6.  * @author Administrator 获得类加载器 
7.  */  
8. public class Hello {  
9.     public static void main(String[] args) {  
10.         Person person = new Person();  
11.         System.out.println(person.getClass().getClassLoader().getClass());  
12.     }  
13. }  

17.使用java的代理

[java] view plain copy

1. package reflect.subject;  
2.   
3. public interface Subject {  
4.     public String say(String name, int age);  
5. }  

[java] view plain copy

1. package reflect.subject;  
2.   
3. public class RealSubject implements Subject {  
4.   
5.     @Override  
6.     public String say(String name, int age) {  
7.         return name + "  " + age;  
8.     }  
9.   
10. }  

[java] view plain copy

1. package reflect.subject;  
2.   
3. import java.lang.reflect.InvocationHandler;  
4. import java.lang.reflect.Method;  
5. import java.lang.reflect.Proxy;  
6.   
7. public class MyInvocationHandler implements InvocationHandler {  
8.     private Object obj = null;  
9.   
10.     public Object bind(Object obj) {  
11.         this.obj = obj;  
12.         return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj  
13.                 .getClass().getInterfaces(), this);  
14.     }  
15.   
16.     @Override  
17.     public Object invoke(Object proxy, Method method, Object[] args)  
18.             throws Throwable {  
19.         System.out.println(proxy.getClass());  
20.         return method.invoke(this.obj, args);  
21.     }  
22.   
23. }  

[java] view plain copy

1. package reflect.test17;  
2.   
3. import reflect.subject.MyInvocationHandler;  
4. import reflect.subject.RealSubject;  
5. import reflect.subject.Subject;  
6.   
7. /** 
8.  * @author Administrator 动态代理测试 
9.  */  
10. public class Hello {  
11.     public static void main(String[] args) {  
12.         MyInvocationHandler demo = new MyInvocationHandler();  
13.         Subject sub = (Subject) demo.bind(new RealSubject());  
14.         String info = sub.say("xxxxx", 20);  
15.         System.out.println(info);  
16.     }  
17. }