Spring 之 AOP

快来打我* 2024-04-06 11:13 77阅读 0赞

> 在软件业，AOP为Aspect Oriented Programming的缩写，意为：[面向切面编程][Link 1]，通过[预编译][Link 2]方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP是[OOP][]的延续，是软件开发中的一个热点，也是[Spring][]框架中的一个重要内容，是[函数式编程][Link 3]的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的[耦合度][Link 4]降低，提高程序的可重用性，同时提高了开发的效率。
> 
> AOP、OOP在字面上虽然非常类似，但却是面向不同领域的两种设计思想。OOP（[面向对象编程][Link 5]）针对业务处理过程的实体及其属性和行为进行抽象封装，以获得更加清晰高效的[逻辑单元][Link 6]划分。而AOP则是针对业务处理过程中的切面进行提取，它所面对的是处理过程中的某个步骤或阶段，以获得逻辑过程中各部分之间低[耦合性][Link 7]的隔离效果。这两种设计思想在目标上有着本质的差异。
> 
> AOP 并没有帮助我们解决任何新的问题，它只是提供了一种更好的办法，能够用更少的工作量来解决现有的一些问题，并且使得系统更加健壮，可维护性更好。同时，它让我们在进行系统架构和[模块设计][Link 8]的时候多了新的选择和新的思路。

### **基本概念** ###

*  Aspect（切面）： Aspect 声明类似于 Java 中的类声明，在 Aspect 中会包含着一些 Pointcut 以及相应的 Advice。
 *  Joint point（连接点）：连接点是在应用执行过程中能够插入切面的一个点。这个点可以是类的某个方法调用前、调用后、方法抛出异常后等。切面代码可以利用这些点插入到应用的正常流程之中，并添加行为
 *  Pointcut（切点）：表示一组 joint point，这些 joint point 或是通过逻辑关系组合起来，或是通过通配、正则表达式等方式集中起来，它定义了相应的 Advice 将要发生的地方。
 *  Advice（通知）：Advice 定义了在 Pointcut 里面定义的程序点具体要做的操作，它通过 before、after 和 around 来区别是在每个 joint point 之前、之后还是代替执行的代码。
 *  前置通知（Before）：在目标方法被调用之前调用通知功能。
 *  后置通知（After）：在目标方法完成之后调用通知，无论该方法是否发生异常。
 *  后置返回通知（After-returning）：在目标方法成功执行之后调用通知。
 *  后置异常通知（After-throwing）：在目标方法抛出异常后调用通知。
 *  环绕通知（Around）：通知包裹了被通知的方法，在被通知的方法调用之前和调用之后执行自定义的行为。
 *  Target（目标对象）：包含连接点的对象。也被称作被通知或被代理对象。
 *  AOP Proxy（AOP代理）：AOP框架创建的对象，包含通知。 在Spring中，AOP代理可以是JDK动态代理或者CGLIB代理
 *  Weaving（织入）：织入描述的是把切面应用到目标对象来创建新的代理对象的过程。 Spring AOP 的切面是在运行时被织入，原理是使用了动态代理技术
 *  introduction（引入）：在不修改代码的前提下，引入可以在**运行期**为类动态地添加一些方法或字段。

> AOP中的Joinpoint可以有多种类型：构造方法调用，字段的设置和获取，方法的调用，方法的执行，异常的处理执行，类的初始化。也就是说在AOP的概念中我们可以在上面的这些Joinpoint上织入我们自定义的Advice，但是在Spring中却没有实现上面所有的joinpoint，确切的说，Spring只支持方法执行类型的Joinpoint。

### **Spring对AOP的支持** ###

**Spring中AOP代理由Spring的IOC容器负责生成、管理，其依赖关系也由IOC容器负责管理**。因此，AOP代理可以直接使用容器中的其它bean实例作为目标，这种关系可由IOC容器的依赖注入提供。Spring创建代理的规则为：

1、**默认使用Java动态代理来创建AOP代理**，这样就可以为任何接口实例创建代理了

2、**当需要代理的类不是代理接口的时候，Spring会切换为使用CGLIB代理**，也可强制使用CGLIB

AOP编程其实是很简单的事情，纵观AOP编程，程序员只需要参与三个部分：

1、定义普通业务组件

2、定义切入点，一个切入点可能横切多个业务组件

3、定义增强处理，增强处理就是在AOP框架为普通业务组件织入的处理动作

