java中的反射和代理模式

编程小猹

已于 2024-02-29 06:53:44 修改

阅读量283

点赞数 5

分类专栏： java基础文章标签： java 代理模式

于 2023-11-17 22:43:03 首次发布

本文链接：https://blog.csdn.net/m0_74229735/article/details/134434514

版权

java基础专栏收录该内容

5 篇文章 0 订阅

订阅专栏

引言

最近在写基于Netty框架将Http请求进行解析，协议转换为RPC远程调用。在这个过程中为了减少硬编码问题，使用了配置文件的方式将RPC服务的信息记录起来，然后再利用动态代理的方式代理RPC泛化调用，在写这个的过程中发现自身对反射、动态代理这方面不够熟悉，于是又系统地复习了一下，写了这篇文章来记录一下。这篇文章主要是介绍反射和代理模式如何使用以及应用场景，底层原理的话就不深究了，主要还是作者太菜了。

基础部分

这一部分主要介绍反射的概念和api和动态代理的基本概念、如何使用。

反射

反射的概述

专业的解释

是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；

对于任意一个对象，都能够调用它的任意属性和方法；

这种动态获取信息以及动态调用对象方法的功能称为Java语言的反射机制。

通俗的理解

利用反射创建的对象可以无视修饰符调用类里面的内容。

可以跟配置文件结合起来使用，把要创建的对象信息和方法写在配置文件中。

读取到什么类，就创建什么类的对象。

读取到什么方法，就调用什么方法。

此时当需求变更的时候不需要修改代码，只要修改配置文件即可。

获取字节码文件对象的三种方式

Class这个类里面的静态方法forName（“全类名”）（最常用）

通过class属性获取

通过对象获取字节码文件对象

代码示例

//1.Class这个类里面的静态方法forName
//Class.forName("类的全类名")： 全类名 = 包名 + 类名
Class clazz1 = Class.forName("com.kjz.reflectdemo.Student");
//源代码阶段获取 --- 先把Student加载到内存中，再获取字节码文件的对象
//clazz 就表示Student这个类的字节码文件对象。
//就是当Student.class这个文件加载到内存之后，产生的字节码文件对象


//2.通过class属性获取
//类名.class
Class clazz2 = Student.class;

//因为class文件在硬盘中是唯一的，所以，当这个文件加载到内存之后产生的对象也是唯一的
System.out.println(clazz1 == clazz2);//true


//3.通过Student对象获取字节码文件对象
Student s = new Student();
Class clazz3 = s.getClass();
System.out.println(clazz1 == clazz2);//true
System.out.println(clazz2 == clazz3);//true

字节码文件和字节码文件对象

java文件：就是我们自己编写的java代码。

字节码文件：就是通过java文件编译之后的class文件（是在硬盘上真实存在的，用眼睛能看到的）

字节码文件对象：当class文件加载到内存之后，虚拟机自动创建出来的对象。

这个对象里面至少包含了：构造方法，成员变量，成员方法。

而我们的反射获取的是什么？字节码文件对象，这个对象在内存中是唯一的。

获取构造方法

规则：

get表示获取
Declared表示私有
最后的s表示所有，复数形式
如果当前获取到的是私有的，必须要临时修改访问权限，否则无法使用

方法名	说明
Constructor<?>[] getConstructors()	获得所有的构造（只能public修饰）
Constructor<?>[] getDeclaredConstructors()	获得所有的构造（包含private修饰）
Constructor<T> getConstructor(Class<?>... parameterTypes)	获取指定构造（只能public修饰）
Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)	获取指定构造（包含private修饰）

代码示例

public class ReflectDemo2 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
        //1.获得整体（class字节码文件对象）
        Class clazz = Class.forName("com.kjz.reflectdemo.Student");


        //2.获取构造方法对象
        //获取所有构造方法（public）
        Constructor[] constructors1 = clazz.getConstructors();
        for (Constructor constructor : constructors1) {
            System.out.println(constructor);
        }

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

        //获取所有构造（带私有的）
        Constructor[] constructors2 = clazz.getDeclaredConstructors();

        for (Constructor constructor : constructors2) {
            System.out.println(constructor);
        }
        System.out.println("=======================");

        //获取指定的空参构造
        Constructor con1 = clazz.getConstructor();
        System.out.println(con1);

        Constructor con2 = clazz.getConstructor(String.class,int.class);
        System.out.println(con2);

        System.out.println("=======================");
        //获取指定的构造(所有构造都可以获取到，包括public包括private)
        Constructor con3 = clazz.getDeclaredConstructor();
        System.out.println(con3);
        //了解 System.out.println(con3 == con1);
        //每一次获取构造方法对象的时候，都会新new一个。

        Constructor con4 = clazz.getDeclaredConstructor(String.class);
        System.out.println(con4);
    }
}

