细节一：被切入的类获取的bean是代理对象

ApplicationContext applicationContext = new ClassPathXmlApplicationContext("application.xml");

@Test
public void test01(){
    Calculate calculate = applicationContext.getBean(Calculate.class);//获取被切入的类
    MyCalculate myCalculate = applicationContext.getBean(MyCalculate.class);
    System.out.println(myCalculate);//报错：No qualifying bean of type 'com.shang.impl.MyCalculate' available
    System.out.println(calculate);
    System.out.println(calculate.getClass());
}

输出

com.shang.impl.MyCalculate@6ff29830
class com.sun.proxy.$Proxy22

我们获得的calculate的类型居然是proxy类型，这不是代理生成的对象嘛？？？

由此我们可以看出，AOP实际上就是代理，IOC容器中保存的是被切入类的代理对象。并且获取对象使用类获取只能用他的接口类型进行获取。

那如果这个类没有实现接口，还可以增强吗？

答曰：可！

Spring的AOP不但有关于JDK的Proxy，而且也支持CGLIB的代理。CGLIB是基于继承的代理模式，CGLIB操作字节码动态生成一个类，将被代理的类作为动态生成的类的父类，从而实现了增强。

细节二：接入点表达式

格式：execution(权限修饰符 返回值 方法全类名.方法参数)

通配符：

• *****
  • 匹配一个或多个字符：execution(public int com.shang.impl.Mycalculate.*(int,int))
  • 匹配任意一个参数: execution(public int com.shang.impl.Mycalculate.add(int,*))
  • 只能匹配一层路径
  • 权限位置不能用代替，不写默认是public ：execution( * com.shang.impl.Mycal.add(int,int))
• …
  • 匹配多个参数，任意类型：execution(public int com.shang.impl.Mycalculate.add(…))
  • 匹配多层路径 ：execution(public int *.add(…))

细节三：通知方法运行时，拿到目标方法的详细信息

只需要在通知方法的参数上加上一个参数：JoinPoint

@Before("execution(public int com.shang.impl.MyCalculate.*(int, int))")
    public static void logBefore(JoinPoint joinPoint) {
        Object[] args = joinPoint.getArgs();
        Signature signature = joinPoint.getSignature();//切入点的签名，有切入点的方法名，全名称，属于哪个类
        JoinPoint.StaticPart staticPart = joinPoint.getStaticPart();

        System.out.println(Arrays.asList(args));
        System.out.println(signature.getName());
        System.out.println(signature);
        System.out.println("方法执行前");
    }

细节四：拿到连接点的返回结果，异常信息

在方法参数分别定义返回值和异常信息，在注释上面加上相应的信息即可

@AfterReturning(value = "execution(public int com.shang.impl.MyCalculate.*(int, int))", returning = "result")
    public static void logReturn(JoinPoint joinPoint, Object result) {
        System.out.println("方法返回");
    }

    @AfterThrowing(value = "execution(public int com.shang.impl.MyCalculate.*(int, int))", throwing = "exception")
    public static void logException(JoinPoint joinPoint, Exception exception) {
        System.out.println("方法执行异常");
    }

细节五：抽取可重用的切入点表达式

步骤：

1. 随便声明一个没有实现的返回void的空方法

@Pointcut("execution(public int com.shang.impl.MyCalculate.add(int, int))")
public void Mypoint();

2. 给方法上标注@Pointcut注解

@Before("MyPoint()")
public static void logStart(JoinPoint joinPoint){}

细节六：环绕通知@Around

• 环绕通知是所有通知类型中功能最为强大的，能够全面地控制连接点，甚至可以控制是 否执行连接点。
• 对于环绕通知来说，连接点的参数类型必须是 ProceedingJoinPoint。它是 JoinPoint 的 子接口，允许控制何时执行，是否执行连接点。
• 对于环绕通知来说，连接点的参数类型必须是 ProceedingJoinPoint。它是 JoinPoint 的 子接口，允许控制何时执行，是否执行连接点。
• 注意：环绕通知的方法需要返回目标方法执行之后的结果，即调用 joinPoint.proceed(); 的返回值，否则会出现空指针异常

理解环绕通知：

在动态代理的过程中，四个通知的作用的分别为

try{
    @Before()
    method.invoke(obj, args);
    @AfterReturning()
}catch (Exception e) {
    @AfterThrowing()
}finally {
    @After()
}

而环绕通知其实就相当于这四个通知的集合体。

@Around("execution(public int com.shang.impl.MyCalculate.*(int, int))")
public static Object around(ProceedingJoinPoint pjp) throws Throwable {
    System.out.println(Arrays.asList(pjp.getArgs()));

    Object proceed = null;
    try{
        //前置通知
        proceed= pjp.proceed(pjp.getArgs());
        //返回通知
    }catch (Exception e){
        //异常通知
    }finally {
        //结束通知
    }

    return proceed;
}

我们可以看见，**pjp.proceed();**实际上就是method.invoke()，我们只需要在他相应的位置加上要做的事，他就是那个位置的通知。而且我们可以通过ProceedingJoinPoint类获取当前的参数等。