Java反射机制

1、Java反射机制概述

1.1、Reflection API

1、反射(Reflection)：是Java语言的一个特性，是被视为动态语言的关键。它允程序在运行时（注意不是编译的时候）来进行自我检查并且对内部的成员进行操作。例如它允许一个Java的类获取他所有的成员变量和方法并且显示出来。而这一特性的实现，需要借助于 Refection API。

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

3、加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个 类只有一个Class对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看 到类的结构，所以，我们形象的称之为：反射。
在这里插入图片描述
4、在JDK中，主要由以下类来实现Java反射机制，这些API都位于java.lang.reflect包中。

  1. Class类：代表一个类。

  2. Field类：代表类的成员变量（成员变量也称为类的属性）。

  3. Method类：代表类的方法。

  4. Constructor类：代表类的构造方法。

  5. Array类：提供了动态创建数组，以及访问数组元素的静态方法。

1.2、静态语言与动态语言

前面我们已经知道，是因为反射机制的原因，Java被视为"动态语言"。其实Java只是因为这一特性，具备动态语言某些的特性，让Java成为"准动态语言"，并不能真正当做动态语言。那么什么是动态语言？什么又是静态语言呢？

1、动态语言

  1. 是一类在运行时可以改变其结构的语言：例如新的函数、对象、甚至代码可以 被引进，已有的函数可以被删除或是其他结构上的变化。通俗点说就是在运行时代码可以根据某些条件改变自身结构。

  2. 主要动态语言：Object-C、C#、JavaScript、PHP、Python、Erlang等

2、静态语言

  1. 与动态语言相对应的，运行时结构不可变的语言就是静态语言。如Java、C、 C++等。

  2. Java不是动态语言，但Java可以称之为“准动态语言”。即Java有一定的动态性，我们可以利用反射机制、字节码操作获得类似动态语言的特性。 Java的动态性让编程的时候更加灵活。

1.3、Java反射机制提供的功能

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

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

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

4、在运行时获取泛型信息

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

6、在运行时处理注解

7、生成动态代理

1.4、反射的使用初体验

/*
Java反射的使用：

疑问1：通过直接new的方式或反射的方式都可以调用公共的结构，开发中到低用那个？
    1.开发中建议使用 new 的方式创建对象
    2.什么时候使用 反射的方式。反射的特征：动态性

疑问2：反射机制与面向对象中的封装性是不是矛盾的？如何看待这两个技术？
    不矛盾。
 */
 
 /**
 * @description: 我们新建一个Person类用于测试反射，Person类里有属性(包括公私有属性)有getter和setter，和一些自定义方法(公私有)，具体Person类在代码最下面。
 * @author: laizhenghua
 * @date: 2020/11/29 19:12
 */
 public class ReflectionTest {
	/* 反射之前，对Person类的操作 */
    @Test
    public void test1(){
        // 1. 创建Person类的对象
        Person p1 = new Person("韩信",22);

        // 2. 通过对象调用其内部的属性与方法
        p1.age = 10;
        System.out.println(p1.toString());
        p1.show();

        // 3. 在Person类外部，不可以通过Person类的对象调用其内部私有结构
        // 比如：私有构造器、name属性、showNation()私有方法
    }
    
	/* 反射之后，对Person类的操作 */
    @Test
    public void test2() throws Exception {
        // 1. 通过反射，创建Person类的对象
        Class clazz = Person.class; // Class<Person> personClass = Person.class

        Constructor constructor1 = clazz.getConstructor(String.class,int.class); // Constructor<Person> constructor ...
        Object obj1 = constructor1.newInstance("韩信",22);
        Person p1 = (Person) obj1;
        System.out.println(p1);

        // 2. 通过反射，调用对象的属性和方法
        // 调属性
        Field age = clazz.getDeclaredField("age");
        age.set(p1,10);
        System.out.println(p1.toString()); // Person{name='韩信', age=10}

        // 调方法
        Method show = clazz.getDeclaredMethod("show");
        show.invoke(p1);

        // 3. 通过反射，调用Person类的私有结构，私有构造器、属性、方法
        // 调私有构造器
        Constructor constructor2 = clazz.getDeclaredConstructor(String.class);
        constructor2.setAccessible(true);
        Person p2 = (Person) constructor2.newInstance("李白");
        System.out.println(p2); // Person{name='李白', age=0}

        // 调私有方法
        Method showNationMethod = clazz.getDeclaredMethod("showNation", String.class);
        showNationMethod.setAccessible(true);
        String nation = (String) showNationMethod.invoke(p2,"中国"); // 我的国籍是中国
        System.out.println(nation);

        // 调私有属性
        Field name = clazz.getDeclaredField("name");
        name.setAccessible(true);
        name.set(p2,"alex");
        System.out.println(p2); // Person{name='alex', age=0}
    }
}