获取构造方法并创建对象

涉及到的方法：newInstance

代码示例：

//首先要有一个javabean类
public class Student {
    private String name;

    private int age;


    public Student() {

    }

    public Student(String name) {
        this.name = name;
    }

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


    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    public String toString() {
        return "Student{name = " + name + ", age = " + age + "}";
    }
}



//测试类中的代码：
//需求1：
//获取空参，并创建对象

//1.获取整体的字节码文件对象
Class clazz = Class.forName("com.kjz.a02reflectdemo1.Student");
//2.获取空参的构造方法
Constructor con = clazz.getConstructor();
//3.利用空参构造方法创建对象
Student stu = (Student) con.newInstance();
System.out.println(stu);


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


//测试类中的代码：
//需求2：
//获取带参构造，并创建对象
//1.获取整体的字节码文件对象
Class clazz = Class.forName("com.kjz.a02reflectdemo1.Student");
//2.获取有参构造方法
Constructor con = clazz.getDeclaredConstructor(String.class, int.class);
//3.临时修改构造方法的访问权限（暴力反射）
con.setAccessible(true);
//4.直接创建对象
Student stu = (Student) con.newInstance("zhangsan", 23);
System.out.println(stu);

获取成员变量

规则：

get表示获取
Declared表示私有
最后的s表示所有，复数形式
如果当前获取到的是私有的，必须要临时修改访问权限，否则无法使用

方法名：

方法名	说明
Field[] getFields()	返回所有成员变量对象的数组（只能拿public的）
Field[] getDeclaredFields()	返回所有成员变量对象的数组，存在就能拿到
Field getField(String name)	返回单个成员变量对象（只能拿public的）
Field getDeclaredField(String name)	返回单个成员变量对象，存在就能拿到

代码示例:

public class ReflectDemo4 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        //获取成员变量对象

        //1.获取class对象
        Class clazz = Class.forName("com.kjz.reflectdemo.Student");

        //2.获取成员变量的对象（Field对象)只能获取public修饰的
        Field[] fields1 = clazz.getFields();
        for (Field field : fields1) {
            System.out.println(field);
        }

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

        //获取成员变量的对象（public + private）
        Field[] fields2 = clazz.getDeclaredFields();
        for (Field field : fields2) {
            System.out.println(field);
        }

        System.out.println("===============================");
        //获得单个成员变量对象
        //如果获取的属性是不存在的，那么会报异常
        //Field field3 = clazz.getField("aaa");
        //System.out.println(field3);//NoSuchFieldException

        Field field4 = clazz.getField("gender");
        System.out.println(field4);

        System.out.println("===============================");
        //获取单个成员变量（私有）
        Field field5 = clazz.getDeclaredField("name");
        System.out.println(field5);

    }
}



public class Student {
    private String name;

    private int age;

    public String gender;

    public String address;


    public Student() {
    }

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


    public Student(String name, int age, String gender, String address) {
        this.name = name;
        this.age = age;
        this.gender = gender;
        this.address = address;
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    /**
     * 获取
     * @return gender
     */
    public String getGender() {
        return gender;
    }

    /**
     * 设置
     * @param gender
     */
    public void setGender(String gender) {
        this.gender = gender;
    }

    /**
     * 获取
     * @return address
     */
    public String getAddress() {
        return address;
    }

    /**
     * 设置
     * @param address
     */
    public void setAddress(String address) {
        this.address = address;
    }

    public String toString() {
        return "Student{name = " + name + ", age = " + age + ", gender = " + gender + ", address = " + address + "}";
    }
}

获取成员变量并获取值和修改值

方法	说明
void set(Object obj, Object value）	赋值
Object get(Object obj)	获取值

代码示例：

public class ReflectDemo5 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, IllegalAccessException {
        Student s = new Student("zhangsan",23,"广州");
        Student ss = new Student("lisi",24,"北京");

        //需求：
        //利用反射获取成员变量并获取值和修改值

        //1.获取class对象
        Class clazz = Class.forName("com.kjz.reflectdemo.Student");

        //2.获取name成员变量
        //field就表示name这个属性的对象
        Field field = clazz.getDeclaredField("name");
        //临时修饰他的访问权限
        field.setAccessible(true);

        //3.设置(修改)name的值
        //参数一：表示要修改哪个对象的name？
        //参数二：表示要修改为多少？
        field.set(s,"wangwu");

        //3.获取name的值
        //表示我要获取这个对象的name的值
        String result = (String)field.get(s);

        //4.打印结果
        System.out.println(result);

        System.out.println(s);
        System.out.println(ss);

    }
}


public class Student {
    private String name;
    private int age;
    public String gender;
    public String address;


