设计模式之代理模式

代理模式

代理模式（Proxy Pattern）给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用，也就是说，代理对象在客户端和目标对象之间起到中介作用，我们在访问实际对象时，是通过代理对象访问的。

代理模式属于结构型设计模式，使用代理模式主要有两个目的：意识保护目标对象，二是增强目标对象。

代理模式的实现主要有两种：静态代理和动态代理。

一、静态代理

静态代理，在程序编译时各个接口、被代理类、代理类等已经确定下来，在程序运行之前就已经生成了代理类的.class文件。

静态代理的实现：

假设一个场景，我是一个实习生，我实习的时候要租房子，但是我不会自己去找房子，而是通过中介代理自己去找房子。

// 创建Person接口
public interface Person {
    // 租房子
    public void rent();
}

// 实习生，真正要租房子的人
public class Trainee implements Person {
    @Override
    public void rent() {
        System.out.println("实习生：我要租房子！");
    }
}

// 中介，代理实习生去找房子
public class Agent implements Person {
    // 被代理的实习生
    private Trainee trainee;
    public Agent(Trainee trainee) {
        this.trainee = trainee;
    }

    @Override
    public void rent() {
        this.trainee.rent();
        System.out.println("中介：我帮实习生找房子");
    }
}

// 客户端测试
public class Test {
    public static void main(String[] args) {
        // 创建一个实习生对象，这个实习生要租房子
        Trainee trainee = new Trainee();

        // 实习生不会自己去找房子，而是通过中介去找房子
        Agent agent = new Agent(trainee);

        // 中介代理实习生去找房子
        agent.rent();
    }
}

这就是静态代理的实现，程序在运行之前我们已经将所有的接口、被代理类、代理类都写好了，没有动态生成.class文件。

二、动态代理

动态代理和静态代理最大的不同点就是，在动态代理中，代理类是在程序运行时动态创建的，优势在于可以很方便的对代理类的函数进行统一的处理，而不用修改每个代理类中的方法。

动态代理有两种实现方式：JDK动态代理和CGLib动态代理，其真正的实现方式和源码有关，比较复杂，这里不予分析。

还是以上面租房子的场景为例。

JDK动态代理

// 创建Person接口
public interface Person {
    // 租房子
    public void rent();
}

// 实习生，真正要租房子的人
public class Trainee implements Person {
    @Override
    public void rent() {
        System.out.println("实习生：我要租房子！");
    }
}

// JDK动态代理，在InvocationHandler中，传入一个被代理对象，在通过代理对象执行方法时，在该类中会通过invoke()方法去执行被代理对象的方法
public class TraineeInvocationHandler implements InvocationHandler {
    // 被代理的对象
    private Object target;
    public Object getInstance(Object target) {
        this.target = target;
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 被代理的对象执行需要执行的方法
        Object res = method.invoke(this.target, args);
        System.out.println("中介帮忙找房子...");
        return res;
    }
}

// 客户端测试
public class Test {
    public static void main(String[] args) {
        // 给一个目标对象，生成一个代理对象
        Person agent = (Person) new TraineeInvocationHandler().getInstance(new Trainee());
        // 通过代理对象去租房子
        agent.rent();
    }
}

CGLib动态代理

// 创建Person接口
public interface Person {
    // 租房子
    public void rent();
}

// 实习生，真正要租房子的人
public class Trainee implements Person {
    @Override
    public void rent() {
        System.out.println("实习生：我要租房子！");
    }
}

// CGLib动态代理，需要自行导入cglib和asm的jar包
public class TraineeMethodInterceptor implements MethodInterceptor {
    // 将目标对象的class传进来，获取代理对象
    public Object getInstance(Class<?> clazz) {
        Enhancer enhancer = new Enhancer();
        // 要把哪个设置为即将生成新类的父类
        enhancer.setSuperclass(clazz);
        enhancer.setCallback(this);
        return enhancer.create();
    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        Object res = methodProxy.invokeSuper(o, objects);
        System.out.println("中介找房子...");
        return res;	
    }
}

// 客户端测试
public class Test {
    public static void main(String[] args) {
        Person agent = (Person) new TraineeMethodInterceptor().getInstance(Trainee.class);
         agent.rent();
    }
}

JDK动态代理和CGLib动态代理对比

1. JDK代理动态生成的类实现了被代理类实现的接口，CGLib代理动态生成的类继承了被代理对象类；
2. JDK代理和CGLib代理都在运行期生成字节码，JDK代理直接写Class字节码，CGLib代理使用ASM框架写Class字节码，CGLib代理实现更复杂，生成代理类比JDK代理效率低；
3. JDK代理调用代理方法是通过反射机制调用的，CGLib代理时通过FastClass机制直接调用方法的，CFLib代理的执行效率更高。

FastClass机制；为代理类和被代理类各生成一个类，这个类会为代理类或被代理类的方法分配一个index（int类型），这个index当作一个入参，FastClass就可以直接定位要调用的方法直接进行调用，省去了反射调用，所以调用效率比JDK代理通过反射调用高。

参考文章：
https://blog.csdn.net/xiaofeng10330111/article/details/105633821
《SPRING5 核心原理与手写30个类实战》