Java实战之03Spring-03Spring的核心之AOP（Aspect Oriented Programming 面向切面编程）

Posted 2020-07-29 铭昊Coder

三、Spring的核心之AOP（Aspect Oriented Programming 面向切面编程）

1、AOP概念及原理

1.1、什么是AOP

OOP：Object Oriented Programming面向对象编程

AOP：Aspect Oriented Programming面向切面编程

1.2、代理

充分理解：间接

主要作用：拦截被代理对象执行的方法，同时对方法进行增强。

1.2.1、静态代理

特点：代理类是一个真实存在的类。装饰者模式就是静态代理的一种体现形式。

1.2.2、动态代理

特点：字节码是随用随创建，随用随加载。是在运行期间生成的一个类。

a、基于接口的动态代理

提供者：JDK官方的Proxy类。

要求：被代理类必须实现一个或多个接口。

b、基于子类的动态代理

提供者：第三方的CGLib，如果报asmxxxx异常，需要导入asm.jar。

要求：被代理类必须是一个子类（不能用final修饰的（最终类），其余类都没问题，因为都是Object的子类）。

注意：在spring中，框架会根据目标类是否实现了接口来决定采用哪种动态代理的方式。

1.3、通过动态代理技术实现AOP思想

1.3.1、回顾转账案例事务支持的四个版本

a、不使用事务

b、持久层介入了业务层处理（越权操作）

c、业务层控制事务，但是出现了持久层的接口，类和相关代码

d、使用ThreadLocal进行解耦

e、借助动态代理技术，实现面向切面编程思想来控制事务

2、Spring中的AOP

2.1、基本概念

连接点(Joinpoint)：连接点指类中的核心业务方法

切入点(Pointcut)：

连接点不一定是切入点，但切入点一定是连接点。

通知(Advice)

通知就是指那些有公用代码的类。

通知中有好多的方法：通知类型。前置通知|后置通知|异常通知|最终通知|环绕通知

目标对象(Target Object)

AOP代理(AOP Proxy)

织入(Weaving)：把通知运行期间插入到核心代码中运行，过程叫做织入

切面(Aspect)：公用代码所关心的某一方面（事务是一个方面；日志也是一个方面）

2.2、具体配置

2.2.1、Spring中的AOP

a、开发阶段（我们做的）

1) 编写核心业务代码（开发主线）：大部分程序员来做，要求熟悉业务需求。

2) 把公用代码抽取出来，制作成通知。（开发阶段最后再做）：AOP编程人员来做。

3) 在配置文件中，声明切入点与通知间的关系，即切面。：AOP编程人员来做。

b、运行阶段（Spring框架完成的）

Spring框架监控切入点方法的执行。一旦监控到切入点方法被运行，使用代理机制，动态创建目标对象的代理对象，根据通知类别，在代理对象的对应位置，将通知对应的功能织入，完成完整的代码逻辑运行。

2.2.2、基于XML的配置

2.2.2.1、AOP的基本配置

a、导入AOP相关的jar包（Spring的AOP是基于IoC的，所以IoC的jar也必须存在）

AOP有关的jar包：4个

b、引入aop名称空间

c、配置切面

 1 <!-- AOP的配置 -->
 2     <aop:config>
 3         <!-- 配置所有切面通用的切入点表达式 -->
 4         <aop:pointcut expression="execution(* cn.itcast.service.impl.*.*(..))" id="pt1"/>
 5     
 6         <!-- 配置切面：切面就是关心的某一个方面 
 7             id：指定的是通知的唯一标识
 8             ref：指定的通知的bean的id
 9         -->
