Spring: AOP使用代码_详解

﹏ヽ暗。殇╰゛Y 2023-08-17 16:47 64阅读 0赞

# Spring AOP #

AOP解决的是`在不修改或少修改现有代码的基础上实现功能增强`的问题

对于实现功能增强, 常见的可使用方式有装饰模式, 代理模式(静态代理, JDK动态代理, cglib动态代理), 继承等, 当然各自有其局限性, 但合适的场景下都能做到不修改现有代码实现功能增强.

而AOP使用的则是动态代理的方式, 实现的关键是AOP框架自动创建的AOP代理

AOP代理主要分为:

*  静态代理:编译期实现, 更好的性能, AspectJ为代表(AOP框架会在编译阶段生成AOP代理类, 其字节码就织入了增强后功能)
 *  动态代理:运行期实现, Spring AOP为代表
    
     *  JDK动态代理:通过反射来接收被代理的类, 要求被代理的类必须实现一个接口, 核心是`InvocationHandler`接口和`Proxy`类
     *  CGLIB动态代理:Code Generation Library, 目标类没有实现接口, 可以在运行时动态的生成某个类的子类

> CGLIB是通过继承的方式做的动态代理, 因此如果某个类被标记为final, 那么它是无法使用CGLIB做动态代理的, 诸如private的方法也是不可以作为切面的

<table> 
 <thead> 
  <tr> 
   <th>术语</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Target</td> 
   <td>目标类, 需要对功能增强的类</td> 
  </tr> 
  <tr> 
   <td>JoinPoint</td> 
   <td>连接点, 目标类上可以被增强的方法, 可以被增强的方法也可以选择是否增强</td> 
  </tr> 
  <tr> 
   <td>PointCut</td> 
   <td>切入点, 被增强的方法, 实际上功能被增强的方法.连接点和切入点是父子集关系</td> 
  </tr> 
  <tr> 
   <td>Advice</td> 
   <td>增强/通知, 用于增强功能的方法组成切面类. 类中的每个方法都代表一个新功能, 这种方法被称为通知</td> 
  </tr> 
  <tr> 
   <td>Weaving</td> 
   <td>织入, 将切入点和通知结合, 达到增强功能的过程, 实质是创建一个代理对象的过程</td> 
  </tr> 
  <tr> 
   <td>Proxy</td> 
   <td>代理, 一个类被AOP织入增强后, 就产生一个结果代理类</td> 
  </tr> 
  <tr> 
   <td>Aspect</td> 
   <td>切面, 切入点和通知结合所形成的横向切面, 是一个抽象概念.如被同一通知增强的多个切入点所构成的切面</td> 
  </tr> 
  <tr> 
   <td>Introduction</td> 
   <td>引介, 一种特殊的通知, 可以在运行期为类动态地添加一些方法或Field</td> 
  </tr> 
 </tbody> 
</table>

# 实现 #

1.  开发者配置`ProxyFactoryBean`和织入的方式
2.  使用`<aop:config>`配置织入等的方式
3.  使用AspectJ的方式

首先给出示例代码的抽象层和代理目标, 之后的实例都是代理该目标:

package com.testAop;
    // 抽象层
    public interface Printable {
        void printlog();
    }

package com.testAop;
    // 代理目标类
    public class LogPrinter implements Printable {
        @Override
        public void printlog() {
            System.out.println("打印Log...");
        }
    }

## 方式1 ##

package com.testAop;
    
    import org.aopalliance.intercept.MethodInterceptor;
    import org.aopalliance.intercept.MethodInvocation;
    
    public class PrinterAspect implements MethodInterceptor {
        public Object invoke(MethodInvocation mi) throws Throwable {
            System.out.println("打印前......");
            Object obj = mi.proceed();
            System.out.println("打印后......");
            return obj;
        }
    }

ApplicationContext.xml:

<bean id="docPrinter" class="org.luvx.service.impl.DocPrinter"></bean>
    <bean id="printerAspect" class="org.luvx.aspect.PrinterAspect1"></bean>
             
    <bean id="proxyFactory" class="org.springframework.aop.framework.ProxyFactoryBean">
    
    
     
    
    <property name="target" ref="docPrinter"></property>
    
    
    <property name="interceptorNames">
        <list>
            <value>printerAspect</value>
        </list>
    </property>
     
    
    
    </bean>

需要配置工厂bean

