AOP(三)

Spring框架一般都是基于AspectJ类实现AOP操作

　　AspectJ不是Spring的组成部分, AspectJ是独立的AOP框架, 实际中一般把AspectJ和Spring框架一起使用, 进行AOP操作.

基于AspectJ实现AOP操作一般有以下两种实现方式:

• 基于xml配置文件实现
• 基于注解方式实现(常用)

在实际项目中, 我们需要先引入相关依赖:

• spring-aop-5.2.6.RELEASE.jar(从Spring框架lib包中导入)
• spring-aspects-5.2.6.RELEASE.jar(从Spring框架lib包中导入)
• com.springsource.net.sf.cglib-2.1.3.jar
• com.springsource.org.aopalliance-1.0.0.jar
• com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar

　　*后三个是AspectJ的依赖, 可以在Google下载, 以下附百度云链接(如有问题考虑更换jar包版本):

　　链接: https://pan.baidu.com/s/14O7oNsgZj1ipndE6HTLonA 提取码: fa2k

切入点表达式

　　作用: 知道对哪个类里面的哪个方法进行增强

　　语法结构: execution([权限修饰符] [返回类型] [类全路径] [方法名称]([参数列表]))

　　举例说明:

　　1. 对com.ryan.class 类里面的 add 方法进行增强:

　　　　execution(* com.ryan.class.add(..))

　　　　说明: *表示包括public, private等所有修饰符, (..)表示所有参数

　　2. 对com.ryan.class 类里面的所有方法进行增强:

　　　　execution(* com.ryan.class.*(..))

　　3. 对com.ryan 包里面的所有类中的所有方法进行增强:

　　　　execution(* com.ryan.*.*(..))

---

以下以一个实例说明:

创建xml文件: (创建context和aop的名称空间; 开启注解扫描; 开启生成Aspect代理对象)

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

    <!--开启注解扫描-->
    <context:component-scan base-package="com.ryan.aspect1"></context:component-scan>

    <!--开启Aspect生成代理对象, 即找到带@aspect注解的类, 生成其代理对象-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

创建被增强类 User.java: 

package com.ryan.aspect1;

import org.springframework.stereotype.Component;

//被增强的类
@Component
public class User {
    public void basic(){
        System.out.println("Basic method.");
    }
}

创建增强类 UserPro.java: 

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

//增强的类
@Component
//生成代理对象
@Aspect
public class UserPro {

    //前置通知 使用切入点表达式, value可省略
    @Before(value = "execution(* com.ryan.aspect1.User.basic(..))")
    public void before(){
        System.out.println("Before.");
    }

    //最终通知, 在方法调用之后执行, 不管有无异常都执行
    @After(value = "execution(* com.ryan.aspect1.User.basic(..))")
    public void After(){
        System.out.println("After.");
    }

    //后置通知/返回通知, 在方法return值后执行, 有异常则不执行
    @AfterReturning(value = "execution(* com.ryan.aspect1.User.basic(..))")
    public void AfterReturning(){
        System.out.println("AfterReturning.");
    }

    //异常通知, 在方法产生异常时执行(可在被增强方法中通过1/0手动触发异常来触发)
    @AfterThrowing(value = "execution(* com.ryan.aspect1.User.basic(..))")
    public void AfterThrowing(){
        System.out.println("AfterThrowing.");
    }

    //环绕通知
    @Around(value = "execution(* com.ryan.aspect1.User.basic(..))")
    public void Around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
        //方法之前执行内容
        System.out.println("Around-Before.");
        //被增强的方法执行
        proceedingJoinPoint.proceed();
        //方法之后执行内容
        System.out.println("Around-After");
    }
}

测试:

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("com/ryan/aspect1/bean.xml");
        User user = context.getBean("user", User.class);
        user.basic();
    }
}

运行结果:

---

关于细节的补充说明:

抽取相同的切入点: 可通过@pointcut注解来提取公共的切入点, 增强类可改写如下:

//增强的类
@Component
//生成代理对象
@Aspect
public class UserPro {

    @Pointcut(value = "execution(* com.ryan.aspect1.User.basic(..))")
    public void pointdemo(){}

    //前置通知 使用切入点表达式, value可省略
    @Before(value = "pointdemo()")
    public void before(){
        System.out.println("Before.");
    }

    //最终通知, 在方法调用之后执行, 不管有无异常都执行
    @After(value = "pointdemo()")
    public void After(){
        System.out.println("After.");
    }

    //后置通知/返回通知, 在方法return值后执行, 有异常则不执行
    @AfterReturning(value = "pointdemo()")
    public void AfterReturning(){
        System.out.println("AfterReturning.");
    }

    //异常通知, 在方法产生异常时执行(可在被增强方法中通过1/0手动触发异常来触发)
    @AfterThrowing(value = "pointdemo()")
    public void AfterThrowing(){
        System.out.println("AfterThrowing.");
    }

    //环绕通知
    @Around(value = "pointdemo()")
    public void Around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
        //方法之前执行内容
        System.out.println("Around-Before.");
        //被增强的方法执行
        proceedingJoinPoint.proceed();
        //方法之后执行内容
        System.out.println("Around-After");
    }
}

当多个增强类增强同一个方法时, 设置增强类的优先级: 在增强类上面添加注解@Order(数字类型值), 数字越小优先级越高, 如:

@Component
//生成代理对象
@Aspect
@Order(1)
public class UserPro {
　　...
}