PS：创作不易，感谢阅读，希望对读者有所帮助，喜欢的话可以点赞、收藏、关注，作者会持续更新 Java 生态圈常见知识。黑色加粗为重点关注内容！

• 基本描述
• 为其他对象提供一种代理，以控制对这个对象的访问
• 主要解决
• 在面向对象系统中，有些对象由于某些原因，直接访问会给使用者或者系统结构带来很多麻烦，可以在访问此对象时加上一个对此对象的访问层。
• 对象创建开销很大
• 某些操作需要安全控制
• 需要进程外的访问
• 何时使用
• 想在访问一个类时做一些控制。
• 如何解决
• 增加中间层。
• 关键代码
• 实现与被代理类组合。
• 优点
• 职责清晰
• 扩展性高
• 缺点
• 由于在客户端和真实主题之间增加了代理对象，因此有些类型的代理模式可能会造成请求的处理速度变慢
• 实现代理模式需要额外的工作，有些代理模式的实现非常复杂。

代码示例

• 静态代理举例：代理类和被代理类在编译期间已经确定

interface ClothFactory{
    void produceCloth();
}

/* 代理类 */
class ProxyClothFactory implements ClothFactory{
    private ClothFactory factory; // 用被代理类对象进行实例化

    public ProxyClothFactory(ClothFactory factory) {
        this.factory = factory;
    }

    @Override
    public void produceCloth() {
        System.out.println("代理工厂准备工作");
        this.factory.produceCloth();
        System.out.println("代理工程后续工作");
    }
}

/* 被代理类 */
class NikeClothFactory implements ClothFactory{

    @Override
    public void produceCloth() {
        System.out.println("Nike工厂生产一批运动服");
    }
}

public class 静态代理举例 {
    public static void main(String[] args){
        // 创建被代理类的对象
        NikeClothFactory nike = new NikeClothFactory();
        // 创建代理类的对象
        ProxyClothFactory proxyClothFactory = new ProxyClothFactory(nike);
        proxyClothFactory.produceCloth();
    }
}

• 动态代理举例：在程序运行时根据需要动态创建目标类的代理对象

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/* 接口 */
interface Human{
    String getBelief();
    void eat(String food);
}

/* 被代理类 */
class SuperMan implements Human{

    @Override
    public String getBelief() {
        return "I believe I can fly!";
    }

    @Override
    public void eat(String food) {
        System.out.println("我喜欢吃" + food);
    }
}

/**
 * 要想实现动态代理，需要解决的问题？
 * 问题一：如何根据加载到内存中的被代理类，动态的创建一个代理类及其对象
 * 问题二：当通过代理类的对象调用方法时，如何动态的去调用被代理类中的同名方法。
 */
class ProxyFactory{
    /* 解决问题一 */
    // 将被代理类传入代理工厂，并调用 Proxy.newProxyInstance 关联代理类和被代理类
    // 创建代理类，返回一个代理类的对象。
    public static Object getProxyInstance(Object obj) {
        MyInvocationHandler handler = new MyInvocationHandler(obj);

        return Proxy.newProxyInstance(obj.getClass().getClassLoader(),
                obj.getClass().getInterfaces(), handler);
    }
}

class MyInvocationHandler implements InvocationHandler{
    private Object obj;
    
    public MyInvocationHandler(Object obj) {
        this.obj = obj;
    }

    /* 解决第二个问题 */
    // 当通过代理类的对象调用方法时，就会自动的调用 InvocationHandler.invoke()
    // 将被代理类要执行的方法的声明在 invoke() 中
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        doSomeThingBefore(); // 可添加代理方法前的额外方法
        // 通过反射机制来运行目标对象的方法
        Object returnValue =  method.invoke(this.obj, args);
        doSomeThingAfter(); // 可添加代理方法后的额外方法
        return returnValue;
    }
}

public class 动态代理举例 {
    public static void main(String[] args){
        SuperMan superMan = new SuperMan();
        // proxyInstance：代理类的对象
        Human proxyInstance = (Human)ProxyFactory.getProxyInstance(superMan);
        // 当通过代理类对象调用方法时，会自动调用被代理类中同名的方法
        System.out.println(proxyInstance.getBelief());
        proxyInstance.eat("麻辣烫");
    }
}