反射

反射：动态语言

核心：Reflection

反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法

简单理解：

是什么：

正常流程是 对象.属性获取属性值, 反射：属性.对象获取属性值

那么类可能就不是一个必须的东西了，可以通过属性反向编写出类

有什么用：

  • 根据类名创建实例（类名可以从配置文件读取，不用new，达到解耦）

  • 用Method.invoke执行方法

 

  1. Java反射机制提供的功能

    1. 在运行时判断任意一个对象所属的类

    2. 在运行时构造任意一个类的对象

    3. 在运行时判断任意一个类所具有的成员变量和方法

    4. 在运行时调用任意一个对象的成员变量和方法

    5. 生成动态代理例如：spring中的控制反转

  2. 反射相关的主要API：

    1. java.lang.Class:代表一个类

    2. java.lang.reflect.Method:代表类的方法

    3. java.lang.reflect.Field:代表类的成员变量

    4. java.lang.reflect.Constructor:代表类的构造方法

反射的简单应用

Teacher类

class Teacher extends ArrayList implements Runnable, Serializable, Comparable {
​
    private String name;
    private int age;
    private String gender;
​
    public Teacher() {}
​
    public Teacher(String name, int age, String gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }
​
    public int getAge() {return age;}
​
    public void setAge(int age) {this.age = age;}
​
    public String getGender() {return gender;}
​
    public void setGender(String gender) {this.gender = gender;}
​
    public String getName() {return name;}
​
    public void setName(String name) {this.name = name;}
    @Override
    public String toString() {
        return "Teacher{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", gender='" + gender + '\'' +
                '}';
    }
    public void lesson(String content) {
        System.out.println(name + "老师在上[" + content + "]课");
    }
    @Override
    public int compareTo(Object o) {return 0;}
    @Override
    public void run() {}
}

软硬编码，与反射的基本应用

**问题**：getField() 方法获取到的是类中公共属性(**public**), 还可以获取到**从父类继承的公共属性.**
​
解决：AccessibleObject类的setAccessible():将accessible标志设置为传递的布尔值(PS:所属性设置为可访问的. 暴力反射)
getDeclaredField() 方法获取到本类中声明的所有属性, 包括私有属性. @Test
    public void test2() {
        // 软编码, 编译时不依赖类, 但是会把硬编码中的编译错误延迟成运行时异常.
        // 但是如果在运行时解决了问题,那么在运行时也不会出问题.
        try {
            // 手工加载类
            Class clazz = Class.forName("com.atguigu.javase.reflect.Teacher");
            // 依据类模板创建对象
            Object obj = clazz.newInstance(); // 相当于 : Object obj = new Teacher()
            System.out.println(obj);
       //反射访问属性的三种方式     
            // 1) 从类模板中先获取到属性定义对象
            Field nameField = clazz.getField("name");
            // 2) 让属性配合目标this对象完成属性访问
            // set方法用于设置属性值, 第一个参数是目标对象, 第2个参数是新值
            nameField.set(obj, "佟刚"); // 相当于 : obj.name = "佟刚";
            System.out.println(nameField.get(obj)); // 相当于 : System.out.println(obj.name);
​
            Field ageField = clazz.getField("age");
            ageField.set(obj, 40); // 相当于 : obj.age = 40
​
            Field genderField = clazz.getField("gender");
            genderField.set(obj, "男"); // 相当于 : obj.gender = "男";
​
            System.out.println(obj);
        } catch (ClassNotFoundException e) { // 类在运行时未找到或者类名写错了
            e.printStackTrace();
        } catch (IllegalAccessException e) { // 尝试访问没有权限的成员
            e.printStackTrace();
        } catch (InstantiationException e) { // 创建对象时出现异常
            e.printStackTrace();
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        }
    }
    @Test
    public void test1() {
        // 硬编码, 对于类有强依赖 没有类就不能创建对象
        Teacher t1 = new Teacher();
        System.out.println(t1);
        /*
        t1.name = "佟刚";
        t1.age = 40;
        t1.gender = "男";
​
        System.out.println(t1.name);
        System.out.println(t1.age);
        System.out.println(t1.gender);
        */
        System.out.println(t1);
​
        Teacher t2 = new Teacher("亚茹", 20, "女");
        System.out.println(t2);
    }
