Java反射的使用

最新推荐文章于 2024-06-12 15:26:43 发布
最新推荐文章于 2024-06-12 15:26:43 发布
阅读量682 收藏 1
点赞数
分类专栏： Java 文章标签： java 后端 反射
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Cicci_/article/details/121165951
版权

Java 反射

Java反射机制概述

  • Reflection（反射）是被视为动态语言的关键，反射机制允许程序在执行期借助于 Reflection API 取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。
  • 加载完类之后，在堆内存的方法区中就产生了一个 Class 类型的对象（一个 类只有一个 Class 对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，我们形象的称之为：反射。

在这里插入图片描述

案例

Person类（该类用于辅助测试）

package com.laoyang.test.day1;

/**
 * @ClassName Person
 * @Description：
 * @Author Laoyang
 * @Date 2021/10/31 17:19
 */
public class Person {
    private String name;
    public int age;

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

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

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

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

    public Person() {
        System.out.println("这是一个Person的空参构造器");
    }

    public void show() {
        System.out.println("你好，我是一个人");
    }

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

测试类

package com.laoyang.test.day1;

import org.junit.Test;
import java.lang.annotation.ElementType;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

/**
 * @ClassName ReflectionTest
 * @Description：
 * @Author Laoyang
 * @Date 2021/10/31 17:16
 */
public class ReflectionTest {
    /**
     * 使用反射之前，对于 Person 类的操作
     */
    @Test
    public void testOne() {
        // 因为 Person 类和当前类在同一包下，所以就不需要导入对应的包了
        
        // 1. 创建 Person 类的对象
        Person person = new Person("Tom", 18);

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

        person.show();

        /*
         在 Person 类外部，不可以通过 Person 类的对象调用其内部的私有结构
         比如：name、showNation() 以及私有的构造器
         */
    }

