您的位置: 首页  >  文章  >  java反射的一些调试

java反射的一些调试

分类: 文章 • 2023-11-25 10:20:10
额，研究过这个的人很多很多，但是我没有很深入的研究过，所以谁也拦不住我去研究研究，然后记录下来······如有雷同··那就雷同了···请多多包涵。


首先是整个项目的结构：

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属性。

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

运行结果：

java反射的一些调试


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

运行结果：

java反射的一些调试


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

运行结果：

java反射的一些调试

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

运行结果：

java反射的一些调试


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

相关推荐