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. 实例化代理对象。

标签：c++,对象模型,函数,static,编辑,参数,编写,系统
来源：