SpringAOP之我的理解（一）------动态代理

概念

代理，概念并不陌生，因为在日常生活中就有鲜明的例子。比如销售中间商，我们可能无法直接联系造产品的厂家，只能找到中间商，我们就一样可以拿到我们需要的产品，这个中间商本质上就是个代理。返回来，程序中的代理模式，其实就是现实中的写照。代理的定义，就是为一个对象提供一种代理以控制对这个对象的访问。

分类

• 静态代理
  静态代理，就是编译之前就已经写好的代理类；
• 动态代理
  动态代理，就是运行时通过反射的机制动态的创建的代理类；

动态代理分类

动态代理分为两类，JDK动态代理和CGLIB动态代理，使用场景：

• JDK动态代理
  被代理的目标类至少实现了一个接口；
• CGLIB动态代理
  被代理的类没有实现接口，当然实现了接口的场合也可以；

JDK动态代理

下面将以一个小的示例来说明JDK动态代理的整个过程，示例如下：

步骤一，创建目标接口，即被代理的接口

package com.silence.spring.proxy.jdk.bussiness;

public interface TargetInterface {

    void methodA();

}

步骤二，创建目标类，即被代理的接口的实现类

package com.silence.spring.proxy.jdk.bussiness.impl;

import com.silence.spring.proxy.jdk.bussiness.TargetInterface;

public class TargetImpl implements TargetInterface {

    public void methodA() {

        System.out.println("invoke methodA");

    }

}

步骤三，创建代理处理器类

package com.silence.spring.proxy.jdk.handler;

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

public class ProxyInvokeHandler implements InvocationHandler {

    private Object target;

    public ProxyInvokeHandler(Object target) {

        this.target = target;

    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        System.out.println("start invoke");

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

        System.out.println("finish invoke");

        return obj;

    }

}

步骤四，创建测试类

package com.silence.spring.proxy.jdk.test;

import com.silence.spring.proxy.jdk.bussiness.TargetInterface;
import com.silence.spring.proxy.jdk.bussiness.impl.TargetImpl;
import com.silence.spring.proxy.jdk.handler.ProxyInvokeHandler;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;

public class Test {

    public static void main(String[] args) {
        //创建一个被代理对象的实例，作为代理类调用时的具体对象
        TargetImpl target = new TargetImpl();
        //创建代理处理器对象的实例
        InvocationHandler invokeHandler = new ProxyInvokeHandler(target);
        //动态生成了一个代理类，代理类也同样实现了被代理的接口
        TargetInterface targetInterface = (TargetInterface) Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(), invokeHandler);
        //调用接口的方法，等同于调用代理类对应的方法
        targetInterface.methodA();

    }

}

步骤五，输出测试结果，证实代理成功

start invoke
invoke methodA
finish invoke

CGLIB动态代理

下面将以一个小的示例来说明CGLIB动态代理的整个过程，示例如下：

步骤一，创建目标类，即被代理的类

package com.silence.spring.proxy.cglib.bussiness;

public class CglibTargetImpl {

    public void methodA() {

        System.out.println("invoke method");

    }

}

创建代理处理器类

package com.silence.spring.proxy.cglib.handler;

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

import java.lang.reflect.Method;
import java.util.concurrent.ConcurrentHashMap;

public class ProxyHandler implements MethodInterceptor {

    private static ConcurrentHashMap<Class, Object> map = new ConcurrentHashMap<Class, Object>();

    public static <T> T getProxy(Class<T> clazz) {

        if (!map.containsKey(clazz)) {
            Enhancer enhancer = new Enhancer();

            enhancer.setSuperclass(clazz);
            enhancer.setCallback(new ProxyHandler());

            map.putIfAbsent(clazz, enhancer.create());
        }

        return (T) map.get(clazz);

    }

    public Object intercept(Object obj, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {

        System.out.println("start invoke");
        //这里一定要调用invokeSuper，否则会出现死循环，死循环原因是处理器类回调了自己
        Object result = methodProxy.invokeSuper(obj, objects);

        System.out.println("finish invoke");

        return result;

    }

}

步骤三，创建测试类

package com.silence.spring.proxy.cglib.test;

import com.silence.spring.proxy.cglib.bussiness.CglibTargetImpl;
import com.silence.spring.proxy.cglib.handler.ProxyHandler;

public class Test {

    public static void main(String[] args) {


        CglibTargetImpl cglibTarget = ProxyHandler.getProxy(CglibTargetImpl.class);

        cglibTarget.methodA();

    }

}

步骤四，输出测试结果，证实代理成功

start invoke
invoke methodA
finish invoke

总结

JDK动态代理与CGLIB动态代理区别：
1.目标：JDK动态代理针对的目标是接口，而CGLIB动态代理针对的目标是实现类；
2.实现方式：JDK动态代理采用目标类与代理类实现相同接口的方式，而CGLIB动态代理采用目标类与代理类继承相同父类的方式；