    /**
     * 使用反射之后，对于 Person 类的操作
     */
    @Test
    public void testTwo() {
        Class personClass = Person.class;
        try {
            // 1. 通过反射，可以创建 Person 类的对象
            Constructor constructor = personClass.getConstructor(String.class, int.class);
            Object obj = constructor.newInstance("Tom", 18);
            Person tom = (Person) obj;
            System.out.println(tom.toString());

            // 2. 通过反射，调用对象指定的属性和方法
            // 调属性
            Field age = personClass.getDeclaredField("age");
            age.set(tom, 10);
            System.out.println(tom.toString());

            // 调方法
            Method show = personClass.getDeclaredMethod("show");
            show.invoke(tom);

            // 通过反射是可以调用 Person 类的私有结构的，比如：私有的构造器、方法、属性
            // 调用私有构造器
            Constructor constructor1 = personClass.getDeclaredConstructor(String.class);
            constructor1.setAccessible(true);
            Person jerry = (Person) constructor1.newInstance("Jerry");
            System.out.println(jerry);

            // 调用私有属性
            Field name = personClass.getDeclaredField("name");
            name.setAccessible(true);
            name.set(jerry, "HanMeimei");
            System.out.println(jerry);

            // 调用私有方法
            Method showNation = personClass.getDeclaredMethod("showNation", String.class);
            showNation.setAccessible(true);
            // 相当于 String nation = jerry.showNation("中国")
            String nation = (String) showNation.invoke(jerry, "中国");
            System.out.println(nation);     // 返回值：中国
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

补充：动态语言 vs 静态语言

  1. 动态语言

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

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

  2. 静态语言

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

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

Java 反射机制研究及应用

Java反射机制提供的功能

  • 在运行时判断任意一个对象所属的类
  • 在运行时构造任意一个类的对象
  • 在运行时判断任意一个类所具有的成员变量和方法
  • 在运行时获取泛型信息
  • 在运行时调用任意一个对象的成员变量和方法
  • 在运行时处理注解
  • 生成动态代理

反射相关的主要API

  • java.lang.Class：代表一个类
  • java.lang.reflect.Method：代表类的方法
  • java.lang.reflect.Field：代表类的成员变量
  • java.lang.reflect.Constructor：代表类的构造器
  • … …

理解 Class 类并获取 Class 的实例

Class 类

  • 在 Object 类中定义了以下的方法，此方法将被所有子类继承：

     public final Class getClass()

  • 以上的方法返回值的类型是一个 Class 类， 此类是 Java 反射的源头，实际上所谓反射从程序的运行结果来看也很好理解，即： 可以通过对象反射知道类的名称。

案例

package com.laoyang.test.day1;

import org.junit.Test;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * @ClassName ReflectionTest
 * @Description：
 * @Author Laoyang
 * @Date 2021/10/31 17:16
 */
public class ReflectionTest {
    @Test
    public void test() {
        Object object = new Object();
        System.out.println(object.getClass());  // class java.lang.Object

        Date date = new Date();
        System.out.println(date.getClass());    // class java.util.Date

        List list = new ArrayList();
        System.out.println(list.getClass());    // class java.util.ArrayList
    }
}

说明

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

    ✔ Class 本身也是一个类

    ✔ Class 对象只能由系统建立对象

    ✔ 一个加载的类在 JVM 中只会有一个 Class 实例

    ✔ 一个Class对象对应的是一个加载到 JVM 中的一个 .class 文件

    ✔ 每个类的实例都会记得自己是由哪个 Class 实例所生成

    ✔ 通过 Class 可以完整地得到一个类中的所有被加载的结构

    ✔ Class 类是 Reflection 的根源，针对任何你想动态加载、运行的类，唯有先获得相应的 Class 对象

Class类的常用方法

方法作用
static Class forName(String name)返回指定类名 name 的 Class 对象
Object newInstance()调用缺省构造函数，返回该 Class 对象的一个实例
getName()返回此 Class 对象所表示的实体名称
（实体：类、接口、数组类、基本类型或 void）
Class getSuperClass()返回当前 Class 对象的父类的 Class 对象
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 对象实例：

    String str = "小白";
Class clazz = str.getClass();

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

    Class clazz = Class.forName(“java.lang.String”);

  4. 其他方式（不做要求）

    ClassLoader cl = this.getClass().getClassLoader(); 
Class clazz4 = cl.loadClass(“类的全类名”);

案例（前三种方式需要掌握）

package com.laoyang.test.day1;

import org.junit.Test;
import java.lang.annotation.ElementType;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

/**
 * @ClassName ReflectionTest
 * @Description：
 * @Author Laoyang
 * @Date 2021/10/31 17:16
 */
public class ReflectionTest {
    /**
     * 获取 Class 实例的方式（前三种方式需要掌握）
     */
    @Test
    public void testThree() throws ClassNotFoundException {
        // 方式一：调用运行时类的属性：".class"
        Class classA = Person.class;
        System.out.println(classA);

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

        // 方式三：调用 Class 的静态方法：forName(String classPath)
        Class classC = Class.forName("com.laoyang.test.day1.Person");   // 找不到对应的类的时候会报错
        Class classD = Class.forName("java.lang.String");
        System.out.println(classC);     // class com.laoyang.test.day1.Person
        System.out.println(classD);     // class java.lang.String

        /*
         加载到内存中的运行时类，会缓存一定的时间，在此时间之内，我们可以通过不同的方式来获取此运行时类
         下面的判断中获取的都是同一个类，所以这里是相等的
         */
        System.out.println(classA == classB);   // true
        System.out.println(classA == classC);   // true

        // 方式四（了解）：使用类的加载器：ClassLoader
        ClassLoader classLoader = ReflectionTest.class.getClassLoader();
        Class classE = classLoader.loadClass("com.laoyang.test.day1.Person");
        System.out.println(classE);     // class com.laoyang.test.day1.Person

        System.out.println(classA == classE);   // true
    }
}

哪些类型可以有Class对象？

  • class：外部类，成员(成员内部类，静态内部类)，局部内部类，匿名内部类
  • interface：接口
  • [ ]：数组
  • enum：枚举
  • annotation：注解@interface
  • primitive type：基本数据类型
  • void

案例

package com.laoyang.test.day1;

import org.junit.Test;
import java.lang.annotation.ElementType;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

/**
 * @ClassName ReflectionTest
 * @Description：
 * @Author Laoyang
 * @Date 2021/10/31 17:16
 */
public class ReflectionTest {
    /**
     * Class 实例可以是哪些结构的说明
     */
    @Test
    public void testFour() {
        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
         这里 a 是 int 类型的一维数组，b 也是 int 类型的一维数组，所以结果为 true
         */
        System.out.println(c10 == c11);     // true
    }
}

疑问

  1. 通过直接 new 的方式或反射的方式都可以调用公共的结构，开发中到底用哪个？

建议：用 new 的方式
什么时候用反射：反射的特征（动态性）

  1. 反射机制与面向对象的封装性是不是矛盾的？如何看待这两个技术？

不矛盾。

对于封装性而言，设计一个类的时候，属性、方法、构造器等，该私有的时候私有 (private) ，该公共的时候公共（public）；封装性主要是为了告诉我们：如果看到一个类中写了一些私有的方法和一些公共的方法时，就告诉我们私有的方法不要用了，只需要使用公共的方法就好了（可以参考单例模式）

对于反射而言，是告诉我们可以使用一个类中的所有属性、方法、构造器等（包括私有的），但是不建议在开发中使用反射去调用私有的一些数据，如果是有需求的话，那就另说了…

关于 java.lang.Class 类的理解

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

    万事万物皆对象

  2. 换句话说：Class 的实例就对应着一个运行时类

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

类的加载与ClassLoader的理解

了解：类的加载过程

当程序主动使用某个类时，如果该类还未被加载到内存中，则系统会通过如下三个步骤来对该类进行初始化：

在这里插入图片描述

  • 加载：将 class 文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后生成一个代表这个类的java.lang.Class 对象，作为方法区中类数据的访问入口（即引用地址）。所有需要访问和使用类数据只能通过这个 Class 对象。这个加载的过程需要类加载器参与。

  • 连接：将 Java 类的二进制代码合并到 JVM 的运行状态之中的过程。

    ✔ 验证：确保加载的类信息符合 JVM 规范，例如：以 cafe 开头，没有安全方面的问题

    ✔ 准备：正式为类变量（static）分配内存并设置类变量默认初始值的阶段，这些内存都将在方法区中进行分配。

    ✔ 解析：虚拟机常量池内的符号引用（常量名）替换为直接引用（地址）的过程。

  • 初始化：

    ✔ 执行类构造器< clinit>() 方法的过程。类构造器< clinit>() 方法是由编译期自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的。（类构造器是构造类信息的，不是构造该类对象的构造器）。

    ✔ 当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发其父类的初始化。

    ✔ 虚拟机会保证一个类的的< clinit>()方法在多线程环境中被正确加锁和同步。

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

了解：什么时候会发生类初始化？

  • 类的主动引用（一定会发生类的初始化）

    ✔ 当虚拟机启动，先初始化 main 方法所在的类

    ✔ new 一个类的对象

    ✔ 调用类的静态成员（除了 final 常量）和静态方法

    ✔ 使用 java.lang.reflect 包的方法对类进行反射调用

    ✔ 当初始化一个类，如果其父类没有被初始化，则先会初始化它的父类

  • 类的被动引用（不会发生类的初始化）

    ✔ 当访问一个静态域时，只有真正声明这个域的类才会被初始化

    ✔ 当通过子类引用父类的静态变量，不会导致子类初始化

    ✔ 通过数组定义类引用，不会触发此类的初始化引用常量不会触发此类的初始化（常量在链接阶段就存入调用类的常量池中了）

案例

package com.laoyang.test.day1;

/**
 * @ClassName ClassLoaderTest
 * @Description： 了解类的加载器
 * @Author Laoyang
 * @Date 2021/11/2 15:37
 */
public class ClassLoaderTest {
    public static void main(String[] args) {
        // 主动引用：一定会导致 A 和 Father 的初始化
        // A a = new A();
        // System.out.println(A.m);
        // Class.forName("com.atguigu.java2.A");
        
        // 被动引用
        A[] array = new A[5];   //不会导致A和Father的初始化
        // System.out.println(A.b);   //只会初始化 Father
        // System.out.println(A.M);   //不会导致A和Father的初始化
    }

    static {
        System.out.println("main所在的类");
    }
}

class Father {
    static int b = 2;
    static {
        System.out.println("父类被加载");
    }
}
class A extends Father {
    static {
        System.out.println("子类被加载");
        m = 300;
    }
    static int m = 100;
    static final int M = 1;
}

类加载器

在这里插入图片描述

类加载器的作用

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

了解：ClassLoader

类加载器作用是用来把类 (class) 装载进内存的。JVM 规范定义了如下类型的类的加载器。

在这里插入图片描述

案例

package com.laoyang.test.day1;

import org.junit.Test;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

/**
 * @ClassName ClassLoaderTest
 * @Description： 了解类的加载器
 * @Author Laoyang
 * @Date 2021/11/2 15:37
 */
public class ClassLoaderTest {
    @Test
    public void testOne() {
        // 对于自定义类，使用系统类加载器进行加载
        ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();
        System.out.println(classLoader);

        // 调用系统类加载器的 getParent() 方法：获取扩展类加载器
        ClassLoader parent = classLoader.getParent();
        System.out.println(parent);

        /*
         调用扩展类加载器的 getParent() 方法：无法获取引导类加载器
         引导类加载器主要负责加载 Java 的核心类库，无法加载自定义类！
         */
        ClassLoader parent1 = parent.getParent();
        System.out.println(parent1);

        ClassLoader classLoader1 = String.class.getClassLoader();
        System.out.println(classLoader1);
    }
}

Properties：用于读取配置文件

jdbc.properties（在当前模块下创建）

user=root
password=123456

db.properties（在当前模块的 src 目录下创建）

user=Tom
password=233333

测试类

package com.laoyang.test.day1;

import org.junit.Test;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

/**
 * @ClassName ClassLoaderTest
 * @Description： 了解类的加载器
 * @Author Laoyang
 * @Date 2021/11/2 15:37
 */
public class ClassLoaderTest {
    /**
     * Properties：用于读取配置文件
     */
    @Test
    public void testTwo() {
        Properties properties = new Properties();
        FileInputStream fis = null;
        try {
            /*
             读取配置文件的方式一：
             Ps：此时的文件，默认在当前模块（module）下
             */
//            fis = new FileInputStream("jdbc.properties");
//            fis = new FileInputStream("src\\db.properties");
//            properties.load(fis);

            /*
             读取配置文件的方式二：使用 ClassLoader
             Ps：配置文件默认识别为：当前模块（module）的 src 文件夹下
             */
            ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();
            InputStream resourceAsStream = classLoader.getResourceAsStream("db.properties");
            properties.load(resourceAsStream);

            String user = properties.getProperty("user");
            String password = properties.getProperty("password");
            System.out.println(user + " = " + password);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

创建运行时类的对象

有了Class对象，能做什么？

创建类的对象：调用 Class 对象的 newInstance() 方法

要求：

  1. 类必须有一个无参数的构造器。
  2. 类的构造器的访问权限需要足够。

难道没有无参的构造器就不能创建对象了吗？

不是！只要在操作的时候明确的调用类中的构造器，并将参数传递进去之后，才可以实例化操作。 步骤如下：

  1. 通过 Class 类的 getDeclaredConstructor(Class … parameterTypes) 取得本类的指定形参类型的构造器。

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

  3. 通过 Constructor 实例化对象。Constructor 类中存在如下方法

    @CallerSensitive
public T newInstance(Object ... initargs) {}

以上是反射机制应用最多的地方

案例

使用运行时类的空参构造器创建对象
package com.laoyang.test.day1;

import org.junit.Test;
import java.util.Random;

/**
 * @ClassName NewIntanceTest
 * @Description： 通过反射创建对应的运行时类的对象
 * @Author Laoyang
 * @Date 2021/11/2 16:51
 */
public class NewIntanceTest {
    @Test
    public void testOne() throws IllegalAccessException, InstantiationException {
        Class<Person> classA = Person.class;

        /*
         newInstance()：调用此方法，创建对应的运行时类的对象吗，内部调用了运行时类的空参构造器

         要想此方法正常的创建运行时类的对象，要求：
         1. 运行时类必须提供空参的构造器
         2. 空参的构造器的访问权限得够用，通常设置为 public（如果设置为 private，会导致找不到对应的构造器然后报错）

         在 javabean 中要求提供一个 public 的空参构造器，原因：
         1. 便于通过反射，创建运行时类的对象
         2. 便于子类继承此运行时类时，默认调用 super() 时，保证父类有此构造器
         */
        Person obj = classA.newInstance();	// 调用 Person 的空参构造器
        System.out.println(obj);
    }
}
使用运行时类的指定参数构造器创建对象
import org.junit.Test;

import java.lang.annotation.ElementType;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

/**
 * @ClassName ReflectionTest
 * @Description：
 * @Author Laoyang
 * @Date 2021/10/31 17:16
 */
public class ReflectionTest {
    @Test
    public void test() {
        //1.根据全类名获取对应的Class对象
        String name = “com.laoyang.test.day1.Person";
        Class clazz = null;
        clazz = Class.forName(name);

        //2.调用指定参数结构的构造器，生成Constructor的实例
        Constructor con = clazz.getConstructor(String.class,Integer.class);

        //3.通过Constructor的实例创建对应类的对象，并初始化类属性
        Person p2 = (Person) con.newInstance("Peter",20);
        System.out.println(p2);
    }
}

体会反射的动态性

package com.laoyang.test.day1;

import org.junit.Test;
import java.util.Random;

/**
 * @ClassName NewIntanceTest
 * @Description： 通过反射创建对应的运行时类的对象
 * @Author Laoyang
 * @Date 2021/11/2 16:51
 */
public class NewIntanceTest {
    /**
     * 体会反射的动态性
     * 在编译期间并不知道我们最后会使用到哪一个类，只有在运行之后才能知道使用的是哪一个
     */
    @Test
    public void testTwo() {
        for (int i = 0; i < 100; i++) {
            int num = new Random().nextInt(3);  // 0-2 之间的随机值
            String classPath = "";
            switch (num) {
                case 0:
                    classPath = "java.util.Date";
                    break;
                case 1:
                    classPath = "java.lang.Object";
                    break;
                case 2:
                    classPath = "com.laoyang.test.day1.Person";
                    break;
                default:
                    System.out.println("出现错误！");
                    break;
            }
            try {
                Object instance = getInstance(classPath);
                System.out.println(instance);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

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

以上代码使用的 Person 类都是最开始创建的那个，再此说明，避免大家搞混

获取运行时类的完整结构

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

Field、Method、Constructor、Superclass、Interface、Annotation

✔ 实现的全部接口

✔ 所继承的父类

✔ 全部的构造器

✔ 全部的方法

✔ 全部的Field

案例

配合测试的父类、子类、接口和自定义注解

接口

package com.laoyang.test.day2;

/**
 * @ClassName MyInterface
 * @Description：
 * @Author Laoyang
 * @Date 2021/11/2 17:24
 */
public interface MyInterface {
    public void info();
}

自定义注解

package com.laoyang.test.day2;

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import static java.lang.annotation.ElementType.*;

/**
 * @ClassName MyAnnotation
 * @Description：
 * @Author Laoyang
 * @Date 2021/11/2 17:29
 */
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
    String value() default "hello";
}

父类

package com.laoyang.test.day2;

import java.io.Serializable;

/**
 * @ClassName Creature
 * @Description：
 * @Author Laoyang
 * @Date 2021/11/2 17:21
 */
public class Creature<T> implements Serializable {
    private char gender;
    public double weight;

    private void breath() {
        System.out.println("生物呼吸");
    }

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

子类

package com.laoyang.test.day2;

/**
 * @ClassName Person
 * @Description：
 * @Author Laoyang
 * @Date 2021/11/2 17:21
 */
@MyAnnotation(value = "person")
public class Biology extends Creature<String> implements Comparable<String>, MyInterface {
    private String name;
    int age;
    public int id;

    public Biology() {
    }

    @MyAnnotation(value = "constructor")
    private Biology(String name) {
        this.name = name;
    }

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

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

    public String display(String interest, int age) throws NullPointerException, ClassCastException {
        return interest + age;
    }

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

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

获取运行时类的属性结构

package com.laoyang.test.day2;

import org.junit.Test;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;

/**
 * @ClassName FieldTest
 * @Description： 获取运行时类的属性结构
 * @Author Laoyang
 * @Date 2021/11/4 10:04
 */
public class FieldTest {
    /**
     * 获取运行时类的属性结构
     */
    @Test
    public void testOne() {
        Class clazz = Biology.class;

        // 获取属性结构
        // getFields()：获取当前运行时类及其父类中声明为 public 访问权限的属性
        Field[] fields = clazz.getFields();
        for (Field field : fields) {
            System.out.println(field);
        }

        System.out.println("-----------------------------------------");

        // getDeclaredFields()：获取当前运行时类中声明的所有属性（不包含父类中声明的属性，且不限制权限）
        Field[] declaredFields = clazz.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println(declaredField);
        }
    }

    /**
     * 获取属性中指定的结构，比如：
     * 权限修饰符  数据类型  变量名
     */
    @Test
    public void testTwo() {
        Class clazz = Biology.class;

        Field[] declaredFields = clazz.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            // 1. 获取权限修饰符
            int modifiers = declaredField.getModifiers();
            /*
             直接打印会打印出对应的权限数字，比如 0、1、2 （具体可看Modifier源码）
             如果是想要获取具体的权限修饰符，则需要调用 Modifier 中的 toString() 方法
             */
            System.out.print(Modifier.toString(modifiers) + "\t");

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

            // 3. 获取变量名
            String name = declaredField.getName();
            System.out.println(name);
        }
    }
}

获取运行时类的方法结构

package com.laoyang.test.day2;

import org.junit.Test;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

/**
 * @ClassName MethodTest
 * @Description： 获取运行时类的方法结构
 * @Author Laoyang
 * @Date 2021/11/4 10:23
 */
public class MethodTest {
    /**
     * 获取运行时类的方法结构
     */
    @Test
    public void testOne() {
        Class clazz = Biology.class;

        // getMethods()：获取当前运行时类及其所有父类中声明为 public 权限的方法
        Method[] methods = clazz.getMethods();
        for (Method method : methods) {
            System.out.println(method);
        }

        System.out.println("----------------------------------------------");

        // getDeclaredMethods()：获取当前运行时类中声明的所有方法（不包含父类中声明的方法）
        Method[] declaredMethods = clazz.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            System.out.println(declaredMethod);
        }
    }

    /**
     * 获取方法中对应的结构，比如：
     * @Xxx注解
     * 权限修饰符  返回值类型  方法名(参数类型1  形参名1,...参数类型n，形参名n) throws XxxException {}
     */
    @Test
    public void testTwo() {
        Class clazz = Biology.class;

        Method[] declaredMethods = clazz.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            /*
             1. 获取方法声明的注解
             注意：如果需要获取到对应的注解，那么该注解必须声明为 @Retention(RetentionPolicy.RUNTIME) 的，否则会导致获取不到
             */
            Annotation[] annotations = declaredMethod.getAnnotations();
            for (Annotation annotation : annotations) {
                System.out.println(annotation);
            }

            // 2. 获取方法的权限修饰符
            int modifiers = declaredMethod.getModifiers();
            System.out.print(Modifier.toString(modifiers) + "\t");

            // 3. 获取方法的返回值类型
            Class returnType = declaredMethod.getReturnType();
            System.out.print(returnType + "\t");

            // 4. 获取方法的方法名
            String name = declaredMethod.getName();
            System.out.print(name + "\t");

            System.out.print("(");

            // 5. 获取方法的形参列表
            Class[] parameterTypes = declaredMethod.getParameterTypes();
            if (!(parameterTypes == null && parameterTypes.length == 0)) {
                for (int i = 0; i < parameterTypes.length; i++) {
                    // 添加一个判断，用于限制逗号的显示
                    if (i == parameterTypes.length -1){
                        System.out.print(parameterTypes[i].getName() + " args_" + i);
                        break;
                    }
                    System.out.print(parameterTypes[i].getName() + " args_" + i + ", ");
                }
            }

            System.out.print(")");

            // 6. 获取方法抛出的异常
            Class[] exceptionTypes = declaredMethod.getExceptionTypes();
            for (int i = 0; i < exceptionTypes.length; i++) {
                if (!(exceptionTypes == null && exceptionTypes.length == 0)) {
                    System.out.print(" throws ");
                    if (i == exceptionTypes.length - 1) {
                        System.out.print(exceptionTypes[i]);
                        break;
                    }
                    System.out.print(exceptionTypes[i] + ",");
                }
            }

            System.out.println();
        }
    }
}

获取运行时类的其它结构

比如：构造器、父类、带泛型的父类、带泛型的父类的泛型、实现的接口、所在的包和声明的注解等…

package com.laoyang.test.day2;

import org.junit.Test;
import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

/**
 * @ClassName OtherTest
 * @Description： 获取运行时类的构造器结构
 * @Author Laoyang
 * @Date 2021/11/4 11:00
 */
public class OtherTest {
    /**
     * 获取运行时类的构造器结构
     */
    @Test
    public void testOne() {
        Class clazz = Biology.class;

        // getConstructors()：获取当前运行时类声明为 public 的构造器
        Constructor[] constructors = clazz.getConstructors();
        for (Constructor constructor : constructors) {
            System.out.println(constructor);
        }
        System.out.println("-----------------------------------------------");

        // getDeclaredConstructors()：获取当前运行时类中声明的所有的构造器
        Constructor[] declaredConstructors = clazz.getDeclaredConstructors();
        for (Constructor declaredConstructor : declaredConstructors) {
            System.out.println(declaredConstructor);
        }
    }

    /**
     * 获取运行时类的父类
     */
    @Test
    public void testTwo() {
        Class clazz = Biology.class;

        Class superclass = clazz.getSuperclass();
        System.out.println(superclass);
    }

    /**
     * 获取运行时类的带泛型的父类
     */
    @Test
    public void testThree() {
        Class clazz = Biology.class;

        Type genericSuperclass = clazz.getGenericSuperclass();
        System.out.println(genericSuperclass);
    }

    /**
     * 获取运行时类的带泛型的父类的泛型
     */
    @Test
    public void testFour() {
        Class clazz = Biology.class;

        Type genericSuperclass = clazz.getGenericSuperclass();
        ParameterizedType parameterizedType = (ParameterizedType) genericSuperclass;
        // 获取泛型类型
        Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
        for (Type actualTypeArgument : actualTypeArguments) {
            System.out.println(actualTypeArgument);     // class java.lang.String
            System.out.println(actualTypeArgument.getTypeName());       // java.lang.String
            System.out.println(((Class) actualTypeArgument).getName()); // java.lang.String
        }
    }

    /**
     * 获取运行时类实现的接口
     */
    @Test
    public void testFive() {
        Class clazz = Biology.class;

        // 获取运行时类实现的接口
        Class[] interfaces = clazz.getInterfaces();
        for (Class anInterface : interfaces) {
            System.out.println(anInterface);
        }

        System.out.println("------------------------");

        // 获取运行时类的父类实现的接口
        Class[] interfaces1 = clazz.getSuperclass().getInterfaces();
        for (Class aClass : interfaces1) {
            System.out.println(aClass);
        }
    }

    /**
     * 获取运行时类所在的包
     */
    @Test
    public void testSix() {
        Class clazz = Biology.class;

        Package aPackage = clazz.getPackage();
        System.out.println(aPackage);
    }

    /**
     * 获取运行时类声明的注解
     * 注解需要声明为：@Retention(RetentionPolicy.RUNTIME)
     */
    @Test
    public void testSeven() {
        Class clazz = Biology.class;

        Annotation[] annotations = clazz.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }
    }
}

小 结

  1. 在实际的操作中，取得类的信息的操作代码，并不会经常开发。
  2. 一定要熟悉 java.lang.reflect 包的作用，反射机制。
  3. 需要知道如何取得属性、方法、构造器的名称，修饰符等。

调用运行时类的指定结构

关于 setAccessible 方法的使用

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

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

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

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

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

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

案例

配合测试的父类、子类、接口和自定义注解

接口

package com.laoyang.test.day3;

/**
 * @ClassName MyInterface
 * @Description：
 * @Author Laoyang
 * @Date 2021/11/2 17:24
 */
public interface MyInterface {
    public void info();
}

自定义注解

package com.laoyang.test.day3;

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import static java.lang.annotation.ElementType.*;

/**
 * @ClassName MyAnnotation
 * @Description：
 * @Author Laoyang
 * @Date 2021/11/2 17:29
 */
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
    String value() default "hello";
}

父类

package com.laoyang.test.day3;

import java.io.Serializable;

/**
 * @ClassName Creature
 * @Description：
 * @Author Laoyang
 * @Date 2021/11/2 17:21
 */
public class Creature<T> implements Serializable {
    private char gender;
    public double weight;

    private void breath() {
        System.out.println("生物呼吸");
    }

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

子类

package com.laoyang.test.day3;

import com.laoyang.test.day2.Creature;
import com.laoyang.test.day2.MyAnnotation;
import com.laoyang.test.day2.MyInterface;

/**
 * @ClassName Person
 * @Description：
 * @Author Laoyang
 * @Date 2021/11/2 17:21
 */
@com.laoyang.test.day2.MyAnnotation(value = "person")
public class Biology extends Creature<String> implements Comparable<String>, MyInterface {
    private String name;
    int age;
    public int id;

    public Biology() {
    }

    @com.laoyang.test.day2.MyAnnotation(value = "constructor")
    private Biology(String name) {
        this.name = name;
    }

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

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

    public String display(String interest, int age) throws NullPointerException, ClassCastException {
        return interest + age;
    }

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

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

    public static void showDesc() {
        System.out.println("我是一个可爱的人！");
    }

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

接口和自定义注解还有父类和之前一致，没有改动

改动了的就是子类的，但是为了搞混，最好重新弄一遍，避免不必要的 bug

调用运行时类的指定属性

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

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

  • 在 Field 中：

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

package com.laoyang.test.day3;

import org.junit.Test;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

/**
 * @ClassName ReflectionTest
 * @Description： 调用运行时类中指定的结构：属性、方法、构造器
 * @Author Laoyang
 * @Date 2021/11/5 10:17
 */
public class ReflectionTest {
    /**
     * 调用运行时类中的属性结构（理解即可）
     */
    @Test
    public void testOne() throws Exception {
        Class clazz = Biology.class;

        // 创建运行时类的对象
        Biology biology = (Biology) clazz.newInstance();

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

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

        /*
         获取当前属性的值
         get()：参数一：获取哪个对象的当前属性值
         */
        int bId = (int) id.get(biology);
        System.out.println(bId);
    }

    /**
     * 如何操作运行时类中的指定的属性（需要掌握）
     */
    @Test
    public void testTwo() throws Exception {
        Class clazz = Biology.class;

        // 创建运行时类的对象
        Biology biology = (Biology) clazz.newInstance();

        // 1. getDeclaredField()：获取运行时类中指定的变量名的属性
        Field name = clazz.getDeclaredField("name");

        // 2. setAccessible()：保证当前属性是可访问的
        name.setAccessible(true);

        // 3. 设置指定对象中对应的属性
        name.set(biology, "Tom");

        // 4. 获取指定对象中对应的属性
        String bName = (String) name.get(biology);
        System.out.println(bName);
    }
}

这里用了 name 和 id 进行演示（两个属性的权限修饰符不同）

调用运行时类的方法

Object invoke(Object obj, Object … args)

说明：

  1. Object 对应原方法的返回值，若原方法无返回值，此时返回 null
  2. 若原方法若为静态方法，此时形参 Object obj 可为null
  3. 若原方法形参列表为空，则 Object[] args 为 null
  4. 若原方法声明为 private，则需要在调用此 invoke() 方法前，显式调用方法对象的 setAccessible(true) 方法，将可访问 private 的方法。
package com.laoyang.test.day3;

import org.junit.Test;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

/**
 * @ClassName ReflectionTest
 * @Description： 调用运行时类中指定的结构：属性、方法、构造器
 * @Author Laoyang
 * @Date 2021/11/5 10:17
 */
public class ReflectionTest {
    /**
     * 如何操作运行时类中的指定的方法（需要掌握）
     */
    @Test
    public void testThree() throws Exception {
        Class clazz = Biology.class;

        // 创建运行时类的对象
        Biology biology = (Biology) clazz.newInstance();

        /*
         1. 获取运行时类中指定的方法
         getDeclaredMethod()：参数一：指明获取的方法的名称
                              参数二：指明获取的方法的形参列表
         */
        Method show = clazz.getDeclaredMethod("show", String.class);

        // 2. 保证当前方法是可访问的
        show.setAccessible(true);

        /*
         3. 调用 invoke() 方法执行对应的方法
         invoke()：参数一：方法的调用者
                   参数二：给方法形参赋值的实参
         invoke() 的返回值即为对应类中调用的方法的返回值；如果调用的运行时类中的方法没有返回值，则此 invoke() 返回 null
         */
        Object china = show.invoke(biology, "China");   // 相当于：biology.show("China")
        System.out.println(china);  // China

        System.out.println("----------------------------");

        // 如何调用静态方法？

        Method showDesc = clazz.getDeclaredMethod("showDesc");
        showDesc.setAccessible(true);

        // 如果调用的运行时类中的方法没有返回值，则此 invoke() 返回 null，以下三种方式都可以成功调用静态方法（第二种比较好理解）
//        Object invoke = showDesc.invoke(biology);   // 相当于：Biology.showDesc()
        Object invoke = showDesc.invoke(Biology.class);   // 相当于：Biology.showDesc()
//        Object invoke = showDesc.invoke(null);   // 相当于：Biology.showDesc()
        System.out.println(invoke); // null
    }
}

包含了静态方法的调用

调用运行时类的指定构造器

package com.laoyang.test.day3;

import org.junit.Test;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

/**
 * @ClassName ReflectionTest
 * @Description： 调用运行时类中指定的结构：属性、方法、构造器
 * @Author Laoyang
 * @Date 2021/11/5 10:17
 */
public class ReflectionTest {
    /**
     * 如何操作运行时类中的指定的构造器（不常用）
     */
    @Test
    public void testFour() throws Exception {
        Class clazz = Biology.class;

        // 调用 Biology 类的 private Biology(String name)
        /*
         1. 获取指定的构造器
         getDeclaredConstructor()：参数：指明构造器的参数列表
         */
        Constructor constructor = clazz.getDeclaredConstructor(String.class);

        // 2. 保证此构造器是可访问的
        constructor.setAccessible(true);

        // 3. 调用此构造器，创建运行时类的对象
        Biology tom = (Biology) constructor.newInstance("Tom");
        System.out.println(tom);
    }
}

反射的应用：动态代理

说明

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

    说明：对象和原始对象都是被代理类的对象

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

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

  • 动态代理使用场合：

    ✔ 调试

    ✔ 远程方法调用

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

Java 动态代理相关 API

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

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

    static Class getProxyClass(ClassLoader loader, Class... interfaces)：创建一个动态代理类所对应的 Class 对象
static Object newProxyInstance(ClassLoader loader, Class[] interfaces,  InvocationHandler h)：直接创建一个动态代理对象
    
loader：类加载器
interfaces：得到被代理类实现的全部接口
h：得到 InvocationHandler 接口的实现类实例

动态代理步骤

  1. 创建一个实现接口 InvocationHandler 的类，它必须实现 invoke 方法，以完成代理的具体操作。

    public Object invoke(Object theProxy, Method method, Object[] params) throws Throwable{}

theProxy：代理类的对象
method：要调用的方法
params：方法调用时所需要的参数

  2. 创建被代理的类以及接口

    interface Subject {
    String say(String name,int age)
}

/**
 * 被代理类
 */
class RealSubject implements Subject {
    @Override
    public String say(String name,int age) {
        return "Hahaha";
    }
}

  3. 通过Proxy的静态方法

    使用 newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)：创建一个Subject接口代理

    RealSubject target = new RealSubject();
// 创建一个代理来包装原始实现
DebugProxy proxy = new DebugProxy(target);
// 通过Subject接口获取代理的引用
Subject sub = (Subject) Proxy.newProxyInstance(Subject.class.getClassLoader(),new Class[] { Subject.class }, proxy);

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

    String info = sub.say(“Peter", 24);
System.out.println(info);

以上步骤代码稍微看一下就好了，因为不是很全面，所以先了解一下文字步骤，然后通过下面的案例进行理解

案例

静态代理

在实现动态代理之前我们先来看一看静态代理是怎么实现的

特点：代理类和被代理类在编译期间，就确定下来了

package com.laoyang.test.day4;

/**
 * @ClassName StaticProxyTest
 * @Description： 静态代理举例
 * @Author Laoyang
 * @Date 2021/11/5 16:53
 */
public class StaticProxyTest {
    /**
     特点：代理类和被代理类在编译期间，就确定下来了
     */
    public static void main(String[] args) {
        // 创建 被代理类 的对象
        NikeClothFactory nike = new NikeClothFactory();

        // 创建 代理类 的对象
        ProxyClothFactory proxyClothFactory = new ProxyClothFactory(nike);

        proxyClothFactory.produceCloth();
    }
}

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();    // 此处调用的是父类的 produceCloth() 方法

        System.out.println("代理工厂做一些后续的收尾工作");
    }
}

/**
 * 被代理类
 */
class NikeClothFactory implements ClothFactory {

    @Override
    public void produceCloth() {
        System.out.println("Nike工厂生产一批运动服");
    }
}

动态代理

要想实现动态代理，需要解决的问题？

问题一：如何根据加载到内存中的 被代理类，动态的创建一个代理类及其对象？

问题二：当通过代理类的对象调用方法时，如何动态的调用 被代理类 中的同名方法？

package com.laoyang.test.day4;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * @ClassName ProxyTest
 * @Description： 动态代理的举例
 * @Author Laoyang
 * @Date 2021/11/5 17:03
 */
public class ProxyTest {
    public static void main(String[] args) {
        SuperMan superMan = new SuperMan();

        // getProxyInstance：代理类的对象
        Human proxyInstance = (Human) ProxyFactory.getProxyInstance(superMan);

        // 当通过代理类对象调用方法时，会自动的调用 被代理类中同名的方法
        String belief = proxyInstance.getBelief();
        System.out.println(belief);

        proxyInstance.eat("重庆火锅");

        System.out.println("---------------------");

        // 使用刚才静态代理中的 被代理类 进行测试
        NikeClothFactory nike = new NikeClothFactory();
        ClothFactory clothFactory = (ClothFactory) ProxyFactory.getProxyInstance(nike);

        clothFactory.produceCloth();
    }
}

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);
    }
}

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

        // 实例化代理类
        handler.bind(obj);

        return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), handler);
    }
}

