Java-JDK动态代理（AOP）使用及实现原理分析

 

动力节点王鹤老师视频地址：https://www.bilibili.com/video/BV1HZ4y1p7F1

博客来自：https://www.cnblogs.com/jia0504/p/13811424.html

第一章:代理的介绍

介绍:我们需要掌握的程度

动态代理(理解) 基于反射机制

掌握的程度:

1.什么是动态代理?

2.动态代理能够做什么?

后面我们在用Spirng和Mybatis的时候,要理解怎么使用的.

1.什么是代理?

代理,在我们日常生活之中就有体现,代购,中介,换ip,商家等等.

比如有一家美国的大学,可以对全世界招生.留学中介(代理 )

留学中介(代理):帮助这家美国的学校招生,中介是学校的代理中介是代替学校完成招生功能
代理特点

  1. 中介和代理他们要做的事情是一致的:招生
  2. 中介是学校代理,学校是目标
  3. 家长-------->中介(学校介绍,办理入学手续)---------->美国学校
  4. 中介是代理,收取费用

2.为什么要找中介

为什么要找中介?
1.中介是专业的,方便.
2.家长现在不能自己去找学校。家长没有能力访问学校.或者美国学校不接收个人来访

买东西都是商家卖, 商家是某个商品的代理, 你个人买东西,肯定不会让你接触到厂家的.

第二章:静态代理

2.1 使用代理模式的作用

  1. 功能增强:在你原有的功能上,增加了额外的功能.新增加的功能,叫做功能增强
  2. 控制访问:代理类不让你访问目标,例如商家不让用户访问厂家

2.2 实现代理的方式

1.静态代理:

1)代理类是自己手工实现的,自己创建一个java类,表示代理类

2)同时你所要代理的目标

特点：1）实现简单2）容易理解。
模拟一个用户购买u盘的行为。
用户是客户端类
商家：代理，代理某个品牌的u盘。
厂家：目标类。
三者的关系：用户（客户端）-—-商家（代理）-—-厂家（目标）
商家和厂家都是卖u盘的，他们完成的功能是一致的，都是卖u盘。

实现步骤:

实现步骤
1.创建一个接口,定义卖u盘的方法,表示你的厂家和商家做的事情
2.创建厂家类,实现1步骤的接口
3.创建商家,就是代理,也需要实现1步骤中的接口
4.创建客户端类,调用商家的方法买一个u盘

2.3 具体实现

实现步骤
1.创建一个接口,定义卖u盘的方法,表示你的厂家和商家做的事情

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/**
 * 定义U盘接口
 *
 * @author zhangzhixi
 * @date 2021/3/17 13:52
 */
public interface IUsb {
    /**
     * 定义卖U盘的方法
     *
     * @param amount 购买数量
     * @return  返回所需要的的价格
     */
    float sell(int amount);
}

2.创建厂家类,实现1步骤的接口

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/**
 * 金士顿厂家类
 *
 * @author zhangzhixi
 * @date 2021/3/17 13:54
 */
public class Kingston implements IUsb {
    /**
     * 128G的U盘出厂价手里是85.0/个单价
     * @param amount 购买数量
     * @return
     */
    @Override
    public float sell(int amount) {
        return 85.0f * amount;
    }
}

3.创建商家,就是代理,也需要实现1步骤中的接口

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
/**
 * 淘宝是一个商家,代理金士顿U盘的销售
 *
 * @author zhangzhixi
 * @date 2021/3/17 13:58
 */
public class TaoBao implements IUsb {
    /**
     * 金士顿厂家
     */
    private Kingston kingston = new Kingston();
 
    @Override
    public float sell(int amount) {
        // 向厂家发送订单,告诉厂家,我买了U盘,厂家发货
        // 发送给工厂,我需要的订单,返回报价
        float price = kingston.sell(amount);
        // 加价,每个U盘加价25元
        price += 25 * amount;
        return price;
    }
}

4.创建客户端类,调用商家的方法买一个u盘　　

?
1
2
3
4
5
6
7
8
9
10
11
12
/**
 * 客户类，买U盘
 * @author zhangzhixi
 * @date 2021/3/17 14:01
 */
 
