想要更加透彻的理解动态代理,首先要熟悉下静态代理
一、静态代理
总结来说:目标类和代理类实现了相同的接口,在代理类中依赖了目标类,代理类的方法中调用了目标类的方法,并做了一些增强性的工作。
1、实现静态代理(demo)
要求,在某个类执行类中的方法时,上下文添加一些日志记录
1)定义接口
public interface Calculate {
int add(int num1,int num2);
}
2)定义被代理类
public class Calculator implements Calculate {
@Override
public int add(int num1, int num2) {
System.out.println(num1 + "+" + num2 + "=" + num1 + num2);
return num1 + num2;
}
}
3)定义代理类
public class CalculatorWithLog implements Calculate {
private Calculator calculator;
public CalculatorWithLog(Calculator calculator) {
this.calculator = calculator;
}
@Override
public int add(int num1, int num2) {
System.out.println("add前添加一点日志");
int sum = calculator.add(num1, num2);
System.out.println("add后添加一点日志");
return sum;
}
}
4)测试
public static void main(String[] args) {
Calculator calculator = new Calculator();
CalculatorWithLog calculatorWithLog = new CalculatorWithLog(calculator);
calculatorWithLog.add(1, 2);
}
2、静态代理的缺陷
- 程序员要手动为每一个目标类编写对应的代理类。如果当前系统已经有成百上千个类,工作量太大了
- 当接口改变时,所有的代理类都需要进行相应的变化,太过于耦合
所以,现在我们的努力方向是:如何少写或者不写代理类,却能完成代理功能?
二、动态代理
参考B站视频:https://www.bilibili.com/video/BV1HZ4y1p7F1?p=7&vd_source=7f24cfc4e2c729f062d4a78d958bfcdf
动态代理指的是:在程序的执行过程中,使用jdk的反射机制,创建代理对象,并动态的指定代理的目标类
动态代理的实现方式常用有两种:
- 使用JDK代理
- 通过CDLIB代理
1、jdk动态代理
jdk动态代理是基于Java的反射机制实现的,使用jdk反射包下的Proxy和InvocationHandler实现代理对象的动态创建。(jdk动态代理要求目标对象必须实现接口)
1)InvocationHandler接口
方法拦截处理器,接口中就一个方法 :invoke(),你的代理类要完成的功能就写在invoke()中
- 调用目标类的方法
- 功能增强,在目标方法调用时,增加功能
方法原型:
// Object proxy:jdk创建的代理对象,无需赋值
// Method method:目标类中的方法
// Object[] args:目标类中方法的参数
public Object invoke(Object proxy, Method method, Object[] args)
2)Method类
通过Method可以执行某个目标类的方法
3)proxy类
是最核心的一个类,使用静态方法 newProxyInstance() ,创建代理对象
方法原型:
// ClassLoader loader:类加载器,负责向内存中加载对象(需要使用目标对象的类加载器)
// Class<?>[] interfaces:目标对象实现的接口
// InvocationHandler h:方法拦截器,我们自己写的代理类需要实现的功能
返回值就是代理对象
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
4)动态代理的实现步骤
- 创建接口,定义目标类要完成的功能
public interface Calculate {
int add(int num1,int num2);
}
- 创建目标类,实现该接口
public class Calculator implements Calculate {
@Override
public int add(int num1, int num2) {
System.out.println(num1 + "+" + num2 + "=" + (num1 + num2));
return num1 + num2;
}
}
- 创建 InvocationHandler 接口的实现类,在invoke()方法中完成代理类的功能
public class MyInvocationHandler implements InvocationHandler {
private Object target = null;
//动态代理,目标对象是活动的,不是固定的,需要传入进来
public MyInvocationHandler(Object target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object res = method.invoke(target, args);
System.out.println("代理对象中进行功能增强....");
return res;
}
}
- 使用proxy类的newProxyInstance()方法,创建代理对象,并把返回值转成接口类型
public class Test {
public static void main(String[] args) {
//1、创建目标对象
Calculator calculator = new Calculator();
//2、创建invocationHandler对象
InvocationHandler invocationHandler = new MyInvocationHandler(calculator);
Calculate proxyInstance =(Calculate) Proxy.newProxyInstance(calculator.getClass().getClassLoader(), calculator.getClass().getInterfaces(),
invocationHandler);
proxyInstance.add(1, 3);
}
}
5)jdk动态代理的执行流程
断点打到InvocationHandler的invoke方法中,查看method和args参数
Proxy.newProxyInstance() 返回的对象,就是jdk创建的一个代理对象
6)动态代理能做什么?
在不改变原来目标方法功能的前提下,可以在代理中增强自己功能代码。
在程序开发中的意义:
- 你所在的项目中,有一个功能是其他人写好的,你可以使用,但是不能满足我的需求,我需要再增加点代码,这次就需要使用代理来进行代码的增强,而不用改原来的代码