    public Student() {
    }

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


    public Student(String name, int age, String gender, String address) {
        this.name = name;
        this.age = age;
        this.gender = gender;
        this.address = address;
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    /**
     * 获取
     * @return gender
     */
    public String getGender() {
        return gender;
    }

    /**
     * 设置
     * @param gender
     */
    public void setGender(String gender) {
        this.gender = gender;
    }

    /**
     * 获取
     * @return address
     */
    public String getAddress() {
        return address;
    }

    /**
     * 设置
     * @param address
     */
    public void setAddress(String address) {
        this.address = address;
    }

    public String toString() {
        return "Student{name = " + name + ", age = " + age + ", gender = " + gender + ", address = " + address + "}";
    }
}

获取成员方法

规则：

get表示获取
Declared表示私有
最后的s表示所有，复数形式
如果当前获取到的是私有的，必须要临时修改访问权限，否则无法使用

方法名	说明
Method[] getMethods()	返回所有成员方法对象的数组（只能拿public的）
Method[] getDeclaredMethods()	返回所有成员方法对象的数组，存在就能拿到
Method getMethod(String name, Class<?>... parameterTypes)	返回单个成员方法对象（只能拿public的）
Method getDeclaredMethod(String name, Class<?>... parameterTypes)	返回单个成员方法对象，存在就能拿到

代码示例：

public class ReflectDemo6 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
        //1.获取class对象
        Class<?> clazz = Class.forName("com.kjz.reflectdemo.Student");


        //2.获取方法
        //getMethods可以获取父类中public修饰的方法
        Method[] methods1 = clazz.getMethods();
        for (Method method : methods1) {
            System.out.println(method);
        }

        System.out.println("===========================");
        //获取所有的方法（包含私有）
        //但是只能获取自己类中的方法
        Method[] methods2 = clazz.getDeclaredMethods();
        for (Method method : methods2) {
            System.out.println(method);
        }

        System.out.println("===========================");
        //获取指定的方法（空参）
        Method method3 = clazz.getMethod("sleep");
        System.out.println(method3);

        Method method4 = clazz.getMethod("eat",String.class);
        System.out.println(method4);

        //获取指定的私有方法
        Method method5 = clazz.getDeclaredMethod("playGame");
        System.out.println(method5);
    }
}

获取成员方法并运行

方法

Object invoke(Object obj, Object... args) ：运行方法

参数一：用obj对象调用该方法

参数二：调用方法的传递的参数（如果没有就不写）

返回值：方法的返回值（如果没有就不写）

代码示例：

package com.kjz.a02reflectdemo1;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class ReflectDemo6 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        //1.获取字节码文件对象
        Class clazz = Class.forName("com.kjz.a02reflectdemo1.Student");
		
        //2.获取一个对象
        //需要用这个对象去调用方法
        Student s = new Student();
        
        //3.获取一个指定的方法
        //参数一：方法名
        //参数二：参数列表，如果没有可以不写
        Method eatMethod = clazz.getMethod("eat",String.class);
        
        //运行
        //参数一：表示方法的调用对象
        //参数二：方法在运行时需要的实际参数
        //注意点：如果方法有返回值，那么需要接收invoke的结果
        //如果方法没有返回值，则不需要接收
        String result = (String) eatMethod.invoke(s, "重庆小面");
        System.out.println(result);

    }
}



public class Student {
    private String name;
    private int age;
    public String gender;
    public String address;


    public Student() {

    }

    public Student(String name) {
        this.name = name;
    }

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

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    public String toString() {
        return "Student{name = " + name + ", age = " + age + "}";
    }

    private void study(){
        System.out.println("学生在学习");
    }

    private void sleep(){
        System.out.println("学生在睡觉");
    }

    public String eat(String something){
        System.out.println("学生在吃" + something);
        return "学生已经吃完了，非常happy";
    }
}

练习实战：

泛型擦除

理解：集合中的泛型只在java文件中存在，当编译成class文件之后，就没有泛型了。

代码示例：

package com.kjz.reflectdemo;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;

public class ReflectDemo8 {
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        //1.创建集合对象
        ArrayList<Integer> list = new ArrayList<>();
        list.add(123);
//        list.add("aaa");

        //2.利用反射运行add方法去添加字符串
        //因为反射使用的是class字节码文件

        //获取class对象
        Class clazz = list.getClass();

        //获取add方法对象
        Method method = clazz.getMethod("add", Object.class);//注意此处为Object.class，因为在字节码对象中没有泛型

        //运行方法
        method.invoke(list,"aaa");