所以进行AOP编程的关键就是定义切入点和定义增强处理，一旦定义了合适的切入点和增强处理，AOP框架将自动生成AOP代理，即：**代理对象的方法=增强处理+被代理对象**的方法。

@Aspect:作用是把当前类标识为一个切面供容器读取
     
    @Pointcut：Pointcut是植入Advice的触发条件。每个Pointcut的定义包括2部分，一是表达式，二是方法签名。方法签名必须是 public及void型。可以将Pointcut中的方法看作是一个被Advice引用的助记符，因为表达式不直观，因此我们可以通过方法签名的方式为 此表达式命名。因此Pointcut中的方法只需要方法签名，而不需要在方法体内编写实际代码。
    @Around：环绕增强，相当于MethodInterceptor
    @AfterReturning：后置增强，相当于AfterReturningAdvice，方法正常退出时执行
    @Before：标识一个前置增强方法，相当于BeforeAdvice的功能，相似功能的还有
    @AfterThrowing：异常抛出增强，相当于ThrowsAdvice
    @After: final增强，不管是抛出异常或者正常退出都会执行

### 集成项目 ###

#### **常规方式** ####

首先编写我们的业务接口和实现类

public interface UserService {
    
       public void add();
    
       public void delete();
    
       public void update();
    
       public void search();
    
    }
    public class UserServiceImpl implements UserService{
    
       @Override
       public void add() {
           System.out.println("增加用户");
      }
    
       @Override
       public void delete() {
           System.out.println("删除用户");
      }
    
       @Override
       public void update() {
           System.out.println("更新用户");
      }
    
       @Override
       public void search() {
           System.out.println("查询用户");
      }
    }

@Aspect
    @Component
    public class AspectConfig {
    
        /**
         * Pointcut
         */
        @Pointcut("(execution(* com.yang.service.impl.UserServiceImpl.*(..)))")
        public void expression() {
        }
    
        @Before("expression()")
        public void before(){
            System.out.println("---------方法执行前---------");
        }
    
        @After("expression()")
        public void after(){
            System.out.println("---------方法执行后---------");
        }
    
        @Around("expression()")
        public void around(ProceedingJoinPoint jp) throws Throwable {
            System.out.println("环绕前");
            System.out.println("签名:"+jp.getSignature());
            //执行目标方法proceed
            Object proceed = jp.proceed();
            System.out.println("环绕后");
            System.out.println(proceed);
        }
    }

#### **自定义注解** ####

@Target({ElementType.METHOD})
    @Retention(RetentionPolicy.RUNTIME)
    public @interface AspectAnnotation {
        String name() default "默认值";
    }

@Aspect
    @Component
    public class AspectAnnotationConfig {
    
        @Pointcut(value = "@annotation(com.yang.config.AspectAnnotation)")
        public void expression() {
        }
    
        @Before("expression()")
        public void before(){
            System.out.println("---------方法执行前---------");
        }
    }

@Service
    public class UserServiceImpl implements UserService {
    
        @AspectAnnotation
        @Override
        public void add() {
            System.out.println("增加用户");
        }
    }

[Link 1]: https://baike.baidu.com/item/%E9%9D%A2%E5%90%91%E5%88%87%E9%9D%A2%E7%BC%96%E7%A8%8B/6016335?fromModule=lemma_inlink
[Link 2]: https://baike.baidu.com/item/%E9%A2%84%E7%BC%96%E8%AF%91/3191547?fromModule=lemma_inlink
[OOP]: https://baike.baidu.com/item/OOP?fromModule=lemma_inlink
[Spring]: https://baike.baidu.com/item/Spring?fromModule=lemma_inlink
[Link 3]: https://baike.baidu.com/item/%E5%87%BD%E6%95%B0%E5%BC%8F%E7%BC%96%E7%A8%8B/4035031?fromModule=lemma_inlink
[Link 4]: https://baike.baidu.com/item/%E8%80%A6%E5%90%88%E5%BA%A6/2603938?fromModule=lemma_inlink
[Link 5]: https://baike.baidu.com/item/%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1%E7%BC%96%E7%A8%8B?fromModule=lemma_inlink
[Link 6]: https://baike.baidu.com/item/%E9%80%BB%E8%BE%91%E5%8D%95%E5%85%83?fromModule=lemma_inlink
[Link 7]: https://baike.baidu.com/item/%E8%80%A6%E5%90%88%E6%80%A7?fromModule=lemma_inlink
[Link 8]: https://baike.baidu.com/item/%E6%A8%A1%E5%9D%97%E8%AE%BE%E8%AE%A1?fromModule=lemma_inlink