/**
 * 解决问题二
 */
class MyInvocationHandler implements InvocationHandler {
    // 需要使用 被代理类 的对象进行赋值
    private Object object;

    // 赋值方式一：使用构造器
//    public MyInvocationHandler(Object object) {
//        this.object = object;
//    }

    // 赋值方式二：使用方法
    public void bind(Object obj) {
        this.object = obj;
    }

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

动态代理与AOP（Aspect Orient Programming)

理解

前面介绍的 Proxy 和 InvocationHandler，很难看出这种动态代理的优势，下面介绍一种更实用的动态代理机制

改进前：

在这里插入图片描述

每个代码段中都存在相同的代码段，导致代码冗余

改进后：

在这里插入图片描述

改进后的说明：代码段1、代码段2、代码段3和蓝色代码段分离开了，但代码段1、2、3又和 一个特定的方法A耦合了！

最理想的效果是：代码块1、2、3既可以执行方法A，又无须在程序中以硬编码的方式直接调用蓝色代码的方法（简单来说就是不会导致代码冗余了）

说明

  • 使用 Proxy 生成一个动态代理时，往往并不会凭空产生一个动态代理，这样没有太大的意义。通常都是为指定的目标对象生成动态代理。
  • 这种动态代理在 AOP 中被称为 AOP 代理，AOP 代理可代替目标对象，AOP 代理包含了目标对象的全部方法。但 AOP 代理中的方法与目标对象的方法存在差异： AOP 代理里的方法可以在执行目标方法之前、之后插入一些通用处理。

