静态代理和动态代理

@

代理模式(静态代理)

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

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

代理模式

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元就好了。

posted @ 2018-09-03 21:58 阿进的写字台 阅读(...) 评论(...) 编辑 收藏