Java反射机制详解

2021-08-31 23:23:15

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

1、关于Class

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

  1. package com.java.reflection;
  2. public class Person {
  3. String name;
  4. private int age;
  5. public Person() {
  6. System.out.println("无参构造器");
  7. }
  8. public Person(String name, int age) {
  9. System.out.println("有参构造器");
  10. this.name = name;
  11. this.age = age;
  12. }
  13. public String getName() {
  14. return name;
  15. }
  16. public void setName(String name) {
  17. this.name = name;
  18. }
  19. public int getAge() {
  20. return age;
  21. }
  22. public void setAge(int age) {
  23. this.age = age;
  24. }
  25. @Override
  26. public String toString() {
  27. return "Person{" +
  28. "name='" + name + '\'' +
  29. ", age=" + age +
  30. '}';
  31. }
  32. }

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

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

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

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

4、ClassLoader类加载器

Java反射机制详解

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

  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. //2、获取系统类加载器的父类加载器(扩展类加载器（extensions classLoader）)
  10. classLoader = classLoader.getParent();
  11. System.out.println("扩展类加载器-->" + classLoader);
  12. //3、获取扩展类加载器的父类加载器
  13. //输出为Null,无法被Java程序直接引用
  14. classLoader = classLoader.getParent();
  15. System.out.println("启动类加载器-->" + classLoader);
  16. //
  17. //4、测试当前类由哪个类加载器进行加载 ,结果就是系统的类加载器
  18. classLoader = Class.forName("com.java.reflection.Person").getClassLoader();
  19. System.out.println("当前类由哪个类加载器进行加载-->"+classLoader);
  20. //5、测试JDK提供的Object类由哪个类加载器负责加载的
  21. classLoader = Class.forName("java.lang.Object").getClassLoader();
  22. System.out.println("JDK提供的Object类由哪个类加载器加载-->" + classLoader);
  23. }
系统的类加载器-->sun.misc.Launcher$AppClassLoader@43be2d65
扩展类加载器-->sun.misc.Launcher$ExtClassLoader@7a9664a1
启动类加载器-->null
当前类由哪个类加载器进行加载-->sun.misc.Launcher$AppClassLoader@43be2d65
JDK提供的Object类由哪个类加载器加载-->null

4.1、getResourceAsStream方法

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

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: 对应类中的方法

  1. public class Person {
  2. private String name;
  3. private int age;
  4. //新增一个私有方法
  5. private void privateMthod(){
  6. }
  7. public Person() {
  8. System.out.println("无参构造器");
  9. }
  10. public Person(String name, int age) {
  11. System.out.println("有参构造器");
  12. this.name = name;
  13. this.age = age;
  14. }
  15. public String getName() {
  16. return name;
  17. }
  18. public void setName(String name) {
  19. this.name = name;
  20. }
  21. /**
  22. *
  23. * @param age  类型用Integer，不用int
  24. */
  25. public void setName(String name , int age){
  26. System.out.println("name: " + name);
  27. System.out.println("age:"+ age);
  28. }
  29. public int getAge() {
  30. return age;
  31. }
  32. public void setAge(int age) {
  33. this.age = age;
  34. }
  35. @Override
  36. public String toString() {
  37. return "Person{" +
  38. "name='" + name + '\'' +
  39. ", age=" + age +
  40. '}';
  41. }
  42. }
  1. @Test
  2. public void testMethod() throws ClassNotFoundException, NoSuchMethodException,
  3. IllegalAccessException, InstantiationException, InvocationTargetException {
  4. Class clazz = Class.forName("com.java.reflection.Person");
  5. //1、得到clazz 对应的类中有哪些方法,不能获取private方法
  6. Method[] methods =clazz.getMethods();
  7. System.out.print("        getMethods: ");
  8. for (Method method : methods){
  9. System.out.print(method.getName() + ", ");
  10. }
  11. //2、获取所有的方法(且只获取当着类声明的方法，包括private方法）
  12. Method[] methods2 = clazz.getDeclaredMethods();
  13. System.out.print("\ngetDeclaredMethods: ");
  14. for (Method method : methods2){
  15. System.out.print(method.getName() + ", ");
  16. }
  17. //3、获取指定的方法
  18. Method method = clazz.getDeclaredMethod("setName",String.class);//第一个参数是方法名，后面的是方法里的参数
  19. System.out.println("\nmethod : " + method);
  20. Method method2 = clazz.getDeclaredMethod("setName",String.class ,int.class);//第一个参数是方法名，后面的是方法里的参数
  21. System.out.println("method2: " + method2);
  22. //4、执行方法！
  23. Object obj = clazz.newInstance();
  24. method2.invoke(obj, "changwen", 22);
  25. }
        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方法

  1. public class PersonInvoke {
  2. public PersonInvoke() {
  3. }
  4. private String method2() {
  5. return "Person private String method2";
  6. }
  7. }
  1. public class StudentInvoke extends PersonInvoke{
  2. private void method1(Integer age) {
  3. System.out.println("Student private void method1, age=:" +age);
  4. }
  5. }

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

  1. /**
  2. * 获取当前类的父类中定义的私有方法
  3. * 直接调用getSuperclass()
  4. */
  5. @Test
  6. public void testGetSuperClass() throws Exception {
  7. String className = "com.java.reflection.StudentInvoke";
  8. Class clazz = Class.forName(className);
  9. Class superClazz = clazz.getSuperclass();
  10. System.out.println(superClazz);
  11. //输出结果：class com.java.reflection.PersonInvoke
  12. }