案例

package com.laoyang.test.day4;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * @ClassName DynamicProxyTest
 * @Description： AOP与动态代理
 * @Author Laoyang
 * @Date 2021/11/6 10:05
 */
public class DynamicProxyTest {
    public static void main(String[] args) {
        Saiyan saiyan = new Saiyan();

        People proxyInstance = (People) ProxyFactorys.getProxyInstance(saiyan);

        String belief = proxyInstance.getBelief();
        System.out.println(belief);

        proxyInstance.eat("水果");

        System.out.println("---------------------");

        // 使用刚才静态代理中的 被代理类 进行测试
        NikeClothFactory nike = new NikeClothFactory();
        ClothFactory clothFactory = (ClothFactory) ProxyFactorys.getProxyInstance(nike);

        clothFactory.produceCloth();
    }
}

interface People {
    String getBelief();

    void eat(String food);
}

/**
 * 被代理类
 */
class Saiyan implements People {
    @Override
    public String getBelief() {
        return "我是超人";
    }

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

class HumanUtil {
    public void methodOne() {
        System.out.println("--------------通用方法一--------------");
    }

    public void methodTwo() {
        System.out.println("--------------通用方法二--------------");
    }
}

class ProxyFactorys {
    /**
     * 调用此方法，返回一个代理类的对象，解决问题一
     * obj：被代理类的对象
     */
    public static Object getProxyInstance(Object obj) {
        // 实例化代理类
        MyInvocationHandlers handler = new MyInvocationHandlers();
        handler.bind(obj);

        return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), handler);
    }
}

