Spring AOP综合简介+AOP原理简单版解析+AOP源码深度解析

目录

一、AOP综合简介

1、介绍

2、实现原理

 3、AOP相关术语

4、AOP在Spring中的配置标签介绍

二、AOP实现原理—手写AOP

1、创建一个Subject接口

2、创建一个目标对象实现接口（使用Jdk代理实现）

3、增强类 （Advice 通知）

 4、增强类的具体实现

5、动态代理实现增强

6、测试及结果分析

三、AOP源码深度解析

待续写！~~~~~~~~~~~~~~~~

---

一、AOP综合简介

1、介绍

AOP为Aspect Oriented Programming的缩写，意为:面向切面编程，通过预编译方式和运行期  动态代理实现程序功能的统一维护的一种技术。

优势：
    减少重复代码、 提高开发效率、维护方便

作用：
        在程序运行期间，不修改源码对已有方法进行增强。面向切面编程，在我们的应用中，经常需要做一些事情，但是这些事情与核心业务无关，比如，要记录所有update方法的执行时间时间，操作人等等信息，记录到日志，通过spring的AOP技术，就可以在不修改update的代码的情况下完成该需求。

2、实现原理

Spring AOP是基于动态代理实现的。AOP中的动态代理主要有两种方式，JDK动态代理和CGLIB动态代理。JDK动态代理通过反射来接收被代理的类，并且要求被代理的类必须实现一个接口。JDK动态代理的核心是InvocationHandler接口和Proxy类。

如果目标类没有实现接口，那么Spring AOP会选择使用CGLIB来动态代理目标类。CGLIB（Code Generation Library），是一个代码生成的类库，可以在运行时动态的生成某个类的子类，注意，CGLIB是通过继承的方式做的动态代理，因此如果某个类被标记为final，那么它是无法使用CGLIB做动态代理的。

关于动态代理，请阅读博文：https://blog.csdn.net/qq_36095679/article/details/89603559

 3、AOP相关术语

Joinpoint（连接点）

所谓连接点是指那些被拦截到的点。在 spring 中,这些点指的是方法,因为 spring 只支持方法类型的连接点。

 Poincut（切入点）

所谓切入点是指我们要对哪些Joinpoint 进行拦截的定义。即 需要增强的目标方法是什么？

Advice（通知/增强）

所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知。 通知的类型：前置通知,后置通知,异常通知,最终通知,环绕通知。

 Introduction（引介）

引介是一种特殊的通知在不修改类代码的前提下, Introduction 可以在运行期为类动态地添加一些方法或 Field。

    动态代理中的InvocationHandler

 Target（目标对象）

代理的目标对象。

Weaving（织入）

是指把增强应用到目标对象来创建新的代理对象的过程。
spring 采用动态代理织入，而 AspectJ 采用编译期织入和类装载期织入。

 Proxy（代理）

一个类被 AOP 织入增强后，就产生一个结果代理类。

Aspect（切面）

是切入点和通知（引介）的结合。（对哪些方法，进行怎样的增强）

4、AOP在Spring中的配置标签介绍

aop:config:
作用：用于声明开始 aop 的配置

aop:aspect:
作用：用于配置切面。

属性：
id：给切面提供一个唯一标识。
ref：引用配置好的通知类 bean 的 id。

aop:pointcut：
 作用：用于配置切入点表达式。就是指定对哪些类的哪些方法进行增强。

属性：
expression：用于定义切入点表达式。

id：用于给切入点表达式提供一个唯一标识

切入点表达式说明
execution(表达式)
表达式语法：execution([修饰符] 返回值类型  包名.类名.方法名(参数)) 

通常情况下，我们都是对业务层的方法进行增强，所以切入点表达式都是切到业务层实现类。
execution( *  com..service.impl.*.*(..) )

写法说明：
    访问修饰符可以省略

    返回值可以使用*号，表示任意返回值

    包名可以使用*号，表示任意包，但是有几级包，需要写几个*
    
    使用..来表示当前包，及其子包

    类名可以使用*号，表示任意类

    方法名可以使用*号，表示任意方法

    参数列表可以使用*，表示参数可以是任意数据类型，但是必须有参数
* com..*.*(*)
    
    参数列表可以使用..表示有无参数均可，有参数可以是任意类型
    
    全通配方式：* *..*.*(..)

aop:before
作用：用于配置前置通知。
指定增强的方法在切入点方法之前执行

属性：
method:用于指定通知类中的增强方法名称

ponitcut-ref：用于指定切入点的表达式的引用

poinitcut：用于指定切入点表达式

执行时间点：
切入点方法执行之前执行

 aop:after-returning
作用：用于配置后置通知

属性：
method：指定通知中方法的名称。

pointct：定义切入点表达式

