设计模式-代理模式

我不是星海2025-07-24 11:32

1.代理模式

1.1什么是代理模式

代理模式就是为一个对象提供一个替身，以控制对这个目标对象的访问。即通过代理对象访问目标对象，这样做的好处是：可以在目标对象实现的基础上，增强额外的功能操作，即扩展目标对象的功能。

要点：即从直接访问目标对象转变为访问代理对象。

1.2代理对象可以为哪些？

1.远程对象。2.创建开销大的对象。3.需要安全控制的对象。

1.3代理模式的三种形式

代理模式的三种形式：1.静态代理。2.JDK动态代理。3.CGLIB动态代理。

1.4代理模式示意图

ProxyObject是代理对象，TargetObject是目标对象，Client客户端依赖代理对象（进行调用），代理对象依赖目标对象，当客户端调用代理对象的时候，代理对象会去调用目标对象。

2.静态代理

2.1静态代理的介绍

静态代理在使用时，需要定义接口或者父类，被代理的对象（即目标对象）与代理对象一起实现相同的接口或者继承相同的父类。

要点：静态代理要求TargetObject，ProxyObject实现相同的接口/继承相同的父类。

2.2实现静态代理模式的步骤

1.定义一个统一的接口：ITeacherDao。

2.目标对象（TargetObject）实现统一的接口：如TeacherDAO实现接口ITeacherDAO。

3.代理对象（ProxyObject）实现统一的接口：如TeacherDAOProxy实现接口ITeacherDAO。

4.Client调用的时候，去调用代理对象（ProxyObject）

5.特别提醒：代理对象与目标对象要实现相同的接口，然后通过调用相同的方法来调用目标对象的方法。

2.3静态代理设计的UML类图

2.4代码实现

2.4.1实现的统一的接口

定义一个统一的接口，定义TargetObject和ProxyTarget都有的方法。

要点：即TargetObject中需要被代理类代理的方法都在统一接口中定义。

java 复制代码 
/**
 * 接口
 */
public interface ITeacherDAO {

    // 授课的方法
    void teach();

}

2.4.2定义TargetObject

TargetObject就是被代理的对象，需要被代理的方法需要定义在统一接口中，并进行实现相关定义的接口。

java 复制代码 
/**
 * TargetObject
 */
public class TeacherDAO implements ITeacherDAO {

    @Override
    public void teach() {
        System.out.println(" 老师授课中... ");
    }

}

2.4.3定义ProxyObject

ProxyObject是代理对象，要进行实现相关统一接口（接口中定义的方法就是Proxy要进行代理Target中的方法），Proxy类中要聚合一个Target进行使用（以接口的形式进行聚合来），只要是实现了相关接口的Target类都可以进行代理。

代理方法中主要是调用聚合的Target类中的方法，前后进行添加一些逻辑，实现代理Target的功能。

java 复制代码 
// 代理对象(ProxyObject)
public class TeacherDaoProxy implements ITeacherDAO {

    // 目标对象, 通过接口进行聚合
    private ITeacherDAO target;

    // 构造器
    public TeacherDaoProxy(ITeacherDAO target) {
        this.target = target;
    }

    @Override
    public void teach() {
        System.out.println("前置代理逻辑.....");
        target.teach();
        System.out.println("提交......");
    }

}

2.5测试静态代理模式

2.5.1测试代码

java 复制代码 
// 客户端
public class Client {

    public static void main(String[] args) {
        // 创建目标对象 (被代理对象)
        TeacherDAO teacherDAO = new TeacherDAO();

        // 创建代理对象, 同时将被代理对象传递给代理对象
        TeacherDaoProxy teacherDaoProxy = new TeacherDaoProxy(teacherDAO);

        // 通过代理对象, 调用被代理对象的方法
        // 即: 执行的时代理对象的方法, 代理对象再去调用目标对象的方法
        teacherDaoProxy.teach();

    }

}

2.5.2测试结果

可以发现静态代理设计模式生效了，在TargetObject方法的前后进行添加了逻辑。

2.6静态代理的优缺点

2.6.1优点

在不修改目标对象的功能前提下，能通过代理对象对目标功能进行扩展。

要点：不修改TargetObject，通过ProxyObject进行扩展原始方法。

