/**
 * Subject 接口
 * IFactory 定义了要做的事情，就是卖东西，但是工厂是委托给商店代卖的
 * 委托类和代理类都实现了IFactory接口
 **/
public interface IFactory { 
    /** 出售 */
    void sell();

}

Vendor类定义如下

/**
 * RealSubject类
 * 真实主题类，是客户端通过代理类间接调用的  真正实现具体需要实现方法的主体。
 * 工厂主，他要卖东西，他是Factory这个抽象主体的具体实现，他要卖东西
 **/
public class Factoryer implements IFactory{

    @Override
    public void sell() {
        System.out.println("出售货物");
    }

}

Shop类定义如下：

/**
 * Proxy代理类
 * 超市，代理卖东西
 **/
public class Shop implements IFactory{

    private Factoryer factoryer;

    public Shop(Factoryer factoryer){
        this.factoryer = factoryer;
    }

    @Override
    public void sell() {
        System.out.println("Shop是商店代理，用于直接对接client顾客，执行sell方法");
        factoryer.sell();
    }
}

其中代理类Shop通过聚合的方式持有了被代理类Factoryer的引用，并在对应的方法中调用Factoryer对应的方法。

下面看看在客户端中如何使用代理类，即客人怎么通过这套代理体系买东西。

public class ClientBuy {

    public static void main(String[] args) {

        // 被代理类
        Factoryer factoryer = new Factoryer();

        // 创建供应商(也就是真正执行卖东西这个方法操作的factoryer)的代理类Shop
        IFactoryer ifactoryer = new Shop(factoryer);

        // 客人买东西时面向的是代理类Shop。
        ifactoryer.sell();
    }
}

在上述代码中，我们可以在Shop中修改或新增一些内容，而不影响被代理类Factoryer 。比如我们可以在Shop类中新增一些额外的处理，类似于筛选购买用户、记录日志等操作。

2.2 静态代理的缺点

静态代理实现简单且不侵入原代码，但当场景复杂时，静态代理会有以下缺点：

1、当需要代理多个类时，代理对象要实现与目标对象一致的接口。我们只有两个选择，1：只维护一个代理类来实现多个接口，但这样会导致代理类过于庞大；2：新建多个代理类，但这样会产生过多的代理类。

2、当接口(IFactoryer)需要增加、删除、修改方法时，目标对象(ClientBuy)与代理类（shop）都要同时修改，不易维护。

于是，动态代理便派上用场了。

三动态代理

动态代理是指代理类在程序运行时进行创建的代理方式。这种情况下，代理类并不是在Java代码中定义的，而是在运行时根据Java代码中的“指示”动态生成的。

相比于静态代理，动态代理的优势在于可以很方便的对代理类的函数进行统一的处理，而不用修改每个代理类的函数。

3.1 基于JDK原生动态代理实现

实现动态代理通常有两种方式：JDK原生动态代理和CGLIB动态代理。这里，我们以JDK原生动态代理为例来进行讲解。

JDK动态代理主要涉及两个类：java.lang.reflect.Proxy和java.lang.reflect.InvocationHandler。

InvocationHandler接口定义了如下方法：

/**
 * 调用处理程序
 */
public interface InvocationHandler { 
    Object invoke(Object proxy, Method method, Object[] args); 
}

顾名思义，实现了该接口的中介类用做“调用处理器”。当调用代理类对象的方法时，这个“调用”会转送到invoke方法中。动态代理中，Proxy 动态产生的代理会调用 InvocationHandler 实现类，所以 InvocationHandler 是实际执行者。

InvocationHandler方法的，第一个参数proxy参数为代理类对象，第二个参数为method，表示具体调用的是代理类的哪个方法，第三个参数args为为第二个参数该方法的参数。

这样对代理类中的所有方法的调用都会变为对invoke的调用，可以在invoke方法中添加统一的处理逻辑(也可以根据method参数对不同的代理类方法做不同的处理)。

下面以添加日志为例来演示一下动态代理。

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

public class LogHandler implements InvocationHandler {
    Object target;  // 被代理的对象，实际的方法执行者

    public LogHandler(Object target) {
        this.target = target;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        before();
        Object result = method.invoke(target, args);  // 调用 target 的 method 方法
        after();
        return result;  // 返回方法的执行结果
    }
    // 调用invoke方法之前执行
    private void before() {
        System.out.println("调用方法sell之前的日志处理");
    }
    // 调用invoke方法之后执行
    private void after() {
        System.out.println("调用方法sell之后的日志处理");
    }
}

客户端编写程序使用动态代理代码如下：

import java.lang.reflect.Proxy;
/**
 * 动态代理测试
 *
 * @author sec
 * @version 1.0
 * @date 2020/3/21 10:40 AM
 **/
public class DynamicClientBuy {
    public static void main(String[] args) {

        // 创建中介类实例
        LogHandler logHandler = new LogHandler(new Factoryer());

        // 获取代理类实例IFactory
        IFactory iFactory = (IFactory) (Proxy.newProxyInstance(
                                            IFactory.class.getClassLoader(), 
                                            new Class[]{IFactory.class}, 
                                            logHandler)
                                        );

        // 通过代理类对象调用代理类方法，实际上会转到invoke方法调用
        iFactory.sell();
    }
}

Proxy.newProxyInstance的三个参数含义为：

loader 自然是类加载器
interfaces 代码要用来代理的接口
h 一个 InvocationHandler 对象

执行之后，打印日志如下：

调用方法sell之前的日志处理
Shop sell goods
调用方法sell之后的日志处理

经过上述验证，我们发现已经成功为我们的被代理类统一添加了执行方法之前和执行方法之后的日志。

四小结

了解代理模式可以让我们的系统设计的更加具有可扩展性。而动态代理的应用就更广了，各类框架及业务场景都在使用。

Java动态代理的优势是实现无侵入式的代码扩展，也就是方法的增强：不改变这个方法的前提下去丰富它；你可以在不用修改源码的情况下，增强一些方法；在方法的前后你可以做你任何想做的事情（甚至不去执行这个方法就可以）。老功能用原来的方法不会有问题，新功能通过代理丰富了原来的方法也能被广泛试用。

动态代理类：在程序运行时，通过反射机制动态生成。
动态代理类通常代理接口下的所有类。
动态代理事先不知道要代理的是什么，只有在运行的时候才能确定。
动态代理的调用处理程序必须事先InvocationHandler接口，及使用Proxy类中的newProxyInstance方法动态的创建代理类。
Java动态代理只能代理接口，要代理类需要使用第三方的CGLIB等类库

掌握到这里其实已经差不多了，关于更多一些例子包括源码的一些分析，这边文章写得很好轻松学，Java 中的代理模式及动态代理，我就不再画蛇添足了，建议看完本篇后快速看下这篇的一些代码例子（多代理的例子），心中会更加有数。

参考：

https://www.choupangxia.com/2020/03/21/java-dynamic-proxy/

https://blog.csdn.net/lovejj1994/article/details/78080124

https://blog.csdn.net/yaomingyang/article/details/81053130

https://blog.csdn.net/u011784767/article/details/78281384

https://blog.csdn.net/briblue/article/details/73928350