java反射机制详解

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/afanti222/article/details/78414893

 Java反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意一个方法和属性;这种动态获取的信息以及动态调用对象的方法的功能称为Java语言的反射机制。

1、关于Class

    1、Class是一个类,一个描述类的类(也就是描述类本身),封装了描述方法的Method,描述字段的Filed,描述构造器的Constructor等属性
    2、对象照镜子后(反射)可以得到的信息:某个类的数据成员名、方法和构造器、某个类到底实现了哪些接口。
    3、对于每个类而言,JRE 都为其保留一个不变的 Class 类型的对象。
        一个 Class 对象包含了特定某个类的有关信息。
    4、Class 对象只能由系统建立对象
    5、一个类在 JVM 中只会有一个Class实例

 

[java] view plain copy
 
 在CODE上查看代码片派生到我的代码片
  1. package com.java.reflection;  
  2.   
  3. public class Person {  
  4.     String name;  
  5.     private int age;  
  6.   
  7.     public Person() {  
  8.         System.out.println("无参构造器");  
  9.     }  
  10.   
  11.     public Person(String name, int age) {  
  12.         System.out.println("有参构造器");  
  13.         this.name = name;  
  14.         this.age = age;  
  15.     }  
  16.   
  17.     public String getName() {  
  18.         return name;  
  19.     }  
  20.   
  21.     public void setName(String name) {  
  22.         this.name = name;  
  23.     }  
  24.   
  25.     public int getAge() {  
  26.         return age;  
  27.     }  
  28.   
  29.     public void setAge(int age) {  
  30.         this.age = age;  
  31.     }  
  32.   
  33.     @Override  
  34.     public String toString() {  
  35.         return "Person{" +  
  36.                 "name='" + name + '\'' +  
  37.                 ", age=" + age +  
  38.                 '}';  
  39.     }  
  40. }  

 

 

2、反射机制获取类有三种方法

 

[java] view plain copy
 
 在CODE上查看代码片派生到我的代码片
  1. /** 
  2.  * 反射机制获取类有三种方法 
  3.  */  
  4. @Test  
  5. public void testGetClass() throws ClassNotFoundException {  
  6.     Class clazz = null;  
  7.   
  8.     //1 直接通过类名.Class的方式得到  
  9.     clazz = Person.class;  
  10.     System.out.println("通过类名: " + clazz);  
  11.   
  12.     //2 通过对象的getClass()方法获取,这个使用的少(一般是传的是Object,不知道是什么类型的时候才用)  
  13.     Object obj = new Person();  
  14.     clazz = obj.getClass();  
  15.     System.out.println("通过getClass(): " + clazz);  
  16.   
  17.     //3 通过全类名获取,用的比较多,但可能抛出ClassNotFoundException异常  
  18.     clazz = Class.forName("com.java.reflection.Person");  
  19.     System.out.println("通过全类名获取: " + clazz);  
  20. }  
通过类名: class com.java.reflection.Person
无参构造器
通过getClass(): class com.java.reflection.Person
通过全类名获取: class com.java.reflection.Person

 

 

3、利用newInstance创建对象:调用的类必须有无参的构造器

 

[java] view plain copy
 
 在CODE上查看代码片派生到我的代码片
  1. /** 
  2.  * Class类的newInstance()方法,创建类的一个对象。 
  3.  */  
  4. @Test  
  5. public void testNewInstance()  
  6.         throws ClassNotFoundException, IllegalAccessException, InstantiationException {  
  7.   
  8.     Class clazz = Class.forName("com.java.reflection.Person");  
  9.   
  10.     //使用Class类的newInstance()方法创建类的一个对象  
  11.     //实际调用的类的那个 无参数的构造器(这就是为什么写的类的时候,要写一个无参数的构造器,就是给反射用的)  
  12.     //一般的,一个类若声明了带参数的构造器,也要声明一个无参数的构造器  
  13.     Object obj = clazz.newInstance();  
  14.     System.out.println(obj);  
  15. }  
无参构造器
Person{name='null', age=0}

 

 

4、ClassLoader类加载器

类加载器详解:http://blog.csdn.net/ochangwen/article/details/51473120

 