        //打印集合
        System.out.println(list);
    }
}

修改字符串的内容

了解字符串不能修改的真正原因：

字符串，在底层是一个byte类型的字节数组，名字叫做value

private final byte[] value;

真正不能被修改的原因：final和private

final修饰value表示value记录的地址值不能修改。

private修饰value而且没有对外提供getvalue和setvalue的方法。所以，在外界不能获取或修改value记录的地址值。

如果要强行修改可以用反射：

代码示例：

String s = "abc";
String ss = "abc";
// private final byte[] value= {97,98,99};
// 没有对外提供getvalue和setvalue的方法，不能修改value记录的地址值
// 如果我们利用反射获取了value的地址值。
// 也是可以修改的，final修饰的value
// 真正不可变的value数组的地址值，里面的内容利用反射还是可以修改的，比较危险

//1.获取class对象
Class clazz = s.getClass();

//2.获取value成员变量（private）
Field field = clazz.getDeclaredField("value");
//但是这种操作非常危险
//JDK高版本已经屏蔽了这种操作，低版本还是可以的
//临时修改权限
field.setAccessible(true);

//3.获取value记录的地址值
byte[] bytes = (byte[]) field.get(s);
bytes[0] = 100;

System.out.println(s);//dbc
System.out.println(ss);//dbc

射和配置文件结合动态获取

需求: 利用反射根据文件中的不同类名和方法名，创建不同的对象并调用方法。

分析:

①通过Properties加载配置文件

②得到类名和方法名

③通过类名反射得到Class对象

④通过Class对象创建一个对象

⑤通过Class对象得到方法

⑥调用方法

代码示例：

public class ReflectDemo9 {
    public static void main(String[] args) throws IOException, ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        //1.读取配置文件的信息
        Properties prop = new Properties();
        //创建输入流
        FileInputStream fis = new FileInputStream("day14-code\\prop.properties");
        //把配置信息加载到配置文件对象中
        prop.load(fis);
        fis.close();
        System.out.println(prop);

        String classname = prop.get("classname") + "";
        String methodname = prop.get("methodname") + "";

        //2.获取字节码文件对象
        Class clazz = Class.forName(classname);

        //3.要先创建这个类的对象
        Constructor con = clazz.getDeclaredConstructor();
        con.setAccessible(true);
        Object o = con.newInstance();
        System.out.println(o);

        //4.获取方法的对象
        Method method = clazz.getDeclaredMethod(methodname);
        method.setAccessible(true);

        //5.运行方法
        method.invoke(o);


    }
}

配置文件中的信息：
classname=com.kjz.a02reflectdemo1.Student
methodname=sleep

利用发射保存对象中的信息

public class MyReflectDemo {
    public static void main(String[] args) throws IllegalAccessException, IOException {
    /*
        对于任意一个对象，都可以把对象所有的字段名和值，保存到文件中去
    */
       Student s = new Student("小A",23,'女',167.5,"睡觉");
       Teacher t = new Teacher("播妞",10000);
       saveObject(s);
    }

    //把对象里面所有的成员变量名和值保存到本地文件中
    public static void saveObject(Object obj) throws IllegalAccessException, IOException {
        //1.获取字节码文件的对象
        Class clazz = obj.getClass();
        //2. 创建IO流
        BufferedWriter bw = new BufferedWriter(new FileWriter("myreflect\\a.txt"));
        //3. 获取所有的成员变量
        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields) {
            field.setAccessible(true);
            //获取成员变量的名字
            String name = field.getName();
            //获取成员变量的值
            Object value = field.get(obj);
            //写出数据
            bw.write(name + "=" + value);
            bw.newLine();
        }

        bw.close();

    }
}

public class Student {
    private String name;
    private int age;
    private char gender;
    private double height;
    private String hobby;

    public Student() {
    }

    public Student(String name, int age, char gender, double height, String hobby) {
        this.name = name;
        this.age = age;
        this.gender = gender;
        this.height = height;
        this.hobby = hobby;
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    /**
     * 获取
     * @return gender
     */
    public char getGender() {
        return gender;
    }

    /**
     * 设置
     * @param gender
     */
    public void setGender(char gender) {
        this.gender = gender;
    }

    /**
     * 获取
     * @return height
     */
    public double getHeight() {
        return height;
    }

    /**
     * 设置
     * @param height
     */
    public void setHeight(double height) {
        this.height = height;
    }

    /**
     * 获取
     * @return hobby
     */
    public String getHobby() {
        return hobby;
    }

    /**
     * 设置
     * @param hobby
     */
    public void setHobby(String hobby) {
        this.hobby = hobby;
    }

    public String toString() {
        return "Student{name = " + name + ", age = " + age + ", gender = " + gender + ", height = " + height + ", hobby = " + hobby + "}";
    }
}

public class Teacher {
    private String name;
    private double salary;