10         <aop:aspect id="loggerAdvice" ref="logger">
11             <!-- 抽取当前切面的通用切入点表达式 
12                 expression属性：指定的就是切入点表达式
13                 id属性：是把切入点表达式赋予唯一标识
14             
15             <aop:pointcut expression="execution(* cn.itcast.service.impl.*.*(..))" id="pt1"/>
16             -->
17             <!-- 配置通知的类型：指的就是在业务核心方法的什么时候执行 
18                 aop:before：指定的是前置通知
19             
20                 method属性：指的是通知里面的哪个方法执行
21                 pointcut属性：指定的是切入点表达式。表明从哪里切入业务主线。
22                             把哪些连接点变成切入点。
23                 切入点表达式：
24                     关键字：execution(表达式)
25                     表达式语法：
26                         访问修饰符  返回值  包名.类名.方法名(参数列表)
27                     全匹配方式：
28                         execution(public void cn.itcast.service.impl.UserServiceImpl.saveUser())
29                     访问修饰符可以不写：
30                         execution(void cn.itcast.service.impl.UserServiceImpl.saveUser())
31                     返回值可以使用通配符：通配符*
32                         execution(* cn.itcast.service.impl.UserServiceImpl.saveUser())
33                     包名可以使用通配符：当使用通配符时，有几级包，写几个*
34                         execution(* *.*.*.*.UserServiceImpl.saveUser())
35                     包名称可以使用..，表明的是当前包及其子包
36                         execution(* cn..UserServiceImpl.saveUser())
37                     类名可以使用通配符：
38                         execution(* cn..*.saveUser())
39                     方法名可以使用通配符：
40                         execution(* cn..*.*())
41                     参数列表可以指定类型：注意的是，如果是基本类型直接写类型名称，如果是引用类型，需要些包名.类名。lang也必须写。例如：java.lang.String
42                         execution(* *..*.*(int))
43                     参数列表可以使用通配符：注意:不能表示有无参数均可。只能表示参数的数据类型是任意的
44                         execution(* *..*.*(*))
45                     有无参数均可，可以使用..来表示：
46                         execution(* *..*.*(..))
47                     最简版：
48                         execution(* *..*.*(..))
49                     建议的写法：
50                         切到业务层具体实现类即可：
51                             execution(* cn.itcast.service.impl.*.*(..))
52                             
53                     pointcut-ref：指定的是通用切入点表达式的唯一标识
54                 -->
55             <aop:before method="printLog" pointcut-ref="pt1"/>        
56         </aop:aspect>
57     </aop:config>

2.2.2.2、切入点表达式

execution:匹配方法的执行(常用)execution(public * *(..))

基本语法：execution([修饰符] 返回值类型 包名.类名.方法名(参数))

within:匹配包或子包中的方法(了解)   within(cn.itcast.aop..*)

this:匹配实现接口的代理对象中的方法(了解) this(cn.itcast.aop.user.UserDAO)

target:匹配实现接口的目标对象中的方法(了解) target(cn.itcast.aop.user.UserDAO)

args:匹配参数格式符合标准的方法(了解) args(int,int)

Spring支持使用如下三个逻辑运算符来组合切入点表达式：

&&：要求连接点同时匹配两个切点表达式

||：要求连接点匹配至少一个切入点表达式

!：要求连接点不匹配指定的切入点表达式

2.2.2.3、切入点的配置方式

方式1：

方式2：

方式3：

1 <aop:pointcut expression="execution(* cn.itcast.service.impl.*.*(..))" id="pt1"/>
2 <aop:before method="printLog" pointcut-ref="pt1"/>

2.2.2.4、通知的类型

 1 <!-- 配置所有切面通用的切入点表达式 -->
 2         <aop:pointcut expression="execution(* cn.itcast.service.impl.*.*(..))" id="pt1"/>
 3         <aop:aspect id="loggerAdvice" ref="logger">
 4             <!-- 指定通知的类型-->
 5             <!-- 前置通知：永远在切入点方法执行之前执行
 6                  它可以获取切入点方法的参数
 7             
 8             <aop:before method="beforePrintLog" pointcut-ref="pt1"/>    -->
 9             
