Java设计模式(二) JDK动态代理

1.什么是代理模式？

    假如你的公司是一家软件公司，你是一位软件工程师。客户带着需求去找公司显然不会直接去找你，而是去找商务，此时客户会认为商务就代表公司

客户 ——>商务（代理对象）——>软件工程师（真实对象）

综上，商务和软件工程师就是代理和被代理的关系，客户是经过商务去访问软件工程师的，商务就是代理对象，软件工程师真实对象。我们需要在调用者调用对象之前产生一个代理对象，而这个代理对象需要和真实的对象建立代理关系。代理必须分为两步：

• 代理对象和真实对象建立代理关系
• 实现代理对象的代理逻辑方法
  

2.JDK动态代理

       JDK动态代理是由java.lang.reflect.*包提供的。它必须借助一个接口才能产生代理对象，因此首先编写一个接口和它的实现类。

//必须经过接口才能产生代理对象
public interface LaoZong {
    public void eat();
    public void sleep();
}

public class LaoZongImpl implements LaoZong {
    public void eat() {
        System.out.println("吃饭");
    }

    public void sleep() {
        System.out.println("睡觉！");
    }
}

   这里的LaoZongImpl 就是真正要访问的对象。

   有了接口和实现类就可以开始动态代理了。使用JDK动态代理必须要去实现java.lang.reflect.InvocationHandler，它里面只有一个invoke方法，并提供接口数组用于下挂代理对象。

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
 * **这就是一个代理对象
 *  建立起真实对象和代理对象之间的关系
 */
public class Mishu implements InvocationHandler {

    //真实的对象
    private Object target;

    /**
     * 建立代理对象和真实对象之间的关系，返回代理对象
     * @param target 真实的对象
     * @return 代理对象
     */
    public Object bind(Object target){
        this.target = target;
        return Proxy.newProxyInstance( target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                this);
    }
    /**
     *  代理逻辑方法
     * @param proxy 代理对象，就是bind生成的对象
     * @param method    当前调度方法
     * @param args  当前方法参数
     * @return  代理结果返回
     * @throws Throwable
     */
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("进入代理逻辑方法");
        System.out.println("在调度真实对象之前的服务");

        Object object = method.invoke( target,args );//相当于调用eat和sleep方法
        System.out.println(method);
        System.out.println("在调度真实对象之后的服务");
        return object;
    }
}

第一步，建立代理和真实对象的关系。这里使用bind方法完成的。这里的target就是真实对象。通过以下代码建立代理对象。

Proxy.newProxyInstance( target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                this);

这里的newProxyInstance方法包含三个参数

• 第一个是类加载器，采用target本身的类加载器
• 第二个是把生成的动态代理对象挂在哪些接口下。这个写法就是挂在target实现的接口下。
• 带三个是实现方法逻辑的代理类，this表示当前对象，它必须实现InvocationHandler接口的Invoke方法，它就是代理逻辑方法的实现方法。

第二步 实现代理逻辑方法。invoke方法可以实现代理逻辑。

 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        
        Object object = method.invoke( target,args );//相当于调用eat和sleep方法
        
        return object;
    }

• proxy，代理对象，bind方法生成的对象
• method，当前调度的方法
• args，调度方法的参数

 Object object = method.invoke( target,args )

上面这串代码相当于调度真实对象的方法，只不过是使用的反射而已。
测试代码：

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

输出结果：

进入代理逻辑方法
在调度真实对象之前的服务
睡觉！
public abstract void com.wanfei.service.LaoZong.sleep()
在调度真实对象之后的服务