[java] view plain copy
 
 在CODE上查看代码片派生到我的代码片
  1. /** 
  2.  * ClassLoader类装载器 
  3.  */  
  4. @Test  
  5. public void testClassLoader1() throws ClassNotFoundException, IOException {  
  6.     //1、获取一个系统的类加载器  
  7.     ClassLoader classLoader = ClassLoader.getSystemClassLoader();  
  8.     System.out.println("系统的类加载器-->" + classLoader);  
  9.   
  10.     //2、获取系统类加载器的父类加载器(扩展类加载器(extensions classLoader))  
  11.     classLoader = classLoader.getParent();  
  12.     System.out.println("扩展类加载器-->" + classLoader);  
  13.   
  14.     //3、获取扩展类加载器的父类加载器  
  15.     //输出为Null,无法被Java程序直接引用  
  16.     classLoader = classLoader.getParent();  
  17.     System.out.println("启动类加载器-->" + classLoader);  
  18.   
  19.     //  
  20.   
  21.     //4、测试当前类由哪个类加载器进行加载 ,结果就是系统的类加载器  
  22.     classLoader = Class.forName("com.java.reflection.Person").getClassLoader();  
  23.     System.out.println("当前类由哪个类加载器进行加载-->"+classLoader);  
  24.   
  25.     //5、测试JDK提供的Object类由哪个类加载器负责加载的  
  26.     classLoader = Class.forName("java.lang.Object").getClassLoader();  
  27.     System.out.println("JDK提供的Object类由哪个类加载器加载-->" + classLoader);  
  28. }  
系统的类加载器-->sun.misc.Launcher$AppClassLoader@43be2d65
扩展类加载器-->sun.misc.Launcher$ExtClassLoader@7a9664a1
启动类加载器-->null
当前类由哪个类加载器进行加载-->sun.misc.Launcher$AppClassLoader@43be2d65
JDK提供的Object类由哪个类加载器加载-->null


4.1、getResourceAsStream方法

[java] view plain copy
 
 在CODE上查看代码片派生到我的代码片
  1.     @Test  
  2.     public void testGetResourceAsStream() throws ClassNotFoundException, IOException {  
  3. //          这么写的话,文件需要放到src目录下  
  4.         //       InputStream in = new FileInputStream("test.properties");  
  5.   
  6.         //5、关于类加载器的一个主要方法  
  7.         //调用getResourceAsStream 获取类路径下的文件对应的输入流  
  8.         InputStream in = this.getClass().getClassLoader()  
  9.                 .getResourceAsStream("com/java/reflection/test.properties");  
  10.         System.out.println("in: " +in);  
  11.   
  12.         Properties properties = new Properties();  
  13.         properties.load(in);  
  14.   
  15.         String driverClass = properties.getProperty("dirver");  
  16.         String jdbcUrl = properties.getProperty("jdbcUrl");  
  17.         //中文可能会出现乱码,需要转换一下  
  18.         String user = new String(properties.getProperty("user").getBytes("ISO-8859-1"), "UTF-8");  
  19.         String password = properties.getProperty("password");  
  20.   
  21.         System.out.println("diverClass: "+driverClass);  
  22.         System.out.println("user: " + user);  
  23.     }  

test.properties内容如下:

dirver=com.mysql.jdbc.Driver;
jdbcUrl=jdbc:mysql://192.168.42.108:3306/test
user=测试
password=993803

结果:

 

in: java.io.BufferedInputStream@2aca0115
diverClass: com.mysql.jdbc.Driver;
user: 测试

 

 

5、Method: 对应类中的方法

 

[java] view plain copy
 
 在CODE上查看代码片派生到我的代码片
  1. public class Person {  
  2.     private String name;  
  3.     private int age;  
  4.   
  5.     //新增一个私有方法  
  6.     private void privateMthod(){  
  7.     }  
  8.       
  9.     public Person() {  
  10.         System.out.println("无参构造器");  
  11.     }  
  12.   
  13.     public Person(String name, int age) {  
  14.         System.out.println("有参构造器");  
  15.         this.name = name;  
  16.         this.age = age;  
  17.     }  
  18.   
  19.     public String getName() {  
  20.         return name;  
  21.     }  
  22.   
  23.     public void setName(String name) {  
  24.         this.name = name;  
  25.     }  
  26.   
  27.     /** 
  28.      *  
  29.      * @param age  类型用Integer,不用int 
  30.      */  
  31.     public void setName(String name , int age){  
  32.         System.out.println("name: " + name);  
  33.         System.out.println("age:"+ age);  
  34.   
  35.     }  
  36.   
  37.     public int getAge() {  
  38.         return age;  
  39.     }  
  40.   
  41.     public void setAge(int age) {  
  42.         this.age = age;  
  43.     }  
  44.   
  45.     @Override  
  46.     public String toString() {  
  47.         return "Person{" +  
  48.                 "name='" + name + '\'' +  
  49.                 ", age=" + age +  
  50.                 '}';  
  51.     }  
  52. }  
