Spring之AOP技术 (6)

目录

1. JDK的动态代理：

2. cglib动态代理：

3、Spring AOP 动态代理类生成

 4. 找切面的具体过程

4. 1 找所有切面 

这里需要细说一下：

4.2 找到合格的切面 

 4.3 对切面进行排序

5. 生成代理对象

6、 代理类的调用：此处以jdk代理类为例

核心步骤：

链式调用的核心方法：

调用顺序：

---

Spring AOP技术是一个难点，缓存、事务都是AOP的一部分。今天，我们就开始AOP的第一讲.

1. JDK的动态代理：

我之前写过一篇关于动态代理的博客《大话设计模式》——读后感 （4）为别人做嫁衣？——动态代理模式（2）_chen_yao_kerr的博客-CSDN博客里面 大概介绍了一下动态代理设计模式。说实话，实际开发中，动态代理用的并不多，除非你是写底层框架的。今天，我们继续说一下动态代理：

package com.zhuguang.jack.proxy;

public interface People {

    public void zhaoduixiang();

    public void yanghaizi() ;
}

package com.zhuguang.jack.proxy;

/*
* 被代理实例
* */
public class Xiaoming implements People {

    //1、在小明双手没有解放之前，小明的父母要帮助小明找到对象

    @Override
    public void zhaoduixiang() {
        System.out.println("我在北京工作，没有时间找对象！！");
    }

    @Override
    public void yanghaizi() {
        System.out.println("努力挣钱， 养孩子");
    }


}

package com.zhuguang.jack.proxy;

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

/*
* 这个是一个增强类，是对目标对象的一个方法增强
* */
public class Parent implements InvocationHandler {

    private People people;

    public Parent(People people) {
        this.people = people;
    }

    /*
    * 帮助消息找到对象，
    * 找到对象以后，帮助小明操持婚礼，带消息
    * */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        //帮他找到对象
        before();

        //这个invoke就会掉到被代理类中的method
        method.invoke(people,args);

        after();

        return null;
    }

    /*
    *  这个方法是小明在找到对象之前，父母帮助他做得事情
    * */
    private void before() {
        System.out.println("我是小明的父母，我需要帮助小明找对象！！");
    }

    /*
    * 找到对象之前，父母帮助他操持婚礼，带小孩
    * */
    private void after() {
        System.out.println("我是小明的父母，我们需要帮助小明操持婚礼，帮他带小孩");
    }
}

package com.zhuguang.jack.proxy;

import sun.misc.ProxyGenerator;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.lang.reflect.Proxy;

public class Test {
    public static void main(String[] args) {
        //proxy对象就是xiaoming这个对象的一个代理实例，xiaoming这个对象就是一个被代理
        People proxy = (People)Proxy.newProxyInstance(People.class.getClassLoader(),new Class[]{People.class},
                new Parent(new Xiaoming()));
        proxy.zhaoduixiang();

        proxy.yanghaizi();

        createProxyClassFile();
    }