2.6.2缺点

系统中代理类较多：因为代理对象需要与目标对象实现一样的接口，所以会有很多代理类。

要点：代理类耦合在系统中，使得系统很庞大，需要代理一个目标对象就需要实现一个代理对象，十分费劲。

难以维护性：需要进行代理TargetObject中新方法的时候，TargetObject，统一接口，ProxyObject都要进行修改，十分复杂。

要点：代理一个方法要维护三个类，维护成本十分大。

3.JDK动态代理

3.1基本介绍

3.1.1什么是JDK动态代理

1.代理对象不需要实现接口，但是目标对象要实现接口，否则不能用动态代理。

要点：JDK动态代理的代理对象类无需实现接口，目标对象需要实现接口。

2.代理对象的生成，是利用JDK的API，动态的在内存中构建代理对象。

要点：JDK动态代理在JVM中进行动态的在内存中生成代理对象，无需编码代理对象。

3.JDK动态代理也被称之为接口动态代理模式。

3.1.2JDK中生成代理对象的API

1 代理类所在的包是java.lang.reflect.Proxy，即JDK动态生成的代理类都是java.lang.reflect.Proxy的子类。

2.JDK实现代理只需要使用newProxyInstance方法，但是这个方法需要接收三个参数，完整的写法是：

Object newProxyInstance(ClassLoader classLoader, Class<?> interfaces, InvocationHandler handler)

调用newProxyInstance方法就可以快速生成TargetObject的代理对象

3.2UML类设计图

3.3实现代码

3.3.1抽象代理接口定义

TargetObject进行实现这个抽象接口，抽象接口中定义的抽象方法都是TargetObject中可以被代理的方法。

要点：TargetObject需要实现一个抽象接口，只有抽象接口中定义的方法才能被代理类所代理使用。

java 复制代码 
// 定义接口, 方便Target Object实现
public interface ITeacherDao {

    void teach();

    String sayHello(String name);

}

3.3.2目标类（TargetObject）的定义

目标类TargetObject需要实现抽象代理接口，实现的这些方法是可以被代理对象所劫持代理的方法。

java 复制代码 
// TargetObject
public class TeacherDao implements ITeacherDao {

    @Override
    public void teach() {
        System.out.println("  老师授课中......  ");
    }

    @Override
    public String sayHello(String name) {
        System.out.println("Hello " + name);
        return "你好 " + name;
    }

}

3.3.3直接使用java.lang.reflect.Proxy使用JDK动态代理

先创建目标对象，然后调用newProxyInstance()方法，传入目标对象的Class对象，再传入生成的代理对象需要实现的接口（TargetObject定义的类也需要实现相关接口），最终传入一个-InvocationHandler接口实现类，实现invoke方法，invoke方法会传入method参数和args参数（method参数就是劫持的调用方法对象，args参数就是劫持函数对象接收的参数列表），在invoke方法中进行实现代理类的逻辑。

java 复制代码 
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class ClientTest {

    public static void main(String[] args) {
        ITeacherDao teacherDao = new TeacherDao();
        ITeacherDao teacherDaoProxy = (ITeacherDao) Proxy.newProxyInstance(teacherDao.getClass().getClassLoader(), teacherDao.getClass().getInterfaces(), new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("我是付庆浩爸爸");
                Object resObj = method.invoke(teacherDao, args);
                System.out.println("我是尹蔚然爷爷");
                return resObj;
            }
        });
        String str = teacherDaoProxy.sayHello("牛逼");
        System.out.println(str);
    }

}

实现步骤：

1.创建TargetObject实现类对象。

2.调用java.lang.reflect.Proxy中的newProxyInstance()方法，需要接收三个参数，ClassLoader（类加载器 => 加载动态生成的代理类的类加载器），interfaces => 需要被代理的接口Class对象数组（TargetObejct类必须实现），InvocationHandler实现类（需要重写Invoke方法，实现代理类的逻辑）

要点：生成的代理类是实现了传进去的interfaces中的接口的类，可以声明为相关接口类型。

3.3.4建立动态代理工厂

3.3.4.1为什么要采用动态代理工厂模式