[java] view plain copy
 
 在CODE上查看代码片派生到我的代码片
  1. @Test  
  2. public void testMethod() throws ClassNotFoundException, NoSuchMethodException,   
  3.         IllegalAccessException, InstantiationException, InvocationTargetException {  
  4.     Class clazz = Class.forName("com.java.reflection.Person");  
  5.   
  6.     //1、得到clazz 对应的类中有哪些方法,不能获取private方法  
  7.     Method[] methods =clazz.getMethods();  
  8.     System.out.print("        getMethods: ");  
  9.     for (Method method : methods){  
  10.         System.out.print(method.getName() + ", ");  
  11.     }  
  12.   
  13.     //2、获取所有的方法(且只获取当着类声明的方法,包括private方法)  
  14.     Method[] methods2 = clazz.getDeclaredMethods();  
  15.     System.out.print("\ngetDeclaredMethods: ");  
  16.     for (Method method : methods2){  
  17.         System.out.print(method.getName() + ", ");  
  18.     }  
  19.   
  20.     //3、获取指定的方法  
  21.     Method method = clazz.getDeclaredMethod("setName",String.class);//第一个参数是方法名,后面的是方法里的参数  
  22.     System.out.println("\nmethod : " + method);  
  23.   
  24.     Method method2 = clazz.getDeclaredMethod("setName",String.class ,int.class);//第一个参数是方法名,后面的是方法里的参数  
  25.     System.out.println("method2: " + method2);  
  26.   
  27.     //4、执行方法!  
  28.     Object obj = clazz.newInstance();  
  29.     method2.invoke(obj, "changwen", 22);  
  30. }  
        getMethods: toString, getName, setName, setName, setAge, getAge, wait, wait, wait, equals, hashCode, getClass, notify, notifyAll,
getDeclaredMethods: toString, getName, setName, setName, setAge, getAge, privateMthod,
method : public void com.java.reflection.Person.setName(java.lang.String)
method2: public void com.java.reflection.Person.setName(java.lang.String,int)
无参构造器
name: changwen
age:22

 

6、invoke方法

[java] view plain copy
 
 在CODE上查看代码片派生到我的代码片
  1. public class PersonInvoke {  
  2.     public PersonInvoke() {  
  3.     }  
  4.   
  5.     private String method2() {  
  6.         return "Person private String method2";  
  7.     }  
  8. }  
[java] view plain copy
 
 在CODE上查看代码片派生到我的代码片
  1. public class StudentInvoke extends PersonInvoke{  
  2.     private void method1(Integer age) {  
  3.         System.out.println("Student private void method1, age=:" +age);  
  4.     }  
  5. }  

获取当前类的父类定义的私有方法

[java] view plain copy
 
 在CODE上查看代码片派生到我的代码片
  1. /** 
  2.  * 获取当前类的父类中定义的私有方法 
  3.  * 直接调用getSuperclass() 
  4.  */  
  5. @Test  
  6. public void testGetSuperClass() throws Exception {  
  7.     String className = "com.java.reflection.StudentInvoke";  
  8.   
  9.     Class clazz = Class.forName(className);  
  10.     Class superClazz = clazz.getSuperclass();  
  11.   
  12.     System.out.println(superClazz);  
  13.     //输出结果:class com.java.reflection.PersonInvoke  
  14. }  

另一种写法