public class Client {
    public static void main(String[] args) {
        TaoBao taoBao = new TaoBao();
        System.out.println(taoBao.sell(2));
    }
}

所以我们再次总结代理类完成的功能:

  1. 目标类中方法的调用
  2. 功能增强

所属我们只有一个代理商,我们实际上可以写多个代理商,

2.4 静态代理的优缺点

我们再次总结一下静态代理的优缺点

优点:

  1. 实现简单
  2. 容易简单

确定:当你的项目中,目标类的代理类很多的时候,有一下的缺点

  1. 当目标类增加了,代理类可能也需要成倍的增加
  2. 当你的接口中功能在增加了,或者修改了,会影响众多的实现类,厂家类,代理都需要修改,影响比较多.

所以我们继续学习动态代理

第三章 动态代理

本章,我们所掌握的是

1)什么是动态代理?

​ 使用jdk的反射机制,创建对象的能力,创建的是代理类的的对象.而不用我们创建类文件,不用写java文件, 什么叫动态?在程序执行时,调用jdk提供的方法才能创建代理类的对象

2)知道动态代理能做什么?

3.1 静态代理和动态代理模式的对比

在静态代理中目标很多的时候,可以使用动态代理,避免静态代理的缺点

在静态代理中目标类很多时候,可以使用动态代理,避免静态代理的缺点。
动态代理中目标类即使很多,

  1. 代理类数量可以很少,

  2. 当你修改了接口中的方法时,不会影响代理类。

动态代理:在程序执行过程中,使用jdk的反射机制,创建代理类对象,并动态的指定要代理目标类。
换句话说:动态代理是一种创建java象的能力,让你不用创建 TaoBao类就能创建代理类对象,除去了中间商

在java中,要想创建对象

    1. 创建类文件,java 文件编译为class
    2. 使用构造方法,创建类的对象

3.2 动态代理的介绍

  1. 动态代理是指代理类对象在程序运行时由JVM根据反射机制动态生成的。动态代理不需要定义代理类的，java源文件。
  2. 动态代理其实就是jdk运行期间，动态创建class字节码并加载到JVM。
  3. 动态代理的实现方式常用的有两种：使用JDK代理，与通过CGLlB动态代理。

动态代理的实现:

  1. jdk动态代理(理解):使用java反射包中的类和接口实现动态代理的功能,反射包java.lang.reflect,里面有三个类:InvocationHandler,Method,Proxy
  2. cglib动态代理(了解): cglib是第三方的工具库,创建代理对象

 

  • cglib的原理是继承，cglib通过继承目标类，创建它的子类，在子类中
  • 重写父类中同名的方法，实现功能的修改。
  • 因为cglib是继承，重写方法，所以要求目标类不能是fina1的，方法也不能是final的。cglib的要求目标类比较宽松，只要能继承就可以了。cglib在很多的框架中使用，
  • 比如mybatis，spring框架中都有使用。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public class TestApp {
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
//        HelloService service = new HelloServiceImpl();
//        service.sayhello("张三");
//        以上是常规方法执行sayhello
//        下面我们使用反射机制进行创建sayhello方法,核心Method(类中的方法)
        HelloServiceImpl target = new HelloServiceImpl();
//        获取sayhello名称对应的Method类对象
//         public Method getM   ethod(String name, Class<?>... parameterTypes)
//        加入,该方法的参数有多个该怎么办?
//        parameterTypes参数是一个类对象数组，按声明的顺序标识方法的形式参数类型。
        Method method = HelloService.class.getMethod("sayhello", String.class);
//        通过Metho可以执行sayhello方法的调用
        /*
        *  public Object invoke(Object obj, Object... args)
        *       表示执行方法的调用
        *   参数:
        *       1.Object,表示对象,要执行这个对象的方法
        *       2.Object...args,方法执行时的参数值
        * 返回值:
        *       Object:方法执行后的返回值
        * */
        Object ret = method.invoke(target, "李四");
    }
}

3.3回顾反射 Method类

Method类的结构图

