SpringAOP详细介绍+实现原理（个人理解）

最新推荐文章于 2024-08-16 17:21:41 发布

大雄君

最新推荐文章于 2024-08-16 17:21:41 发布

阅读量1.7k

点赞数 4

分类专栏： spring学习

本文链接：https://blog.csdn.net/weixin_43092168/article/details/90183832

版权

spring学习专栏收录该内容

4 篇文章 0 订阅

订阅专栏

前言

一切皆为学习交流。本文主要介绍Spring AOP，以及我对它的实现原理的理解。在介绍spring AOP的过程中顺带展示如何使用基于注解的Spring AOP

文章目录

何为AOP

大家都知道OOP（Object-Oriented Programing，面向对象编程），OOP引入封装、继承和多态性等概念来建立一种对象层次结构，用以模拟公共行为的一个集合。但是，当我们需要对那些分散的对象加入一些公共行为的时候，比如日志功能，OOP就会显得非常的乏力。例如：

//现在有一对象叫zhangsan(implement interface Person)，他有一个行为（方法）sayHello
public class Zhangsan implements Person{
    private String name ;
    {
        name = "zhangsan" ;
    }
    @Override
    public void sayHello() {
        System.out.println("hello , I am "+ name);
    }

想对他的sayHello行为进行一个日志记录，执行前要告诉我他要执行什么行为，以及告诉我执行完了。
对于一个方法很简单，我们采取编码的方式可以做到：

public void sayHello() {
    //执行前日志
    System.out.println("zhangsan 要执行 sayHello 了");
    System.out.println("hello , I am "+ name);    
    //执行后日志
    System.out.println("zhangsan 执行完 sayHello 了");
}

但是如果张三的行为增加了，还有person的实现类增加了，那么要进行这样的日志记录将会非常的麻烦，并且这样的代码会分散到所有的对象中，导致大量的代码重复，不利于解耦。
AOP就是为了解决这样的问题而生的。

AOP利用一种称为“横切”的技术，剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其名为Aspect”，即方面。所谓“方面”，简单地说，就是将那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可操作性和可维护性。AOP代表的是一个横向的关系，如果说“对象”是一个空心的圆柱体，其中封装的是对象的属性和行为；那么面向方面编程的方法，就仿佛一把利刃，将这些空心圆柱体剖开，以获得其内部的消息。而剖开的切面，也就是所谓的“方面”了。然后它又以巧夺天功的妙手将这些剖开的切面复原，不留痕迹。

AOP中的几个概念

切面（Aspect）：一个关注点的模块化，这个关注点可能会横切多个对象。其实愿意的话切面可以简单地概括为Aspect = Join point + Advice。
连接点（Join point）：程序执行过程中某个特定的点，在Spring AOP中一个连接点总是代表一个方法的执行。
通知(Advice)：在切面（Aspect）的某个特定连接点上（Join point）执行的动作。
切入点（Pointcut）：匹配连接点（Join point）的断言。切入点就是告诉我们哪些连接点会被拦截，并执行相应的Advice（增强操作）。
引入（Introduction）：声明额外的方法或字段。Spring AOP允许你向任何被通知(Advice)对象引入一个新的接口（及其实现类）。
目标对象（Target object）：被一个或多个切面（Aspect）所通知（Advice）的对象，也称作被通知对象。
织入（Weaving）：把切面（aspect）连接到其他的应用程序类型或者对象上，并创建一个被通知对象的这一个过程称为织入。

通知(Advice)的类型：

前置通知（Before advice）：某个连接点执行前的通知，即某个方法执行前的触发的操作
返回后通知（After returning advice）：连接点顺利执行完后的通知，如果连接点有返回值，可以对返回值进行操作。
抛出异常后通知（After throwing advice）：顾名思义，如果连接点执行过程中抛出了异常，触发该通知。
后置通知（After advice）：该通知不管连接点是否顺利执行正常退出都执行。
环绕通知（Around advice）：这是最强大的一种通知类型。环绕通知可以在方法前后完成自定义的行为。它也会选择是否继续执行连接点或直接返回它们自己的返回值或抛出异常来结束执行。也就是前面所有的通知他都能做到。

使用动态代理实现并理解AOP

实现AOP的技术，主要分为两大类：一是采用动态代理技术，利用截取消息的方式，对该消息进行装饰，以取代原有对象行为的执行；二是采用静态织入的方式，引入特定的语法创建“方面”，从而使得编译器可以在编译期间织入有关“方面”的代码。

现在我们使用动态代理技术去实现我们在上面提到需求，为Zhangsan的sayHello方法添加日志功能。
首先我们有一个Person接口，里面规范了人的一个打招呼的行为sayHello

public interface Person {
    void sayHello();
}

有一个Person实现类Zhangsan

public class Zhangsan implements Person{
    private String name ;
    {
        name = "zhangsan" ;
    }
    @Override
    public void sayHello() {
        System.out.println("hello , I am "+ name);
    }
}

现在使用动态代理来为zhangsan的sayHello行为进行日志记录

public class PersonLoggingProxy {
    //代理对象（Target object）
    private  Person target ;

