【23设计模式】代理模式及其应用

通过操作代理对象来调用目标类，这样就可以实现调用者和目标对象的解耦合。

应用场景：AOP 的实现、RPC 远程调用、Java 注解对象获取、日志框架、全局性异常处理、事务处理等。

代理的类型

静态代理

public interface Subject {
    void request();
}

// 真实类
public class RealSubject implements Subject {
    @Override
    public void request() {
        System.out.println("访问真实主题方法...");
    }
}

// 代理类
public class SubProxy implements Subject {

    /**
     * 真实对象 （将真实对象委托给代理对象）
     */
    private RealSubject realSubject;

    @Override
    public void request() {
        if(realSubject == null){
            realSubject = new RealSubject();
        }
        preRequest();
        realSubject.request();
        postRequest();
    }

    // 方法增强
    public void preRequest() {
        System.out.println("访问真实主题之前的预处理。");
    }
    public void postRequest() {
        System.out.println("访问真实主题之后的后续处理。");
    }
}

public static void main(String[] args) {
    SubProxy proxy = new SubProxy();
    proxy.request();
}

动态代理（JDK）

public interface AbstractSubject {
    void request();
}

public class RealSubA implements AbstractSubject {
    @Override
    public void request() {
        System.out.println("A对象被代理");
    }
}

public class RealSubB implements AbstractSubject {
    @Override
    public void request() {
        System.out.println("B对象被代理");
    }
}

// 代理类
public class DynamicProxy implements InvocationHandler {

    private Object obj;

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

    @Override
    public Object invoke(Object o, Method m, Object[] args) throws InvocationTargetException, IllegalAccessException {
        m.invoke(obj, args);
        return null;
    }
}

实现InvocationHandler接口，即可被定义为代理类，核心方法invoke()有三个参数

• Object proxy: 动态代理对象
• Method method: 表示最终要执行的方法，真正的目标方法
• Object[] args:向目标方法传递的参数

public static void main(String[] args) {

    InvocationHandler handler = new DynamicProxy(new RealSubA());

    //        ClassLoader classLoader = AbstractSubject.class.getClassLoader();
    //        System.out.println(classLoader);
    //
    //        Class<?>[] interfaces = AbstractSubject.class.getInterfaces();
    //        System.out.println(Arrays.toString(interfaces));

    AbstractSubject subject = (AbstractSubject) Proxy.newProxyInstance(
        AbstractSubject.class.getClassLoader(),
        new Class[]{AbstractSubject.class},
        handler);
    
    subject.request();
}

要用 JDK 动态代理的话，就需要知道目标对象的类加载器、目标对象的接口、目标对象是谁

Proxy.newProxyInstance()方法就是将目标对象绑定到代理类上去

简单解析

动态代理的优势在于能够很方便的对代理类中方法进行集中处理，而不用修改每个被代理的方法。因为所有被代理的方法（真正执行的方法）都是通过在 InvocationHandler 中的 invoke 方法调用的。所以我们只需要对 invoke 方法进行集中处理。

基础补充：反射

在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；

Class类对象的实例化

Class.forname("com.xxx.xxx.xx") // 完整的包路径名
对象.getClass();
类.class

Class<?> aClass = Class.forName("com.algebra.common.login.LoginPerson");
Class<LoginPerson> loginPersonClass = LoginPerson.class;
LoginPerson p = new LoginPerson();
Class<? extends LoginPerson> pClass = p.getClass();

Class类

Construct类

Annotation类

Method类

Field类

代理实现方式

JDK

JDK代理是不需要依赖第三方的库，只要JDK环境就可以进行代理，需要满足以下要求：

• 实现InvocationHandler接口，重写invoke()

• 使用Proxy.newProxyInstance()产生代理对象

• 被代理的对象必须要实现接口

实现方式见上述《动态代理（JDK）》

CJLIB

CGLib 必须依赖于CGLib的类库,需要满足以下要求：

• 实现MethodInterceptor接口，重写intercept()

• 使用Enhancer对象.create()产生代理对象

import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

public class CjDynamicProxy implements MethodInterceptor {

    private Object obj;

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

    @Override
    public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        return method.invoke(obj, args);
    }
}

import org.springframework.cglib.proxy.Enhancer;

public static void main(String[] args) {
    
    // 代理类class文件存入本地磁盘方便我们反编译查看源码
    System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "./code");
    
    CjDynamicProxy proxy = new CjDynamicProxy(new RealSubA());
    Enhancer enhancer = new Enhancer();
    enhancer.setCallback(proxy);
    enhancer.setSuperclass(AbstractSubject.class);
    AbstractSubject realA = (AbstractSubject) enhancer.create();
    realA.request();
}

区分

• 如果目标对象实现了接口，默认情况下会采用JDK的动态代理实现AOP，可以强制使用CGLIB实现AOP
• 如果目标对象没有实现了接口，必须采用CGLIB库，spring会自动在JDK动态代理和CGLIB之间转换

Mybatis中的动态代理

public class MapperProxy<T> implements InvocationHandler, Serializable {
	// ...

public class MapperProxyFactory<T> {
	// ...