?
1
2
3
4
5
Class Method
    java.lang.Object
        java.lang.reflect.AccessibleObject
            java.lang.reflect.Executable
                java.lang.reflect.Method

class.getMethod

?
1
Method method = HelloService.class.getMethod("sayhello", String.class,Integer.class);

提出问题?

?
1
public Method getMethod(String name, Class<?>... parameterTypes)

加入,该方法的参数有多个该怎么办?
parameterTypes参数是一个类对象数组，按声明的顺序标识方法的形式参数类型。

3.4JDK动态代理

jdk动态代理:
1.反射, Method类,表示方法。类中的方法。通过Method可以执行某个方法

2.jdk动态代理的实现
反射包java.lang. reflect,里面有三个类：InvocationHandler，Method，Proxy

第一个接口：Interface InvocationHandler：表示你的代理要干啥

public interface InvocationHandler

InvocationHandler是由代理实例的调用处理程序实现的接口 。
每个代理实例都有一个关联的调用处理程序。 当在代理实例上调用方法时，方法调用将被编码并分派到其调用处理程序的invoke方法。

​ 1)InvocationHandler接口(调用处理器):就一个方法 invoke()

​ invoke():表示代理对象要执行的功能代码。你的代理类要完成的功能就写在invoke（）方法中。

代理完成的功能：

?
1
2
1.调用目标方法,执行目标方法的功能
2.功能增强,在目标方法调用时,增加功能

方法原型：

?
1
2
3
4
5
6
7
参数：object proxy：jdk创建的代理对象，无需赋值。
     Method method:目标类中的方法，jdk提供method对象的
     object[]args:目标类中方法的参数，jdk提供的。
-------------------------------------------------------------------------
Object invoke(Object proxy,方法 method,Object[] args)throws
     
    Throwable处理代理实例上的方法调用并返回结果。

怎么用？

?
1
2
1.创建类实现接口InvocationHandler
2.重写invoke()方法,把原来静态代理中代理类要完成的功能，写在这

第二个类：Method：确切说就是目标类中的方法

　　Method类:表示方法的,确切的说就是目标类中的方法。
作用:通过 Method可以执行某个目标类的方法, Method. invoke();

method. invoke(目标对象,方法的参数)

说明:method.invoke()就是为了用来执行目标方法的,等同于静态代理中的　　

?
1
2
3
//    向厂家发送订单,告诉厂家,我买了U盘,厂家发货
//    发送给工厂,我需要的订单,返回报价
       float price = factory.sell(amount);

第三个类：Proxy类：创建代理对象