直接使用java.lang.reflect.Proxy.newProxyInstance进行耦合在Client中创建对象是一个糟糕的选择，因为我们如果想要创建目标对象代理对象的时候，就需要重新写一遍newProxyInstance中复杂的逻辑，太费劲了这样，维护起来简直是灾难，所以建议直接建立一个代理工厂类，需要创建代理对象的时候，就直接调用这个工厂中的方法创建代理对象，需要改变创建对象的逻辑的时候，就直接去修改工厂类中的方法逻辑即可。

3.3.4.2建立动态代理工厂的步骤

1.维护一个target字段，负责进行忖出目标对象 => 表示生产谁的代理对象。

2.维护一个构造器，在构造动态代理对象的时候，传入一个TargetObject表示构造哪个类型的对象

要点：一个工厂实例可以对应创建一个类型的TargetObject的实例对象。

3.定义一个getProxyInstance方法，用于进行返回一个Proxy对象，调用Proxy.newProxyInstance方法进行构造Proxy代理对象，在InvocationHandler的实例化对象里面重写的invoke方法中进行定义代理对象的逻辑。

java 复制代码 
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

// 制造动态代理的工厂
public class ProxyFactory {

    // 维护一个目标对象, Object
    private Object target;

    // 构造起, 对target进行初始化
    public ProxyFactory(Object target) {
        this.target = target;
    }

    // 获取动态代理对象'
    public Object getProxyInstance() {
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(), new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("JDK代理开始~~");
                        // 反射机制调用目标对象
                        Object returnVal = method.invoke(target, args);
                        System.out.println("JDK代理结束~~");
                        return returnVal;
                    }
                });
    }
    
}

这样通过代理对象工厂进行创建出来的Proxy代理对象，是解耦后的，不用每次创建代理对象都需要书写java.lang.reflect.Proxy.newProxyIntance()的逻辑了，这样大大降低了代码工作量，提高了代码的可维护性。

java 复制代码 
/**
 * 测试客户端
 */
public class Client {

    public static void main(String[] args) {
        // 创建目标对象
        ITeacherDao target = new TeacherDao();

        // 给目标对象, 创建代理对象, 可以转换为TargetObject实现的接口类型
        ITeacherDao proxyInstance = (ITeacherDao) new ProxyFactory(target).getProxyInstance();

        // class com.sun.proxy.$Proxy0 可以发现创建出来动态代理类是com.sun.proxy包下的类
        System.out.println("proxyInstance = " + proxyInstance.getClass());

        // 通过ProxyObject, 调用目标对象的方法
        proxyInstance.teach();

        String str = proxyInstance.sayHello("付庆浩");
        System.out.println(str);
    }

}

4.CGLIB动态代理

4.1基本介绍

4.1.1思想转变

代理类由实现接口转变为继承类。

静态代理和JDK动态代理模式都要求目标对象是实现一个接口，但是有时候目标对象只是一个单独的对象，并没有实现任何的接口，这个时候可以使用目标对象子类来实现代理，也就是CGLIB代理。

4.1.2为什么CGLIB是动态代理？

CGLIB代理也被称为子类代理，它是内存中构建一个子类对象从而实现对目标对象功能扩展，并且CGLIB代理也被列为动态代理模式。

4.1.3CGLIB在库中的使用？

CGLIB是一个强大的高性能的代码生成包，它可以在运行期扩展Java类与实现Java接口（在运行时动态扩展Java类与实现Java接口），广泛的被用于各种AOP框架使用（例如SpringAOP），实现方法拦截。

要点：SpringAOP中的方法拦截是靠动态代理实现的。

4.1.4在AOP编程中如何选择代理模式

1.目标对象需要实现接口，使用JDK代理。

2.目标对象不需要实现接口，使用CGLIB编程。

4.1.5CGLIB的底层是如何实现的？

CGLIB的底层是通过字节码处理框架ASM来转换字节码并生成新的类。

要点：CGLIB底层依赖的ASM操作字节码。

4.2UML类图的设计

MethodInterceptor是CGLIB库内部的接口，需要定义代理对象工厂的类进行实现，来编辑代理对象的逻辑，在工厂类ProxyFactory内部通过getProxyInstance进行创建target对应的代理对象，使用interceptor编写对应的代理对象逻辑。

4.3实现代码

