我家小花儿

这个屌丝很懒，什么也没留下！

热门标签

Spring6 - （14） GoF之代理模式_gof的代理模式和接口实现类的关系

作者：我家小花儿 | 2024-05-13 06:38:35

踩

gof的代理模式和接口实现类的关系

在这里插入图片描述

文章目录

Spring6 -（14）GoF之代理模式

Spring6 -（14）GoF之代理模式

1. 对代理模式的理解

场景：拍电影的时候，演员找替身演员，这就是一个代理模式

替身演员去代理演员完成表演

思考：演员为什么要找替身呢？（为什么要使用代理模式呢？）

第一个原因：怕自己受伤，找个替身（保护自己）
第二个原因：自己完成不来这种高难度的动作，替身演员可以完成（功能增强）
A对象无法和B对象直接交互时，也可以使用代理模式来解决

Java程序中的代理模式的作用：

当一个对象需要受到保护的时候，可以考虑使用代理对象去完成某个行为
需要给某个对象的功能个进行增强的时候，可以考虑找一个代理进行增强

代理模式中有一个非常重要的特点：对于客户端程序来说，使用代理对象时就像在使用目标对象一样。【在程序中，目标需要被保护时】

代理模式中有三大角色：

目标对象（演员）
代理对象（替身演员）
目标对象和代理对象的公共接口（演员和替身演员应该具有相同的行为动作）

为什么演员和替身演员要有相同的行为动作呢？

是因为不想让观众知道是替身演员。这里的观众其实就是“客户端程序”，如果你使用代理模式的话，对应客户端程序来所，客户端是无法察觉到的，客户端在使用代理对象的时候就象在使用目标对象。

代理模式的类图：

在这里插入图片描述

代理模式在代码实现上，包括两种形式：

静态代理
动态代理

2. 静态代理

代理类是程序员提前写好的，成为静态代理

下面是静态动力的演示：

定义一个接口：OrderService

package com.julissa.proxy.service;

public interface OrderService {
    /**
     * 生成订单
     */
    void generate();

    /**
     * 查看订单详情
     */
    void detail();

