6、代理模式

代理在日常生活中很常见，比如各种代售点、代购等等，从本质来说，都是为了方便。 Java 代码中的代理不是如此，它主要是为了保护被代理对象以及增强方法功能。

保护体现在客户端不能直接获取目标对象，只能获取代理类，通过代理类访问目标对象，隐藏具体实现细节。增强体现在可以增加部分其它逻辑，如打印日志操作，增强方法，实际上 Spring AOP 就是这样干的。

代理模式分以下几部分组成：

• 抽象主题类：被代理类的抽象接口或抽象类
• 真实主题类：被代理类的具体实现
• 代理类：提供接口，供客户端访问的代理类

具体代码结构：

public class StaticAgency {

    interface Subject {
        void request();
    }

    class RealSubject implements Subject {
        @Override
        public void request() {
            System.out.println("真实方法被调用");
        }
    }

    class Proxy implements Subject {

        private RealSubject realSubject;

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

        private void preRequest() {
            System.out.println("真实方法调用前");
        }

        private void postRequest() {
            System.out.println("真实方法调用前");
        }
    }

}

如上图所示这种代理方式又叫静态代理，它和动态代理的区别如下：

• 静态代理：在编译期就可以确定代理类和主题的对应关系，如上图所示 Proxy 和 RealSubject 在编译器就可以确定
• 动态代理：在运行期手动建立对应关系

采用动态代理可以提高系统的灵活性，可扩展性。Java 代码有两种实现动态代理的方式：

• JDK 动态代理：通过反射实现，必须实现接口
• cglib 动态代理：通过继承实现

关于这块在我的博客 Spring AOP 中有介绍，感兴趣的可以去查一下，这里我简单介绍下原理：

JDK 动态代理基于 InvocationHandler 接口和 Proxy 类实现，InvocationHandler 接口包含 invoke() 方法：

/**
* @param proxy ：生成的代理对象
* @param method：目标对象的方法，通过反射调用
* @param args：目标对象方法的参数
*/
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable 

实现该接口后，调用代理类方法会回调到 invoke() 方法，在 invoke() 方法中通过反射调用主题类方法，实现方法的增强。

代理类 Proxy 一般在回调类中通过如下方法创建：

/**
* @param loader 类加载器，一般传递主题类(被代理类)的类加载器
* @param interfaces 被代理类的接口
* @param h 回调处理句柄
*/
public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)

一般情况下这样使用：

return (主题抽象接口) Proxy.newProxyInstance(target.getClass().getClassLoader(),
											target.getClass().getInterfaces(),
											this);

如上图所示，target 即主题方法实现类，前两个参数分别表示它的类加载器和方法，this 就是上文提到的实现 InvocationHandler 接口的类，也就是将来会回调的类。

总结一下，JDK 动态代理创建回调类，通过它基于反射创建代理类，代理类和主题类实现相同接口，并且句柄回调指向回调类。将来调用主题方法，回调到 invoke() 方法，在 invoke() 方法中实现增强和方法调用，这也是 JDK 动态代理必须实现接口的原因。

cglib 动态代理基于 MethodInterceptor 接口和 Enhancer 类实现，Enhancer 就是具体代理类，MethodInterceptor 接口类似上面提到的 InvocationHandler 接口，通过它完成回调，具体使用如下所示：

Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(target.getClass());
enhancer.setCallback(this);
return (A) enhancer.create();

和 JDK 动态代理类似，target 就是主题类，this 就是回调类。JDK 动态代理基于反射创建实现相同接口的代理类，cglib 通过直接继承主题类实现代理类。Spring AOP 默认有接口用 JDK 动态代理，没有接口用 cglib 动态代理

最后聊聊 AOP，AOP 是一种思想，面向切面编程，是对 OOP 某些方面的增强，主要用于增强方法，如公共的权限校验，日志等操作都可以通过 AOP 实现，最后给出 JDK 动态代理的实现示例方便理解：

// 接口类
public interface ExInterface {
    void execute();
}
// 具体需要加强的类
public class A implements ExInterface{
    public void execute(){
        System.out.println("执行A的 execute 方法...");
    }
}
// 具体代理类
public class JDKProxy implements InvocationHandler{

    private A target;
    
    public JDKProxy(A target){
        this.target=target;
    }

    public ExInterface createProxy(){
        return (ExInterface) Proxy.newProxyInstance(
        target.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
	}

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if("execute".equals(method.getName())) {
            AuthCheck.authCheck();
            Object result = method.invoke(target, args);
            Report.recordLog();
            return result;
        } eles if("delete".equals(method.getName())) {
        } else {
			return method.invoke(target,args);
        }
    }
}
// 如何使用
A a = new A();
JDKProxy jdkProxy = new JDKProxy(a);
ExInterface proxy = jdkProxy.createProxy();
proxy.execute();