[java] view plain copy
 
 在CODE上查看代码片派生到我的代码片
  1. /** 
  2.   * @param className  某个类的全类名 
  3.   * @param methodName 类的一个方法的方法名,该方法也可能是私有方法 
  4.   * @param args  调用该方法需要传入的参数 ...可变参数的意思 
  5.   * @return 调用方法后的返回值 
  6.   */  
  7.  public Object invoke(String className, String methodName, Object ... args) {  
  8.      Object obj = null;  
  9.      try {  
  10.          obj = Class.forName(className).newInstance();  
  11.          return invoke(obj, methodName, args);  
  12.   
  13.      } catch (InstantiationException e) {  
  14.          e.printStackTrace();  
  15.      } catch (IllegalAccessException e) {  
  16.          e.printStackTrace();  
  17.      } catch (ClassNotFoundException e) {  
  18.          e.printStackTrace();  
  19.      }  
  20.      return invoke(null, methodName, args);  
  21.  }  
  22.  /** 
  23.   * @param obj  方法执行的那个对象 
  24.   * @param methodName 类的一个方法的方法名,该方法也可能是私有方法,还可能是该方法在父类中定义的私有方法 
  25.   * @param args  调用该方法需要传入的参数 ...可变参数的意思 
  26.   * @return 调用方法后的返回值 
  27.   */  
  28.  public Object invoke(Object obj, String methodName, Object ... args) {  
  29.      //1、获取Method对象  
  30.      Class [] parameterTypes = new Class[args.length];  
  31.      for (int i=0 ; i<args.length; i++){  
  32.          parameterTypes[i] = args[i].getClass();  
  33.      }  
  34.   
  35.      try {  
  36.          //2、执行Method方法  
  37.          Method method = getMethod(obj.getClass(), methodName,parameterTypes);  
  38.   
  39.          //通过反射执行private方法  
  40.          method.setAccessible(true);  
  41.   
  42.          //3、返回方法的返回值  
  43.          return method.invoke(obj,args);  
  44.   
  45.      } catch (Exception e) {  
  46.   
  47.      }  
  48.   
  49.      return null;  
  50.  }  
  51.   
  52.  /** 
  53.   * 获取clazz 的methodName 方法, 该方法可能是私有方法,还可能是父类中的私有方法 
  54.   */  
  55.  public Method getMethod(Class clazz, String methodName, Class ... parameterTypes) {  
  56.      //注意这个循环里的内容!!!  
  57.      for (; clazz != Object.class; clazz = clazz.getSuperclass()){  
  58.          try {  
  59.              return clazz.getDeclaredMethod(methodName, parameterTypes);  
  60.          } catch (Exception e) { //这里要写Exception,不然会出错,应该是有部分异常没有捕获  
  61.   
  62.          }  
  63.      }  
  64.      return null;  
  65.  }  

测试:

[java] view plain copy
 
 在CODE上查看代码片派生到我的代码片
  1. @Test  
  2. public void testInvoke2() {  
  3.     Object obj = new StudentInvoke();  
  4.     invoke(obj, "method1", 10);  
  5.   
  6.     Object result = invoke(obj, "method2");  
  7.     System.out.println(result);  
  8. }  
private void method1,age:10
Person private String method2

 

 

7、Field字段

 

[java] view plain copy
 
 在CODE上查看代码片派生到我的代码片
  1. public class Person {  
  2.     public String name;  
  3.     private Integer age;  
  4.   
  5.     public Person() {  
  6.     }  
  7.   
  8.     public Person(String name, Integer age) {  
  9.         this.name = name;  
  10.         this.age = age;  
  11.     }  
  12. }  
[java] view plain copy
 
 在CODE上查看代码片派生到我的代码片
  1. /** 
  2.  * Field: 封装了字段的信息 
  3.  */  
  4. @Test  
  5. public void testField() throws  
  6.         ClassNotFoundException, NoSuchFieldException, IllegalAccessException {  
  7.   
  8.     Class clazz = Class.forName("com.java.reflection.Person");  
  9.   
  10.     //1、获取字段  
  11.     //1.1 获取Field的数组,私有字段也能获取  
  12.     Field[] fields = clazz.getDeclaredFields();  
  13.     for (Field field: fields) {  
  14.         System.out.print(field.getName() + ", ");  
  15.     }  
  16.   
  17.     //1.2 获取指定名字的Field(如果是私有的,见下面的4)  
  18.     Field field = clazz.getDeclaredField("name");  
  19.     System.out.println("\n获取指定Field名=: " + field.getName());  
  20.   
  21.     Person person = new Person("ABC", 12);  
  22.     //2、获取指定对象的Field的值  
  23.     Object val = field.get(person);  
  24.     System.out.println("获取指定对象字段'name'的Field的值=: " + val);  
  25.   
  26.     //3、设置指定对象的Field的值  
  27.     field.set(person, "changwen2");  
  28.     System.out.println("设置指定对象字段'name'的Field的值=: " + person.name);  
  29.   
  30.     //4、若该字段是私有的,需要调用setAccessible(true)方法  
  31.     Field field2 = clazz.getDeclaredField("age");  
  32.     field2.setAccessible(true);  
  33.     System.out.println("获取指定私有字段名=: " + field2.getName());  
  34. }  
