Spring——面向切面编程（AOP模块）

秒速五厘米 2023-02-19 15:27 4阅读 0赞

### Spring——面向切面编程（AOP模块） ###

*   *   *  Spring AOP 简介
         *  AOP
         *  AOP 的目的
         *  AOP 当中的概念：
         *  实现
         *   *  实际的代码
             *  使用注解来开发 Spring AOP
             *  环绕通知
             *  切面的优先级

### Spring AOP 简介 ###

如果说 IoC 是 Spring 的核心，那么面向切面编程就是 Spring 最为重要的功能之一了，在数据库事务中切面编程被广泛使用。

### AOP ###

AOP即 Aspect Oriented Program 面向切面编程,是对OOP即面向对象的程序设计和POP面向过程的程序设计的补充。  
首先，在面向切面编程的思想里面，把功能分为核心业务功能，和周边功能。

所谓的核心业务，比如登陆，增加数据，删除数据都叫核心业务  
所谓的周边功能，比如性能统计，日志，事务管理等等  
周边功能在 Spring 的面向切面编程AOP思想里，即被定义为切面

在面向切面编程AOP的思想里面，核心业务功能和切面功能分别独立进行开发，然后把切面功能和核心业务功能 “编织” 在一起，这就叫AOP

### AOP 的目的 ###

AOP能够将那些与业务无关，却为业务模块所共同调用的逻辑或责任（例如事务处理、日志管理、权限控制等）封装起来，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可拓展性和可维护性。

### AOP 当中的概念： ###

*  切入点（Pointcut）  
    在哪些类，哪些方法上切入（where）
 *  通知（Advice）  
    在方法执行的什么实际（when:方法前/方法后/方法前后）做什么（what:增强的功能）
 *  切面（Aspect）  
    切面 = 切入点 + 通知，通俗点就是：在什么时机，什么地方，做什么增强！
 *  织入（Weaving）  
    把切面加入到对象，并创建出代理对象的过程。（由 Spring 来完成）

### 实现 ###

为了更好的说明 AOP 的概念，我们来举一个实际中的例子来说明：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW5nMTgyMzgwMzI4OTE_size_16_color_FFFFFF_t_70]

在上面的例子中，包租婆的核心业务就是签合同，收房租，那么这就够了，灰色框起来的部分都是重复且边缘的事，交给中介商就好了，这就是 **AOP 的一个思想：让关注点代码与业务代码分离！**

#### 实际的代码 ####

我们来实际的用代码感受一下

1.在 Package【pojo】下新建一个【Landlord】类（我百度翻译的包租婆的英文）：

package pojo;
    
    import org.springframework.stereotype.Component;
    
    @Component("landlord")
    public class Landlord { 
        public void service() { 
            // 仅仅只是实现了核心的业务功能
            System.out.println("签合同");
            System.out.println("收房租");
        }
    }

2.在 Package【aspect】下新建一个中介商【Broker】类（我还是用的翻译…）：

package aspect;
    
    import org.aspectj.lang.annotation.After;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Before;
    import org.springframework.stereotype.Component;
    
    @Component
    @Aspect
    class Broker { 
    
        @Before("execution(* pojo.Landlord.service())")
        public void before(){ 
            System.out.println("带租客看房");
            System.out.println("谈价格");
        }
    
        @After("execution(* pojo.Landlord.service())")
        public void after(){ 
            System.out.println("交钥匙");
        }
    }

3.在 applicationContext.xml 中配置自动注入，并告诉 Spring IoC 容器去哪里扫描这两个 Bean：

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xmlns:context="http://www.springframework.org/schema/context"
           xmlns:aop="http://www.springframework.org/schema/aop"
           xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
    
        <context:component-scan base-package="aspect" />
        <context:component-scan base-package="pojo" />
    
        <aop:aspectj-autoproxy/>
    </beans>

4.在 Package【test】下编写测试代码：

package test;
    
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    import pojo.Landlord;
    
    public class TestSpring { 
    
        public static void main(String[] args) { 
    
            ApplicationContext context =
                    new ClassPathXmlApplicationContext("applicationContext.xml");
            Landlord landlord = (Landlord) context.getBean("landlord", Landlord.class);
            landlord.service();
    
        }
    }

5.执行看到效果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW5nMTgyMzgwMzI4OTE_size_16_color_FFFFFF_t_70 1]  
这个例子使用了一些注解，现在看不懂没有关系，但我们可以从上面可以看到，我们在 Landlord 的 service() 方法中仅仅实现了核心的业务代码，其余的关注点功能是根据我们设置的切面自动补全的。

#### 使用注解来开发 Spring AOP ####

使用注解的方式已经逐渐成为了主流，所以我们利用上面的例子来说明如何用注解来开发 Spring AOP

**第一步：选择连接点**  
Spring 是方法级别的 AOP 框架，我们主要也是以某个类额某个方法作为连接点，另一种说法就是：选择哪一个类的哪一方法用以增强功能。

....
    public void service() {
        // 仅仅只是实现了核心的业务功能
        System.out.println("签合同");
        System.out.println("收房租");
    }
    ....

我们在这里就选择上述 Landlord 类中的 service() 方法作为连接点。