    public Teacher() {
    }

    public Teacher(String name, double salary) {
        this.name = name;
        this.salary = salary;
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return salary
     */
    public double getSalary() {
        return salary;
    }

    /**
     * 设置
     * @param salary
     */
    public void setSalary(double salary) {
        this.salary = salary;
    }

    public String toString() {
        return "Teacher{name = " + name + ", salary = " + salary + "}";
    }
}

代理模式

代理模式在Java中应用十分广泛，它说的是使用一个代理将对象包装起来然后用该代理对象取代原始对象，任何原始对象的调用都需要通过代理对象，代理对象决定是否以及何时将方法调用转到原始对象上。这种模式可以这样简单理解：你自己想要做某件事情(被代理类)，但是觉得自己做非常麻烦或者不方便，所以就叫一个另一个人(代理类)来帮你做这个事情，而你自己只需要告诉要做啥事就好了。

那为什么要使用代理模式呢？

Java中使用代理技术主要用于扩展原功能又不侵入（修改）源代码。至于应用的话下面进阶部分会详细说明。

代理模式主要分为一下几类：

静态代理

静态代理是在编译时就已经确定代理类的代理对象的行为，代理类和真实类的关系在编译期间就确定了。
静态代理需要为每一个被代理的类创建一个代理类，当需要代理多个类时，会导致类的数量急剧增加。

2.动态代理

动态代理是在运行时动态地创建代理类和代理对象，不需要针对每个被代理的类单独编写代理类，因此更加灵活。
Java中的动态代理主要通过java.lang.reflect.Proxy和java.lang.reflect.InvocationHandler接口实现。

3.远程代理

远程代理是一种能够隐藏对象存在于不同地址空间的技术，客户端无需知道对象存在于不同的地址空间，只需要像调用本地对象一样调用远程对象。
例如，Java中的RMI（远程方法调用）就是一种远程代理的应用。

4.虚拟代理

虚拟代理是延迟创建开销大的对象，例如在图片加载时显示占位图直到真正需要加载图片时才创建真实的图片对象。
虚拟代理可以提高系统的性能和响应速度，同时节约资源。

5.保护代理

保护代理控制对原始对象的访问，允许或拒绝对真实主题的访问，例如权限控制。
保护代理可以根据用户的权限决定是否执行某个操作，从而实现安全访问。

6.缓存代理

缓存代理为开销大的运算结果提供暂时存储，以便重复利用，以减少对真实对象的访问。

下面详细介绍一下静态代理和动态代理

静态代理

静态代理其实就是程序运行之前，提前写好代理类，编译之后直接运行即可起到代理的效果。因此静态代理是一种在编译期间就确定代理对象和真实对象的关系的代理方式。

静态代理类的基本结构

在静态代理中，通常包括以下几个角色：

抽象主题接口（Subject）：定义了真实主题类和代理类共同实现的接口。
真实主题类（被代理类）（RealSubject）：实现了抽象主题接口定义的业务逻辑，是代理模式中的实际执行对象。
代理类（ProxySubject）：实现了抽象主题接口，并封装了真实主题类。在代理类中可以在调用真实主题类的方法之前或之后执行一些额外的逻辑。
客户端（Client）：通过代理类来访问真实主题类的对象。

Java中的静态代理要求代理类(ProxySubject)和真实主题类(RealSubject)都实现同一个接口(Subject)。静态代理中代理类在编译期就已经确定，而动态代理则是JVM运行时动态生成，静态代理的效率相对动态代理来说相对高一些，但是静态代理代码冗余大，一旦需要修改接口，代理类和委托类都需要修改。

代码演示

// 1. 抽象主题接口
interface Subject {
    void doOperation();
}

// 2. 真实主题类
class RealSubject implements Subject {
    public void doOperation() {
        System.out.println("RealSubject is doing operation.");
    }
}

// 3. 代理类
class Proxy implements Subject {
    private RealSubject realSubject;

    public Proxy(RealSubject realSubject) {
        this.realSubject = realSubject;
    }