name, age, 
获取指定Field名=: name
获取指定对象字段'name'的Field的值=: ABC
设置指定对象字段'name'的Field的值=: changwen2
获取指定私有字段名=: age

 

[java] view plain copy
 
 在CODE上查看代码片派生到我的代码片
  1. /** 
  2.  * 一个实例: 
  3.  * 反射获取一个继承Person2的Student类 
  4.  * 设置字段"age"=20(该字段可能为私有,可能在其父类中) 
  5.  */  
  6. @Test  
  7. public void testClassField() throws ClassNotFoundException, IllegalAccessException, InstantiationException {  
  8.     String className = "com.java.reflection.Student";  
  9.     String fieldName = "age";  //可能为私有,可能在其父类中  
  10.     Object val = 20;  
  11.   
  12.     //创建className 对应类的对象,并为其fieldName赋值为val  
  13.     Class clazz = Class.forName(className);  
  14.     Field field = null;  
  15.     for (Class clazz2 = clazz; clazz2 != Object.class; clazz2 = clazz2.getSuperclass()){  
  16.         try {  
  17.             field = clazz2.getDeclaredField(fieldName);  
  18.         } catch (Exception e) {  
  19.   
  20.         }  
  21.     }  
  22.   
  23.     Object obj = clazz.newInstance();  
  24.     assert field != null;  
  25.     field.setAccessible(true);  
  26.     field.set(obj, val);  
  27.   
  28.     Student stu = (Student) obj;  
  29.     System.out.println("age = " + stu.getAge());  
  30. }  

 

 

8、构造器(Constructor)

 

[java] view plain copy
 
 在CODE上查看代码片派生到我的代码片
  1. /** 
  2.  * 构造器:开发用的比较少 
  3.  */  
  4. @Test  
  5. public void testConstructor() throws ClassNotFoundException, NoSuchMethodException,  
  6.         IllegalAccessException, InvocationTargetException, InstantiationException {  
  7.     String className = "com.java.reflection.Person";  
  8.     Class<Person> clazz = (Class<Person>) Class.forName(className);  
  9.   
  10.     //1.获取Constructor对象  
  11.     Constructor<Person>[] constructors =  
  12.             (Constructor<Person>[]) Class.forName(className).getConstructors();  
  13.   
  14.     for (Constructor<Person> constructor: constructors) {  
  15.         System.out.println(constructor);  
  16.     }  
  17.   
  18.     Constructor<Person> constructor = clazz.getConstructor(String.class, Integer.class);  
  19.     System.out.println("指定的-->" + constructor);  
  20.   
  21.     //2.调用构造器的newInstance()方法创建对象  
  22.     Object obj= constructor.newInstance("changwen", 11);  
  23. }  
public com.java.reflection.Person()
public com.java.reflection.Person(java.lang.String,java.lang.Integer)
指定的-->public com.java.reflection.Person(java.lang.String,java.lang.Integer)

 

 

9、注解(Annotation)

 

    •从 JDK5.0 开始,Java 增加了对元数据(MetaData)的支持,也就是Annotation(注释)
    •Annotation其实就是代码里的特殊标记,这些标记可以在编译,类加载, 运行时被读取,并执行相应的处理.通过使用Annotation,程序员可以在不改变原有逻辑的情况下,在源文件中嵌入一些补充信息.
    •Annotation 可以像修饰符一样被使用,可用于修饰包,类,构造器, 方法,成员变量, 参数,局部变量的声明,这些信息被保存在Annotation的 “name=value”对中.
    •Annotation能被用来为程序元素(类,方法,成员变量等)设置元数据