10             <!-- 后置通知：切入点方法正确执行之后执行。它和例外通知只会有一个执行 
11                 它可以获取切入点方法的返回值
12                 除了在通知的方法中提供一个参数之外，还需要在配置文件中提供一个属性
13                 returning属性：指定的是后置通知中方法参数的变量名称，严格区分大小写。
14             
15             <aop:after-returning method="afterReturningPrintLog" pointcut-ref="pt1" returning="rtValue"/>-->
16             
17             <!-- 例外通知：切入点方法执行时产生异常后执行。它和后置通知只会有一个执行 
18                 除了在通知的方法中提供一个Throwable类型的参数之外，还需要在配置文件中提供一个属性
19                 throwing属性：指定的是例外通知中方法参数的变量名称。严格区分大小写。
20             -->
21             <aop:after-throwing method="afterThrowingprintLog" pointcut-ref="pt1" throwing="th"/>
22             
23             <!-- 最终通知：无论切入点方法是否正确执行了，它都会在最后执行 
24             <aop:after method="printLog" pointcut-ref="pt1"/>-->
25             
26             <!-- 环绕通知：详情请见Logger类中的注释
27             <aop:around method="aroundPrintLog" pointcut-ref="pt1"/>-->
28         </aop:aspect>

 1     /**
 2      * 前置通知：它可以获取切入点方法的参数
 3      * Spring框架给我们提供了一个接口：JoinPoint
 4      * 在程序执行到前置通知方法时，spring框架会为我们注入该接口的实现类。
 5      * 该接口中有一个方法：
 6      *         Object[] args = jp.getArgs();
 7      */
 8     public static void beforePrintLog(JoinPoint jp){
 9         Object[] args = jp.getArgs();
10         System.out.println(Arrays.toString(args));
11         System.out.println("Logger的beforePrintLog方法开始记录日志。。。。。。。");
12     }
13     
14     /**
15      * 后置通知：它可以获取切入点方法的返回值
16      * 需要我们在后置通知的方法中提供一个参数，参数的类型是Object
17      * 参数的变量名称必须和配置文件中的returning属性保持一致
18      */
19     public static void afterReturningPrintLog(Object rtValue){
20         System.out.println(rtValue);
21         System.out.println("Logger的afterReturningPrintLog方法开始记录日志。。。。。。。");
22     }
23     
24     /**
25      * 例外通知：它可以获取切入点方法的异常对象
26      * 需要我们在例外通知的方法中提供一个参数，参数的类型是Throwable
27      * 参数的变量名称必须和配置文件中的throwing属性保持一致 
28      */
29     public static void afterThrowingprintLog(Throwable th){
30         System.out.println("异常信息是："+th);
31         System.out.println("Logger的afterThrowingprintLog方法开始记录日志。。。。。。。");
32     }
33     
34     /**
35      * 环绕通知详细说明：
36      *         它不是在配置切入点方法的前后执行，而是spring给我们提供的一种方式。让我们自己决定该通知是前置还是后者，例外还是最终。
37      * 问题：
38      *     当我们执行时，只会看见通知方法的语句输出，而看不到业务核心方法的输出语句。
39      * 分析原因：
40      *     在我们使用动态代理控制事务时，有明确的一句话调用业务核心方法：method.invoke(obj,args);
41      *     而此时我们没有明确的调用业务核心方法。
42      *     所以只能看到通知的语句输出，而无法看到业务核心方法的语句输出。
43      * 解决办法：
44      *     Spring给我们提供的一个接口：ProceedingJoinPoint
45      *     当Spring框架在执行通知时，会为我们提供该接口的实现类，我们在使用时，直接用即可。无须关心谁给我们提供。
46      *     ProceedingJoinPoint接口有一个方法：proceed()，它就相当于method的invoke方法。
47      *      pjp.proceed();    ======== method.invoke(obj,args);
48      *  
49      */
50     public static void aroundPrintLog(ProceedingJoinPoint pjp){
51         try {
52 //            System.out.println("Logger的aroundPringLog方法开始记录日志。。。。。。。");
53             pjp.proceed();
54 //            System.out.println("Logger的aroundPringLog方法开始记录日志。。。。。。。");
55         } catch (Throwable e) {
56 //            System.out.println("Logger的aroundPringLog方法开始记录日志。。。。。。。");
57             e.printStackTrace();
58         }finally{
59             System.out.println("Logger的aroundPringLog方法开始记录日志。。。。。。。");
60         }
61         
62     }

注意：相同类型的通知，执行的先后顺序是由配置文件的前后顺序决定的。

2.2.2.5、前置通知获取参数

2.2.2.6、后置通知获取返回值

2.2.2.7、异常通知获取异常对象

2.2.3、基于注解的配置

2.2.3.1、使用Spring注解进行AOP配置的前提

a、资源交给Spring管理（核心业务对象，通知对象）

注意：代码中请使用@Compoment注解。

b、AOP有关的注解配置

开启Spring对@AspectJ注解的支持

c、常用的AOP注解

@Aspect 配置切面

@Before：前置通知

@AfterReturning:后置通知

@AfterThrowing：异常通知

@After：最终通知

@Around：环绕通知

d、配置一个前置通知的例子

2.2.3.2、切入点的配置

a、局部的：只能当前方法使用

b、使用@Pointcut：配置公用的切入点

要求：声明在无返回值方法上方，方法名即切入点名称，方法最好声明为private

c、配置全局的

2.2.3.3、前置通知获取参数

2.2.3.4、后置通知获取返回值

2.2.3.5、异常通知获取异常对象

2.2.3.6、多个相同类型的通知执行顺序

核心业务代码：