class MyInvocationHandlers implements InvocationHandler {
    private Object object;

    public void bind(Object obj) {
        this.object = obj;
    }

    /**
     * 此方法的作用：当我们通过代理类的对象，调用方法 A 时，就会自动的调用如下方法：invoke()
     * 将 被代理类 要执行的方法 A 的功能声明在 invoke() 方法中
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        HumanUtil util = new HumanUtil();
        util.methodOne();

        /*
         method：即为代理类对象调用的方法，此方法也就作为了 被代理类对象 要调用的方法
         object：被代理类的对象
         */
        Object invokeObj = method.invoke(object, args);

        util.methodTwo();
        return invokeObj;
    }
}
万能的小白。
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
实体对象转map/map转实体对象
DevGu
09-27 704
/** * 实体对象转成Map * * @param obj 实体对象 * @return */ public static Map<String, Object> object2Map(Object obj) { Map<String, Object> map = new HashMap<>(); if (obj == null) { return map;
什么是反射机制？反射机制的应用场景有哪些？
weixin_46248981的博客
04-12 2011
1.反射机制介绍 Java反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法，对于任意一个对象，都能调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法功能称为Java语言的反射机制。 2.获取Class对象的两种方式 如果我们动态获取到这些信息，我们需要依靠Class对象。Class类对象将一个类的方法、变量等信息告诉运行的程序。 1.如果指定具体类的情况下可以使用 Class alunbarClass = TargetObject.class; 但是我们一般是不知
Java 反射使用大全
朱豪凯的博客
06-10 7977
好多年前自己记的关于Java反射的笔记，这么些年下来，自己用到反射的时候就看这一份就够了。但是笔记以文件形式存放不方便，所以将其放到CSDN中，也希望能给更多小伙伴带来帮助。
Java Reflection 反射使用 完全指南
最新发布
李斯维的博客空间
06-12 1038
Java 中的反射大家都不陌生，有很多很好的文章都进行了讲解，但是很难找到一篇文章能完全解释反射的所有用法，特别是反射获取这个对象的注解的信息和泛型信息，往往都停留在了获取类的函数、方法，构造上。所以这篇文章将全面讲解 Java 反射中的所有用法，特别是对于类中的注解的获取上。另外，本文章不会对反射的原理进行讲解，看完本文你应该只能学会怎么用反射，至于其原理，本文不会涉及。
java反射基本使用
m0_51765966的博客
04-09 526
java反射基本使用 反射入门教程
Java的9种常用反射操作详解
weixin_31188147的博客
08-02 1383
Java反射是Java编程语言的一种强大功能，它能够检查和修改运行时对象的行为。我们将详细探讨Java反射中的9个主要操作。
Java反射使用总结
01-27
反射非常强大和有用，很多java框架中都有反射的影子，例如spring、mybatis等等，JDBC利用反射将数据库的表字段映射到java对象的getter/setter方法。Jackson,GSON,Boon等类库也是利用反射将JSON文件的属性映射到java...
java反射使用示例分享
09-04
Java反射是Java语言提供...总之，这个简单的Java反射示例展示了如何使用反射来调用一个类的方法，包括获取方法、设置参数类型、创建实例以及执行方法调用。理解并熟练运用反射是成为一名高级Java开发者的关键技能之一。
java 反射的使用
11-09
以下是对Java反射使用及相关知识点的详细阐述： 1. **获取Class对象** - `Class.forName(String className)`: 通过全限定类名获取Class对象。 - `object.getClass()`: 对象的`getClass()`方法返回该对象的Class...
java反射使用
05-17
关于java反射的一些基本使用 JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法；这种动态获取的信息以及动态调用对象的方法的功能...
java反射机制介绍及使用
10-09
Java反射机制是Java语言提供的一种强大的工具，它允许程序在运行时动态地访问和修改类的行为。这种机制的核心在于能够获取类的元数据信息，并基于这些信息实例化对象、调用方法、访问和修改字段的值，从而实现高度的...
Java反射机制的使用和学习方法
07-27
Java反射机制的使用和学习方法,从底层阐述Java反射机制的原理，让我们更加了解Java反射
Java中的反射以及使用方法
qq_33866936的博客
05-24 671
在程序运行阶段, 动态获取一个类中的属性或者方法, 把这种机制成为反射机制. 可以说, 没有反射就没有Java的任何框架。
java 反射的基本用法
qq_41976630的博客
03-17 8815
反射
Java 反射常用方法
菜鸟记录
04-22 1518
⏹Java 反射常用方法
java 反射操作详解
西凉的悲伤博客
05-09 1424
本文将用到 Student 类和 Address 类进行演示。return name + "成绩是：" + score;} }} }
反射机制及应用场景
weixin_40683982的博客
09-23 2023
1、反射：动态获取信息或动态调用对象的方法的机制。对于任意一个类，都能知道他的所有属性与方法，对于任意对象，都可以获取对象的方法。 应用场景：在第三方应用开发过程中，如果某一个类的方法属性是私有的，或者只对应用系统开放，可以通过反射机制获得自己所需要的信息。 实现方式：1）调用运行时类本身的.class属性 2）利用运行时类的...
【Java 基础】Java 反射使用方法简介
瞎叨叨的一天的博客
09-30 507
反射简介
【Java 反射的使用】
qq_64317046的博客
11-19 1224
Java的反射（reflection）机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性，既然能拿到那么，我们就可以修改部分类型信息；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射（reflection）机制。
java反射使用案例
05-24
下面是一个使用Java反射的简单案例： 假设我们有一个类Person： ```java public class Person { private String name; private int age; public Person(String name, int age) { this.name = name; this....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值