java中的反射和代理模式

java中的反射和代理模式

目录

引言

基础部分

反射

反射的概述

专业的解释

通俗的理解

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

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

获取构造方法

获取构造方法并创建对象

获取成员变量

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

获取成员方法

获取成员方法并运行

练习实战：

泛型擦除

修改字符串的内容

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

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

代理模式

静态代理

静态代理类的基本结构

代码演示

动态代理

JDK动态代理

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

仅有接口的情况

CGLIB动态代理

使用步骤

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

进阶部分（应用）

Spring Aop中动态代理的应用

RPC框架

引言

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

基础部分

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

反射

反射的概述

专业的解释

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

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

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

通俗的理解

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

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

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

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

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

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

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

• 通过class属性获取

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

代码示例

//1.Class这个类里面的静态方法forName
//Class.forName("类的全类名")： 全类名 = 包名 + 类名
Class clazz1 = Class.forName("flectdemo.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表示所有，复数形式
• 如果当前获取到的是私有的，必须要临时修改访问权限，否则无法使用

代码示例

public class ReflectDemo2 {public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {//1.获得整体（class字节码文件对象）Class clazz = Class.forName("flectdemo.Student");//2.获取构造方法对象//获取所有构造方法（public）Constructor[] constructors1 = Constructors();for (Constructor constructor : constructors1) {System.out.println(constructor);}System.out.println("=======================");//获取所有构造（带私有的）Constructor[] constructors2 = DeclaredConstructors();for (Constructor constructor : constructors2) {System.out.println(constructor);}System.out.println("=======================");//获取指定的空参构造Constructor con1 = Constructor();System.out.println(con1);Constructor con2 = Constructor(String.class,int.class);System.out.println(con2);System.out.println("=======================");//获取指定的构造(所有构造都可以获取到，包括public包括private)Constructor con3 = DeclaredConstructor();System.out.println(con3);//了解 System.out.println(con3 == con1);//每一次获取构造方法对象的时候，都会新new一个。Constructor con4 = DeclaredConstructor(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 = Constructor();
//3.利用空参构造方法创建对象
Student stu = (Student) wInstance();
System.out.println(stu);System.out.println("=============================================");//测试类中的代码：
//需求2：
//获取带参构造，并创建对象
//1.获取整体的字节码文件对象
Class clazz = Class.forName("com.kjz.a02reflectdemo1.Student");
//2.获取有参构造方法
Constructor con = DeclaredConstructor(String.class, int.class);
//3.临时修改构造方法的访问权限（暴力反射）
con.setAccessible(true);
//4.直接创建对象
Student stu = (Student) wInstance("zhangsan", 23);
System.out.println(stu);

获取成员变量

规则：

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

方法名：

代码示例:

public class ReflectDemo4 {public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {//获取成员变量对象//1.获取class对象Class clazz = Class.forName("flectdemo.Student");//2.获取成员变量的对象（Field对象)只能获取public修饰的Field[] fields1 = Fields();for (Field field : fields1) {System.out.println(field);}System.out.println("===============================");//获取成员变量的对象（public + private）Field[] fields2 = DeclaredFields();for (Field field : fields2) {System.out.println(field);}System.out.println("===============================");//获得单个成员变量对象//如果获取的属性是不存在的，那么会报异常//Field field3 = Field("aaa");//System.out.println(field3);//NoSuchFieldExceptionField field4 = Field("gender");System.out.println(field4);System.out.println("===============================");//获取单个成员变量（私有）Field field5 = DeclaredField("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 = der = 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) {der = 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 + "}";}
}

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

代码示例：

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("flectdemo.Student");//2.获取name成员变量//field就表示name这个属性的对象Field field = DeclaredField("name");//临时修饰他的访问权限field.setAccessible(true);//3.设置(修改)name的值//参数一：表示要修改哪个对象的name？//参数二：表示要修改为多少？field.set(s,"wangwu");//3.获取name的值//表示我要获取这个对象的name的值String result = ((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 = der = 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) {der = 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表示所有，复数形式
• 如果当前获取到的是私有的，必须要临时修改访问权限，否则无法使用

代码示例：

public class ReflectDemo6 {public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {//1.获取class对象Class<?> clazz = Class.forName("flectdemo.Student");//2.获取方法//getMethods可以获取父类中public修饰的方法Method[] methods1 = Methods();for (Method method : methods1) {System.out.println(method);}System.out.println("===========================");//获取所有的方法（包含私有）//但是只能获取自己类中的方法Method[] methods2 = DeclaredMethods();for (Method method : methods2) {System.out.println(method);}System.out.println("===========================");//获取指定的方法（空参）Method method3 = Method("sleep");System.out.println(method3);Method method4 = Method("eat",String.class);System.out.println(method4);//获取指定的私有方法Method method5 = DeclaredMethod("playGame");System.out.println(method5);}
}

获取成员方法并运行

方法

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

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

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

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

代码示例：

package com.kjz.a02reflectdemo1;import flect.InvocationTargetException;
import flect.Method;public class ReflectDemo6 {public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException {//1.获取字节码文件对象Class clazz = Class.forName("com.itheima.a02reflectdemo1.Student");//2.获取一个对象//需要用这个对象去调用方法Student s = new Student();//3.获取一个指定的方法//参数一：方法名//参数二：参数列表，如果没有可以不写Method eatMethod = Method("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 flectdemo;import flect.InvocationTargetException;
import flect.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 = Class();//获取add方法对象Method method = Method("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 = DeclaredField("value");
//但是这种操作非常危险
//JDK高版本已经屏蔽了这种操作，低版本还是可以的
//临时修改权限
field.setAccessible(true);//3.获取value记录的地址值
byte[] bytes = (byte[]) (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 = ("classname") + "";String methodname = ("methodname") + "";//2.获取字节码文件对象Class clazz = Class.forName(classname);//3.要先创建这个类的对象Constructor con = DeclaredConstructor();con.setAccessible(true);Object o = wInstance();System.out.println(o);//4.获取方法的对象Method method = DeclaredMethod(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 = Class();//2. 创建IO流BufferedWriter bw = new BufferedWriter(new FileWriter("myreflect\a.txt"));//3. 获取所有的成员变量Field[] fields = DeclaredFields();for (Field field : fields) {field.setAccessible(true);//获取成员变量的名字String name = Name();//获取成员变量的值Object value = (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 = der = 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) {der = 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中使用代理技术主要用于扩展原功能又不侵入（修改）源代码。至于应用的话下面进阶部分会详细说明。

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

1. 静态代理

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

     2.动态代理

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

     3.远程代理

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

     4.虚拟代理

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

     5.保护代理

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

     6.缓存代理

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

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

静态代理

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

静态代理类的基本结构

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

1. 抽象主题接口（Subject）：定义了真实主题类和代理类共同实现的接口。
2. 真实主题类（被代理类）（RealSubject）：实现了抽象主题接口定义的业务逻辑，是代理模式中的实际执行对象。
3. 代理类（ProxySubject）：实现了抽象主题接口，并封装了真实主题类。在代理类中可以在调用真实主题类的方法之前或之后执行一些额外的逻辑。
4. 客户端（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) {alSubject = 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{@Overridepublic void buyHouse() {System.out.println("去选房，购房.");}
}

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

package stPro;import flect.InvocationHandler;
import flect.Method;/*** 代理类*/
public class MyProxyPlus implements InvocationHandler {// 把真实主题类对象传递进来进行增强private Object object;public MyProxyPlus(Object object) {this.object = object;}@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {// 1、执行原来的业务逻辑Object result = method.invoke(object, args);
//        2、执行增强逻辑System.out.println("对原有的功能进行增强");return result; // 如果原有业务逻辑有返回值别忘了返回}
}

测试类

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

仅有接口的情况

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

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

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

代理类

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

测试类

import flect.Proxy;/*** 测试类*/
public class Test {public static void main(String[] args) {//        1、将你要做的事情，传递给代理对象(并做功能增强MyProxyPlus)IBuyHouse iBuyHouse = (IBuyHouse) wProxyInstance(ClassLoader(),new Class[]{IBuyHouse.class}, new MyProxyPlus());//        2、执行代理类方法iBuyHouse.buyHouse();}
}

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

CGLIB动态代理

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

使用步骤

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

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

// 步骤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) ate();// 调用代理对象proxyObject.doSomething();}
}

//切面类
@Aspect
@Component
public class TestAspect {/*** 表示所有有cn.tera.aop.RedisPoint注解的方法* 都会执行先读取Redis的行为*/@Pointcut("@a.aop.RedisPoint)")public void pointCut() {}/*** 实际获取数的流程*/@Around("pointCut()")public Object advise(ProceedingJoinPoint joinPoint) {try {/*** 先去查询redis*/Object data = (some_key);if (data == null) {/*** joinPoint.proceed()表示执行原方法* 如果redis中没有缓存，那么就去执行原方法获取数据* 然后塞入redis中，下次就能直接获取到缓存了*/data = joinPoint.proceed();RedisUtility.put(some_key, data);}return data;} catch (Throwable r) {return null;}}
}

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

public class SimpleRpcFrame {/*** 创建一个远程请求代理对象*/public static <T> T getRemoteProxy(Class<T> service) {return (T) ClassLoader(),new Class<?>[]{service},new RpcHandler(service));}/*** 处理具体远程调用的类*/static class RpcHandler implements InvocationHandler {private Class service;public RpcHandler(Class service) {this.service = service;}@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {/*** 根据接口名和方法名，发起一次特定的网络请求，获取数据*/Object result = Name(), Name(), args);return result;}}
}

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