//问题：getField() 方法获取到的是类中公共属性(public), 还可以获取到 从父类继承的公共属性. 
​
//解决：AccessibleObject类的setAccessible():将accessible标志设置为传递的布尔值(PS:所属性设置为可访问的. 暴力反射)
//getDeclaredField() 方法获取到本类中声明的所有属性, 包括私有属性.
​
//获取类继承的类模板与接口
 @Test
    public void test4() throws ClassNotFoundException {
        Class clazz = Class.forName("com.atguigu.javase.reflect.Teacher");
        Class superclass = clazz.getSuperclass();// 获取父类的类模板对象
        System.out.println(superclass);
        Class[] interfaces = clazz.getInterfaces(); // 获取本类实现了的所有的接口的对象数组.
        for (Class anInterface : interfaces) {
            System.out.println(anInterface);
        }
    }
​
​

 

类加载器

Class类：

public final Class getClass() ：返回值的类型是一个Class类，此类是Java反射的源头，实际上所谓反射从程序的运行结果来看也很好理解，即：可以通过对象反射求出类的名称。

Class对象表示java中的类型, java中有2种数据类型, 1) 基本数据类型 2) 引用数据类型

image-20210121193108754

Class本身也是一个类 Class 对象只能由系统建立对象 一个类在 JVM 中只会有一个Class实例 一个Class对象对应的是一个加载到JVM中的一个.class文件 每个类的实例都会记得自己是由哪个 Class 实例所生成 通过Class可以完整地得到一个类中的完整结构

常用方法:

方法名功能说明
static Class forName(String name) 返回指定类名 name 的 Class 对象
Object newInstance() 调用缺省构造函数，返回该Class对象的一个实例
String getName() 返回此Class对象所表示的实体（类、接口、数组类、基本类型或void）名称
Class [] getInterfaces() 获取当前Class对象的接口(获取本类实现了的所有的接口的对象数组.)
ClassLoader getClassLoader() 返回该类的类加载器
Class getSuperclass() 返回表示此Class所表示的实体的超类的Class(获取父类的类模板对象)
Constructor[] getConstructors() 返回一个包含某些Constructor对象的数组
Field[] getDeclaredFields() 返回Field对象的一个数组
Method getMethod(String name,Class … paramTypes) 返回一个Method对象，此对象的形参类型为paramType

实例化Class类对象(四种方法)

  1. 前提：若已知具体的类，通过类的class属性获取，该方法最为安全可靠，程序性能最高

    实例：Class clazz = String.class;

  2. 前提：已知某个类的实例，调用该实例的getClass()方法获取Class对象 实例：Class clazz = “www.atguigu.com”.getClass();

  3. 前提：已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取，可能抛出ClassNotFoundException 实例：Class clazz = Class.forName(“java.lang.String”);

  4. 其他方式(不做要求) ClassLoader cl = this.getClass().getClassLoader(); Class clazz4 = cl.loadClass(“类的全类名”);

     // 1) 已经了类, 通过类的静态属性.class 获取类模板对象
        Class clazz1 = Teacher.class; // 这种方式最高效, 最安全. 属于硬编码
     // 2) 根据对象反向获取它的类模板
        Teacher t = new Teacher();
        Class clazz2 = t.getClass(); // 软编码
     // 3) 通过类的全限定名称, 动态定位
        Class clazz3 = Class.forName("com.atguigu.javase.reflect.Teacher");
     // 4) 通过类加载器对象来手工加载
        ClassLoader classLoader = this.getClass().getClassLoader();// 当前对象的类模板的加载器
        //ReflectTest.class.getClassLoader(); // 和上面一样
        Class clazz4 = classLoader.loadClass("com.atguigu.javase.reflect.Teacher");

 

了解：类的加载过程
了解：ClassLoader 小重点

