1 基于接口的代理模式

什么是代理？

简单来说，代理是指一个对象代替另一个对象去做某些事情。

例如，对于每个程序员来说，他都有编程的能力：

interface Programmable {
    void developSoftware();
}

对于Java程序员，他会编写Java代码：

class JavaProgrammer implements Programmable {
    @Override
    public void developSoftware() {
        System.out.println("编写Java代码");
    }
}

对于JavaScript程序员，他会编写JavaScript代码：

class JavaScriptProgrammer implements Programmable {
    @Override
    public void developSoftware() {
        System.out.println("编写JavaScript代码");
    }
}

……

为了完成一个商业软件，需要各种程序员共同协作。

因此，互联网公司出现了：

class ITCompany implements Programmable {
    private List<Programmable> programmers = new LinkedList<>();

    public void recruitProgrammer(Programmable programmer) {
        programmers.add(programmer);
    }
    
    @Override
    public void developSoftware() {
        designProduct();
        programmers.forEach(Programmable::developSoftware);
        operate();
    }
    
    public void designProduct() {
        System.out.println("产品设计");
    }
    
    public void operate() {
        System.out.println("上线运营");
    }
}

此时，互联网公司对程序员进行了代理，并通过提供额外的功能，完善了善软件开发流程：产品设计 → 编写代码 → 上线运营等。

ITCompany company = new ITCompany();
company.recruitProgrammer(new JavaProgrammer());
company.recruitProgrammer(new JavaScriptProgrammer());
company.developSoftware();

输出如下：

产品设计
编写Java代码
编写JavaScript代码
上线运营

以上方式被称为静态代理模式，步骤如下：

1. 实现被代理接口。
2. 保存被代理对象。
3. 自定义增强方法。
4. 实现被代理的方法。

2 JDK动态代理-Proxy

静态代理有一个明显的局限性，那就是它只能固定代理某一类接口。如果需要代理其他接口，就必须重新编写一个代理类。

java.lang.reflect.Proxy提供了一系列创建动态代理类和实例的静态方法。

例如，为了创建Programmable接口的代理类，可以按如下方式：

// 1、自定义增强方法
InvocationHandler handler = new MyInvocationHandler();
// 2、创建代理类
Class<?> proxyClass = Proxy.getProxyClass(Programmable.class.getClassLoader(), Programmable.class);
// 3、创建代理对象
Programmable p = (Programmable) proxyClass.getConstructor(InvocationHandler.class).newInstance(handler);

或者：

Programmable p = (Programmable) Proxy.newProxyInstance(Programmable.class.getClassLoader(),
                                                       new Class<?>[] { Programmable.class },
                                                       handler);

很明显，第二种方式更加简便（推荐使用）。它其实是对第一种方式进行了封装，并且做了许多安全处理：

public static Object newProxyInstance(ClassLoader loader,
                                      Class<?>[] interfaces,
                                      InvocationHandler h)
    throws IllegalArgumentException
{
    // 1、安全检查
    Objects.requireNonNull(h);
    final Class<?>[] intfs = interfaces.clone();
    final SecurityManager sm = System.getSecurityManager();
    if (sm != null) {
        checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
    }

    // 2、根据接口创建代理类（如果已存在，会直接返回之前创建的代理类）
    Class<?> cl = getProxyClass0(loader, intfs);

    // 3、实例化代理对象
    try {
        if (sm != null) {
            checkNewProxyPermission(Reflection.getCallerClass(), cl);
        }

        final Constructor<?> cons = cl.getConstructor(constructorParams);
        final InvocationHandler ih = h;
        if (!Modifier.isPublic(cl.getModifiers())) {
            AccessController.doPrivileged(new PrivilegedAction<Void>() {
                public Void run() {
                    cons.setAccessible(true);
                    return null;
                }
            });
        }
        return cons.newInstance(new Object[]{h});
    } catch (IllegalAccessException|InstantiationException e) {
    }
}

我们可以发现，Proxy创建代理对象的核心步骤有两步：

1. 创建代理类。
2. 实例化代理对象。

本站声明：
1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；

2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；

3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；

4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；

5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。