反射、代理简单理解_代理和反射-优快云博客

本文链接：https://blog.youkuaiyun.com/m0_58087746/article/details/143224098

反射

反射允许对成员变量，成员方法和构造方法的信息进行编程访问

但是获取不是从类里面获取的，是从类的字节码（.class）文件中获取的，所以我们首先要学习如何获取类的class对象。

在Java中，定义好了一个类Class，就是用来描述字节码文件的

获取class对象的三种方式

1. Class.forname("全类名");

2.类名.class

3.对象.getClass();

这三种方式对应编码的三个阶段：

代码实现，Student类是一个标准的JavaBean，下述代码是获取Student类的class对象的三种方式

public class MyReflectDemo1 {
    public static void main(String[] args) throws ClassNotFoundException {
        /*
        获取class对象的三种方式
        1.Class.forName("全类名")
        2.类名.class
        3.对象.getClass();
         */
        //1.第一种方式
        //最为常用
        //全类名：包名+类名
        Class clazz = Class.forName("myreflect1.Student");

        //2.第二种方式
        //一般更多当参数使用
        Class clazz2 = Student.class;

        //3.第三种方式
        //当我们已经有该类对象才可以使用
        Student s = new Student();
        Class clazz3 = s.getClass();
        
        //打印
        System.out.println(clazz);
        System.out.println(clazz2);
        System.out.println(clazz3);
    }
}

在Java中一切皆对象。

class对象，构造方法，成员变量，成员方法。都有与之相对应的类，以便获取对象，如图示：

利用反射获取构造方法

Class类中用于获取构造方法的方法
    Constructor<?>[] getConstructors()：返回所有公共构造方法对象的数组
    Constructor<?>[] getDeclaredConstructors()：返回所有构造方法对象的数组
    Constructor<T> getConstructor(class<?>... parameterTypes)：返回单个公共构造方法对象
    Constructor<T> getDeclaredConstructor(class<?>...parameterTypes)：返回单个构造方法对象

    Constructor类中用于创建对象的方法
    T newInstance(object... initargs)：根据指定的构造方法创建对象
    setAccessible(boolean flag)：设置为true，表示取消访问检查

其中，在用private修饰符的构造方法创建对象时，会报错。此时需要用暴力反射。

con4.setAccessible(true); 表示临时取消权限的校验

利用反射获取成员变量

Class类中用于获取成员变量的方法
    Field[] getFields():                    返回所有公共成员变量对象的数组
    Field[] getDeclaredFields():            返回所有成员变量对象的数组
    Field getField(String name):            返回单个公共成员变量对象
    Field getDeclaredField(String name):    返回单个成员变量对象

Field类中用于创建对象的方法
void set(Object obj, Object value): 赋值
Object get(Object obj) 获取值

利用反射获取成员方法

Class类中用于获取成员方法的方法
Method[] getMethods():返回所有公共成员方法对象的数组，包括继承的
Method[] getDeclaredMethods():返回所有成员方法对象的数组，不包括继承的
Method getMethod(String name, Class<?>.. parameterTypes):返回单个公共成员方法对象
Method getDeclaredMethod(String name, Class<?>... parameterTypes):返回单个成员方法对象

获取方法的修饰符
获取方法的名字
获取方法的形参
获取方法的返回值
获取方法抛出的异常

获取方法后，如何将方法运行起来呢？

Method类中用于创建对象的方法
Object invoke(Object obj, Object... args):运行方法
参数一:用obj对象调用该方法
参数二:调用方法的传递的参数(如果没有就不写)
返回值:方法的返回值(如果没有就不写)

        Student s = new Student();
        m.setAccessible(true);

        //参数1 s:表示方法的调用者
        //参数2 "汉堡包"：表示在调用方法的时候传递的实际参数
        String result = (String) m.invoke(s, "汉堡包");
        System.out.println(result);

反射的作用：

1.获取一个类里面所有的信息，获取到了之后，再执行其他的业务逻辑

2.结合配置文件，动态创建对象并调用方法

示例一：将对象所有的字段名和值，保存到文件中，首先创建两个完整的JavaBean类

通过IO流，写入txt文件

运行结果：

示例二：结合配置文件动态创建对象