    /**
     * 修改订单
     */
    void modify();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

定义接口的实现类：OrderServiceImpl

package com.julissa.proxy.service;

public class OrderServiceImpl implements OrderService{
    @Override
    public void generate() {
        //模拟生成订单的耗时
        try {
            Thread.sleep(1234);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("订单已生成");
    }

    @Override
    public void detail() {
        //模拟查看订单的耗时
        try {
            Thread.sleep(2541);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("订单信息如下：******");
    }

    @Override
    public void modify() {
        //模拟修改订单的耗时
        try {
            Thread.sleep(1010);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("订单已修改");
    }
}

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

客户端程序：

package com.julissa.proxy.client;

import com.julissa.proxy.service.OrderService;
import com.julissa.proxy.service.OrderServiceImpl;

public class Test {
    public static void main(String[] args) {
        OrderService orderService = new OrderServiceImpl();
        orderService.generate();
        orderService.modify();
        orderService.detail();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

其中Thread.sleep()方法的调用是为了模拟操作耗时。

项目已上线，并且运行正常，只是客户反馈系统有一些地方运行较慢，要求项目组对系统进行优化。于是项目负责人就下达了这个需求。首先需要搞清楚是哪些业务方法耗时较长，于是让我们统计每个业务方法所耗费的时长。如果是你，你该怎么做呢？

第一种方案：直接修改Java源代码，在每个业务方法中添加统计逻辑，如下：

package com.julissa.proxy.service;

public class OrderServiceImpl implements OrderService{
    @Override
    public void generate() {
        //模拟生成订单的耗时
        long begin = System.currentTimeMillis();
        try {
            Thread.sleep(1234);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("订单已生成");
        long end = System.currentTimeMillis();
        System.out.println("耗费时长"+(end - begin)+"毫秒");
    }

    @Override
    public void detail() {
        //模拟查看订单的耗时
        long begin = System.currentTimeMillis();
        try {
            Thread.sleep(2541);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("订单信息如下：******");
        long end = System.currentTimeMillis();
        System.out.println("耗费时长"+(end - begin)+"毫秒");
    }

    @Override
    public void modify() {
        //模拟修改订单的耗时
        long begin = System.currentTimeMillis();
        try {
            Thread.sleep(1010);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("订单已修改");
        long end = System.currentTimeMillis();
        System.out.println("耗费时长"+(end - begin)+"毫秒");
    }
}
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

需求可以满足，但显然是违背了OCP开闭原则,而且代码没有得到复用，这种方案不可取。

第二种方案：编写一个子类继承OrderServiceImpl，在子类中重写每个方法，代码如下：

package com.julissa.proxy.service;

public class OrderServiceImplSub extends OrderServiceImpl{
    @Override
    public void generate() {
        long begin = System.currentTimeMillis();
        super.generate();
        long end = System.currentTimeMillis();
        System.out.println("耗时"+(end - begin)+"毫秒");
    }

    @Override
    public void detail() {
        long begin = System.currentTimeMillis();
        super.detail();
        long end = System.currentTimeMillis();
        System.out.println("耗时"+(end - begin)+"毫秒");
    }

    @Override
    public void modify() {
        long begin = System.currentTimeMillis();
        super.modify();
        long end = System.currentTimeMillis();
        System.out.println("耗时"+(end - begin)+"毫秒");
    }
}

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

这种方式可以解决，但是存在两个问题：

第一个问题：假设系统中有100个这样的业务类，需要提供100个子类，并且之前写好的创建Service对象的代码，都要修改为创建子类对象。
第二个问题：由于采用了继承的方式，导致代码之间的耦合度较高。

这种方案也不可取。

第三种方案：使用代理模式（这里采用静态代理）

可以为OrderService接口提供一个代理类。

package com.julissa.proxy.service;

public class OrderServiceProxy implements OrderService{// 代理对象（代理对象和目标对象要有相同的行为或方法，所有要实现公共接口）

   // 将目标对象作为代理对象的属性，这种关系叫做关联关系，比继承关系的耦合度低
    private OrderService orderService;

    // 通过构造方法将目标对象传递给代理对象
    public OrderServiceProxy(OrderService orderService) {
        this.orderService = orderService;
    }
    @Override
    public void generate() {// 代理方法
        //增强
        long begin = System.currentTimeMillis();
        // 执行目标对象的目标方法
        orderService.generate();
        long end = System.currentTimeMillis();
        System.out.println("耗时"+(end - begin)+"毫秒");
    }

    @Override
    public void detail() {// 代理方法
        //增强
        long begin = System.currentTimeMillis();
        // 执行目标对象的目标方法
        orderService.detail();
        long end = System.currentTimeMillis();
        System.out.println("耗时"+(end - begin)+"毫秒");
    }

    @Override
    public void modify() {// 代理方法
        //增强
        long begin = System.currentTimeMillis();
        // 执行目标对象的目标方法
        orderService.modify();
        long end = System.currentTimeMillis();
        System.out.println("耗时"+(end - begin)+"毫秒");
    }
}

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

这种方式的优点：符合OCP开闭原则，同时采用的是关联关系，所以程序的耦合度较低。所以这种方案是被推荐的。

编写客户端程序：

package com.julissa.proxy.client;

import com.julissa.proxy.service.OrderService;
import com.julissa.proxy.service.OrderServiceImpl;
import com.julissa.proxy.service.OrderServiceProxy;

public class Client {
    public static void main(String[] args) {
        // 创建目标对象
        OrderService target = new OrderServiceImpl();
        // 创建代理对象
        OrderService proxy = new OrderServiceProxy(target);
        // 调用代理对象的代理方法
        proxy.generate();
        proxy.modify();
        proxy.detail();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

运行结果：

在这里插入图片描述

以上就是代理模式中的静态代理，其中OrderService接口是代理类和目标类的共同接口。OrderServiceImpl是目标类。OrderServiceProxy是代理类。

大家思考一下：如果系统中业务接口很多，一个接口对应一个代理类，显然也是不合理的，会导致类爆炸。怎么解决这个问题？动态代理可以解决。因为在动态代理中可以在内存中动态的为我们生成代理类的字节码。代理类不需要我们写了。类爆炸解决了，而且代码只需要写一次，代码也会得到复用。

3. 动态代理

在程序运行阶段，在内存中动态生成代理类，被称为动态代理，目的是为了减少代理类的数量。解决代码复用的问题。

在内存当中动态生成类的技术常见的包括：

JDK动态代理技术：只能代理接口。
CGLIB动态代理技术：CGLIB(Code Generation Library)是一个开源项目。是一个强大的，高性能，高质量的Code生成类库，它可以在运行期扩展Java类与实现Java接口。它既可以代理接口，又可以代理类，底层是通过继承的方式实现的。性能比JDK动态代理要好。（底层有一个小而快的字节码处理框架ASM。）
Javassist动态代理技术：Javassist是一个开源的分析、编辑和创建Java字节码的类库。是由东京工业大学的数学和计算机科学系的 Shigeru Chiba （千叶滋）所创建的。它已加入了开放源代码JBoss 应用服务器项目，通过使用Javassist对字节码操作为JBoss实现动态"AOP"框架。

3.1 JDK动态代理

还是使用静态代理中的例子：一个接口和一个实现类。

OrderService

package com.julissa.proxy.service;

public interface OrderService {
    /**
     * 生成订单
     */
    void generate();

    /**
     * 查看订单详情
     */
    void detail();

    /**
     * 修改订单
     */
    void modify();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

OrderServiceImpl

package com.julissa.proxy.service;

public class OrderServiceImpl implements OrderService{
    @Override
    public void generate() {
        //模拟生成订单的耗时
        try {
            Thread.sleep(1234);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("订单已生成");
    }

    @Override
    public void detail() {
        //模拟查看订单的耗时
        try {
            Thread.sleep(2541);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("订单信息如下：******");
    }

    @Override
    public void modify() {
        //模拟修改订单的耗时
        try {
            Thread.sleep(1010);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("订单已修改");
    }
}
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

我们在静态代理的时候，除了以上一个接口和一个实现类之外，还需要写一个代理类UserServiceProxy！

在动态代理中UserServiceProxy代理类是可以动态生成的。这个类不需要写。我们直接写客户端程序即可：

package com.julissa.proxy.client;

import com.julissa.proxy.service.OrderService;
import com.julissa.proxy.service.OrderServiceImpl;

import java.lang.reflect.Proxy;

public class Client {
    public static void main(String[] args) {
        //创建目标对象
        OrderService target = new OrderServiceImpl();
        //创建代理对象
        Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(),调用处理器对象)
        //调用代理对象的代理方法
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

OrderService orderServiceProxy = Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), 调用处理器对象);

这行代码做了两件事：

第一件事：在内存中生成了代理类的字节码class
第二件事：创建代理对象

Proxy类全名：java.lang.reflect.Proxy。这是JDK提供的一个类（所以称为JDK动态代理）。主要是通过这个类在内存中生成代理类的字节码。

其中newProxyInstance()方法有三个参数：

第一个参数：类加载器。在内存中生成了字节码，要想执行这个字节码，也是需要先把这个字节码加载到内存当中的，加载类就需要类加载器，并且JDK要求，目标类的的类加载器类和代理类的类加载器要使用同一个。
第二个参数：接口类型。代理类和目标类实现相同的接口，所以要通过这个参数告诉JDK动态代理生成的类要实现哪些接口。
第三个参数：调用处理器。这是一个JDK动态代理规定的接口，接口全名：java.lang.reflect.InvocationHandler。显然这是一个回调接口，也就是说调用这个接口中方法的程序已经写好了，就差这个接口的实现类了，在调用处理器接口编写的代码，就是增强代码。

所以接下来我们要写一下java.lang.reflect.InvocationHandler接口的实现类，并且实现接口中的方法，代码如下：

package com.julissa.proxy.service;

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

public class TimerInvocationHandler implements InvocationHandler {
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        return null;
    }
}
1
2
3
4
5
6
7
8
9
10
11

InvocationHandler接口中有一个方法invoke，这个invoke方法上有三个参数：

第一个参数：Object proxy。代理对象。设计这个参数只是为了后期的方便，如果想在invoke方法中使用代理对象的话，尽管通过这个参数来使用。
第二个参数：Method method。目标对象上的目标方法（要执行的目标方法就是它）。
第三个参数：Object[] args。目标方法调用时要传的参数。

我们将来肯定是要调用“目标方法”的，但要调用目标方法的话，需要“目标对象”的存在，“目标对象”从哪儿来呢？我们可以给TimerInvocationHandler提供一个构造方法，可以通过这个构造方法传过来“目标对象”，代码如下：

package com.julissa.proxy.service;

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

public class TimerInvocationHandler implements InvocationHandler {

    // 目标对象
    private Object target;

    // 通过构造方法来传目标对象
    public TimerInvocationHandler(Object target) {
        this.target = target;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        return null;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

有了目标对象我们就可以在invoke()方法中调用目标方法了。代码如下：

package com.julissa.proxy.service;

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

public class TimerInvocationHandler implements InvocationHandler {

    // 目标对象
    private Object target;

    // 通过构造方法来传目标对象
    public TimerInvocationHandler(Object target) {
        this.target = target;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 目标执行之前增强。
        long begin = System.currentTimeMillis();
        // 调用目标对象的目标方法
        //四要素：那个对象，哪个方法，什么参数。返回什么值
        Object retValue = method.invoke(target, args);
        // 目标执行之后增强。
        long end = System.currentTimeMillis();
        System.out.println("耗时"+(end - begin)+"毫秒");
        // 一定要记得返回
        return retValue;
    }
}
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

到此为止，调用处理器就完成了。接下来，应该继续完善Client程序：

package com.julissa.proxy.client;

import com.julissa.proxy.service.OrderService;
import com.julissa.proxy.service.OrderServiceImpl;
import com.julissa.proxy.service.TimerInvocationHandler;

import java.lang.reflect.Proxy;

public class Client {
    public static void main(String[] args) {
        //创建目标对象
        OrderService target = new OrderServiceImpl();
        //创建代理对象
        //实现了OrderService接口，所以可以向下转型
        OrderService proxyObj =(OrderService) Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), new TimerInvocationHandler(target));
        //调用代理对象的代理方法
        proxyObj.generate();
        proxyObj.detail();
        proxyObj.modify();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

运行客户端程序

InvocationHandler接口中的invoke()方法什么时候被调用？

注意：当你调用代理对象的代理方法的时候，注册在InvocationHandler接口中的invoke()方法会被调用，注册在InvocationHandler接口中的invoke()方法都会被调用。

可以看到，不管你有多少个Service接口，多少个业务类，这个TimerInvocationHandler接口是不是只需要写一次就行了，代码是不是得到复用了

而且最重要的是，以后程序员只需要关注核心业务的编写了，像这种统计时间的代码根本不需要关注。因为这种统计时间的代码只需要在调用处理器中编写一次即可。

到这里，JDK动态代理的原理就结束了。

不过我们看以下这个代码确实有点繁琐，对于客户端来说，用起来不方便：

我们可以提供一个工具类：ProxyUtil，封装一个方法：

package com.julissa.proxy.utils;

import com.julissa.proxy.service.OrderService;
import com.julissa.proxy.service.TimerInvocationHandler;

import java.lang.reflect.Proxy;

public class ProxyUtil {
    /**
     * 获取代理对象
     * @param target 目标对象
     * @return 代理对象
     */
    public static OrderService getProxyObj(Object target){
         //底层调用JDK动态代理
        OrderService proxyObj =(OrderService) Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                new TimerInvocationHandler(target));
        return proxyObj;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

这样客户端代码就不需要写那么繁琐了：

package com.julissa.proxy.client;

import com.julissa.proxy.service.OrderService;
import com.julissa.proxy.service.OrderServiceImpl;
import com.julissa.proxy.service.TimerInvocationHandler;
import com.julissa.proxy.utils.ProxyUtil;

import java.lang.reflect.Proxy;

public class Client {
    public static void main(String[] args) {
        //创建目标对象
        OrderService target = new OrderServiceImpl();
        //创建代理对象
        //实现了OrderService接口，所以可以向下转型
        OrderService proxyObj = ProxyUtil.getProxyObj(target);
        //调用代理对象的代理方法
        proxyObj.generate();
        proxyObj.detail();
        proxyObj.modify();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

3.2 CGLIB动态代理

CGLIB既可以代理接口，又可以代理类。底层采用继承的方式实现。所以被代理的目标类不能使用final修饰。

使用CGLIB，需要引入它的依赖：

<dependency>
  <groupId>cglib</groupId>
  <artifactId>cglib</artifactId>
  <version>3.3.0</version>
</dependency>			
1
2
3
4
5

我们准备一个没有实现接口的类，如下：

package com.julissa.proxy.service;

/**
 * 目标类
 */
public class UserService {
    /**
     * 用户登陆
     * @param username 用户名
     * @param password 密码
     * @return 登陆结果
     */
    public Boolean login(String username, String password){
        System.out.println("系统正砸验证信息");
        if ("admin".equals(username) && "123456".equals(password)) {
            return true;
        }
        return false;
    }

    /**
     * 用户注销
     */
    public void logout(){
        System.out.println("用户退出");
    }
}
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

使用CGLIB在内存中为UserService类生成代理类，并创建对象

package com.julissa.proxy.client;

import com.julissa.proxy.service.UserService;
import net.sf.cglib.proxy.Enhancer;

/**
 * 客户端程序
 */
public class Client2 {
    public static void main(String[] args) {
        // 创建字节码增强器
        // 这个对象是CGLib库中的核心对象，就是依靠它生成代理类
        Enhancer enhancer = new Enhancer();
        // 告诉cglib要继承哪个类
        enhancer.setSuperclass(UserService.class);
        // 设置回调函数(等同于JDK动态代理的调用处理器)
        enhancer.setCallback(new UserServiceInterceptor());
        // 创建代理对象
        // 这一步会做两件事：
        // 1.在内存中生成UserService的子类，其实就是代理类的字节码
        // 2. 创建代理对象
        UserService userService = (UserService) enhancer.create();
        // 调用代理对象的方法
        Boolean aBoolean = userService.login("admin", "123456");
        System.out.println(aBoolean?"登陆成功":"登陆失败");
        userService.logout();
    }
}
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

编写MethodInterceptor接口实现类：

package com.julissa.proxy.service;

import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

public class UserServiceInterceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object target, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        // 前增强
        long begin = System.currentTimeMillis();
        // 调用目标
        Object retValue = methodProxy.invokeSuper(target, objects);
        // 后增强
        long end = System.currentTimeMillis();
        System.out.println("耗时" + (end - begin) + "毫秒");
        // 一定要返回
        return retValue;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

MethodInterceptor接口中有一个方法intercept()，该方法有4个参数：

第一个参数：目标对象

第二个参数：目标方法

第三个参数：目标方法调用时的实参

第四个参数：代理方法

对于高版本的JDK，如果使用CGLIB，需要在启动项中添加两个启动参数：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7WCayQAn-1679894878459)(null)]

–add-opens java.base/java.lang=ALL-UNNAMED
–add-opens java.base/sun.net.util=ALL-UNNAMED

运行客户端程序

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家小花儿/article/detail/562319