Spring AOP原理剖析---动态代理方式

        动态代理的实现的选择，在调用getProxy()方法时，我们可选用的AopProxy接口有两个实现类，这两种都是动态代理生成代理对象的方式，一种就是基于JDK的，一种是基于Cglib的。

①JDK动态代理技术

        目标类有接口，是基于接口动态生成实现类的代理对象，目标类有接口的情况下这是默认方式。

②Cglib动态代理技术

        目标类无接口且不能使用final修饰，是基于被代理对象动态生成子对象为代理对象，目标类无接口的时候默认使用此方式，目标类有接口的时候，可以手动配置<aop:config proxy-target-class="true">强制使用Cglib方式。

流程图如下：

 下面代码实现两种动态代理方式

基于JDK的动态代理

首先创建一个接口

package com.itchj.proxy;

public interface UserDao {
    public int add(int a, int b);
}

创建实现类（目标对象）

package com.itchj.proxy;

public class UserDaoImpl implements UserDao{
    @Override
    public int add(int a, int b) {
        System.out.println("方法执行");
        return a + b;
    }
}

创建代理对象

package com.itchj.proxy;

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

public class ProxyTest {

    public static void main(String[] args) {
        UserDaoImpl userDaoImpl = new UserDaoImpl();
        UserDao proxy = (UserDao) Proxy.newProxyInstance(userDaoImpl.getClass().getClassLoader(), userDaoImpl.getClass().getInterfaces(), new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                //方法执行之前
                System.out.println("方法执行之前执行" + method.getName() + "参数" + args);
                int invoke = (int) method.invoke(userDaoImpl, args);
                System.out.println("方法执行之后");
                return invoke;
            }
        });
        proxy.add(1, 2);
    }

}

基于Cglib的动态代理

创建父类

package com.itchj.testProxy;

public class Target {

    public void show(){
        System.out.println("目标对象执行。。。。");
    }
}

创建增强方法对象

package com.itchj.testProxy;

public class MyAdvice {

    public void before(){
        System.out.println("前置增强。。。");

    }

    public void after(){
        System.out.println("后置增强。。。");
    }

}

生成代理对象

package com.itchj.testProxy;

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

public class CglibTest {
    public static void main(String[] args) {

        //Cglib基于父类（目标类）生成Proxy

        //目标对象
        Target target = new Target();
        //通知对象
        MyAdvice myAdvice = new MyAdvice();
        //Cglib代码编写
        Enhancer enhancer = new Enhancer();//增强器对象
        //设置父类
        enhancer.setSuperclass(Target.class);//生成的代理对象就是其子类
        //设置回调
        enhancer.setCallback(new MethodInterceptor() {
            @Override
            //intercept方法相当于JDK的Proxy的invoke方法
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                myAdvice.before();
                Object res = method.invoke(target, objects);//执行目标方法
                myAdvice.after();
                return res;
            }
        });
        //生成代理对象
        Target proxy = (Target) enhancer.create();//代理返回的对象就是目标对象的子类可以用目标对象类型接受

        //测试
        proxy.show();
    }
}

        最后还有一点不同就是基于JDK的动态代理技术生成的代理对象和目标对象相当于兄弟平级关系不能用目标对象的类型接受代理对象（但可以使用接口类型接收），而基于Cglib的动态代理技术它的代理对象是目标对象的子类，所以可以用目标对象类型接收。