另一种写法

  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. } catch (InstantiationException e) {
  13. e.printStackTrace();
  14. } catch (IllegalAccessException e) {
  15. e.printStackTrace();
  16. } catch (ClassNotFoundException e) {
  17. e.printStackTrace();
  18. }
  19. return invoke(null, methodName, args);
  20. }
  21. /**
  22. * @param obj  方法执行的那个对象
  23. * @param methodName 类的一个方法的方法名，该方法也可能是私有方法,还可能是该方法在父类中定义的私有方法
  24. * @param args  调用该方法需要传入的参数 ...可变参数的意思
  25. * @return 调用方法后的返回值
  26. */
  27. public Object invoke(Object obj, String methodName, Object ... args) {
  28. //1、获取Method对象
  29. Class [] parameterTypes = new Class[args.length];
  30. for (int i=0 ; i<args.length; i++){
  31. parameterTypes[i] = args[i].getClass();
  32. }
  33. try {
  34. //2、执行Method方法
  35. Method method = getMethod(obj.getClass(), methodName,parameterTypes);
  36. //通过反射执行private方法
  37. method.setAccessible(true);
  38. //3、返回方法的返回值
  39. return method.invoke(obj,args);
  40. } catch (Exception e) {
  41. }
  42. return null;
  43. }
  44. /**
  45. * 获取clazz 的methodName 方法， 该方法可能是私有方法，还可能是父类中的私有方法
  46. */
  47. public Method getMethod(Class clazz, String methodName, Class ... parameterTypes) {
  48. //注意这个循环里的内容！！！
  49. for (; clazz != Object.class; clazz = clazz.getSuperclass()){
  50. try {
  51. return clazz.getDeclaredMethod(methodName, parameterTypes);
  52. } catch (Exception e) { //这里要写Exception，不然会出错，应该是有部分异常没有捕获
  53. }
  54. }
  55. return null;
  56. }

测试：

  1. @Test
  2. public void testInvoke2() {
  3. Object obj = new StudentInvoke();
  4. invoke(obj, "method1", 10);
  5. Object result = invoke(obj, "method2");
  6. System.out.println(result);
  7. }
private void method1,age:10
Person private String method2