　　proxy类：核心的对象，创建代理对象。之前创建对象都是new类的构造方法（）
现在我们是使用proxy类的方法，代替new的使用。
方法：静态方法 newProxyInstance(）
作用是：创建代理对象，等同于静态代理中的TaoBao taoBao=new TaoBao()

我们来观察方法原型

?
1
2
3
4
5
6
    public static Object newProxyInstance(
        ClassLoader loader,
        Class<?>[] interfaces,
        InvocationHandler h)  
throws IllegalArgumentException
    

参数:

　　参数1：ClassLoader loader 类加载器,负责向内存中加载对象的,使用反射机制获取对象的classLoader,如何获取? 类 a, a.getCalss().getClassLoader(),目标对象的类加载器

　　参数2：Class<?>[] interfaces: 接口,目标对象实现的接口,也是反射获取的

　　参数3：InvocationHandlerh : 我们自己写的,代理类要完成的功能

方法的返回值也就是代理对象

第四章 实现动态代理的步骤

案例一：

  1. 创建接口,定义目标类要完成的功能
  2. 创建目标类实现接口
  3. 创建InvocationHandler接口的实现类,在invoke方法中完成代理类的功能
    1. 调用目标方法
    2. 增强功能
  4. 使用Proxy类的静态方法,创建代理对象,并把返回值转换成接口类型

第一步：创建接口

UsbSell：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/**
 * 定义U盘接口
 *
 * @author zhangzhixi
 * @date 2021/3/17 13:52
 */
public interface UsbSell {
    /**
     * 定义卖U盘的方法
     *
     * @param amount 购买数量
     * @return  返回所需要的的价格
     */
    float sell(int amount);
}

第二步：创建目标类实现接口

KingstonFactory：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/**
 * 金士顿厂家类
 *
 * @author zhangzhixi
 * @date 2021/3/17 13:54
 */
public class KingstonFactory implements UsbSell {
    /**
     * 128G的U盘出厂价手里是85.0/个单价
     *
     * @param amount 购买数量
     * @return
     */
    @Override
    public float sell(int amount) {
        System.out.println("目标类中,执行了sell目标方法");
        return 85.0f * amount;
    }
}

第三步：创建代理类　(于2023-06-29增加获取代理对象的方法，并添加泛型处理)

MySellHandler:(过时，看下面的类，通过泛型处理)

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
/**
 * @author zhangzhixi
 * @date 2021/3/17 17:32
 */
public class MySellHandler implements InvocationHandler {
    // 目标对象
    private Object target = null;
    /**
     * 1.动态代理:目标对象是活动的,不是固定的,需要传进来
     * 传入是谁。就给谁创建代理(传入金士顿厂家，就给金士顿创建代理)
     */
    public MySellHandler(Object target) {
        // 给目标对象赋值
        this.target = target;
    }
 
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
 
        /**
         * 执行目标方法
         * 参数：
         *      obj –调用基础方法的对象
         *      args –用于方法调用的参数
         *      返回：使用args参数在obj上分派此对象表示的方法的结果
         */
        Object res = method.invoke(target, args);
 
        // 执行功能增强
        if (res != null) {
            // 商家手中的加价，1/个加价25
            float price = (float) res;
            price = price + (25 * (int) args[0]);
            // 增加后的U盘价格
            res = price;
        }
        return res;
    }
}

MySellHandler

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
/**
 * @author zhangzhixi
 * @date 2021/3/17 17:32
 */
class MySellHandler<T> implements InvocationHandler {
    // 目标对象
    private T target = null;
 
 
    /**
     * 1.动态代理:目标对象是活动的,不是固定的,需要传进来
     * 传入是谁。就给谁创建代理(传入金士顿厂家，就给金士顿创建代理)
     */
    public MySellHandler(T target) {
        // 给目标对象赋值
        this.target = target;
    }
 
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
 
        /**
         * 执行目标方法
         * 参数：
         *      obj –调用基础方法的对象
         *      args –用于方法调用的参数
         *      返回：使用args参数在obj上分派此对象表示的方法的结果
         */
        Object res = method.invoke(target, args);
 
        // 执行功能增强
        if (res != null) {
            // 商家手中的加价，1/个加价25
            float price = (float) res;
            price = price + (25 * (int) args[0]);
            // 增加后的U盘价格
            res = price;
        }
        return res;
    }
 
    /**
     * 获取目标对象的代理对象
     *
     * @return 代理对象
     */
    public T getProxyInstance() {
        return (T) Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
    }
}

第四步：测试，使用Proxy类的静态方法,创建代理对象,并把返回值转换成接口类型

MySellTest(过时，看下面的测试类，进行调用)

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import java.lang.reflect.Proxy;
 
/**
 * @author zhangzhixi
 * @date 2021/3/17 17:46
 */
public class MySellTest {
    public static void main(String[] args) {
 
        /**
         * 参数1：类加载器,负责向内存中加载对象的
         * 参数2：接口,目标对象实现的接口,也是反射获取的
         * 参数3：我们自己写的,代理类要完成的功能,传入目标类
         */
        UsbSell usb = (UsbSell) Proxy.newProxyInstance(
                KingstonFactory.class.getClassLoader(),
                KingstonFactory.class.getInterfaces(),
                new MySellHandler(new KingstonFactory())
        );
        float sell = usb.sell(2);
        System.out.println(sell);
    }
}

MySellTest

