Java编程思想读书笔记--第14章类型信息

7.动态代理

　　代理是基本的设计模式之一，它是你为了提供额外的或不同的操作，而插入的用来代替“实际”对象的对象。这些操作通常涉及与“实际”对象的通信，因此代理通常充当着中间人的角色。

　　什么是代理模式？

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

　　代理模式有什么好处？

　　在某些情况下，一个客户不想或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。

　　代理模式一般涉及到的角色有：

　　抽象角色：声明真实对象和代理对象的共同接口,这样一来在任何可以使用目标对象的地方都可以使用代理对象。

　　代理角色：代理对象内部含有目标对象的引用，从而可以在任何时候操作目标对象；代理对象提供一个与目标对象相同的接口，以便可以在任何时候替代目标对象。代理对象通常在客户端调用传递给目标对象之前或之后，执行某个操作，而不是单纯地将调用传递给目标对象，同时，代理对象可以在执行真实对象操作时，附加其他的操作，相当于对真实对象进行封装。

　　真实角色：定义了代理对象所代表的目标对象，代理角色所代表的真实对象，是我们最终要引用的对象,定义了代理对象所代表的目标对象。

public interface AbstractObject {
    public void doSomething();
}

public class RealObject implements AbstractObject {
    public void doSomething() {
        System.out.println("doSomething");
    }
}

public class ProxyObject implements AbstractObject{
    private AbstractObject abstractObject;
    public ProxyObject(AbstractObject abstractObject){
        this.abstractObject = abstractObject;
    }
    public void doSomething() {
        System.out.println("Proxy doSomething");
        abstractObject.doSomething();
    }
}

public class PorxyDemo {
    public static void main(String[] args) {
        new ProxyObject(new RealObject()).doSomething();
    }
}

　

　　Java的动态代理比代理的思想更向前迈进了一步，代理类是在程序运行时动态生成的。

　　动态代理的优势

　　动态代理的优势在于可以方便的对代理类的函数进行统一的处理，而不用修改代理类的每个函数。

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

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

　　当我们调用代理类对象的方法时，这个调用会转送到invoke方法中，代理类对象作为proxy参数传入，参数method标识了我们具体调用的是代理类的哪个方法，args为这个方法的参数。这样一来，我们对代理类中的所有方法的调用都会变成对invoke的调用，这样我们可以在invoke方法中添加统一的处理逻辑（也可以根据method参数对不同的代理类方法做不同的处理）。我们调用Proxy类的newProxyInstance方法获取一个代理类实例，这个代理类实现了指定的接口并且会把方法调用分发到指定的调用处理器。

public interface AbstractObject {
    public void doSomething();
    public void doOtherThing();
}

public class RealObject implements AbstractObject {
    public void doSomething() {
        System.out.println("doSomething");
    }
    public void doOtherThing() {
        System.out.println("doOtherThing");
    }
}

public class DynamicProxyHandler implements InvocationHandler{
    private AbstractObject abstractObject;
    public DynamicProxyHandler(AbstractObject abstractObject) {
        this.abstractObject = abstractObject;
    }
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        System.out.println("before");
        Object result = method.invoke(abstractObject, args);
        System.out.println("after");
        return result;
    }
}

public class DynamicProxyDemo {
    public static void main(String[] args) {
        DynamicProxyHandler dynamicProxyHandler = new DynamicProxyHandler(new RealObject());
        AbstractObject proxy = (AbstractObject) Proxy.newProxyInstance(AbstractObject.class.getClassLoader(), new Class[]{AbstractObject.class}, dynamicProxyHandler);
        proxy.doSomething();
        proxy.doOtherThing();
    }
}

　　 动态代理小结

　　首先通过newProxyInstance方法获取代理类实例，而后通过这个代理类实例调用代理类的方法，该调用会被转发给中介类的invoke方法，在invoke方法中我们调用委托类的相应方法，并且可以添加自己的处理逻辑。

　　

转载于:https://www.cnblogs.com/yumo/p/6131076.html