SpringAOP——动态代理

什么是代理？
   答：代理是一种常用的设计模式，其目的就是为其他对象提供一个代理以控制对某个对象的访问。代理类负责为委托类预处理消息，过滤消息并转发消息，以及进行消息被委托类执行后的后续处理。

代理可分为动态代理和静态代理两种，在此简单的了解一下动态代理，静态代理自行度娘哈。
AOP中使用的两种动态代理：
      特点：字节码随用随创建，随用随加载
      作用：不用在修改源码的基础上对方法增强
      分类：
            基于接口的动态代理，即JDK代理：
                  涉及的类：Proxy
                  提供者：JDK官方
            基于子类的动态代理，即CGLIB代理：
                  涉及的类：Enhancer
                  提供者：第三方cglib库

JDK代理

原理：
      通过反射根据类加载器和被代理对象的接口创建代理类
如何创建代理对象：
      使用Proxy类中的newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
创建代理对象的要求(缺点)：
      被代理类至少实现一个接口，如果没有则不能使用
话不多说，先上代码。

先创建一个接口并写出一个它的实现类，模仿一个手机厂家

//接口
public interface PhoneProducer {

    public void salePhone(float money);
}




//手机厂商
public class Produce implements PhoneProducer {
    @Override
    public void salePhone(float money) {
        System.out.println("销售出一台手机，厂家得到了"+money+"元");
    }

}

现实生活中每个人买手机肯定不是直接从厂家拿货，肯定需要经过手机售卖店里买，而售卖店才是去厂家拿货，所以可以将手机售卖店成为厂商的代理，即代理类对象（jdkproxy）,代理类需要实现InvocationHandler接口并重写其中的invoke()方法，代码如下：

//模式一个顾客
public class Customer {

    public static void main(String[] args) {
        Produce produce = new Produce();
        //创建代理对象
        PhoneProducer jdkproxy =(PhoneProducer) Proxy.newProxyInstance(
                produce.getClass().getClassLoader(),
                produce.getClass().getInterfaces(),
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        Object result = null;
                        //增强代码，即模仿一个手机售卖店
                        if("salePhone".equals(method.getName())){
                            Float money = (Float)args[0]*0.8f;
                            result = method.invoke(produce,money);
                            System.out.println("售卖店得到了"+((Float)args[0]-money)+"元");
                        }
                        return result;
                    }
                });
		//代理类对象调用salePhone方法
        jdkproxy.salePhone(1200f);
    }
}

输出的结果如下：

销售出一台手机，厂家得到了960.0元
售卖店得到了240.0元

分析上面的JDK动态代理的代码：
1、建代理对象时调用了Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h),三个参数的作用分别为：

      1)ClassLoader loader：它是用于加载代理对象字节码，也是被代理对象的类加载器（也就是说和被代理对象使用相同的类加载器）。固定写法：被代理对象.getClass().getClassLoader()

      2)Class<?>[] interfaces：字节码数组。它是用于让代理对象jdkproxy和被代理对象produce拥有相同的方法（也就是代理类和被代理类实现同一个接口，所以要获取被代理类的接口让代理类也去实现这个接口PhoneProducer ）。固定写法：被代理对象.getClass().getInterfaces()

      3)InvocationHandler h：用于增强方法，它是让我们写如何代理，一般是写一个改接口的实现类（这里我们使用了匿名内部类）。

2、 重点：接口InvocationHandler的invoke方法需要被重写，执行代理对象的方法jdkproxy.salePhone(1200f)前一定会先执行该方法invoke，起到拦截的作用来增强被执行的方法。
该方法public Object invoke(Object proxy, Method method, Object[] args) throws Throwable的三个参数和返回值的作用分别是：
      1)Object proxy：代理对象的引用。（一般不用)

      2)Method method：表示当前执行的方法。

      3)Object[] args：当前执行方法所需的参数。

      4)return 返回值：和被代理对象的方法有相同的返回值。

方法中的method.invoke();具体用法参照反射中的讲解

CGLIB代理

原理：使用CGLib实现动态代理，完全不受代理类必须实现接口的限制，而且CGLib底层采用ASM字节码生成框架，使用字节码技术生成代理类。生成的代理类是被代理类的子类
      需要用到第三方的jar包，cglib和asm(用来生成java字节码的框架)
如何创建代理对象：
      使用cEnhancer类中的create()
创建代理对象的要求：
      被代理类不能是最终类，即不能使用final修饰，因为cglib代理的原理是创建一个被代理类的子类，而被final修饰的类不能被继承。

和上面一样，只不过没有经过接口实现，cglib代理的类并不需要实现一个接口，解脱了jdk代理必须要经过接口才能代理的烦恼。

//手机厂商
public class Produce {
    public void salePhone(float money) {
        System.out.println("销售出一台手机，厂家得到了"+money+"元");

    }
}

//模式一个顾客
public class Customer {

    public static void main(String[] args) {
        //创建一个将要被代理的对象
        Produce produce = new Produce();
        //创建代理对象,
        Produce cglibProxy =(Produce) Enhancer.create(produce.getClass(), new MethodInterceptor() {
            @Override
            public Object intercept(Object obj, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
                Object result = null;
                //增强代码，即模仿一个手机售卖店
                if ("salePhone".equals(method.getName())) {
                    Float temp =(Float) args[0];   //将参数先赋值给一个临时变量
                    args[0] = (Float) args[0] * 0.8f;   //一台手机厂家可以得到多钱
                    result = methodProxy.invokeSuper(obj, args);
                    System.out.println("售卖店得到了" + (temp -(Float) args[0]) + "元");  //店家一台手机赚取多少钱
                }
                return result;
            }
        });
        cglibProxy.salePhone(3000f);  //一台手机以3k的价格卖出
    }
}

分析：
    使用Enhancer.create()创建代理类，public static Object create(Class type, Callback callback)，我们这里使用了还是匿名内部类，实现了Callback类的子接口MethodInterceptor，重写了该接口的intercept()，仔细观察该方法和上面的invoke()的前三个参数一样，含义也还是一样的。唯一多出的一个是methodProxy对象，含义是：生成的代理类对方法的代理引用。

JDK代理和CGLIB代理的区别

原理：
jdk代理：通过反射生成一个实现指定接口的匿名类，在调用方法前调用实现InvocationHandler接口的类中的invoke()方法，使调用的方法增强(前置处理、后置处理等)。
cglib代理：cglib底层通过asm字节码生成框架生成代理类的字节码class文件加载进去，并将生成的代理类继承被代理类，对代理类的代理方法进行增强(前置处理、后置处理等)。

源代码在这！！如有问题的希望可以指出，谢谢

以上是近期对springAop中的两种动态代理的简单的了解，如果有错误或者异议欢迎指出。