    public PersonLoggingProxy(Person target) {
        this.target = target;
    }

    public Person getLoggingProxy(){
        Person proxy = null ;
        //得到代理对象的ClassLoader
        ClassLoader loader = target.getClass().getClassLoader() ;
        //得到代理对象的类型
        Class[] interfaces = new Class[]{Person.class} ;
        //创建InvocationHandler
        InvocationHandler handler = new InvocationHandler() {
            @Override
            
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                String methodName = method.getName();
                Class<?> aClass = proxy.getClass();
                //调用前置日志（前置通知）
                System.out.println(aClass.getTypeName()+"调用了"+methodName)
                try {
                //调用被代理对象的方法
                    method.invoke(target,args) ;
                    //调用后日志（返回通知）
                    System.out.println(aClass.getTypeName()+"执行完了"+methodName);
                }catch (Exception e){
                    e.getStackTrace() ;
                    //这里可以写抛出异常后通知
                }
                //这里可以写后置通知
                //这一个整个方法就是一个环绕通知
                return null;
            }
        };

        proxy = (Person) Proxy.newProxyInstance(loader,interfaces,handler) ;

        return proxy ;
    }
    public void setTarget(Person target) {
        this.target = target;
    }
}

现在我们可以通过PersonLoggingProxy类对张三的行为进行日志记录了

public class Main {
    public static void main(String[] args) {
        Person zhangsan = new Zhangsan() ;
        Person proxy = new PersonLoggingProxy(zhangsan).getLoggingProxy();
        proxy.sayHello();
   }
}

运行结果：

com.sun.proxy.$Proxy0调用了sayHello
hello , I am zhangsan
com.sun.proxy.$Proxy0执行完了sayHello

这样，即使我们有很多Person实现类，并且都要对他们进行日志记录，我们也不用在类里面进行硬编码，不用在每个方法前面加上一句System.out.println("XXX 要执行 sayHello 了");和后面加上一句System.out.println("XXX 执行完 sayHello 了");，此外动态代理还能实现更加强大的功能，诸如修改传入参数，返回结果等。

假设我们现在有一个Lisi，同样是Person的实现类，想要进行日志记录也很简单

public class Lisi implements Person {
    private  String name ;
    {
        name = "Lisi" ;
    }
    @Override
    public void sayHello() {

        System.out.println("hello , I am "+ name);

    }

}

使用同样的操作

Person lisi =new Lisi() ;
Person proxy1 = new PersonLoggingProxy(lisi).getLoggingProxy();
proxy1.sayHello();

效果：

com.sun.proxy.$Proxy0调用了sayHello
hello , I am Lisi
com.sun.proxy.$Proxy0执行完了sayHello

注：这里需要用到JAVA的动态代理的知识不做介绍

在Spring中使用AOP

诚然，如果每要实现AOP，都需要我们像上面去做的话，会很累。spring AOP API 将会让我们非常简单就可以使用AOP。
注：我是基于Spring-boot 2.1.4示例

首先在spring-boot项目中导入Spring AOP依赖

<!-- 加入web模块方便测试 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aop</artifactId>
</dependency>

<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
</dependency>

spring-boot是默认开启AOP的不需要任何配置文件，直接使用（spring.aop.auto=true）

编写PersonAspect类

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class PersonAspect {
	//定义切点
    @Pointcut("execution(public * yong.com.springaop.SpringAop.*.*(..))")
    public  void pointCut(){}
    //前置通知
    @Before("pointCut()")
    public  void doBefore(JoinPoint joinPoint){
        System.out.println("准备执行"+joinPoint.getSignature().getName());
    }
    //后置通知
    @After("pointCut()")
    public void doAfter(JoinPoint joinPoint){
        System.out.println("已执行完"+joinPoint.getSignature().getName());
    }
//    下面可以接着写各种通知
    返回通知
//    @AfterReturning
//    异常通知
//    @AfterThrowing
//    环绕通知
//    @Around
}

编写一个Controller用于测试AOP是否生效

package yong.com.springaop.SpringAop;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
public class AopController {
   @ResponseBody
   @RequestMapping("/aop")
   public String aopController(){
       return "执行成功" ;
   }
}

启动运行该项目，在浏览器上访问http://localhost:8080/aop

可以看到控制台输出日志：

以上便是简单的Spring AOP使用步骤。

总结

Spring中AOP的实现依赖于Spring的IOC容器，代理的生成，管理及其依赖关系都是由IOC容器负责，Spring默认使用JDK动态代理，在需要代理类而不是代理接口的时候，Spring会自动切换为使用CGLIB代理。
AOP技术的优势使得需要编写的代码量大大缩减，节省了时间，控制了开发成本。同时也使得开发人员可以集中关注于系统的核心商业逻辑。此外，它更利于创建松散耦合、可复用与可扩展的大型软件系统。
注：如果有一些小伙伴想看源代码或者懒得打一遍，源代码已上传到GitHub上面源代码，可以clone下来看看，有错的地方也欢迎大家修改。