**第二步：创建切面**  
选择好了连接点就可以创建切面了，我们可以把切面理解为一个拦截器，当程序运行到连接点的时候，被拦截下来，在开头加入了初始化的方法，在结尾也加入了销毁的方法而已，在 Spring 中只要使用 @Aspect 注解一个类，那么 Spring IoC 容器就会认为这是一个切面了：

注意： 被定义为切面的类仍然是一个 Bean ，需要 @Component 注解标注  
代码部分中在方法上面的注解看名字也能猜出个大概，下面来列举一下 Spring 中的 AspectJ 注解：

<table> 
 <thead> 
  <tr> 
   <th align="left">注解</th> 
   <th align="left">说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><code>@Before</code></td> 
   <td align="left">前置通知，在连接点方法前调用</td> 
  </tr> 
  <tr> 
   <td align="left"><code>@After</code></td> 
   <td align="left">后置通知，在连接点方法后调用</td> 
  </tr> 
  <tr> 
   <td align="left"><code>@Around</code></td> 
   <td align="left">环绕通知，它将覆盖原有方法，但是允许你通过反射调用原有方法，后面会讲</td> 
  </tr> 
  <tr> 
   <td align="left"><code>@AfterReturning</code></td> 
   <td align="left">返回通知，在连接点方法执行并正常返回后调用，要求连接点方法在执行过程中没有发生异常</td> 
  </tr> 
  <tr> 
   <td align="left"><code>@AfterThrowing</code></td> 
   <td align="left">异常通知，当连接点方法异常时调用</td> 
  </tr> 
 </tbody> 
</table>

有了上表，我们就知道 before() 方法是连接点方法调用前调用的方法，而 after() 方法则相反，这些注解中间使用了定义切点的正则式，也就是告诉 Spring AOP 需要拦截什么对象的什么方法，下面讲到。

**第三步：定义切点**  
在上面的注解中定义了 execution 的正则表达式，Spring 通过这个正则表达式判断具体要拦截的是哪一个类的哪一个方法：

***execution(* pojo.Landlord.service())**  
依次对这个表达式作出分析：

*  execution：代表执行方法的时候会触发
 *  \*：代表任意返回类型的方法
 *  pojo.Landlord：代表类的全限定名
 *  service()：被拦截的方法名称

通过上面的表达式，Spring 就会知道应该拦截 pojo.Lnadlord 类下的 service() 方法。上面的演示类还好，如果多出都需要写这样的表达式难免会有些复杂，我们可以通过使用 @Pointcut 注解来定义一个切点来避免这样的麻烦：

package aspect;
    
    import org.aspectj.lang.annotation.After;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Before;
    import org.aspectj.lang.annotation.Pointcut;
    import org.springframework.stereotype.Component;
    
    @Component
    @Aspect
    class Broker { 
    
        @Pointcut("execution(* pojo.Landlord.service())")
        public void lService() { 
        }
    
        @Before("lService()")
        public void before() { 
            System.out.println("带租客看房");
            System.out.println("谈价格");
        }
    
        @After("lService()")
        public void after() { 
            System.out.println("交钥匙");
        }
    }

#### 环绕通知 ####

我们来探讨一下环绕通知，这是 Spring AOP 中最强大的通知，因为它集成了前置通知和后置通知，它保留了连接点原有的方法的功能，所以它及强大又灵活，让我们来看看：

package aspect;
    
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.annotation.Around;
    import org.aspectj.lang.annotation.Aspect;
    import org.springframework.stereotype.Component;
    
    @Component
    @Aspect
    class Broker { 
    
    // 注释掉之前的 @Before 和 @After 注解以及对应的方法
    // @Before("execution(* pojo.Landlord.service())")
    // public void before() { 
    // System.out.println("带租客看房");
    // System.out.println("谈价格");
    // }
    //
    // @After("execution(* pojo.Landlord.service())")
    // public void after() { 
    // System.out.println("交钥匙");
    // }
    
        // 使用 @Around 注解来同时完成前置和后置通知
        @Around("execution(* pojo.Landlord.service())")
        public void around(ProceedingJoinPoint joinPoint) { 
            System.out.println("带租客看房");
            System.out.println("谈价格");
    
            try { 
                joinPoint.proceed();
            } catch (Throwable throwable) { 
                throwable.printStackTrace();
            }
    
            System.out.println("交钥匙");
        }
    }

运行测试代码，结果仍然正确：  
![在这里插入图片描述][20200621151832263.png]

#### 切面的优先级 ####

1.  如果同一个切面类中有多个同一类型的通知（比如前置通知），按照通知的定义顺序执行。
2.  如果有多个切面类，则可以通过设置切面类的order进行设置优先级，注意：order的数值越小越先执行。

> 作者：我没有三颗心脏  
> 链接：https://www.jianshu.com/p/994027425b44  
> 来源：简书

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW5nMTgyMzgwMzI4OTE_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200621150342511.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW5nMTgyMzgwMzI4OTE=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW5nMTgyMzgwMzI4OTE_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200621151758150.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW5nMTgyMzgwMzI4OTE=,size_16,color_FFFFFF,t_70
[20200621151832263.png]: https://img-blog.csdnimg.cn/20200621151832263.png