java动态代理之自我理解

动态代理
首先看代理两字，一般生活中所理解的代理就是，我给厂家代理卖东西，有人来我这买，他看不到后面的厂家的，意思就是他不知道厂家，不知道委托人，然后我做代理，我的客户都是我的朋友，所以又给过滤了一边客户。
那么有动态代理就有静态代理
静态代理就是在程序运行之前就存在的。
实现同一个接口

public interface Sell {
    void sell();
    void ad();
}

厂商类

public class Vendor implements Sell {
    public void sell() {
        System.out.println("In sell method");
    }
    public void ad() {
        System,out.println("ad method")
    }
}

代理类

public class BusinessAgent implements Sell {
    private Vendor mVendor;

    public BusinessAgent(Vendor vendor) {
        mVendor = vendor;
    }

    public void sell() { mVendor.sell(); }
    public void ad() { mVendor.ad(); }
}

现在一个需求，让这个代理只卖东西给小姑娘
我们就不用改厂商的代码了
改businessagent的就可以了。

    public void sell() {
        if (isgirl()) {
            vendor.sell();
        }
    }

这就是代理模式第一个优点：实现客户和厂商之间的解耦。能够做一些额外的处理，然而静态代理的模式的局限性就是运行之前必须编好代理类,

那么动态代理就很不错了。
假设我们要实现这样一个需求：在执行委托类中的方法之前输出“before”，在执行完毕后输出“after”。 只要在vendor.sell() 方法前后加上before after就好了。可是如果有上百个方法那不是要累死？

使用动态代理

（1）InvocationHandler接口

在使用动态代理时，我们需要定义一个位于代理类与委托类之间的中介类，这个中介类被要求实现InvocationHandler接口，这个接口的定义如下：

public interface InvocationHandler {
    Object invoke(Object proxy, Method method, Object[] args);
}

从InvocationHandler这个名称我们就可以知道，实现了这个接口的中介类用做“调用处理器”。当我们调用代理类对象的方法时，这个“调用”会转送到invoke方法中，代理类对象作为proxy参数传入，参数method标识了我们具体调用的是代理类的哪个方法，args为这个方法的参数。这样一来，我们对代理类中的所有方法的调用都会变为对invoke的调用，这样我们可以在invoke方法中添加统一的处理逻辑（也可以根据method参数对不同的代理类方法做不同的处理）。因此我们只需在中介类的invoke方法实现中输出“before”，然后调用委托类的invoke方法，再输出“after”。下面我们来一步一步具体实现它。

（2）委托类的定义

动态代理方式下，要求委托类必须实现某个接口，这里我们实现的是Sell接口。委托类Vendor类的定义如下：

public class Vendor implements Sell {
    public void sell() {
        System.out.println("In sell method");
    }
    public void ad() {
        System,out.println("ad method")
    }
}

（3）中介类

上面我们提到过，中介类必须实现InvocationHandler接口，作为调用处理器”拦截“对代理类方法的调用。中介类的定义如下：

public class DynamicProxy implements InvocationHandler {
    private Object obj; //obj为委托类对象；

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

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("before");
        Object result = method.invoke(obj, args);
        System.out.println("after");
        return result;
    }
}

从以上代码中我们可以看到，中介类持有一个委托类对象引用，在invoke方法中调用了委托类对象的相应方法（第11行），看到这里是不是觉得似曾相识？通过聚合方式持有委托类对象引用，把外部对invoke的调用最终都转为对委托类对象的调用。这不就是我们上面介绍的静态代理的一种实现方式吗？实际上，中介类与委托类构成了静态代理关系，在这个关系中，中介类是代理类，委托类就是委托类；

代理类与中介类也构成一个静态代理关系，在这个关系中，中介类是委托类，代理类是代理类。也就是说，动态代理关系由两组静态代理关系组成，这就是动态代理的原理。下面我们来介绍一下如何”指示“以动态生成代理类。