    public static void createProxyClassFile() {
        byte[] $Proxy0s = ProxyGenerator.generateProxyClass("$Proxy0", new Class[]{People.class});

        try {
            FileOutputStream fileOutputStream = new FileOutputStream("$Proxy0.class");
            fileOutputStream.write($Proxy0s);
            fileOutputStream.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

通过以上几段代码，我们就实现了JDK的动态代理的技术了。我们的核心方法就是Xiaoming这个类实现了zhaoduixiang这件事。但是，通过动态代理，我们对小明找对象这件事情实现了功能的增强。找对象之前和找对象之后。

那么，它是如何实现这样的增强的呢？

我们可以在根目录下找到代理类$proxy的class文件了：

下面贴出来代码：

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

import com.zhuguang.jack.proxy.People;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

public final class $Proxy0 extends Proxy implements People {
    private static Method m1;
    private static Method m4;
    private static Method m3;
    private static Method m2;
    private static Method m0;

    public $Proxy0(InvocationHandler var1) throws  {
        super(var1);
    }

    public final boolean equals(Object var1) throws  {
        try {
            return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final void yanghaizi() throws  {
        try {
            super.h.invoke(this, m4, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final void zhaoduixiang() throws  {
        try {
            super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final String toString() throws  {
        try {
            return (String)super.h.invoke(this, m2, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final int hashCode() throws  {
        try {
            return (Integer)super.h.invoke(this, m0, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m4 = Class.forName("com.zhuguang.jack.proxy.People").getMethod("yanghaizi");
            m3 = Class.forName("com.zhuguang.jack.proxy.People").getMethod("zhaoduixiang");
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

通过代理类 $Proxy0我们知道，这个代理类实现了接口People。也就是说，我们时间调用的是内存中的代理类的  $Proxy0.zhaoduixiang() 方法。 而这个方法内部, 通过反射又调用了 h.invoke(this, m3, (Object[])null)， 那这个h是什么呢？ 其实，它就是parent的实例。m3 是什么呢？m3对应的就是zhaoduixiang()这个方法。

调用逻辑就是：$Proxy0.zhaoduixiang()   --- > h.invoke(this, m3, (Object[])null)   h是parent实例 ---->  xiaoming.zhaoduixiang().  因为，我们在parent的invoke方法中实现了对zhaoduixiang（）的增强。也就是在找对象之前，之后，我们还可以添加好多方法去干别的事情。这样也就实现了增强功能。

2. cglib动态代理：

我们首先需要引入依赖包：

      cglib
      cglib
      3.2.5
    
    
      cglib
      cglib-nodep
      3.2.5
    

被代理类：

package com.zhuguang.jack.cglib;

/*
* 这里不实现接口
* */
public class TargetClass {

    public void add() {
        System.out.println("TargetClass.add");
    }

    /*
    * 这里有一个开启事务
    * */
    public void del() {
        System.out.println("TargetClass.del");
    }


    /*
    * 增强缓存
    * */
    public void query() {
        System.out.println("TargetClass.query");
    }

}

针对被代理类3个方法的3个增强：

package com.zhuguang.jack.cglib;

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

import java.lang.reflect.Method;



//这个是对add方法的一个拦截
public class AddInterceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("AddInterceptor.intercept.before");
//        method.invoke(obj,args);
        proxy.invokeSuper(obj,args);
        System.out.println("AddInterceptor.intercept.after");
        return null;
    }
}

package com.zhuguang.jack.cglib;

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

import java.lang.reflect.Method;

public class DelInterceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("DelInterceptor.intercept.before");
        proxy.invokeSuper(obj,args);
        System.out.println("DelInterceptor.intercept.after");
        return null;
    }
}

package com.zhuguang.jack.cglib;

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

import java.lang.reflect.Method;

public class QueryInterceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("QueryInterceptor.intercept.before");
        proxy.invokeSuper(obj,args);
        System.out.println("QueryInterceptor.intercept.after");
        return null;
    }
}

工厂：

package com.zhuguang.jack.cglib;

import net.sf.cglib.proxy.Callback;
import net.sf.cglib.proxy.Enhancer;

public class CglibInstanceFactory {

    public static Object getInstance() {

        //拿到字节码增强器
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(TargetClass.class);
        enhancer.setCallbackFilter(new CglibFilter());

        Callback[] callbacks = {
                new AddInterceptor(),
                new DelInterceptor(),
                new QueryInterceptor()};
        enhancer.setCallbacks(callbacks);
        return enhancer.create();
    }
}

测试类：

package com.zhuguang.jack.cglib;

public class Test {
    public static void main(String[] args) {
        TargetClass instance = (TargetClass)CglibInstanceFactory.getInstance();
        instance.query();
    }
}

这就是cglib的动态代理。

3、Spring AOP 动态代理类生成

 上一讲，我们已经说到了AOP的开启，其实就是AnnotationAwareAspectJAutoProxyCreator注入并实例化BeanDefinition。

我们在Spring之实例化Bean _ @Resource和@Autowired实现原理（3）_chen_yao_kerr的博客-CSDN博客

中重点谈到了populateBean() 和 initializeBean（）这两个方法。而我说initializeBean() 方法是对Bean进行初始化操作的。其实这个方法也是AOP的入口方法：

 进入这个方法：

protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
		if (System.getSecurityManager() != null) {
			AccessController.doPrivileged((PrivilegedAction