pointcut-ref：指定切入点表达式的引用

执行时间点：
切入点方法正常执行之后。它和异常通知只能有一个执行

 aop:after-throwing
作用：用于配置异常通知

属性：
method：指定通知中方法的名称。

pointct：定义切入点表达式

pointcut-ref：指定切入点表达式的引用

执行时间点：
切入点方法执行产生异常后执行。它和后置通知只能执行一个

 aop:after
作用：用于配置最终通知

属性：
method：指定通知中方法的名称。

pointct：定义切入点表达式

pointcut-ref：指定切入点表达式的引用

执行时间点：
无论切入点方法执行时是否有异常，它都会在其后面执行。

 aop:around：
作用：用于配置环绕通知

属性：
method：指定通知中方法的名称。

pointct：定义切入点表达式

pointcut-ref：指定切入点表达式的引用

说明：
它是 spring 框架为我们提供的一种可以在代码中手动控制增强代码什么时候执行的方式。

注意：
通常情况下，环绕通知都是独立使用的

*spring 框架为我们提供了一个接口：ProceedingJoinPoint，它可以作为环绕通知的方法参数。
*在环绕通知执行时，spring 框架会为我们提供该接口的实现类对象，我们直接使用就行。

 配置实例：

一般通知 

       

       
           
           
           
           
       

   

环绕通知（不能与一般通知同时存在）
    
        
        

           

        

    

二、AOP实现原理—手写AOP

1、创建一个Subject接口

speak（）方法就是 Poincut切入点

public interface Subject {
 
    String speak();
}

2、创建一个目标对象实现接口（使用Jdk代理实现）

public class TargetSubject implements Subject {
 
    @Override
    public String speak() {
        System.out.println("目标对象的原方法被执行");
        return "结束";
    }
}

3、增强类 （Advice 通知）

import java.lang.reflect.Method;
public interface ILogger {
    void start(Method method);
    void end(Method method);
}

 4、增强类的具体实现

import java.lang.reflect.Method;
import java.util.Date;

//具体的 增强方法
public class DLogger implements ILogger{
    @Override
    public void start(Method method) {
        System.out.println(new Date()+ method.getName() + " 前置通知");
    }
    @Override
    public void end(Method method) {
        System.out.println(new Date()+ method.getName() + " 后置通知");
    }
}

5、动态代理实现增强

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

public class DynaProxyHello1 implements InvocationHandler {
    //调用对象，用于通知的对象
    private Object proxy;
    //目标对象，需要增强的对象
    private Object target;

    public Object bind(Object target,Object proxy){
        this.target=target;
        this.proxy=proxy;
        return Proxy.newProxyInstance(this.target.getClass().getClassLoader(), this.target.getClass().getInterfaces(), this);
    }


    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        Object result = null;
        //反射得到增强类的实例
        Class clazz = this.proxy.getClass();
        //反射得到增强类的Start方法   前置通知
        Method start = clazz.getDeclaredMethod("start", new Class[]{Method.class});
            //反射执行start方法
        start.invoke(this.proxy,  new Object[]{method});
        //执行目标对象的原本方法
        method.invoke(this.target, args);
        //反射得到增强类的end方法   后置通知
        Method end = clazz.getDeclaredMethod("end", new Class[]{Method.class});
            //反射执行end方法
        end.invoke(this.proxy, new Object[]{method});
        return result;
    }

}

在生产动态代理这个过程，Spring AOP做了大量的工作：包括从配置文件，获取到需增强的方法Pointcut，如何增强Advice(通知)，aspect（切面）等，这一系列过程的讲解，请阅读本文第三节   三、AOP源码深度解析

6、测试及结果分析

package test.myCglib;

public class Test {
    public static void main(String[] args) {
        Subject o = (Subject)new DynaProxyHello1()
                .bind(new TargetSubject(), new DLogger());
      o.speak();
    }
}

结果展示：

Fri Jun 14 16:14:57 CST 2019speak 前置通知
目标对象的原方法被执行
Fri Jun 14 16:14:57 CST 2019speak 后置通知

三、AOP源码深度解析

待续写！~~~~~~~~~~~~~~~~

 

本篇博客，总结于以下各位大神的博客，小编在此表示敬佩和感谢。

参考文献：

 https://www.cnblogs.com/lcngu/p/5339555.html（简单版实例 讲解）

https://blog.csdn.net/wyl6019/article/details/80136000（AOP原理 源码解析）

https://blog.csdn.net/qq_26323323/article/details/81012855（AOP 源码 深度解析）

https://blog.csdn.net/MoreeVan/article/details/11977115（AOP 源码解析）

https://my.oschina.net/guangshan/blog/1797461（AOP 源码解析）

https://blog.csdn.net/forezp/article/details/84927180