静态代理和动态代理

Posted 2021-01-03 homejim

代理模式（静态代理）

代理模式是为其他对象提供一种代理以控制对这个对象的访问。

定义上也不算好理解， 上一个 《大话设计模式》 的图。

Subject 类（一般是抽象类或接口）， 定义了一个方法。

RealSubject 类实现了这个接口， 正常的情况我们只需要 new 出这个类的实例对象， 然后调用这个方法就可以了。

但是， 如果我们有需求说想要在这个方法的前面和后面进行一些操作， 那么，原始的方法已经无法满足了。

以租房子打比方：

房东李老板有一套房子， 他打算出租， 但是带人看了几次房子以后， 发现自己没有那么多时间。 于是他把房子委托给了中介公司小王， 小王帮他带人看房子，然后收取中介费。

在该例子中， 房子是李老板的， 他（RealSubject）将租房子这个权限委托给了小王（Proxy）。

抽象

首先， 抽象出房东这个接口， 而李老板是它的具体实现。

public interface Landlord {
    boolean rental();
}

具体对象

房东是一个抽象意义上的概念， 而李老板， 是一个具有意义上的房东， 我们称之为是房东的一个实现。

public class LandlordImpl implements Landlord {

    public boolean rental() {
        System.out.println("李老板的房子出租啦");
        return true;
    }
}

代理对象

代理代表真实对象的功能以及在此基础上添加访问控制。

那就是中介小王， 他获得了李老板的授权， 可以带人去看房子， 但李老板明确了自己的条件， 房租至少5000， 如果是美女可以考虑降一点（小王就代表李老板进行一些过滤（访问控制））。

如果租客满意了， 打算租房子就跟小王说。 小王当然想租客租给租客， 有佣金嘛。但是， 具体的房子租不租还是要看房东。

我们就可以定义中介小王是房东的代理对象。他代表租房子以及访问控制。

public class LandlordProxy implements Landlord{
    private final Landlord landlord;

    public LandlordProxy(Landlord landlord) {
        this.landlord = landlord;
    }

    public boolean rental() {
        beforeRental();
        if (landlord.rental()) {
            afterRental();
        }
        return false;
    }

    private void afterRental() {
        System.out.println("收取佣金");
    }

    private void beforeRental() {
        System.out.println("带人看房子");
    }
    
}

如果有一天， 李老板觉得一天最多接受 5 次看房。

那显然， 这是需要在小王那进行控制的。那么我们的类就可以这么改

public class LandlordProxy implements Landlord{
    private final Landlord landlord;

    private static final int NUM_ALLOWED = 5;

    private int numPersons = 1;

    public LandlordProxy(Landlord landlord) {
        this.landlord = landlord;
    }

    public boolean rental() {
        if (numPersons < NUM_ALLOWED) {
            System.out.println("今天李老板不接客了");
        } else {
            beforeRental();
            numPersons++;
            if (landlord.rental()) {
                afterRental();
            }
        }

        return false;
    }

    private void afterRental() {
        System.out.println("收取佣金");
    }

    private void beforeRental() {
        System.out.println("带人看房子");
    }

}

代理对象的特征是

1. 和被代理对象实现了同一个接口；
2. 内部含有一个被代理对象的示例；

优点

1. 真实对象可以专注于自己的业务逻辑控制；
2. 非业务逻辑相关的部分， 可以通过代理类来处理；
3. 隐藏了真实的对象， 对外只暴露代理对象。
4. 扩展性：由于实现了相同的接口， 因此被代理对象的逻辑不管如何变化， 代理对象都不需要更改。

使用场合

1. 控制对真实对象的访问；
2. 实现日志记录；
3. 统计对象的访问数量；
4. 等等。

一些思考

在代理对象内部， 真实对象是什么时候被初始化的， 以及初始化的对象是由谁产生的？

在我看过的代码和书籍中， 有如下几种， 对此我也是很困惑， 以下是我的一些见解

不推荐

1. 将真实对象在代理对象构造函数内部初始化出来。

public LandlordProxy() {
    landlord = new LandlordImpl();
}

