Spring 学习笔记 Part07

1. AOP的概念

全称 Aspect Oriented Programming，即面向切面编程。简单来说就是把我们程序重复的代码段抽取出来，在需要执行的时候，使用动态代理的技术，在不修改源码的基础上，对我们已有的方法进行增强。

作用：在程序运行期间，可以不修改源码对已有方法进行增强。

优势：减少重复代码，提高开发效率，维护方便。

2. Spring 中的 AOP

Spring 中的 AOP 是通过配置的方式来实现上一章节的内容（动态代理）。

AOP的相关术语：

Joinpoint（连接点）：

所谓连接点是指那些被拦截到的点。在 Spring 中，这些点指的是方法，因为 Spring 只支持方法类型的连接点。

Pointcut（切入点）：

所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义。

通俗的说，业务层中所有的方法都是连接点，通过 if (” “.equals( method.getName( ) ) ) 拦截并增强的就是切入点。

Advice（通知/增强）：

所谓通知是指拦截到连接点之后所要做的事情是通知。

通知的类型：前置通知、后置通知、异常通知、最终通知、环绕通知。（本part第5、6小节介绍）

Introduction（引介）：

引介是一种特殊的通知在不修改类代码的前提下，Introduction可以在运行期为类动态地添加一些方法或 Field。

Target（目标对象）：

代理的目标对象。

Weaving（织入）：

是指增强目标对象到创建新的代理对象的过程。

Spring 采用动态代理织入，而 AspectJ 采用编译器织入和类装载期织入。

Proxy（代理）：

一个类被 AOP 织入增强后，就产生一个结果代理类。
Aspect（切面）：

是切入点和通知（引介）的结合（通俗的说就是被增强类的方法和调用的工具类的方法的对应关系）。

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

3. 基于XML的AOP配置

导入AOP的约束

<?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: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/aop 
                 http://www.springframework.org/schema/aop/spring-aop.xsd">
</beans>

spring中基于XML的AOP配置步骤

1、把业务层Bean和通知Bean注入，都交给spring来管理

service层对象
<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl"/>
以日志对象为例，作为AOP的通知
<bean id="logger" class="com.itheima.utils.Logger"/>

2、使用< aop:config >标签表明开始AOP的配置

<aop:config>
   <!-- 标签体内用于配置切面 -->
</aop:config>

3、使用< aop:aspect >标签表明配置切面

id属性：是给切面提供一个唯一标识，随便取名

ref属性：是指定通知类bean的Id

<aop:config>
    <aop:aspect id="logAdvice" ref="logger">
        <!-- 标签体内用于配置通知的类型、通知使用的方法、和与切入点方法的关联 -->
    </aop:aspect>
</aop:config>

4、在< aop:aspect >标签的内部使用对应标签来配置通知的类型

（我们现在示例是让printLog方法在切入点方法执行之前之前：所以是前置通知）

< aop:before >：表示配置前置通知

method属性：用于指定Logger类中哪个方法是前置通知

pointcut属性：用于指定切入点表达式，该表达式的含义指的是对业务层中哪些方法增强

ponitcut-ref属性：用于指定切入点的表达式的引用

方法一：pointcut属性直接指定
	（写在aop:aspect标签内部就仅能当前切面使用）

<aop:config>
    <aop:aspect id="logAdvice" ref="logger">
        <aop:before method="printLog" 
                    pointcut="execution(public void com.itheima.service.impl.AccountServiceImpl.saveAccount())">
        </aop:before>
    </aop:aspect>
</aop:config>

方法二：分离配置，用pointcut-ref属性指定外部配置好的pointcut的id
	（写在aop:aspect外面，就变成了所有切面可用）
<aop:config>
    <aop:pointcut id="pt1" 
                  expression="execution(public void com.itheima.service.impl.AccountServiceImpl.saveAccount())" >
    </aop:pointcut>
    <aop:aspect id="logAdvice" ref="logger">
        <aop:before method="printLog" pointcut-ref="pt1"/>
    </aop:aspect>
</aop:config>
切入点表达式配置（aop:pointcut）必须在切面（aop:aspect）之前。

pointcut的属性：
	id属性：用于指定表达式的唯一标识。
	expression属性：用于指定表达式内容。

切入点表达式的写法：

在内部配置时在< aop:[advice-type] >标签的pointcut属性里使用关键字，或在分离配置时在< pointcut >标签里的expression属性里使用关键字。

关键字：execution(表达式)

表达式：
访问修饰符返回值包名.包名.包名.类名.方法名(参数列表)

标准的表达式写法：
public void com.itheima.service.impl.AccountServiceImpl.saveAccount( )

4. 切入点表达式的写法

导入切入点表达式解析器的坐标

<dependencies>
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.8.13</version>
    </dependency>
</dependencies>

切入点表达式的语法