    public void doOperation() {
        System.out.println("Proxy do something before calling the real object.");
        realSubject.doOperation();
        System.out.println("Proxy do something after calling the real object.");
    }
}

// 4. 客户端
public class Client {
    public static void main(String[] args) {
        RealSubject realSubject = new RealSubject(); // 创建真实主题对象
        Proxy proxy = new Proxy(realSubject); // 创建代理对象，并传入真实主题对象
        proxy.doOperation(); // 通过代理对象调用真实主题对象的方法
    }
}

动态代理

动态代理是一种在运行时创建代理对象的机制，它允许我们在不事先知道具体类型的情况下，通过代理对象来调用目标对象的方法。

在动态代理中，代理类在JVM运行时动态生成，而不是在编译期间手动编写。它可以实现对目标对象的方法进行拦截和增强，提供了更灵活的方式来实现代理。

动态代理主要分为JDK动态代理和CGLIB动态代理，区别在于使用JDK动态代理必须有一个接口，使用CGLIB动态代理不需要接口。

JDK动态代理

JDK动态代理依靠反射来实现，代理类和真实主题类不需要实现同一个接口。真实主题类需要实现需要代理的接口，否则无法创建动态代理。

JDK动态代理不仅可以代理有接口有实现类的情况，也可以代理只有接口没有实现类的情况。

使用JDK动态代理无需引入任何外部的jar包，JDK已经给我们提供了一种获取代理对象的API，只需要我们传入相关信息，它就可以返回我们需要的代理对象。

为真实主题类产生代理对象的方法

//CLassLoader loader:类的加载器  
//Class<?> interfaces:得到全部的接口(代理的全部接口)
//InvocationHandler h:得到InvocationHandler接口的子类的实例(增强业务逻辑的，也就是说增加额外功能)
public static Object newProxyInstance(ClassLoader loader, 
Class<?>[] interfaces,
InvocationHandler h) 
throws IllegalArgumentException

用于增加代理类额外逻辑的接口InvocationHandler

//Object proxy:被代理的对象  
//Method method:要调用的方法  
//Object[] args:方法调用时所需要参数  
public interface InvocationHandler {  
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable;  
}

有接口有真实主题类的情况

定义需要增强的接口（需要添加额外业务逻辑的方法）

public interface IBuyHouse {

//    定义要做的事情
    public void buyHouse();
}

真实主题类

/**
 * 真实主题类
 */
public class HouseDelegation implements IBuyHouse{

    @Override
    public void buyHouse() {
        System.out.println("去选房，购房.");
    }
}

代理类（也可以写成匿名内部类直接传入到Proxy.newProxyInstance（）中）

package com.lydms.testPro;

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

/**
 * 代理类
 */
public class MyProxyPlus implements InvocationHandler {

    // 把真实主题类对象传递进来进行增强
    private Object object;

    public MyProxyPlus(Object object) {
        this.object = object;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 1、执行原来的业务逻辑
        Object result = method.invoke(object, args);
//        2、执行增强逻辑
        System.out.println("对原有的功能进行增强");
        return result; // 如果原有业务逻辑有返回值别忘了返回
    }
}

测试类

import java.lang.reflect.Proxy;
/**
 * 测试类
 */
public class test {

    public static void main(String[] args) {
//        获取IBuyHouse的代理对象
        HouseDelegation houseDelegation = new HouseDelegation();
//        1、将你要做的事情，传递给代理对象(并做功能增强MyProxyPlus)
        IBuyHouse iBuyHouse = (IBuyHouse) Proxy.newProxyInstance(houseDelegation.getClass().getClassLoader(),
                houseDelegation.getClass().getInterfaces(), new MyProxyPlus(houseDelegation));
//        2、执行代理类方法
        iBuyHouse.buyHouse();
    }
}

仅有接口的情况

假如说上面我们只定义了IBuyCar接口和IBuyHouse接口，没有真实主题类，也是可以实现的。定义一个InvocationHandler接口的实现，用于写业务逻辑，把所有的业务逻辑写在invoke方法中就行了

定义需要增强的接口（需要添加业务逻辑（为什么不说是额外业务逻辑？因为这是仅有接口没有真实主题类的情况，真实主题都没有那还谈什么额外业务逻辑呢？本来就没有逻辑。但是逻辑从无到有不也是从无到有的一种情况嘛！）的方法）

public interface IBuyHouse {

//    定义要做的事情
    public void buyHouse();
}

代理类

/**
 * 代理类
 */
public class MyProxyPlus implements InvocationHandler {
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("对原有的功能进行增强");
        return null;
    }
}

测试类

import java.lang.reflect.Proxy;

/**
 * 测试类
 */
public class Test {
    public static void main(String[] args) {

//        1、将你要做的事情，传递给代理对象(并做功能增强MyProxyPlus)
        IBuyHouse iBuyHouse = (IBuyHouse) Proxy.newProxyInstance(Test.class.getClassLoader(),
                new Class[]{IBuyHouse.class}, new MyProxyPlus());

//        2、执行代理类方法
        iBuyHouse.buyHouse();
    }
}

了解Mapper底层原理的读者不难发现，这就是Mapper动态代理的底层原理。只要定义接口，不需要写实现类（真实主题类）

CGLIB动态代理

CGLIB（Code Generation Library）动态代理是通过在运行时生成目标类的子类来实现的。它不要求目标类必须实现接口，可以直接代理普通的类。CGLIB 动态代理使用字节码技术，通过继承目标类并重写其方法来实现代理逻辑。在运行时，代理对象是目标类的子类对象，通过子类对象调用方法时，会先执行代理逻辑，然后再调用实际对象的方法。

使用步骤

1.cglib是第三方jar，因此需要引入jar包

<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>2.2.2</version>
</dependency>

2.定义目标类

class MyActualClass {
    public void doSomething() {
        System.out.println("Doing something");
    }
}

3.定义一个实现 MethodInterceptor 接口的类（也可以直接作为匿名内部类传入Enhancer.create（））

// 步骤2：实现 MethodInterceptor 接口
class MyMethodInterceptor implements MethodInterceptor {
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        // 在实际对象方法调用前执行额外逻辑
        System.out.println("Before method call");

