什么是代理模式

最新推荐文章于 2024-06-04 15:15:01 发布

SLQ1893

最新推荐文章于 2024-06-04 15:15:01 发布

阅读量714

点赞数

分类专栏： Java 文章标签：代理模式

本文链接：https://blog.csdn.net/SLQ1893/article/details/126214789

版权

Java 专栏收录该内容

7 篇文章 1 订阅

订阅专栏

代理模式的定义与特点

代理模式的定义：由于某些原因需要给某对象提供一个代理以控制对该对象的访问。这时，访问对象不适合或者不能直接引用目标对象，代理对象作为访问对象和目标对象之间的中介。

代理模式的主要优点有：

代理模式在客户端与目标对象之间起到一个中介作用和保护目标对象的作用；
代理对象可以扩展目标对象的功能；
代理模式能将客户端与目标对象分离，在一定程度上降低了系统的耦合度，增加了程序的可扩展性

其主要缺点是：

代理模式会造成系统设计中类的数量增加
在客户端和目标对象之间增加一个代理对象，会造成请求处理速度变慢；
增加了系统的复杂度；

那么如何解决以上提到的缺点呢？答案是可以使用动态代理方式

根据代理的创建时期，代理模式分为静态代理和动态代理。

静态：由程序员创建代理类或特定工具自动生成源代码再对其编译，在程序运行前代理类的 .class 文件就已经存在了。
动态：在程序运行时，运用反射机制动态创建而成。

静态代理

代理模式的主要角色如下。

抽象主题（Subject）类：通过接口或抽象类声明真实主题和代理对象实现的业务方法。
真实主题（Real Subject）类：实现了抽象主题中的具体业务，是代理对象所代表的真实对象，是最终要引用的对象。
代理（Proxy）类：提供了与真实主题相同的接口，其内部含有对真实主题的引用，它可以访问、控制或扩展真实主题的功能。

在代码中，一般代理会被理解为代码增强，实际上就是在原代码逻辑前后增加一些代码逻辑，而使调用者无感知。

抽象主题（Subject）类

package com.slq.demo01;

/**
 * @author : SLQ1893
 * @date : 2022-06-01 22:42
 * @description : 抽象主题
 */
public interface Subject {
    void request();
}

真实主题（Real Subject）类

package com.slq.demo01;

/**
 * @author : SLQ1893
 * @date : 2022-06-01 22:43
 * @description :真实主题
 */
public class RealSubject implements Subject {

    @Override
    public void request() {
        System.out.println("访问真实主题方法。。。");
    }
}

代理（Proxy）类

package com.slq.demo01;

/**
 * @author : SLQ1893
 * @date : 2022-06-01 22:45
 * @description : 代理
 */
public class ProxyObject implements Subject {

    private RealSubject realSubject;

    @Override
    public void request() {
        if (realSubject == null) {
            realSubject = new RealSubject();
        }
        preRequest();
        realSubject.request();
        postRequest();
    }

    public void preRequest() {
        System.out.println("访问真实主题之前的预处理");
    }

    public void postRequest() {
        System.out.println("访问真实主题之后的后续处理");
    }
}

测试类

package com.slq.demo01;

/**
 * @author : SLQ1893
 * @date : 2022-06-01 22:41
 * @description :测试类
 */
public class ProxyTest {
    public static void main(String[] args) {
        ProxyObject proxyObject = new ProxyObject();
        proxyObject.request();
    }
}

再来举一个例子：

张老三找老师

package com.slq.demo03;

/**
 * @author : SLQ1893
 * @date : 2022-06-01 22:55
 * @description : 顶层接口IPerson
 */
public interface IPerson {
    /**
     * 找老师
     */
    void findTeacher();
}

package com.slq.demo03;

/**
 * @author : SLQ1893
 * @date : 2022-06-01 22:59
 * @description :
 */
public class ZhangSan implements IPerson {
    @Override
    public void findTeacher() {
        System.out.println("儿子张三提出要求");
    }
}

