Java常用设计模式--代理模式（Proxy Pattern）

所谓代理模式是指客户端并不直接调用实际的对象，而是通过调用代理，来间接的调用实际的对象。代理模式（Proxy Pattern）属于结构型模式。

代理模式中的角色

1. 抽象对象角色(AbstractObject)：声明了目标对象和代理对象的共同接口，这样依赖在任何可以使用目标对象的地方都可以使用代理对象。
2. 目标对象角色(RealObject)：定义了代理对象所代表的目标对象。
3. 代理对象角色(ProxyObject)：代理对象内部含有目标对象的引用，从而可以在任何时候操作目标对象；代理对象提供一个与目标对象相同的接口，以便可以在任何时候替代目标对象。代理对象通常在客户端调用传递给目标对象之前或者之后，执行某个操作，而不是单纯的将调用传递给目标对象。

 举个例子：

你想喝奶茶，但是你不想自己去奶茶店买，而是找了外卖小哥送，这就是代理模式

 静态代理

package com.example.proxy;

/**
 * 抽象对象角色 奶茶
 */
public interface BuyMilkyTea {

    void buyMilkyTea();

}

package com.example.proxy;

/**
 * 目标对象角色 我
 */
public class MyPeople implements BuyMilkyTea {
    @Override
    public void buyMilkyTea() {
        System.out.println("我拿到奶茶");
    }
}

package com.example.proxy;

/**
 * 代理对象角色 外卖小哥
 */
public class TakeOutPeople implements BuyMilkyTea {

    private BuyMilkyTea buyMilkyTea;

    public TakeOutPeople(BuyMilkyTea buyMilkyTea) {
        this.buyMilkyTea = buyMilkyTea;
    }

    @Override
    public void buyMilkyTea() {
        System.out.println("配送前操作，取奶茶");
        buyMilkyTea.buyMilkyTea();
        System.out.println("配送后操作，确认送达");
    }
}

package com.example.proxy;

public class Test {

    public static void main(String[] args) {

        MyPeople myPeople = new MyPeople();
        TakeOutPeople takeOutPeople = new TakeOutPeople(myPeople);
        takeOutPeople.buyMilkyTea();
    }

}

缺点:
　　代理类和委托类实现相同的接口，同时要实现相同的方法。这样就出现了大量的代码重复。如果接口增加一个方法，除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法。增加了代码维护的复杂度。

动态代理

动态代理有别于静态代理，是根据代理的对象，动态创建代理类。这样，就可以避免静态代理中代理类接口过多的问题。动态代理是实现方式，是通过反射来实现的，借助Java自带的java.lang.reflect.Proxy,通过固定的规则生成。
其步骤如下：

1. 编写一个委托类的接口，即静态代理的抽象对象角色(AbstractObject)
2. 实现一个真正的委托类，即静态代理的目标对象角色(RealObject)：
3. 创建一个动态代理类，实现InvocationHandler接口，并重写该invoke方法
4. 在测试类中，生成动态代理的对象。

 

package com.example.dynamicproxy;

/**
 * 抽象对象角色 奶茶
 */
public interface BuyMilkyTea {

    void buyMilkyTea();

}

package com.example.dynamicproxy;

/**
 * 目标对象角色 我
 */
public class MyPeople implements BuyMilkyTea {
    @Override
    public void buyMilkyTea() {
        System.out.println("我拿到奶茶");
    }
}

package com.example.dynamicproxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

/**
 * 动态代理类
 */
public class DynamicTakeOutPeople implements InvocationHandler {

    private Object object;

    public DynamicTakeOutPeople(Object object) {
        this.object = object;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object invoke = method.invoke(object, args);
        return invoke;
    }
}

package com.example.dynamicproxy;

import java.lang.reflect.Proxy;

public class Test {

    public static void main(String[] args) {

        MyPeople myPeople = new MyPeople();
        DynamicTakeOutPeople dynamicTakeOutPeople = new DynamicTakeOutPeople(myPeople);
        ClassLoader classLoader = dynamicTakeOutPeople.getClass().getClassLoader();
        BuyMilkyTea buyMilkyTea = (BuyMilkyTea)Proxy.newProxyInstance(classLoader, new Class[]{BuyMilkyTea.class}, dynamicTakeOutPeople);
        buyMilkyTea.buyMilkyTea();
    }

}