JDK动态代理模式

这个笔记是完全摘抄《Java EE互联网轻量级框架整合开发 SSM框架和Redis实现》这本书。

动态代理的意义在于生成了一个占位(也称为代理对象)，来代理真实对象，从而控制真实对象的访问。

概念：

代理，可以理解为我是一个程序员，只会生产代码，不善言谈与商务，而我们自己想扩展业务却不想花费时间与人沟通，这时就想着找一个代理来代替自己来扩展业务，当代理和客户谈妥了之后，再让我这名程序员来做事。

从中可以看出，代理的真实作用是：再真实对象访问之前或者之后加入对应的逻辑，或者根据其他规则控制是否使用真实的对象，而再上述中，就控制了客户对我的访问。

在上面所述中，代理人和程序员是代理和被代理的关系，客户是通过代理人来访问程序员的。此时客户就是程序中的调用者，代理人就是代理对象，程序员就是真实对象。我们需要在调用者调用对象之前产生一个代理对象，而这个代理对象需要和真实对象建立代理关系。所以代理必须分为两个步骤：

    1 代理对象和真实对象建立代理关系

    2 实现代理对象的代理逻辑方法

再java中有许多代理的实现，一般我们最常见到的有两种：JDK动态代理和CGLIB动态代理。

JDK动态代理

JDK动态代理是java.lang.reflect.*包提供的方式，它必须借助一个接口才能产生对象，所以先定义接口：

2.1 定义一个接口：

public interface HelloWorld {
    public void syaHelloWorld();
}

2.2 实现接口：

public class HelloWorldImpl implements HelloWorld{
    @Override
    public void syaHelloWorld() {
        System.out.println("hello world");
    }
}

2.3 实现动态代理绑定和代理逻辑实现

以上实现了Java接口和实现类的关系，此时可以开始动态代理了。首先要建立代理对象和真实服务对象的关系，然后实现代理逻辑，一共分为两个步骤。

在JDK动态代理中，要实现代理逻辑类必须去实现java.lang.refelct.InvocationHandler接口，它里面定义了一个invoke方法，并提供接口数组用于下挂代理对象。

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

public class JdkProxyExample implements InvocationHandler {
    // 真实对象
    private Object target = null;

    /**
     * 建立代理对象和真实对象的代理关系，并返回代理对象
     * @param target   真实对象 
     * @return  代理对象
     */
    public Object bind(Object target){
        this.target = object;
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),this)
    }

    /**
     * 代理方法逻辑
     * @param proxy 代理对象
     * @param method    当前调度的方法
     * @param args  当前方法参数
     * @return  代理结果返回
     * @throws Throwable    异常
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("进入代理逻辑方法");
        System.out.println("在调度真实对象之前的服务");
        Object obj = method.invoke(target,args);// 相当于调用sayHello()方法
        System.out.println("在调度真实对象之后的服务");
        return obj;
    }
}

第一个方法：建立代理对象和真实对象的关系。该方法里的第一个参数用类的属性target保存了真实对象，并通过newPorxyInstance()方法建立并生成代理对象。

  /**
     * 建立代理对象和真实对象的代理关系，并返回代理对象
     * @param target   真实对象
     * @return  代理对象
     */
    public Object bind(Object target){
        this.target = object;
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),
                                        target.getClass().getInterfaces(),this)
    }

newProxyInstance方法有三个参数：

    第一个是类加载器，采用target本身的类加载器。

    第二个参数是把生成的动态代理对象下挂到哪些接口下，这个写法是放在target实现的接口下。

    第三个是定义实现方法逻辑的代理类，this表示当前对象，它必须实现InvocationHandler接口的invoke方法，它就是代理逻辑方法的实现方法。

第二个方法：实现代理逻辑方法。invoke方法可以实现代理逻辑，invoke方法的3个参数的含义如下所示：

     proxy,代理对象，就是bind方法生成的对象

     methods，当前调度的方法

    args，调度方法的参数

    当我们使用了代理对象调度方法后，它就会进入到invoke方法里面。

  @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("进入代理逻辑方法");
        System.out.println("在调度真实对象之前的服务");
        Object obj = method.invoke(target,args);// 相当于调用sayHello()方法
        System.out.println("在调度真实对象之后的服务");
        return obj;
    }

   Object obj = method.invoke(target,args)；

这行代码相当于调度真实对象的方法，只是通过发射技术实现而已。

类比前面的例子，proxy相当于代理人，target就是程序猿，bind方法就是建立代理人和程序猿代理关系的方法。而invoke就是商务逻辑，它控制了对程序猿的访问。

接下来就开始测试JDK动态代理

public static void main(String[] args) {
    JdkProxyExample jdk = new JdkProxyExample();
    // 绑定关系，因为挂在接口HelloWorld下，所以声明代理对象HelloWorld proxy
    HelloWorld proxy = (HelloWorld)jdk.bind(new HelloWorldImpl());
    // 注意，此时HelloWorld对象已经是一个代理对象，它会进入代理的逻辑方法invoke里
    proxy.syaHelloWorld();
}

运行结果如下：

进入代理逻辑方法
在调度真实对象之前的服务
hello world
在调度真实对象之后的服务