类加载器是用来把类(class)装载进内存的。JVM 规范定义了两种类型的类加载器：启动类加载器(bootstrap)和用户自定义加载器(user-defined class loader)。 JVM在运行时会产生3个类加载器组成的初始化加载器层次结构 ，如下图所示：

image-20210121200658718

 

public void test7() throws Exception {
    // 我们主要用的是系统类加载器 负责加载用户自定义类
    ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
    System.out.println(systemClassLoader);
    // 它的父类加载器是扩展类加载器 负责加载jdk/jre/lib/ext目录下的所有.jar
    ClassLoader extClassLoader = systemClassLoader.getParent();
    System.out.println(extClassLoader);
    // 扩展类加载器的父类加载器是引导类加载器(最核心,最底层) 负责加载jdk/jre/lib目录下的所有.jar
    ClassLoader bootstrap = extClassLoader.getParent();
    System.out.println(bootstrap);
​
    // 类加载时, 双亲委派机制
    // 系统类加载有2个父类加载器, 就是它的双亲
    // 当我们要加载一个类时, 比如要加Teacher类
    //      1) 加载类的任务首先委派给扩展类载器, 扩展类加载器进一步也要把任务委派给引导类加载器.
    //              引导类加载器会检查要加载的是什么类,Teacher类不是核心类, 它就会把加载请求驳回给扩展类加载器
    //              扩展类加载器会检查要加载的是什么类,Teacher也不是该我加载, 继续把这个请示驳回
    //              最终又回到系统加载器, 再由系统类加载器加载Teacher类
​
    //      2) 加载类的任务首先委派给扩展类载器, 扩展类加载器进一步也要把任务委派给引导类加载器.
    //              引导类加载器会检查要加载的是什么类, java.util.HashMap, 它会当仁不让, 直接加载
    //              返回给扩展类加载器的消息就是已经加载了, 继续返回给系统类加载器
    //              最终又回到系统加载器, 类已经加载完毕, 结束!!
​
    // 作用是防止用户自定义类恶意替换JRE中的核心类
}

有了Class对象，能做什么？

创建类的对象

  • newInstance()方法

    获取类的无参构造器

    前提条件： 1）类必须有一个无参数的构造器。 ​ 2）类的构造器的访问权限需要足够。

  • getDeclaredConstructor(Class … parameterTypes)取得本类的指定形参类型的构造器

    向构造器的形参中传递一个对象数组进去，里面包含了构造器中所需的各个参数。

  • Constructor类中存在一个方法

    public T newInsTance (Object ... initargs )

