大话设计模式——5.代理模式（Proxy Pattern）

1.定义

为其他具体对象提供一种代理用以控制对这个对象的访问，属于结构型模式。
UML图：

2.示例

生活中有许多的代理，如房产中介，房主出售的房子挂在中介处，中介帮忙寻找需要的客户，客户不需要直接接触房主。

1）Subject：房子

public interface House {

    /**
     * 卖房子
     */
    void sell();
}

2）RealSubject：将要出售的别墅

public class Villa implements House {

    @Override
    public void sell() {
        System.out.println("房东出售大别墅");
    }
}

3）Proxy：房产中介（静态代理）

public class HouseProxy implements House {

    private Villa villa = new Villa();

    @Override
    public void sell() {
        findCustomers();
        villa.sell();
    }
    
    private void findCustomers() {
        System.out.println("寻找客户");
    }
}

4）client：客户端运行

public class Main {

    public static void main(String[] args) {
        // 无代理
        House villa = new Villa();
        villa.sell();
        System.out.println("----代理----");
        // 有代理
        House villaProxy = new HouseProxy();
        villaProxy.sell();
    }
}

2.1 采用动态代理

1）JDK动态代理

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


public class JDKHouseProxy implements InvocationHandler {

    // 代理的目标类，运行时进行具体指定
    private Object targetObj;

    public Object newInstance(Object targetObj) {
        // 指定具体的目标类
        this.targetObj = targetObj;

        // 构建目标代理类
        return Proxy.newProxyInstance(targetObj.getClass().getClassLoader(), targetObj.getClass().getInterfaces(), this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("实现jdk动态代理 before");

        // 调用目标类方法
        Object result = method.invoke(targetObj, args);

        System.out.println("实现jdk动态代理 after");

        return result;
    }
}

2）CGLib动态代理

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;


public class CGLibHouseProxy implements MethodInterceptor {

    public Object newInstance(Object targetObj) {

        // 创建代理
        Enhancer enhancer = new Enhancer();
        // 设置目标类为父类
        enhancer.setSuperclass(targetObj.getClass());
        // 设置代理类（回调）
        enhancer.setCallback(this);

        return enhancer.create();
    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("CGLib代理 before ");
        Object result = methodProxy.invokeSuper(o, objects);
        System.out.println("CGLib代理 after ");
        return result;
    }
}

3）运行结果

public class Main {

    public static void main(String[] args) {
        // 无代理
        House villa = new Villa();
        villa.sell();
        System.out.println("----代理----");
        // 有代理
        House villaProxy = new HouseProxy();
        villaProxy.sell();

        // jdk动态代理
        System.out.println("----JDK代理----");
        House jdkHouseProxy = (House) new JDKHouseProxy().newInstance(villa);
        jdkHouseProxy.sell();

        // CGLib代理
        System.out.println("----CGLib代理----");
        House cglibHouseProxy = (House)new CGLibHouseProxy().newInstance(villa);
        cglibHouseProxy.sell();
    }
}

静态代理：由程序或者特定工具生成源代码，在程序编译时已经确定目标类和代理类的关系。容易造成代码冗余，即每个目标类都需要为止创建一个代理类
动态代理：通过java的反射机制在程序运行期间动态的为目标类创建代理类。无需为每个目标类都创建一个代理类，使用更加灵活，具备很好的扩展性

• JDK代理：目标类需要实现一个接口，为spring默认的代理方式。
• CGLib代理：有时候目标类是没有实现接口的，那么就采用改方式进行代理。通过在内存中构建目标类的派生类，继承目标类的方法进行改写。采用继承的方式进行代理，因此如果目标类是final类，或者方法是private、static属性

3.总结

• 无需修改代理的对象源码，符合开闭原则，可使系统具有较好的灵活性和可扩展性
• 可以对代理的具体对象做增强处理，如增加一些功能等
• 增加了系统的复杂性与调用过程的链路

4.代理模式 VS 装饰模式

• 代理模式代理的是具体的对象，可保护目标对象与增强目标对象的功能
• 装饰模式装饰的是一类对象，可对一类具有共同特点的对象进行控制和处理
• 装饰模式适合于需要动态地给对象添加新功能的情况，代理模式适合于需要控制对对象访问的情况。