关键字：execution(表达式)
        表达式：
        	访问修饰符  返回值  包名.包名.包名...类名.方法名(参数列表)
        标准的表达式写法：
        	public void com.itheima.service.impl.AccountServiceImpl.saveAccount()
        访问修饰符可以省略
        	void com.itheima.service.impl.AccountServiceImpl.saveAccount()
        返回值可以使用通配符，表示任意返回值
        	* com.itheima.service.impl.AccountServiceImpl.saveAccount()
        包名可以使用通配符，表示任意包。但是有几级包，就需要写几个*.
        	* *.*.*.*.AccountServiceImpl.saveAccount())
        包名可以使用..表示当前包及其子包
        	* com..AccountServiceImpl.saveAccount()
        	* *..AccountServiceImpl.saveAccount()
        类名和方法名都可以使用*来实现通配
        	* *..*.*()
        参数列表：
        1.可以直接写数据类型：
        	基本类型直接写名称           
        		* *..*.*(int)
        	引用类型写包名.类名的方式     
        		* *..*.*(java.lang.String)
        2.可以使用通配符表示任意类型，但是必须有参数
        	* *..*.*(*)
        3.可以使用..表示有无参数均可，有参数可以是任意类型
        	* *..*.*(..)
        	
        全通配写法：
        * *..*.*(..)

        实际开发中切入点表达式的通常写法：
        切到业务层实现类下的所有方法
        * com.itheima.service.impl.*.*(..)

5. 四种常用通知类型

配置前置通知 < aop:before >：在切入点方法执行之前执行
配置后置通知< aop:after-returning >：在切入点方法正常执行之后值。（它和异常通知永远只能执行一个）
配置异常通知< aop:after-throwing >：在切入点方法执行产生异常之后执行。（它和后置通知永远只能执行一个）
配置最终通知< aop:after >：无论切入点方法是否正常执行它都会在其后面执行

<aop:config>
       <!--配置表达式 -->
        <aop:pointcut id="pt1" expression="execution(* com.itheima.service.impl.*.*(..))"/>
    
        <!--配置切面 -->
        <aop:aspect id="logAdvice" ref="logger">
            
            配置前置通知：在切入点方法执行之前执行
            <aop:before method="beforePrintLog" pointcut-ref="pt1" />

            配置后置通知：在切入点方法正常执行之后值。（它和异常通知永远只能执行一个）
            <aop:after-returning method="afterReturningPrintLog" pointcut-ref="pt1"/>

            配置异常通知：在切入点方法执行产生异常之后执行。（它和后置通知永远只能执行一个）
            <aop:after-throwing method="afterThrowingPrintLog" pointcut-ref="pt1"/>

            配置最终通知：无论切入点方法是否正常执行它都会在其后面执行
            <aop:after method="afterPrintLog" pointcut-ref="pt1"/>

        </aop:aspect>
</aop:config>

通俗的说，以切入点方法执行函数method.invoke( )为基准，前置通知aop:before在它执行前执行，后置通知aop:after-returning在它执行后执行。异常通知aop:after-throwing在产生异常时执行（catch里），最终通知aop:after无论程序正常异常与否都会执行（finally里）。

值得注意的是，后置通知aop:after-returning和异常通知aop:after-throwing永远只会执行一个（要么程序正常，要么程序异常）。

/**
 * 用记录日志的工具类举例，它负责提供公共的代码让AOP调用
 */
public class Logger {

    /**
     * 前置通知
     */
    public  void beforePrintLog(){
        System.out.println("前置通知Logger类中的beforePrintLog方法开始记录日志了。。。");
    }

    /**
     * 后置通知
     */
    public  void afterReturningPrintLog(){
        System.out.println("后置通知Logger类中的afterReturningPrintLog方法开始记录日志了。。。");
    }
    /**
     * 异常通知
     */
    public  void afterThrowingPrintLog(){
        System.out.println("异常通知Logger类中的afterThrowingPrintLog方法开始记录日志了。。。");
    }

    /**
     * 最终通知
     */
    public  void afterPrintLog(){
        System.out.println("最终通知Logger类中的afterPrintLog方法开始记录日志了。。。");
    }
    
}

6. 环绕通知

spring中的环绕通知是spring框架为我们提供的一种可以在代码中手动控制增强方法何时执行的方式。

先在xml中配置环绕通知，详细的业务需要在Logger类中配置。

<aop:config>
       
        <aop:pointcut id="pt1" expression="execution(* com.itheima.service.impl.*.*(..))"></aop:pointcut>
       
        <aop:aspect id="logAdvice" ref="logger">
            <!-- 配置环绕通知 详细的业务需要在Logger类中配置-->
            <aop:around method="aroundPrintLog" pointcut-ref="pt1"/>
        </aop:aspect>
    
</aop:config>

当我们配置了环绕通知之后，将会调用 Logger 类中的 aroundPrintLog 方法。但是切入点方法就不会自动执行了，需要实现的业务需要我们自行在Logger类中编写。

Spring框架为我们提供了一个接口：ProceedingJoinPoint。该接口有一个方法 proceed( ) ，此方法就相当于明确调用切入点方法。该接口可以作为环绕通知的方法参数，在程序执行时，spring框架会为我们提供该接口的实现类供我们使用。

public class Logger {

    /* 环绕通知，实际就是回归自行编写的方式实现动态代理 */
    public Object aroundPringLog(ProceedingJoinPoint pjp){
        Object rtValue = null;
        try{
            Object[] args = pjp.getArgs();//得到方法执行所需的参数

            System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。前置");

            rtValue = pjp.proceed(args);//明确调用业务层方法（切入点方法）

            System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。后置");

            return rtValue;
        }catch (Throwable t){
            System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。异常");
            throw new RuntimeException(t);
        }finally {
            System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。最终");
        }
    }
}