1. 构造函数不做改变， 在使用方法时

public boolean rental() {
    if(landlord==null){
        landlord = new LandlordImpl(); 
    }
    if (numPersons < NUM_ALLOWED) {
        System.out.println("今天李老板不接客了");
    } else {
        beforeRental();
        numPersons++;
        if (landlord.rental()) {
            afterRental();
        }
    }

    return false;
}

以上两种的思想都是在代理对象内部对真实对象进行初始化， 我个人不是很赞同这种做法。

如果我们代理对象代理的不仅仅是李老板， 又代理了王老板， 那么怎么办？要写两个基本一模一样的代理类？

推荐做法

就是我们使用的， 在构造函数中传入

public LandlordProxy(Landlord landlord) {
        this.landlord = landlord;
}

将真实对象的初始化交给调用者来进行。

这样， 不管是什么老板， 他们可以自己管理自己的租房方法， 但是相同的工作由代理来做， 而只需要一个代理类。实现了代码的复用。

动态代理

如果是一两个方法需要进行代理， 我们使用静态代理那挺好。

但如果我们的接口中有 20 个方法， 每个方法都需要在前后加上前后的逻辑， 比如说记录一下日志。那么， 我们就一直需要做一些重复性的工作， 相同的代码需要写很多遍， 不单单是写的时候痛苦， 后面维护起来也很难受。

基于此， 动态代理诞生了。

在程序运行时运用反射机制动态创建代理类

在 Java 中， 实现动态代理很简单

定义一个实现InvocationHandler的类

如下所示

public class DynamicProxy implements InvocationHandler {

    private Object target;

    public DynamicProxy(Object target) {
        this.target = target;
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println(System.currentTimeMillis() + " 进入了方法");
        // 中间是这个方法
        Object result = method.invoke(target, args);
        System.out.println(System.currentTimeMillis() + " 方法执行完毕");
        return result;
    }
}

target 是我们需要代理的真实对象， 该参数一样建议在构造函数中传入。

实现 invoke 方法，方法内部在前后实现我们需要的逻辑， 中间就是

Object result = method.invoke(target, args);

最后返回 result 即可。

调用定义的类

 public static void main(String[] args) {
    Landlord landlord = new LandloadImpl();
    DynamicProxy dynamicProxy = new DynamicProxy(landlord);
    // 这一步是关键
    Landlord landlordProxy = (Landlord) Proxy.newProxyInstance(
            landlord.getClass().getClassLoader(),
            landlord.getClass().getInterfaces(),
            dynamicProxy
    );
    landlordProxy.rental();
}

其实我们就是要使用 JDK 给我们提供的 newProxyInstance 函数， 该函数返回对应代理的对象的接口， 我们调用相应的方法即可。

优化

newProxyInstance 方法需要传入的参数可以进一步进行优化。

我们在 DynamicProxy方法中， 可以加入该函数。

@SuppressWarnings("unchecked")
public <T> T getProxy() {
    return (T)Proxy.newProxyInstance(
            target.getClass().getClassLoader(),
            target.getClass().getInterfaces(),
            this
    );
}

这样在我们获得代理对象时候就简单很多，main 函数可以改写成这样

public static void main(String[] args) {
    Landlord landlord = new LandloadImpl();
    DynamicProxy dynamicProxy = new DynamicProxy(landlord);
    Landlord landlordProxy = dynamicProxy.getProxy();
    landlordProxy.rental();
}

动态代理为我们带来了方便， 但是呢， JDK 所提供的动态代理， 我们通过 newProxyInstance 函数可以知道， 被代理的对象必须要实现某个接口。

如果我们要代理的对象没有接口怎么办？

后续文章打算讲一下 CGLIB 和 Sping Aop 是怎么为我们打开一个新的世界的。

代理之故事的结局

最后中介小王和李老板的故事结局是怎么样的呢？

程序员小H租了房子， 李老板和小王按规定各付中介费1750， 最后小王、李老板和小H商量了一下， 不走公司的流程， 各付1000元就好了。