基本的 Annotation

•使用 Annotation时要在其前面增加@符号,并把该Annotation 当成一个修饰符使用.用于修饰它支持的程序元素
•三个基本的Annotation:
    –@Override:限定重写父类方法,该注释只能用于方法
    –@Deprecated:用于表示某个程序元素(类,方法等)已过时
    –@SuppressWarnings:抑制编译器警告.

自定义 Annotation

    •定义新的 Annotation类型使用@interface关键字
    •Annotation 的成员变量在Annotation 定义中以无参数方法的形式来声明.其方法名和返回值定义了该成员的名字和类型.
    •可以在定义Annotation的成员变量时为其指定初始值,指定成员变量的初始值可使用default关键字
    •没有成员定义的Annotation称为标记;包含成员变量的Annotation称为元数据Annotation

 

 

[java] view plain copy
 
 在CODE上查看代码片派生到我的代码片
  1. @Retention(RetentionPolicy.RUNTIME) //运行时检验  
  2. @Target(value = {ElementType.METHOD})  //作用在方法上  
  3. public @interface AgeValidator {  
  4.   
  5.     int min();  
  6.     int max();  
  7. }  

 

[java] view plain copy
 
 在CODE上查看代码片派生到我的代码片
  1. /** 
  2.  * 通过反射才能获取注解 
  3.  */  
  4. @Test  
  5. public void testAnnotation() throws Exception {  
  6.     //这样的方式不能使用注解  
  7.     Person3 person3 = new Person3();  
  8.     person3.setAge(10);*/  
  9.   
  10.     String className = "com.java.reflection.Person3";  
  11.     Class clazz = Class.forName(className);  
  12.     Object obj = clazz.newInstance();  
  13.   
  14.     Method method = clazz.getDeclaredMethod("setAge",Integer.class);  
  15.     int val =40;  
  16.   
  17.     //获取注解  
  18.     Annotation annotation = method.getAnnotation(AgeValidator.class);  
  19.     if (annotation != null){  
  20.         if (annotation instanceof AgeValidator){  
  21.             AgeValidator ageValidator = (AgeValidator) annotation;  
  22.   
  23.             if (val< ageValidator.min() || val>ageValidator.max()){  
  24.                 throw new RuntimeException("数值超出范围");  
  25.             }  
  26.         }  
  27.     }  
  28.   
  29.     method.invoke(obj, val);  
  30.     System.out.println(obj);  
  31. }  

提取 Annotation信息

•JDK5.0 在 java.lang.reflect包下新增了 AnnotatedElement接口,该接口代表程序中可以接受注释的程序元素
•当一个 Annotation类型被定义为运行时Annotation后,该注释才是运行时可见,当 class文件被载入时保存在 class文件中的 Annotation才会被虚拟机读取
•程序可以调用AnnotationElement对象的如下方法来访问 Annotation信息
–获取 Annotation实例:
getAnnotation(Class<T> annotationClass)

JDK 的元Annotation

•JDK 的元Annotation 用于修饰其他Annotation 定义
•@Retention:只能用于修饰一个 Annotation定义,用于指定该 Annotation可以保留多长时间,@Rentention包含一个RetentionPolicy类型的成员变量,使用 @Rentention时必须为该 value成员变量指定值:
    –RetentionPolicy.CLASS:编译器将把注释记录在 class文件中.当运行 Java程序时,JVM 不会保留注释.这是默认值
    –RetentionPolicy.RUNTIME:编译器将把注释记录在class文件中. 当运行 Java 程序时, JVM 会保留注释. 程序可以通过反射获取该注释
    –RetentionPolicy.SOURCE:编译器直接丢弃这种策略的注释
•@Target: 用于修饰Annotation 定义,用于指定被修饰的 Annotation能用于修饰哪些程序元素.@Target 也包含一个名为 value的成员变量.
•@Documented:用于指定被该元 Annotation修饰的 Annotation类将被 javadoc工具提取成文档.
•@Inherited:被它修饰的 Annotation将具有继承性.如果某个类使用了被@Inherited 修饰的Annotation, 则其子类将自动具有该注释
展开阅读全文

没有更多推荐了,返回首页