2020-06-20

SSM-Spring【实现AOP】

字数统计: 2.9k字 | 阅读时长: 12分

一、AOP的简单了解

（一）什么是AOP

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

（二）AOP的作用及优势

作用：
在程序运行期间，不修改源码对已有方法进行增强。
优势：
减少重复代码
提高开发效率
维护方便

二、Spring中的AOP术语和细节

1、Joinpoint（连接点）：
所谓连接点是指那些被拦截到的点。在 spring 中,这些点指的是方法,因为 spring 只支持方法类型的连接点
2、Pointcut（切入点）：
所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义
3、Advice（通知/增强）：
所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知
通知的类型：前置通知,后置通知,异常通知,最终通知,环绕通知
4、Introduction（引介）：
引介是一种特殊的通知在不修改类代码的前提下, Introduction 可以在运行期为类动态地添加一些方法或 Field
5、Target（目标对象）：
被代理对象
6、Weaving（织入）：
是指把增强代码应用到目标对象来创建新的代理对象的过程。
spring 采用动态代理织入，而 AspectJ 采用编译期织入和类装载期织入。
7、Proxy（代理）：
一个类被 AOP 织入增强后，就产生一个结果代理类
8、Aspect（切面）：
是切入点和通知（引介）的结合

三、Spring基于XML的AOP

针对AOP的快速入门，提供模拟案例（不关注业务，只关注常用的用法）进行参考，如下：

（一）项目结构

项目结构

（二）pom.xml:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.zuobiao</groupId>
    <artifactId>springDay03_AOP</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.7</version>
        </dependency>
    </dependencies>
</project>

注：如果需要使用AOP，则一定要记得导入aspectjweaver。

（三）service层

IAccountService.java:

/**
 * 模拟业务层
 */
public interface IAccountService {
    /**
     * 无参数无返回值
     */
    void addAccount();

    /**
     * 有参数无返回值
     * @param i
     */
    void updateAccount(int i);

    /**
     * 无参数有返回值
     * @return
     */
    int delAccount();
}

AccountServiceImpl.java:

public class AccountServiceImpl implements IAccountService {
    public void addAccount() {
        System.out.println("添加账户");
    }

    public void updateAccount(int i) {
        System.out.println("更新账户");
    }

    public int delAccount() {
        System.out.println("删除账户");
        return 0;
    }
}

（四）utils

Logger.java:

/**
 * 用来记录日志的工具类，它里面提供了公共的代码
 */
public class Logger {
    public void printLog(){
        System.out.println("Logger类中的pringLog方法开始记录日志了");
    }
}

（五）进行AOP的配置

bean.xml:

<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">

    <!-- 先配置ioc -->
    <bean id="accountService" class="com.zuobiao.service.impl.AccountServiceImpl"></bean>

    <!-- 配置aop -->
    <!-- 使用谁进行通知 -->
    <bean id="logger" class="com.zuobiao.utils.Logger"></bean>  <!-- 共用代码类对象 -->
    <!-- 表明开始aop配置 -->
    <aop:config>
        <!-- 表明开始切面配置 -->
         <aop:aspect id="logAdvance" ref="logger">
             <!-- 表明什么时候通知，如何通知，通知谁 -->
             <!-- 切入点表达式 -->
             <aop:before method="printLog" pointcut="execution(* com.zuobiao.service.impl.*.*(..))"></aop:before>
         </aop:aspect>
    </aop:config>
</beans>

四、切入点表达式的写法

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

五、通知类型

（一）四种常用通知类型

aop:before
作用：
	用于配置前置通知。指定增强的方法在切入点方法之前执行
属性：
	method:用于指定通知类中的增强方法名称
	ponitcut-ref：用于指定切入点的表达式的引用
	poinitcut：用于指定切入点表达式
执行时间点：
	切入点方法执行之前执行

aop:after-returning
作用：
	用于配置后置通知
属性：
	method：指定通知中方法的名称。
	pointct：定义切入点表达式
	pointcut-ref：指定切入点表达式的引用
执行时间点：
	切入点方法正常执行之后。它和异常通知只能有一个执行

aop:after-throwing
作用：
	用于配置异常通知
属性：
	method：指定通知中方法的名称。
	pointct：定义切入点表达式
	pointcut-ref：指定切入点表达式的引用
执行时间点：
	切入点方法执行产生异常后执行。它和后置通知只能执行一个

aop:after
作用：
	用于配置最终通知
属性：
	method：指定通知中方法的名称。
	pointct：定义切入点表达式
	pointcut-ref：指定切入点表达式的引用
执行时间点：
	无论切入点方法执行时是否有异常，它都会在其后面执行。

针对第三点中的项目，如果Logger.java修改为如下：
Logger.java:

/**
 * 用来记录日志的工具类，它里面提供了公共的代码
 */
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方法开始记录日志了");
    }
}

并且假设service中的addAccount方法，分别需要Logger中的这四个方法进行方法增强，那么可配置如下：