7、Field字段

  1. public class Person {
  2. public String name;
  3. private Integer age;
  4. public Person() {
  5. }
  6. public Person(String name, Integer age) {
  7. this.name = name;
  8. this.age = age;
  9. }
  10. }
  1. /**
  2. * Field: 封装了字段的信息
  3. */
  4. @Test
  5. public void testField() throws
  6. ClassNotFoundException, NoSuchFieldException, IllegalAccessException {
  7. Class clazz = Class.forName("com.java.reflection.Person");
  8. //1、获取字段
  9. //1.1 获取Field的数组,私有字段也能获取
  10. Field[] fields = clazz.getDeclaredFields();
  11. for (Field field: fields) {
  12. System.out.print(field.getName() + ", ");
  13. }
  14. //1.2 获取指定名字的Field（如果是私有的，见下面的4)
  15. Field field = clazz.getDeclaredField("name");
  16. System.out.println("\n获取指定Field名=: " + field.getName());
  17. Person person = new Person("ABC", 12);
  18. //2、获取指定对象的Field的值
  19. Object val = field.get(person);
  20. System.out.println("获取指定对象字段'name'的Field的值=： " + val);
  21. //3、设置指定对象的Field的值
  22. field.set(person, "changwen2");
  23. System.out.println("设置指定对象字段'name'的Field的值=: " + person.name);
  24. //4、若该字段是私有的，需要调用setAccessible(true)方法
  25. Field field2 = clazz.getDeclaredField("age");
  26. field2.setAccessible(true);
  27. System.out.println("获取指定私有字段名=: " + field2.getName());
  28. }
name, age, 
获取指定Field名=: name
获取指定对象字段'name'的Field的值=： ABC
设置指定对象字段'name'的Field的值=: changwen2
获取指定私有字段名=: age
  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. //创建className 对应类的对象，并为其fieldName赋值为val
  12. Class clazz = Class.forName(className);
  13. Field field = null;
  14. for (Class clazz2 = clazz; clazz2 != Object.class; clazz2 = clazz2.getSuperclass()){
  15. try {
  16. field = clazz2.getDeclaredField(fieldName);
  17. } catch (Exception e) {
  18. }
  19. }
  20. Object obj = clazz.newInstance();
  21. assert field != null;
  22. field.setAccessible(true);
  23. field.set(obj, val);
  24. Student stu = (Student) obj;
  25. System.out.println("age = " + stu.getAge());
  26. }

8、构造器(Constructor)

  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. //1.获取Constructor对象
  10. Constructor<Person>[] constructors =
  11. (Constructor<Person>[]) Class.forName(className).getConstructors();
  12. for (Constructor<Person> constructor: constructors) {
  13. System.out.println(constructor);
  14. }
  15. Constructor<Person> constructor = clazz.getConstructor(String.class, Integer.class);
  16. System.out.println("指定的-->" + constructor);
  17. //2.调用构造器的newInstance()方法创建对象
  18. Object obj= constructor.newInstance("changwen", 11);
  19. }
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
  1. @Retention(RetentionPolicy.RUNTIME) //运行时检验
  2. @Target(value = {ElementType.METHOD})  //作用在方法上
  3. public @interface AgeValidator {
  4. int min();
  5. int max();
  6. }
  1. /**
  2. * 通过反射才能获取注解
  3. */
  4. @Test
  5. public void testAnnotation() throws Exception {
  6. //这样的方式不能使用注解
  7. Person3 person3 = new Person3();
  8. person3.setAge(10);*/
  9. String className = "com.java.reflection.Person3";
  10. Class clazz = Class.forName(className);
  11. Object obj = clazz.newInstance();
  12. Method method = clazz.getDeclaredMethod("setAge",Integer.class);
  13. int val =40;
  14. //获取注解
  15. Annotation annotation = method.getAnnotation(AgeValidator.class);
  16. if (annotation != null){
  17. if (annotation instanceof AgeValidator){
  18. AgeValidator ageValidator = (AgeValidator) annotation;
  19. if (val< ageValidator.min() || val>ageValidator.max()){
  20. throw new RuntimeException("数值超出范围");
  21. }
  22. }
  23. }
  24. method.invoke(obj, val);
  25. System.out.println(obj);
  26. }

提取 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, 则其子类将自动具有该注释
上一篇：Java 反射机制详解


下一篇：with admin option /with grant option