package com.slq.demo03;

/**
 * @author : SLQ1893
 * @date : 2022-06-01 23:01
 * @description :
 */
public class ZhangLaoSan implements IPerson {

    private ZhangSan zhangSan;

    public ZhangLaoSan(ZhangSan zhangSan) {
        this.zhangSan = zhangSan;
    }

    @Override
    public void findTeacher() {
        System.out.println("张老三开始找老师");
        zhangSan.findTeacher();
        System.out.println("开始学习");
    }
}

package com.slq.demo03;

/**
 * @author : SLQ1893
 * @date : 2022-06-01 23:12
 * @description :
 */
public class Test {
    public static void main(String[] args) {
        ZhangLaoSan zhangLaoSan = new ZhangLaoSan(new ZhangSan());
        zhangLaoSan.findTeacher();
    }
}

使用代理模式主要有两个目的：一是保护目标对象，二是增强目标对象。

在前面介绍的代理模式中，代理类中包含了对真实主题的引用，这种方式存在两个缺点。

真实主题与代理主题一一对应，增加真实主题也要增加代理。
设计代理以前真实主题必须事先存在，不太灵活。采用动态代理模式可以解决以上问题，如 SpringAOP。

动态代理

动态代理也叫 JDK 代理或接口代理，有以下特点：

代理对象不需要实现接口
代理对象的生成是利用 JDK 的 API 动态的在内存中构建代理对象
能在代码运行时动态地改变某个对象的代理，并且能为代理对象动态地增加方法、增加行为

一般情况下，动态代理的底层不用我们亲自去实现，可以使用线程提供的 API 。例如，在 Java 生态中，目前普遍使用的是 JDK 自带的代理和 CGLib 提供的类库。

JDK 实现代理只需要使用 newProxyInstance 方法，该方法需要接收三个参数，语法格式如下：

static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h )

注意该方法在 Proxy 类中是静态方法，且接收的三个参数说明依次为：

ClassLoader loader：指定当前目标对象使用类加载器，获取加载器的方法是固定的
Class<?>[] interfaces：目标对象实现的接口的类型，使用泛型方式确认类型
InvocationHandler h：事件处理，执行目标对象的方法时，会触发事件处理器的方法，把当前执行目标对象的方法作为参数传入。

JDK动态代理

package com.slq.demo04;

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

/**
 * @author : SLQ1893
 * @date : 2022-06-01 23:16
 * @description :
 */
public class JdkFuDao implements InvocationHandler {

    private IPerson target;


    public IPerson getInstance(IPerson target) {
        this.target = target;
        Class<?> clazz = target.getClass();
        return (IPerson) Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces(), this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        before();
        Object invoke = method.invoke(this.target, args);
        after();
        return invoke;
    }

    private void before() {
        System.out.println("这里是C语言中文辅导班，已经收集到您的需求，开始挑选老师");
    }

    private void after() {
        System.out.println("双方同意，开始辅导");
    }
}

package com.slq.demo04;

/**
 * @author : SLQ1893
 * @date : 2022-06-01 23:33
 * @description :
 */
public class ZhaoLiu implements IPerson {
    @Override
    public void findTeacher() {
        System.out.println("符合赵六的要求");
    }

    public void buyInsure() {

    }
}

package com.slq.demo04;

/**
 * @author : SLQ1893
 * @date : 2022-06-01 23:35
 * @description : 顶层接口IPerson
 */
public interface IPerson {
    /**
     * 找老师
     */
    void findTeacher();
}

package com.slq.demo04;

/**
 * @author : SLQ1893
 * @date : 2022-06-01 23:38
 * @description :
 */
public class Test {
    public static void main(String[] args) {
        JdkFuDao jdkFuDao = new JdkFuDao();

        IPerson zhaoliu = jdkFuDao.getInstance(new ZhaoLiu());
        zhaoliu.findTeacher();

    }
}

需要注意的是，代理对象不需要实现接口，但是目标对象一定要实现接口，否则不能用动态代理。