/* Person类 */
class Person{
    private String name;
    public int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    private Person(String name){
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public void show(){
        System.out.println("你好，我是一个人");
    }
    private String showNation(String nation){
        System.out.println("我的国籍是："+nation);
        return nation;
    }
}

2、Class类详解

2.1、关于java.lang.Class类的理解

1、类的加载过程：

  1. 程序经过java.exe命令以后，会生成一个或多个字节码文件(.class结尾)。
  2. 接着我们使用java.exe命令对某个字节码文件进行解释运行。相当于将某个字节码文件加载到内存中。此过程就称为类的加载。加载到内存中的类，我们就称之为 [运行时类]，此运行时类，就作为Class的一个实例。

2、换句话说，Class的实例就对应着一个运行时类。

3、在Object类中定义了public final Class getClass()方法，此方法将被所有子类继承。此方法返回值的类型是一个Class类， 此类是Java反射的源头。

4、Class 类

可以把反射理解为对象照镜子，对象照镜子后可以得到的信息：某个类的属性、方法和构造器、某个类到底实现了哪些接口。对于每个类而言，JRE 都为其保留一个不变的 Class 类型的对象。一个 Class 对象包含了特定某个结构(class/interface/enum/annotation/primitive type/void/[])的有关信息。

  • Class本身也是一个类
  • Class 对象只能由系统建立对象
  • 一个加载的类在 JVM 中只会有一个Class实例
  • 一个Class对象对应的是一个加载到JVM中的一个.class文件
  • 每个类的实例都会记得自己是由哪个 Class 实例所生成
  • 通过Class可以完整地得到一个类中的所有被加载的结构
  • Class类是Reflection的根源，针对任何你想动态加载、运行的类，唯有先获得相应的 Class对象

2.2、获取Class类的实例(4种方式)

1、加载到内存中的运行时类，会缓存一定的时间，我们可以通过不同的方式来获取此运行时类。

/* 获取Class的实例的方式，前3中使用较多是重点 */
@Test
public void test() throws ClassNotFoundException {
    // 方式1：调用运行时类的属性 .class
    Class<Person> clazz1 = Person.class;
    System.out.println(clazz1);

    // 方式2：通过运行时类的对象，调用getClass()
    Person p1 = new Person();
    Class clazz2 = p1.getClass();
    System.out.println(clazz2);

    // 方式3：调用Class的静态方法  forName(String classPath)，参数classPath：类的全限定名称
    Class clazz3 = null;
    try {
        clazz3 = Class.forName("com.lzh.java1.Person");
        // Class clazz = Class.forName("java.lang.String");
        System.out.println(clazz3);
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }

    // 方式4：使用类的加载器    ClassLoader
    ClassLoader classLoader = ReflectionTest2.class.getClassLoader();
    Class clazz4 = classLoader.loadClass("com.lzh.java1.Person");
    System.out.println(clazz4);

    System.out.println(clazz1 == clazz2); // true
    System.out.println(clazz1 == clazz3); // true
}

2、哪些类型可以有Class对象？

（1）class： 外部类，成员(成员内部类，静态内部类)，局部内部类，匿名内部类

（2）interface：接口

（3）[]：数组

（4）enum：枚举

（5）annotation：注解@interface

（6）primitive type：基本数据类型

（7）void

Class c1 = Object.class; 
Class c2 = Comparable.class; 
Class c3 = String[].class; 
Class c4 = int[][].class; 
Class c5 = ElementType.class; 
Class c6 = Override.class; 
Class c7 = int.class; 
Class c8 = void.class; 
Class c9 = Class.class;

int[] a = new int[10];
int[] b = new int[100]; 
Class c10 = a.getClass(); 
Class c11 = b.getClass(); // 只要元素类型与维度一样，就是同一个Class System.out.println(c10 == c11);

2.3、使用ClassLoader加载配置文件

1、前面我们已经知道ClassLoader是类的加载器，它可以获取Class类的实例。

2、ClassLoader负责载入系统的所有Resources（Class，文件，来自网络的字节流等），通过ClassLoader从而将资源载入JVM。每个class都有一个reference，指向自己的ClassLoaderClass.getClassLoader() 。

3、因为ClassLoader载入系统资源的特性，我们可以完成一个小案例，实现配置文件的载入！

首先我们在当前module下新建一个文件(db.properties)

name=alex
password=123

不是使用ClassLoader，传统读取方式

@Test
public void test3(){
    File file = new File("db.properties");
    Properties properties = new Properties();
    FileReader reader = null;
    try {
        reader = new FileReader(file);
        properties.load(reader);
        String name = properties.getProperty("name");
        String password = properties.getProperty("password");
        System.out.println("debug name --> " + name); // debug name --> alex
        System.out.println("debug password --> " + password); // debug password --> 123
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        try {
            assert reader != null;
            reader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

使用ClassLoader

/* ClassLoader的使用实例：读取配置文件(db.properties)，此时db.properties需要移动到src目录下 */
@Test
public void test4(){
    Properties properties = new Properties();

    ClassLoader classLoader = this.getClass().getClassLoader();
    InputStream inputStream = classLoader.getResourceAsStream("db.properties"); // 配置文件默认识别为：当前module的src下
    try {
        properties.load(inputStream);
        String name = properties.getProperty("name");
        String password = properties.getProperty("password");

        System.out.println("debug name --> " + name); // debug name --> alex
        System.out.println("debug password --> " + password); // debug password --> 123

    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            assert inputStream != null;
            inputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

小结：

  • 类加载的作用：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后在堆中生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口。
  • 类缓存：标准的JavaSE类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，它将维持加载（缓存）一段时间。不过JM垃圾回收机制可以回收这些Class对象。

2.4、通过反射创建运行时类的对象

1、newInstance() 方法

/* 通过反射创建运行时类的对象 */
 @Test
 public void test1() throws IllegalAccessException, InstantiationException {
     Class<Person> clazz = Person.class;
     // Class<Person> c = Class.forName("com.lzh.java2.Person");
     /*
     newInstance(); 调用此方法，创建对应的运行时类的对象.内部调用了运行时类的空参构造器
     要想此方法正常的创建运行时类的对象，要求：
         1. 运行时类必须提供空参的构造器
         2. 空参的构造器的访问权限的够。通常设置为public

     在javabean中要去提供一个public的空参构造器。原因：
         1. 便于通过反射，创建运行类的对象
         2. 便于子类继承此运行时类时，默认调用super()时，保证父类有此构造器
      */
     Person p1 = clazz.newInstance();
     System.out.println(p1);


	/*
     newInstance() 调用此方法，创建运行时类的对象
     我们可以做个试验，可以在公有无参构造器中添加一些输出的代码，运行
     试验结果说明，本质上还是调用了构造器创建对象，也只有构造器能造对象
     */
 }

2、体会反射的动态性

/* 体会反射的动态性 */
@Test
public void test2(){
    for(int i = 0;i < 10;i++){
        int number = new Random().nextInt(3); // 0 1 2
        String classPath = "";
        switch(number){
            case 0:
                classPath = "java.util.Date";
                break;
            case 1:
                classPath = "java.lang.Object";
                break;
            case 2:
                classPath = "com.lzh.java2.Person";
                break;
        }

        try {
            Object obj = getInstance(classPath);
            System.out.println(obj);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

/*
创建一个指定类的对象，classPath：指定类的全名
 */
public Object getInstance(String classPath) throws Exception {
    Class clazz = Class.forName(classPath);
    return clazz.newInstance();
}

2.5、通过反射获取运行时类的完整结构

我们知道Java反射机制的源头是java.lang.Class类，我们可以通过这个类获取运行时类的完整结构，包括类的属性、方法和构造器、某个类到底实现了哪些接口等。所以我们要想获取某个运行时类的的结构，就必须先获取这个类对应的Class类的实例，并调用实例的某些方法从而获取我们想要信息。

为了方便测试，我们先编写测试代码，包括父类，子类，自定义的接口，自定义的注解，私有方法，私有属性，公有方法，公有属性，泛型等。为了方便查看，我全部写在一个类里面：

@MyAnnotation(value="hi")
public class Man extends Creature<String> implements Comparable<String>,MyInterface {

    private String name;
    int age;
    public int id;

    public Man(){}

    @MyAnnotation(value="abc")
    private Man(String name){
        this.name = name;
    }

    Man(String name,int age){
        this.name = name;
        this.age = age;
    }

    @MyAnnotation
    private String showNation(String nation){
        System.out.println("我的国籍是：" + nation);
        return nation;
    }

    public String display(String interest){
        System.out.println();
        return interest;
    }

    @Override
    public void info() {
        System.out.println("我是一个人");
    }

    @Override
    public int compareTo(String o) {
        return 0;
    }
}

// 提供Man的父类Creature<T>
class Creature<T> implements Serializable {
    private char gender;
    public double weight;

    private void breath(){
        System.out.println("生物呼吸");
    }
    public void eat(){
        System.out.println("生物吃东西");
    }
}

// 自定义接口
interface MyInterface{
    void info();
}

// 提供注解
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE, MODULE})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation{
    String value() default "hello";
}

1、通过反射获取运行时类的全部属性(Field)

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

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

Field类包含的方法：

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

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

  3. public String getName() 返回Field的名称

代码测试

/**
 * @description: 获取当前运行时类的属性结构
 * @author: laizhenghua
 * @date: 2020/12/1 12:39
 */
public class FieldTest {
	/* Class类实例的方法 */
    @Test
    public void test1(){

        Class<Man> clazz = Man.class;
        // 获取属性结构
        // getFields()：获取当前运行类及其父类中声明为public访问权限的属性
        Field[] fields1 = clazz.getFields();

        for(Field field:fields1){
            System.out.println(field);
        }

        // getDeclaredFields()：获取当前运行类中声明的所有属性(不包含父类中声明的属性)
        Field[] fields2 = clazz.getDeclaredFields();
        for(Field field:fields2){
            System.out.println(field);
        }
    }
	/* Field类里的方法，包括权限修饰符、数据类型、变量名 */
    @Test
    public void test2(){
        try {
            Class clazz = Class.forName("com.lzh.java2.Man");

            Field[] fields1 = clazz.getDeclaredFields();
            for(Field field:fields1){
                // 1. 权限修饰符
                // int modifier = field.getModifiers();
                System.out.print(Modifier.toString(field.getModifiers()) + "\t");

                // 2. 数据类型
                Class type = field.getType();
                System.out.print(type.getName() + "\t");

                // 3. 变量名
                // String name = field.getName();
                System.out.print(field.getName() + "\t");

                System.out.println();
            }
        }catch (ClassNotFoundException e){
            e.printStackTrace();
        }
    }
}

2、通过反射获取运行时类的全部方法

  1. public Method[] getDeclaredMethods() 返回此Class对象所表示的类或接口的全部方法(不包含父类中声明的方法)。

  2. public Method[] getMethods() 返回此Class对象(当前运行时类)所声明的类、父类或接口的public权限的方法。

Method类中包含的方法：

  1. public Class<?> getReturnType() 取得全部的返回值

  2. public Class<?>[] getParameterTypes() 取得全部的参数

  3. public int getModifiers() 取得修饰符

  4. public Class<?>[] getExceptionTypes() 取得异常信息

关于代码的测试，可自行完成。

3、通过反射获取运行时类的全部构造器

  1. public Constructor<T>[] getConstructors() 返回此 Class 对象所表示的类的所有public构造方法。

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

Constructor类中包含的方法：

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

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

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

有关方法的测试，可自行完成。

4、通过反射获取运行时类的父类

  1. public Class<? Super T> getSuperclass() 返回表示此 Class 所表示的实体（类、接口、基本类型）的父类的 Class。
  2. 测试
@Test
public void test2(){
    Class<Person> personClass = Person.class;
    
    // 获取运行时类父类的Class
    Class<? super Person> superclass = personClass.getSuperclass();
    System.out.println(superclass); // class com.howie.pojo.Creature

    // 获取运行时类带泛型的父类
    Type genericSuperclass = personClass.getGenericSuperclass();
    System.out.println(genericSuperclass); // com.howie.pojo.Creature<java.lang.String>

    // 获取运行时类带泛型的父类的泛型
    ParameterizedType parameterized = (ParameterizedType) genericSuperclass;
    Type[] actualTypeArguments = parameterized.getActualTypeArguments(); // 获取泛型参数
    System.out.println(actualTypeArguments[0]); // class java.lang.String
    // System.out.println(actualTypeArguments[0].getTypeName());
}

5、通过反射获取运行实类实现的接口

  1. public Class<?>[] getInterfaces() 确定此对象所表示的类或接口实现的接口。
  2. 测试
@Test
public void test3(){
    Class<Person> personClass = Person.class;
    // 获取运行类实现的接口
    Class<?>[] interfaces = personClass.getInterfaces();
    for (Class c : interfaces){
        System.out.println(c);
    }

    // 获取运行时类父类的实现的接口
    Class<?>[] superInterfaces = personClass.getSuperclass().getInterfaces();
    for (Class c : superInterfaces){
        System.out.println(c);
    }
}

6、通过反射获取运行时类所在包

  1. Package getPackage() 获取运行时类所包
  2. 测试
@Test
public void test(){
    Class<Person> personClass = Person.class;
    Package classPackage = personClass.getPackage();
    System.out.println(classPackage); // package com.howie.pojo
}

7、通过反射获取运行时类声明的注解

  1. getAnnotation(Class<T> annotationClass) 返回该元素的指定类型的注释
  2. getDeclaredAnnotations() 返回直接存在于此运行时类上的所有注释(不包含父类中声明)
  3. Annotation[] getAnnotations() 获取运行时类声明的注解
@Test
public void test(){
    Class<Person> personClass = Person.class;
    Annotation[] annotations = personClass.getAnnotations();
    for(Annotation annotation : annotations){
        System.out.println(annotation); // @com.howie.pojo.MyAnnotation(value=world)
    }
}

8、泛型相关

  1. 获取父类泛型类型：Type getGenericSuperclass()
  2. 泛型类型：ParameterizedType
  3. 获取实际的泛型类型参数数组：getActualTypeArguments()

小结

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

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

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

3、调用运行时类指定的结构

3.1、调用指定的属性

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

1、获取指定属性的方法

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

2、在Field类中包含的方法：

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

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

3、代码测试

@Test
public void FieldTest(){
    // 获取指定的属性
    try {
        Class clazz = Class.forName("com.lzh.java2.Man");
        // 获取运行时类的对象
        Man man = (Man) clazz.newInstance();

        // 获取指定的属性：要求运行时类的属性声明为 public
        Field id = clazz.getField("id"); // 开发中通常不适用此方法

        /*
        设置当前属性的值    set()方法
        参数1：指明设置那个对象的属性
        参数2：将此属性值设置为多少
         */
        id.set(man,1001);

        // 获取当前属性的值：get(Object obj) 参数obj：获取哪个对象的当前属性值
        int manId = (int) id.get(man); // 1001
        System.out.println(manId);

    }catch (Exception e){
        e.printStackTrace();
    }
}

@Test
/*
如何操作运行时中类指定的属性 --> 需要掌握
 */
public void test1(){
    try{
        // 获取运行时类对象
        Class clazz = Class.forName("com.lzh.java2.Man");
        Man man = (Man) clazz.newInstance();

        // 获取指定的属性
        // 1 getDeclaredField(String field)   获取运行时类中指定变量名的属性(忽略权限)
        Field name = clazz.getDeclaredField("name");
        name.setAccessible(true); // 2 保证当前属性是可以访问的(可以理解为取消封装)

        // 3 获取、设置指定对象的此属性值
        name.set(man,"李白");

        String manName = (String) name.get(man);
        System.out.println(manName);

    }catch(Exception e){
        e.printStackTrace();
    }
}

关于setAccessible方法的使用

  • Method和Field、Constructor对象都有setAccessible()方法。

  • setAccessible启动和禁用访问安全检查的开关。

  • 参数值为true则指示反射的对象在使用时应该取消Java语言访问检查。

  1. 提高反射的效率。如果代码中必须用反射，而该句代码需要频繁的被 调用，那么请设置为true。

  2. 使得原本无法访问的私有成员也可以访问

  • 参数值为false则指示反射的对象应该实施Java语言访问检查

3.2、调用指定的方法

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

  1. 通过Class类的getMethod(String name, Class<?>... parameterTypes)方法取得 一个Method对象，并设置此方法操作时所需要的参数类型。但是以上方法不常用，我们常用的方法是Method getDeclaredMethod(String name, Class<?>... parameterTypes)来获取运行时类中指定的方法。

  2. 之后使用Object invoke(Object obj, Object[] args)进行调用，并向方法中传递要设置的obj对象的参数信息。
    在这里插入图片描述2、代码测试

@Test
/*
如何操作运行时类中指定的方法 --> 需要掌握
 */
public void methodTest(){
    // 操作非静态方法
    Class clazz = null;
    try{
        // 1. 获取运行时类的对象
        clazz = Class.forName("com.lzh.java2.Man");
        Man man = (Man) clazz.newInstance();

        // 2. 获取运行时类中指定的某个方法
        // getDeclaredMethod(String name,Class<?>)  参数1：指明获取方法的名称   参数2：指明获取的方法的形参列表
        Method showNation = clazz.getDeclaredMethod("showNation", String.class);
        showNation.setAccessible(true); // 保证当前方法可以访问

        // invoke(Object obj,Object...arg) 参数1：方法的调用这   参数2：给方法形参赋值的实参
        // invoke()方法的返回值即为运行时类方法执行时返回的返回值
        showNation.invoke(man,"china"); // 3. 调用invoke()方法
        // Object nation = showNation.invoke(man,"china");

        // 执行结果
        // 我的国籍是：china

    }catch(Exception e){
        e.printStackTrace();
    }

    // 操作静态方法
    // public static void speak() --> 静态方法
    try {
        Method speak = clazz.getDeclaredMethod("speak");
        speak.setAccessible(true);

        Object value = speak.invoke(clazz.newInstance());
        System.out.println(value); // null

        // 说明：如果调用的运行时类中的方法没有返回值，则此invoke()方法返回null
    }catch(Exception e){
        e.printStackTrace();
    }
}

Object invoke(Object obj, Object … args)说明：

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

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

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

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

3.3、调用指定的构造器

前面我们已经知道，通过反射我们也可以获取运行时类中声明的构造器，同样我们也可以调用运行时类中指定的构造器。

  1. 通过Class类的Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)取得一个Constructor对象。
  2. 通过Constructor对象的T newInstance(Object ... initargs)就可以造出一个对象！
    代码测试：
/*
如何调用运行时类中指定的构造器
 */
@Test
public void constructorTest(){
    // private Man(String name) 指定运行时类的构造器
    Class clazz = null;
    try{
        // 1. 获取Class的实例
        clazz = Class.forName("com.lzh.java2.Man");
        // 2. 获取运行时类中指定的构造器
        // getDeclaredConstructor() 参数：指明构造器的参数列表
        Constructor constructor = clazz.getDeclaredConstructor(String.class);
        // Man类里的有参构造器 private Man(String name){...}
        
        // 3. 保证此构造器是可以被访问的
        constructor.setAccessible(true);
        // 4. 调用此构造器创建运行时类的对象
        Man man = (Man) constructor.newInstance("韩信");
        System.out.println(man);

    }catch (Exception e){
        e.printStackTrace();
    }
}

4、反射机制的应用：动态代理

4.1、动态代理模式介绍

1、代理设计模式的原理：使用一个代理将对象包装起来, 然后用该代理对象取代原始对象。任何对原始对象的调用都要通过代理。代理对象决定是否以及何时将方法调用转到原始对象上。

2、之前为大家讲解过代理机制的操作，属于静态代理，特征是代理类和目标对象的类都是在编译期间确定下来，不利于程序的扩展。同时，每一个代理类只能为一个接口服务，这样一来程序开发中必然产生过多的代理。最好可以通过一个代理类完成全部的代理功能。

3、动态代理是指客户通过代理类来调用其它对象的方法，并且是在程序运行时根据需要动态创建目标类的代理对象。

4、动态代理使用场合：

  1. 调试

  2. 远程方法调用

5、动态代理相比于静态代理的优点：

抽象角色中（接口）声明的所有方法都被转移到调用处理器一个集中的方法中处理，这样我们可以更加灵活和统一的处理众多的方法。

4.2、Java动态代理相关API

  1. Proxy ：专门完成代理的操作类，是所有动态代理类的父类。通过此类为一个或多个接口动态地生成实现类。

  2. 提供用于创建动态代理类和动态代理对象的静态方法

在这里插入图片描述

4.3、实现动态代理的步骤

1、创建一个实现接口InvocationHandler的类，它必须重写invoke方法，以完成代理的具体操作。
在这里插入图片描述
2、创建被代理的类以及接口
在这里插入图片描述
3、通过Proxy的静态方法 newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h) 创建 一个Subject接口代理。

4、通过 Subject代理调用RealSubject实现类的方法

4.4、动态代理代码示例

1、静态代理

/*
静态代理举例：
    特点：编译期间，代理类和被代理类就已经确定下来了
 */

// 定义代理接口
interface ClothFactory{
    void produceCloth();
}

// 创建代理类
class ProxyClothFactory implements ClothFactory {
    private ClothFactory clothFactory; // 用被代理类进行实例化

    public ProxyClothFactory(ClothFactory clothFactory){
        this.clothFactory = clothFactory;
    }

    @Override
    public void produceCloth(){
        System.out.println("代理工厂做一些准备工作");
        clothFactory.produceCloth();
        System.out.println("代理工厂做一些后续的收尾工作");
    }
}

// 创建被代理类
class NikeClothFactory implements ClothFactory {
    @Override
    public void produceCloth(){
        System.out.println("nike工厂生产一批运动服");
    }
}

public class StaticProxyTest {
    public static void main(String[] args){
        // NikeClothFactory nikeClothFactory = new NikeClothFactory(); 创建代理类对象
        ClothFactory proxy = new ProxyClothFactory(new NikeClothFactory()); // 创建被代理类对象
        proxy.produceCloth();
    }
}

2、动态代理

// 创建代理接口
interface Human{
    String getBelief(); // 获取信仰
    void eat(String food);
}

// 创建被代理类
class SuperMan implements Human{
    @Override
    public String getBelief(){
        return "I believe I can fly!";
    }

    @Override
    public void eat(String food){
        System.out.println("我喜欢吃：" + food);
    }
}

/*
要想实现动态代理，需要解决的问题：
    问题1：如何根据加载到内存中的被代理类，动态的创建一个代理类及其对象
    问题2：当通过代理类的对象调用方法时，如何动态的去调用被代理类中同名方法
 */
// 创建代理类
class ProxyFactory{
    // 调用此方法，返回一个代理类的对象。解决问题1
    public static Object getProxyInstance(Object obj){ // obj：被代理类的对象

        MyInvocationHandler handler = new MyInvocationHandler();
        handler.bank(obj);
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(),obj.getClass().getInterfaces(),handler);
    }
}

class MyInvocationHandler implements InvocationHandler {
    private Object obj; // 需要使用被代理类的对象进行赋值
    public void bank(Object obj){
        this.obj = obj;
    }

    // 当我们通过代理类的对象，调用方法a时，就会自动调用如下方法：invoke()
    // 将别代理类要执行的方法a的功能，就声明在invoke()方法中
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // method：即为代理类对象调用的方法，此方法也就作为被代理类对象要调用的方法
        // obj：被代理类的对象
        Object returnValue = method.invoke(obj,args);
        // 上述方法的返回值就作为当前类中的invoke()
        return returnValue;
    }
}

public class ProxyTest {

    public static void main(String[] args) {
        // 创建代理类的对象
        // SuperMan superMan = new SuperMan(); 代理类对象
        Human proxyInstance = (Human) ProxyFactory.getProxyInstance(new SuperMan());
        // 当通过代理类对象调用方法时，会自动的调用被代理类中同名的方法
        String belief = proxyInstance.getBelief();
        System.out.println(belief);
        proxyInstance.eat("四川麻辣烫");

        ClothFactory clothFactory = (ClothFactory) ProxyFactory.getProxyInstance(new NikeClothFactory());
        clothFactory.produceCloth();



    }
}

end

Thanks for watching!

end

Logo
CSDN学习社区

CSDN联合极客时间，共同打造面向开发者的精品内容学习社区，助力成长！

更多推荐

cover

用 OpenAI Assistants 做大模型应用开发

avatar CSDN学习社区
cover

1 小时解读鸿蒙 10 大热点问题

avatar CSDN学习社区
cover

1 小时解读鸿蒙 10 大热点问题

avatar CSDN学习社区