*  目标类的确定太小了, 每次只能指定一个目标类, 如果我们想对别的类也进行加强, 那么就需要在工厂bean中又配置一个目标类

## 方式2 ##

在方式1基础上, 只需要修改配置方式, 不再自己设置工厂bean, 并扩大了目标类的范围

## 方式3 ##

方式1, 2中, 在切面类中需要实现接口并重写方法

下面介绍使用`AspectJ`框架实现AOP, 不用实现接口且能灵活的指定通知.

首先需要将切面类修改为:

import org.aspectj.lang.ProceedingJoinPoint;
    public class PrinterAspect {
    
        public Object testAround(ProceedingJoinPoint joinPoint) throws Throwable {
            System.out.println("打印前......");
            Object obj = joinPoint.proceed();
            System.out.println("打印后......");
            return obj;
        }
    }

**通知类型**

<table> 
 <thead> 
  <tr> 
   <th>类型</th> 
   <th>说明</th> 
   <th>配置标签</th> 
   <th>注解</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>before</td> 
   <td>前置通知, 在方法执行前执行, 如果通知抛出异常, 阻止方法运行, 可用于各种校验</td> 
   <td>aop:before</td> 
   <td>@Before</td> 
  </tr> 
  <tr> 
   <td>around</td> 
   <td>环绕通知, 方法执行前后分别执行, 可以阻止方法的执行. 要求必须手动执行目标方法.</td> 
   <td>aop:around</td> 
   <td>@Around</td> 
  </tr> 
  <tr> 
   <td>after</td> 
   <td>最终通知, 方法执行完毕后执行, 无论方法是否出现异常, 可清理现场</td> 
   <td>aop:after</td> 
   <td>@After</td> 
  </tr> 
  <tr> 
   <td>afterReturning</td> 
   <td>后置通知, 方法正常返回后执行, 可以获得方法的返回值, 如果方法中抛出异常, 通知无法执行,可用于常规数据处理)</td> 
   <td>aop:after-returning</td> 
   <td>@AfterReturning</td> 
  </tr> 
  <tr> 
   <td>afterThrowing</td> 
   <td>抛出异常通知, 方法抛出异常后执行, 如果方法没有抛出异常, 不会执行, 可用于封装异常信息</td> 
   <td>aop:after-throwing</td> 
   <td>@AfterThrowing</td> 
  </tr> 
 </tbody> 
</table>

> 另外有一种不常用的引介通知, 配置标签为`aop:declare-parents`.

### xml实现 ###

关注的点只有切面类(不需要实现通知类型接口), 切入点范围, 还有通知类型. 所以在配置文件中, 也只需要配置这三个关键的东西即可

我们知道织入过程表面上是切入点和通知结合的过程, 代码上可以体现为上述配置`pointcut-ref`属性的过程

### 注解实现 ###

此种实现和xml实现时相同的原理, 不同之处在于能够尽量较少配置文件的内容

步骤共有6步:

1.  扫描目标类:添加`@component`
2.  扫描切面类:添加`@component`
3.  声明切面类:添加`@Aspect`
4.  指定切入点:添加`@Pointcut("execution(* org.luvx.anno.service.impl.*.*(..))")`
5.  指定通知:添加`@Around("pointCut()")`
6.  在xml中扫描注解和启用aop, 如下
7.      <context:component-scan base-package="org.luvx.anno"></context:component-scan>
        <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
    
    切面类:

package com.testAop;
    
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.annotation.Around;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Pointcut;
    import org.springframework.stereotype.Component;
    
    @Component
    @Aspect
    public class PrinterAspectConf {
    
        @Pointcut("execution(* com.testAop.*.*(..))")
        private void pointCut() {
        }
    
        @Around("pointCut()")
        public Object testAround(ProceedingJoinPoint joinPoint) throws Throwable {
            System.out.println("打印前......");
            Object obj = joinPoint.proceed();
            System.out.println("打印后......");
            return obj;
        }
    }

**注意点**

> 指定切入点时, 切入点的方法是`private void`, 且没有参数的, 指定通知时, 需要指明切入点, 即注解value值为切入点方法 `@AfterReturning` 使用此注解可以获得返回值, 必须在注解中确定返回值参数名称。 `@AfterThrowing` 使用此注解在遇到异常时, 可以获得具体异常信息, 必须在注解确定第二个参数名称
> 
> 原文：http://211.159.175.179/article/69