4.3.1使用Maven引入CGLIB

java 复制代码 
<!-- https://mvnrepository.com/artifact/cglib/cglib -->
<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>3.3.0</version>
</dependency>

4.3.2TargetObject被代理对象类的定义

java 复制代码 
/**
 * TargetObject类的设计
 */
public class TeacherDao {

    public String teach() {
        System.out.println(" 老师授课中 , 我是cglib代理, 不需要实现接口 ");
        return "hello";
    }

}

4.3.3ProxyFactory代理对象工厂类的定义

1.和JDK实现代理对象工厂类的逻辑一样，使用成员字段进行接收目标对象，一个代理对象工厂类的实例就可以创建一个类型的对象的代理对象，使用构造器进行聚合要生成代理对象的实例对象。

2.定义getProxyInstance方法进行获取代理对象，主要使用工具类Enhancer，实例化一个工具类，使用setSuperclass设置父类，使用setCallback设置实现了MethodInterceptor接口的类的实例化对象，主要是设置定义代理对象逻辑的实例化对象，最终调用enhancer.create()创建代理对象，并进行返回。

3.类实现MethodInterceptor接口，重写interceptor方法，定义代理对象的逻辑。

java 复制代码 
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

/**
 * 代理对象生产工厂
 */
public class ProxyFactory implements MethodInterceptor {

    // 维护一个目标对象
    private Object target;

    // 构造器, 传入一个被代理的对象
    public ProxyFactory(Object target) {
        this.target = target;
    }

    // 返回一个代理对象: 是target对象的代理对象
    public Object getProxyInstance() {
        // 1. 创建一个工具类
        Enhancer enhancer = new Enhancer();
        // 2. 设置父类
        enhancer.setSuperclass(target.getClass());
        // 3. 设置回调函数
        enhancer.setCallback(this);
        // 4. 创建子类对象, 即代理对象
        return enhancer.create();
    }

    @Override
    public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        System.out.println("Cglib代理模式~~ 开始");
        Object returnVal = method.invoke(target, args);
        System.out.println("Cglib代理模式~~ 结束");
        return returnVal;
    }
}

4.4测试CGLIB动态代理

4.4.1测试代码

java 复制代码 
/**
 * 测试客户端
 */
public class Client {

    public static void main(String[] args) {
        // 创建目标对象
        TeacherDao target = new TeacherDao();
        // 获取到代理对象, 并且将目标对象传递给代理对象
        TeacherDao proxyInstance = (TeacherDao) new ProxyFactory(target).getProxyInstance();

        // 执行代理对象的方法, 触发intercept方法, 从而实现对目标对象的调用
        String res = proxyInstance.teach();
        System.out.println("res = " + res);

    }

}

4.4.2测试结果

5.代理模式的变体

5.1防火墙代理

内网通过代理穿透防火墙，实现对公网的访问。

5.2缓存代理

比如：当请求图片文件等资源，先到缓存代理取，如果取到资源就OK，如果取不到资源，再到公网或者数据库去取，然后缓存。

要点：其实redis在后端和MySQL之间就算一个缓存代理。

5.3远程代理

远程对象的本地代表，通过它可以将远程对象当作本地对象进行调用。远程代理通过网络和真正的远程对象沟通信息。

要点：本地Client通过代理访问到远程对象进行调用。

5.4同步代理

主要用于多线程编程中，完成多线程间同步的工作。

要点：多线程编程中，使用同步代理完成多线程间的同步工作。

热门推荐
01Qwen3-Coder 快速上手教程 | Qwen Code + Claude Code02全球最强模型Grok4，国内已可免费使用！（附教程）03vue数据变化但页面不变04【2025.7.18】更新vscode后所有.vue文件template标签后报红的临时解决办法，Vue - Official 插件3.0.2导致05KGG转MP3工具|非KGM文件|解密音频06ChatGPT Agent 完全使用指南：2025年7月最新功能详解07Cursor Claude 模型无法使用的解决方法08这次领先Cursor！体验了Trae 2.0 SOLO 模式，超酷！09Claude Code用不了？来试下Qwen3-Coder加持的Qwen Code吧10赛博保姆出列！Gemini CLI & Claude Code + Kimi 手把手教程