<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">

    <!-- 先配置ioc -->
    <bean id="accountService" class="com.zuobiao.service.impl.AccountServiceImpl"></bean>

    <!-- 配置aop -->
    <!-- 使用谁进行通知 -->
    <bean id="logger" class="com.zuobiao.utils.Logger"></bean>  <!-- 共用代码类对象 -->
    <!-- 表明开始aop配置 -->
    <aop:config>
        <!-- 表明开始切面配置 -->
         <aop:aspect id="logAdvance" ref="logger">
             <!-- 表明什么时候通知，如何通知，通知谁 -->
             <aop:before method="beforePrintLog" pointcut="execution(* com.zuobiao.service.impl.*.*(..))"></aop:before>
             <aop:after-returning method="afterReturningPrintLog" pointcut="execution(* com.zuobiao.service.impl.*.*(..))"></aop:after-returning>
             <aop:after-throwing method="afterThrowingPrintLog" pointcut="execution(* com.zuobiao.service.impl.*.*(..))"></aop:after-throwing>
             <aop:after method="afterPrintLog" pointcut="execution(* com.zuobiao.service.impl.*.*(..))"></aop:after>
         </aop:aspect>
    </aop:config>
</beans>

但是仔细思考，我们会发现即使是相同的切入点表达式也需要重复进行指定，因此Spring就提供了一个<aop:pointcut>标签可以提取相同的切入点表达式，并且我们只需要在配置的标签中使用point-cut属性调用即可。如下：

<!-- 表明开始aop配置 -->
<aop:config>
    <!-- 表明开始切面配置 -->
     <aop:pointcut id="pt1" expression="execution(* com.zuobiao.service.impl.*.*(..))"/>
     <aop:aspect id="logAdvance" ref="logger">
         <!-- 表明什么时候通知，如何通知，通知谁 -->
         <!-- 简化后的配置 -->
         <aop:before method="beforePrintLog" pointcut-ref="pt1"></aop:before>
         <aop:after-returning method="afterReturningPrintLog" pointcut-ref="pt1"></aop:after-returning>
         <aop:after-throwing method="afterThrowingPrintLog" pointcut-ref="pt1"></aop:after-throwing>
         <aop:after method="afterPrintLog" pointcut-ref="pt1"></aop:after>
     </aop:aspect>
</aop:config>

（二）环绕通知

aop:around：
作用：
	用于配置环绕通知
属性：
	method：指定通知中方法的名称。
	pointct：定义切入点表达式
	pointcut-ref：指定切入点表达式的引用
说明：
	它是 spring 框架为我们提供的一种可以在代码中手动控制增强代码什么时候执行的方式。
注意：
	通常情况下，环绕通知都是独立使用的

针对第三点中的项目，如果Logger.java修改为如下：
Logger.java:

/**
 * 用来记录日志的工具类，它里面提供了公共的代码
 */
public class Logger {

    /**
     * 环绕通知
     * @param pjp
     * @return
     */
    public Object aroundPrintLog(ProceedingJoinPoint pjp){
        Object rtValue = null;
        try{
            Object[] args = pjp.getArgs();
            System.out.println("前置通知");

            rtValue = pjp.proceed(args);        //环绕通知必须明确调用切入点方法

            System.out.println("后置通知");
            return rtValue;
        }catch (Throwable t){
            System.out.println("异常通知");
            throw new RuntimeException();
        }finally {
            System.out.println("最终通知");
        }
    }
}

注：spring 框架为我们提供了一个接口：ProceedingJoinPoint，它可以作为环绕通知的方法参数。在环绕通知执行时，spring 框架会为我们提供该接口的实现类对象，我们直接使用就行。
配置修改如下：

<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">

    <!-- 先配置ioc -->
    <bean id="accountService" class="com.zuobiao.service.impl.AccountServiceImpl"></bean>

    <!-- 配置aop -->
    <!-- 使用谁进行通知 -->
    <bean id="logger" class="com.zuobiao.utils.Logger"></bean>  <!-- 共用代码类对象 -->
    <!-- 表明开始aop配置 -->
    <aop:config>
        <!-- 表明开始切面配置 -->
         <aop:pointcut id="pt1" expression="execution(* com.zuobiao.service.impl.*.*(..))"/>
         <aop:aspect id="logAdvance" ref="logger">
             <!-- 表明什么时候通知，如何通知，通知谁 -->
             <!-- 配置环绕通知 -->
             <aop:around method="aroundPrintLog" pointcut-ref="pt1"></aop:around>
         </aop:aspect>
    </aop:config>
</beans>

（三）小结

其实环绕通知就相当于其他四个常用通知。只不过四个常用的四个通知是可以通过XML文件或者和注解的方式进行配置；
而环绕通知则是通过代码自己手动进行配置。

六、总结

其实也可以通过注解的方式进行配置来实现AOP，但是由于在实际使用时会有一点小问题（通知的执行顺序有点小问题），因此此处不做总结。

Java新手，若有错误，欢迎指正！

| 阅读量次