设计模式 动态代理模式

目录

1.JDK动态代理

2.CGLIB动态代理

---

动态代理的意义在于生成一个占位（又称代理对象），来代理真实对象，从而控制真实对象的访问。

商务和软件工程师是代理和被代理的关系，客户是经过商务去访问软件工程师的。此时客户就是程序中的调用者，商务就是代理对象，软件工程师就是真实对象。我们需要在调用者调用对象乙前产生一个代理对象，而这个代理对象需要和真实对象建立代理关系，所以代理必须分为两个步骤：
    ·代理对象和真实对象建立代理关系。
    ·实现代理对象的代理逻辑方法。
在Java中有多种动态代理技术，比如JDK、CGLIB、Javassist、ASM，其中最常用的动态代理技术有两种：一种是JDK动态代理，这是JDK自带的功能；另一种是CGLIB，这是第三方提供的一个我术。目前，Spring常用JDK和CGLIB，而MyBatis 还使用了Javassist，无论哪种代理其技术，它们的理念都是相似的。
两种最常用的动态代理技术：JDK和CGLIB。在JDK动态代理中，我们必须使用接口，而CGLIB不需要，所以使用CGLIB会更简单一些。下面依次讨论这两种最常用的动态代理。

1.JDK动态代理

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

package com.learn.proxy;

public interface HelloWorld {
    public void sayHelloWorld();
}

 然后提供实现类HelloWordlmpl来实现接口

package com.learn.proxy;

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

 这是最简单的Java接口和实现类的关系，此时可以开始动态代理了。按照我们之前的分析，先要建立起代理对象和真实服务对象的关系，然后实现代理逻辑，所以一共分为两个步骤。
在JDK动态代理中，要实现代理逻辑类必须去实现java.lang.reflect.InvocationHandler接口，它里面定义了一个invoke方法，并提供接口数组用于下挂代理对象

package com.learn.proxy;

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=target;
        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);
        System.out.println("在调度真实对象之后的服务");
        return obj;
    }
}

 第1步，建立代理对象和真实对象的关系。这里是使用了bind方法去完成的，方法里面首先用类的属性target保存了真实对象，然后通过如下代码建立并生成代理对象。

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

其中newProxyInstance方法包含3个参数。
    ·第1个是类加载器，我们采用了target 本身的类加载器。
    ·第2个是把生成的动态代理对象下挂在哪些接口下，这个写法就是放在target实现的接口下。HelloWorldlmpl对象的接口显然就是HelloWorld，代理对象可以这样声明：HelloWorld proxy=xxxx；。
    ·第3个是定义实现方法逻辑的代理类，this表示当前对象，它必须实现InvocationHandler 接口的invoke方法，它就是代理逻辑方法的现实方法。
第2步，实现代理逻辑方法。invoke方法可以实现代理逻辑，invoke方法的3个参数的含义如下所示。
    ·proxy，代理对象，就是bind方法生成的对象。

    ·method，当前调度的方法。
    ·args，调度方法的参数。
当我们使用了代理对象调度方法后，它就会进入到invoke方法里面。

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

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

测试

package com.learn.proxy;

public class Test {

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

    public static void main(String[] args) {
        testJdkProxy();
    }
}

 首先通过bind方法绑定了代理关系，然后在代理对象调度sayHelloWorld 方法时进入了代理的逻辑，测试结果如下：

 

2.CGLIB动态代理

JDK动态代理必须提供接口才能使用，在一些不能提供接口的环境中，只能采用其他第三方技术，比如CGLIB动态代理。它的优势在于不需要提供接口，只要一个非抽象类就能实现动态代理。

package com.learn.reflect;

public class ReflectServiceImpl {
    public void sayHello(String name) {
        System.err.println("Hello " + name);
    }
}

选取ReflectServicelmpl类作为例子，它不存在实现任何接口，所以没办法使用JDK动态代理，这里采用CBLIB动态代理技术

package com.learn.proxy;


import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

public class CglibProxyExample implements MethodInterceptor {
    /**
    * 生成cglib代理对象
    * */
    public Object getProxy(Class cls){
        //CGLIb enhancer增强类对象
        Enhancer enhancer=new Enhancer();
        //设置增强类型
        enhancer.setSuperclass(cls);
        //定义代理逻辑对象为当前对象，要求当前对象实现MethodInterceptor方法
        enhancer.setCallback(this);
        //生成并返回代理对象
        return enhancer.create();
    }

    /**
     * 代理逻辑方法
     * @param proxy 代理对象
     * @param  method 方法
     * @param  args 方法参数
     * @param methodProxy 方法代理
     * @return 代理逻辑返回
     * @throws Throwable 异常
    * */
    @Override
    public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        System.err.println("调用真实对象前");
        //CGLIB反射调用真实对象方法
        Object result=methodProxy.invokeSuper(proxy,args);
        System.err.println("调用真实对象后");
        return result;
    }

}

这里用了CGLIB的加强者Enhancer，通过设置超类的方法（setSuperclass），然后通过setCallback方法设置哪个类为它的代理类。其中，参数为this就意味着是当前对象，那就要求用this 这个对象实现接口Methodlnterceptor的方法—intercept，然后返回代理对象。
那么此时当前类的intercept方法就是其代理逻辑方法，其参数内容见代注解，我们在反射真实对象方法前后进行了打印，CGLIB是通过如下代码完成的。

Object result=methodProxy.invokeSuper(proxy,args);

测试CGLIB动态代理

public static void testCGLIBProxy(){
        CglibProxyExample cpe=new CglibProxyExample();
        ReflectServiceImpl obj= (ReflectServiceImpl) cpe.getProxy(ReflectServiceImpl.class);
        obj.sayHello("aaa");
    }

测试结果

掌握了JDK动态代理就很容易掌握CGLIB动态代理，因为二者是相似的。它们都是用getProxy方法生成代理对象，制定代理的逻辑类。而代理逻辑类要实现一个接口的一个方法，那么这个接口定义的方法就是代理对象的逻辑方法，它可以控制真实对象的方法。

注：需要导入包

asm-5.0.4.jar
cglib-3.2.5.jar