?
1
2
3
4
5
6
7
8
9
class MySellTest {
    public static void main(String[] args) {
        // 1、创建代理对象，使用Proxy
        UsbSell proxyInstance = new MySellHandler<>(new KingstonFactory()).getProxyInstance();
        // 2、调用方法
        float price = proxyInstance.sell(2);
        System.out.println("通过动态代理对象，调用方法：" + price);
    }
}

 案例二：项目中存在一个Calculator类，代表一个计算器，它可以进行加减乘除操作，实现：在每个方法执行前后打印日志。

　　 与案例一不同的是，这里使用的代理类直接去实现业务方法。然后再主方法中再通过Proxy执行业务方法

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
 
/**
 * @author zhangzhixi
 * @date 2021-9-1 17:44
 */
public interface Calculator {
    void add(int a, int b);
 
    void subtract(int a, int b);
}
 
/**
 * 目标类，实现Calculator接口（如果一开始就面向接口编程，其实是不存在这一步的，CalculatorImpl原本就实现Calculator接口）
 */
class CalculatorImpl implements Calculator {
 
    /**
     * 加
     */
    @Override
    public void add(int a, int b) {
        System.out.println("相加结果为："+(a + b));
    }
 
    /**
     * 减
     */
    @Override
    public void subtract(int a, int b) {
        System.out.println("相减结果为："+(a - b));
    }
}
 
/**
 * 静态代理类，实现Calculator接口
 */
class CalculatorProxy implements Calculator {
    /**
     * 代理对象内部维护一个目标对象引用
     */
    private final Calculator target;
 
    /**
     * 通过构造方法，传入目标对象
     * @param target 目标接口的实现
     */
    public CalculatorProxy(Calculator target) {
        this.target = target;
    }
 
    /**
     * 调用目标对象的add，并在前后打印日志
     * @param a number1
     * @param b number2
     */
    @Override
    public void add(int a, int b) {
        System.out.println("add方法开始...");
        target.add(a, b);
        System.out.println("add方法结束...");
    }
 
    /**
     * 调用目标对象的subtract，并在前后打印日志
     * @param a number1
     * @param b number2
     */
    @Override
    public void subtract(int a, int b) {
        System.out.println("subtract方法开始...");
        target.subtract(a, b);
        System.out.println("subtract方法结束...");
    }
}
 
class Test {
    public static void main(String[] args) throws Exception {
        /*
         * 参数1：类加载器，随便给一个
         * 参数2：需要生成代理Class的接口，比如Calculator
         * */
        Class<?> calculatorProxyClazz = Proxy.getProxyClass(Calculator.class.getClassLoader(), Calculator.class);
 
        // 得到唯一的有参构造 $Proxy(InvocationHandler h)，和反射的Method有点像，可以理解为得到对应的构造器执行器
        Constructor<?> constructor = calculatorProxyClazz.getConstructor(InvocationHandler.class);
 
        // 用构造器执行器执行构造方法，得到代理对象。构造器需要InvocationHandler入参
        Calculator calculatorProxyImpl = (Calculator) constructor.newInstance(new InvocationHandler() {
 
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                // 使用代理执行目标方法
                return method.invoke(new CalculatorProxy(new CalculatorImpl()), args);
            }
        });
 
        // 调用代理对象的方法
        calculatorProxyImpl.add(3, 5);
    }
}

执行结果：

posted @   Java小白的搬砖路  阅读(587)  评论(0)  编辑  收藏  举报
编辑推荐：
· go语言实现终端里的倒计时
· 如何编写易于单元测试的代码
· 10年+ .NET Coder 心语，封装的思维：从隐藏、稳定开始理解其本质意义
· .NET Core 中如何实现缓存的预热？
· 从 HTTP 原因短语缺失研究 HTTP/2 和 HTTP/3 的设计差异
阅读排行：
· 分享一个免费、快速、无限量使用的满血 DeepSeek R1 模型，支持深度思考和联网搜索！
· 基于 Docker 搭建 FRP 内网穿透开源项目（很简单哒）
· ollama系列01：轻松3步本地部署deepseek，普通电脑可用
· 按钮权限的设计及实现
· 25岁的心里话

喜欢请打赏

扫描二维码打赏

支付宝打赏

点击右上角即可分享
微信分享提示
AI IDE Trae
❉
❉
❉
❉
❉