在配置文件中写入全类名，方法名。表示程序运行时创建类对象并调用方法。

在主程序中，分为以下几个步骤：

1.读取配置文件中的信息

//1.读取配置文件中的信息
        Properties prop = new Properties();
        FileInputStream fis = new FileInputStream("prop\\properties.java");
        prop.load(fis);

        fis.close();
        System.out.println(prop);

2.获取全类名和方法名

        //2.获取全类名和方法名
        String className = (String)prop.get("classname");
        String methodName = (String)prop.get("method");

        System.out.println(className);
        System.out.println(methodName);

3.利用反射创建对象并运行方法

        //3.利用反射创建对象并运行方法
        Class clazz = Class.forName(className);

4.获取构造方法

        //4.获取构造方法
        Constructor con = clazz.getDeclaredConstructor();
        Object o = con.newInstance();
        System.out.println(o);

5.获取成员方法并运行

        //5.获取成员方法并运行
        Method method = clazz.getDeclaredMethod(methodName);
        method.setAccessible(true);
        method.invoke(o);

运行结果如下

如果要创建其他类对象，运行其中的方法，不用更改程序，只需更改配置文件

例如：创建Teacher类对象，运行其中的teach方法，在properties.java中更改为：

运行结果如下：

总结：

代理

在Java中，代理（proxy）是一种设计模式，它允许你在不改变原始类的前提下增强、控制或简化

方法调用。代理模式广泛用于面向对象编程中的 AOP（面向切面编程），尤其是在框架如 Spring

中。

代理可以简单理解为：在原始对象前插入一个“中间人”来控制对原始对象的访问。这使得你可以在

方法调用前后做一些额外的操作，如日志记录、权限检查、事务管理等。

代理长什么样？

代理里面就是对象要被代理的方法

Java通过什么来保证代理的样子？

通过接口保证，对象和代理需要实现同一个接口，接口中就是被代理的所有方法

举例：

坤哥会唱歌，会跳舞，所以坤哥类里面有这两种方法，被代理的对象（坤哥）有几种方法，代理就需要几种方法与之对应，坤哥和代理的方法都要统一定义在接口中

代理的分类：

1、静态代理（Static Proxy）：代理类在编译时已经存在，开发者需要手动编写代理类

2、动态代理（Dynamic Proxy）：在运行时动态创建的代理类

动态代理

以坤哥的唱歌，跳舞的需求为例，

步骤1：定义一个Star接口，接口定义唱歌和跳舞的抽象方法，其次定义一个BigStar类，生成标准JavaBean，实现Star接口，重写里面的抽象方法，如图：

步骤2：创建一个代理类，在代理类中创建实现代理的方法，创建代理需要传入被代理的对象，即为BigStar类的对象，返回的是代理对象，由于代理对象也需要实现Star接口，所以这边直接可以写Star（接口多态）。

/**
     * 方法的作用：
     * 给一个明星的对象，创建一个代理
     * @param bigStar:被代理的明星对象
     * @返回值：给明星创建的代理
     */
public static Star createProxy(BigStar bigStar) {
}

步骤3：完善创建代理的方法，静态类Proxy中提供了为对象产生代理对象的方法，因此直接调用方法，返回的是代理对象。

方法中传递的三个参数的简单理解：

ClassLoader loader：用于加载生成的代理类的类加载器。一般传递目标类（即代理对象所属类）的类加载器。当前类ProxyUtil就是代理类，故传递当前类的类加载器ProxyUtil.class.getClassLoader()

class<?>[ ] interfaces：指定代理类要实现的接口。数组决定了代理对象的类型和方法列表。如果有多个接口需要实现，都需要写入{ }。此处代理类要实现的接口为Star，故传入Star字节码文件的Class对象

InvocationHandler h：一个接口实例，用于定义代理对象的行为。通过匿名内部类实现InvocationHandler接口，并重写invoke方法。

需求：想要明星唱首歌

1.获取代理的对象

代理对象 = ProxyUtil.createProxy(大明星的对象)；

2.再调用代理的唱歌方法

代理对象.唱歌的方法("歌曲名称")；

当外界代理对象调用唱歌方法以后，唱歌方法会去调用invoke方法。

InvocationHandler中的invoke方法：