        // 调用实际对象的方法
        Object result = proxy.invokeSuper(obj, args);

        // 在实际对象方法调用后执行额外逻辑
        System.out.println("After method call");

        return result;
    }
}

测试类

public class Main {
    public static void main(String[] args) {
        //创建代理对象
        Enhancer enhancer = new Enhancer();
        //设置代理对象父类
        enhancer.setSuperclass(MyActualClass.class);
        //传入增强逻辑的接口
        enhancer.setCallback(new MyMethodInterceptor());
        //生成对应的代理对象
        MyActualClass proxyObject = (MyActualClass) enhancer.create();

        // 调用代理对象
        proxyObject.doSomething();
    }
}

动态代理和静态代理的区别

动态代理和静态代理在实现方式和使用方法上存在一些区别。下面是它们之间的主要区别：

实现方式：静态代理需要在编译期间就确定代理类和真实类的关系，而动态代理是在运行时动态地创建代理对象和代理类。
代理对象的创建：静态代理需要为每个被代理的类创建一个代理类，并在编译期间进行编码。而动态代理是通过反射机制在运行时动态地创建代理对象，无需为每个被代理的类创建专门的代理类。
接口要求：静态代理和动态代理都是基于接口来实现的。静态代理要求代理类和真实类都实现同一个接口，而动态代理则可以在运行时为任意接口创建代理对象。
灵活性：动态代理相比静态代理更加灵活，可以在运行时动态地决定代理对象和代理逻辑。动态代理可以处理多个被代理的类，无需为每个类都创建一个代理类，减少了代码量。
扩展性：动态代理具有较好的扩展性，可以通过不同的调用处理器（InvocationHandler）实现对代理逻辑的动态修改。

进阶部分（应用）

这一部分主要是介绍一些流行框架中对动态代理的应用。

Spring Aop中动态代理的应用

在Spring框架中，动态代理是实现面向切面编程（AOP）的核心机制。Spring AOP通过使用动态代理技术，为目标对象动态地创建代理对象，从而实现横切关注点的模块化管理。

下面是Spring AOP对动态代理的应用过程：

定义切面（Aspect）： 在Spring AOP中，切面是一个包含通知和切点的类。通知定义了在切点上执行的逻辑，而切点则指定了切面将被应用的连接点（Join Point）。

创建通知（Advice）： 通知是切面中具体的逻辑代码。Spring AOP提供了五种类型的通知：前置通知（Before）、后置通知（After）、返回通知（AfterReturning）、异常通知（AfterThrowing）和环绕通知（Around）。开发者可以根据需求选择合适的通知类型，并实现相应的通知逻辑。

配置切点（Pointcut）： 切点定义了在哪些连接点上应用通知切点表达式是用来匹配连接点的规则，可以根据方法签名、注解、包名等来定义切点。

创建代理对象（Proxy）： 在Spring AOP中，通过动态代理来创建代理对象。Spring AOP支持两种类型的动态代理：JDK动态代理和CGLIB动态代理。如果目标对象实现了接口，Spring AOP将使用JDK动态代理；如果目标对象没有实现接口，Spring AOP将使用CGLIB动态代理。代理对象会包装目标对象，并在目标对象的方法执行前后，或者出现异常时触发相应的通知。

织入（Weaving）： 织入是将切面应用到目标对象上的过程。在Spring AOP中，织入可以在编译期、加载期或运行期进行。Spring AOP采用运行期织入，也就是在程序运行时动态地将切面织入到目标对象中。

代码示例：

//切面类
@Aspect
@Component
public class TestAspect {
    /**
     * 表示所有有cn.tera.aop.RedisPoint注解的方法
     * 都会执行先读取Redis的行为
     */
    @Pointcut("@annotation(cn.tera.aop.RedisPoint)")
    public void pointCut() {
    }