综合例子

 public void test3() {
        try {
            Class clazz = clazz = Class.forName("com.atguigu.javase.javabean.Student");
            //Object obj = clazz.newInstance(); // 无参构造器
            //public Student(int id, String name, int grade, double score) {
       // 反射的方式,使用全参构造器创建对象
            // 必须提供形参的类型列表(所有类型的Class对象)
            Constructor constructor = clazz.getConstructor(int.class, "".getClass(), int.class, double.class);
            // 通过构造器创建实体对象, 必须提供方法调用时的实参列表
            Object obj = constructor.newInstance(1, "小刚", 4, 50.5);
            System.out.println(obj);
            // 反射方式调用 public void study(String content, int hours)
      // 反射的方式调用方法
            // 1) 从类模板中获取到方法对象
            // 必须提供方法名, 和 所有参数的类型列表
            // getMethod 可以获取到本类的和从父类继承的所有公共方法
            //Method studyMethod = clazz.getMethod("study", String.class, int.class);
            // getDeclaredMethod可以获取到类中声明的所有方法, 包括私有的
            Method studyMethod = clazz.getDeclaredMethod("study", String.class, int.class);
            studyMethod.setAccessible(true); // 如果方法是private或无法访问, 需要暴力反射
            // 2) 让方法配合目标this对象完成 调用
            // 必须提供目标this对象  和 实参列表
            Object retValue = studyMethod.invoke(obj, "MySQL", 9);// 相当于 obj.study("MySQL", 9);
            System.out.println(retValue); // 如果方法返回值类型为void, 实际返回的就是null
​
            // 也可以获取从父类继承的公共方法. 如果方法是无参的, 获取时不需要提供类型列表
            Method hashCode = clazz.getMethod("hashCode");
            Object invoke = hashCode.invoke(obj); // 调用时也不需要实参
            System.out.println(invoke);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) { // 访问不能访问的元素, 比如私有成员
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) { // 方法名写错了, 参数类型提供错了, 方法如果是非公共方法getMethod肯定不行
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }

通过反射调用类的完整结构

  • 实现的全部接口

    • public Class<?>[] getInterfaces()

      确定此对象所表示的类或接口实现的接口。

  • 所继承的父类

    • public Class<? Super T> getSuperclass()

      返回表示此 Class 所表示的实体（类、接口、基本类型）的父类的 Class。

  • 全部的构造器

    • public Constructor<T>[] getConstructors()

      返回此 Class 对象所表示的类的所有public构造方法。

    • public Constructor<T>[] getDeclaredConstructors() 返回此 Class 对象表示的类声明的所有构造方法。

    • Constructor类中：

      • 取得修饰符: public int getModifiers();

      • 取得方法名称: public String getName();

      • 取得参数的类型：public Class<?>[] getParameterTypes();

  • 全部的方法

    • public Method[] getDeclaredMethods() 返回此Class对象所表示的类或接口的全部方法

    • public Method[] getMethods() 返回此Class对象所表示的类或接口的public的方法

    • Method类中：

      • public Class<?> getReturnType()取得返回值类型

      • public Class<?>[] getParameterTypes()取得全部的参数类型

      • public int getModifiers()取得修饰符

      • public Class<?>[] getExceptionTypes()取得所有抛出的异常类型

  • 全部的Field

    • public Field[] getFields() 返回此Class对象所表示的类或接口的public的Field。

    • public Field[] getDeclaredFields() 返回此Class对象所表示的类或接口的全部Field。

    • Field方法中：

      • public int getModifiers() 以整数形式返回此Field的修饰符

      • public Class<?> getType() 得到Field的属性类型

      • public String getName() 返回Field的名称。

小 结

  1. 在实际的操作中，取得类的信息的操作代码，并不会经常开发。

  2. 一定要熟悉java.lang.reflect包的作用，反射机制。

  3. 如何取得属性、方法、构造器的名称，修饰符等。

通过反射调用类中的指定方法、指定属性

  1. 调用指定方法

    通过反射，调用类中的方法，通过Method类完成。步骤：

    1. 通过Class类的getMethod(String name,Class…parameterTypes)方法取得一个Method对象，并设置此方法操作时所需要的参数类型。

    2. 之后使用Object invoke(Object obj, Object[] args)进行调用，并向方法中传递要设置的obj对象的参数信息。

      1. Object 对应原方法的返回值，若原方法无返回值，此时返回null

      2. 若原方法若为静态方法，此时形参Object obj可为null

      3. 若原方法形参列表为空，则Object[] args为null

      4. 若原方法声明为private,则需要在调用此invoke()方法前，显式调用方法对象的setAccessible(true)方法，将可访问private的方法。

  2. 调用指定属性

    在反射机制中，可以直接通过Field类操作类中的属性，通过Field类提供的set()和get()方法就可以完成设置和取得属性内容的操作。

    1. public Field getField(String name) 返回此Class对象表示的类或接口的指定的public的Field。

    2. public Field getDeclaredField(String name)返回此Class对象表示的类或接口的指定的Field。

    在Field中：

    • public Object get(Object obj) 取得指定对象obj上此Field的属性内容

    • public void set(Object obj,Object value) 设置指定对象obj上此Field的属性内容

      PS:在类中属性都设置为private的前提下，在使用set()和get()方法时，首先要使用Field类中的setAccessible(true)方法将需要操作的属性设置为可以被外部访问。

    • public void setAccessible(true)访问私有属性时，让这个属性可见。

posted @ 2021-01-25 13:49  WZZR  阅读(297)  评论(0)    收藏  举报