    /**
     * 实际获取数的流程
     */
    @Around("pointCut()")
    public Object advise(ProceedingJoinPoint joinPoint) {
        try {
            /**
             * 先去查询redis
             */
            Object data = RedisUtility.get(some_key);
            if (data == null) {
                /**
                 * joinPoint.proceed()表示执行原方法
                 * 如果redis中没有缓存，那么就去执行原方法获取数据
                 * 然后塞入redis中，下次就能直接获取到缓存了
                 */
                data = joinPoint.proceed();
                RedisUtility.put(some_key, data);
            }
            return data;
        } catch (Throwable r) {
            return null;
        }
    }
}

以上代码背后的原理使用的就是java动态代理。当然这里要求被注解的方法所在的类必须是实现了接口的（回想下Proxy.newProxyInstance方法的签名），否则就需要使用另外一个GCLib的库了，不过这就是另外一个故事了，这里就不展开了。

RPC框架

在RPC（Remote Procedure Call）框架中，动态代理被广泛应用于实现远程服务的透明调用和通信。通过动态代理，RPC框架可以将远程服务封装成本地代理对象，使得服务消费者可以像调用本地方法一样调用远程服务，而无需关心网络通信和协议细节。

以下是RPC框架中动态代理的主要应用场景和方式：

远程服务代理： RPC框架使用动态代理来生成客户端的代理对象，该代理对象负责将方法调用转发到远程服务，并处理相关的网络通信细节。对于服务消费者来说，调用远程服务就像调用本地方法一样简单，具体的远程通信过程都被动态代理对象所隐藏。
透明的远程调用： 通过动态代理，RPC框架可以实现透明的远程调用，使得服务消费者无需手动编写远程调用代码，也不需要关心底层的网络通信和序列化细节。这样大大简化了分布式系统开发的复杂性。
动态协议适配： RPC框架中的动态代理也可以用于根据服务接口选择合适的通信协议，例如根据服务接口的特征自动选择HTTP、TCP等不同的通信协议，以满足不同服务的通信需求。
服务治理和容错处理： RPC框架通过动态代理还可以实现服务治理和容错处理的功能，包括负载均衡、服务降级、重试机制等，从而提高分布式系统的可靠性和稳定性。

总之，在RPC框架中，动态代理的应用使得远程服务调用变得更加简单、高效和可靠，为开发者提供了方便的远程服务调用和服务治理机制。

下面是远程服务代理的代码示例：

在一些rpc框架中，客户端只需要关注接口的的调用，而具体的远程请求则由框架内部实现，例如我们模拟一个简单的rpc 请求，接口如下：

public interface OrderInterface {
    /**
     * 生成一张新订单
     */
    void addOrder();
}

rpc框架可以生成接口的代理对象，例如：

public class SimpleRpcFrame {
    /**
     * 创建一个远程请求代理对象
     */
    public static <T> T getRemoteProxy(Class<T> service) {
        return (T) Proxy.newProxyInstance(service.getClassLoader(),
                new Class<?>[]{service},
                new RpcHandler(service));
    }

    /**
     * 处理具体远程调用的类
     */
    static class RpcHandler implements InvocationHandler {
        private Class service;

        public RpcHandler(Class service) {
            this.service = service;
        }

        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            /**
             * 根据接口名和方法名，发起一次特定的网络请求，获取数据
             */
            Object result = RemoteCallUtility.request(service.getName(), method.getName(), args);
            return result;
        }
    }
}

而客户端调用的时候不需要接口的具体实现，只需要通过rpc框架获取接口的代理即可，此时究竟是采用http协议或者直接通过socket请求数据都交由框架负责了，例如：

public class RpcInvoker {
    public void invoke() {
        OrderInterface order = SimpleRpcFrame.getRemoteProxy(OrderInterface.class);
        order.addOrder();
    }
}

动态代理在现在的流行框架中运用广泛，这里就不再一一举例了。如果读者想要去读源码或者手写这些框架就一定要对动态代理有深刻理解。

编程小猹

关注

5
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
2
评论
java中的反射和代理模式

专业的解释是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意属性和方法；这种动态获取信息以及动态调用对象方法的功能称为Java语言的反射机制。通俗的理解利用反射创建的对象可以无视修饰符调用类里面的内容。可以跟配置文件结合起来使用，把要创建的对象信息和方法写在配置文件中。读取到什么类，就创建什么类的对象。读取到什么方法，就调用什么方法。此时当需求变更的时候不需要修改代码，只要修改配置文件即可。
复制链接

扫一扫