Spring FrameWork从入门到NB - Spring AOP（实战）

这篇文章的目的是对上一篇文章有关AOP概念的温习和巩固，通过实战的方式。

引入依赖

首先需要引入Spring Aspect依赖

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>5.2.5.RELEASE</version>
        </dependency>

@EnableAspectJAutoProxy

先声明一下，例子都使用注解方式实现，不用xml配置的方式了，其实区别不大，但是本人不喜欢xml配置的方式。

Configuration文件中加入@EnableAspectJAutoProxy注解。

@Configuration()
@ComponentScan(value={"springAop"})
@EnableAspectJAutoProxy
@PropertySource("classpath:application.properties")
@EnableAsync
public class MyConfiguration {
}

业务类

准备一个业务类UserService，目标就是为了实现AOP功能，所以业务类不需要实现任何业务逻辑：

public interface IUserService {
    public boolean addUser();
    public boolean deleteUser();
    public boolean updateUser();
}

IUserService的实现类UserService，为了验证AfterThrowing类的Advice，我们将updateUser方法直接抛出异常，模拟业务类抛异常的场景：

package springAop;

import org.springframework.stereotype.Component;

@Component
public class UserService implements IUserService{
    @Override
    public boolean addUser() {
        System.out.println("add user in userService");
        return true;
    }

    @Override
    public boolean deleteUser() {
        System.out.println("delete user in userService");
        return false;
    }

    @Override
    public boolean updateUser() {
        throw new RuntimeException("cant be updated...");
    }
}

目前为止涉及到的Spring AOP的概念：目标对象，也就是Target object，本例中目标对象就是UserService。

编写切面

编写一个用于记录日志的切面，我们需要一步步认识切面类中涉及到的AOP概念或术语。

下面用于处理日志切面的类LogManagement就是一个Aspect：

@Aspect
@Component
public class LogManagement {
}

对于Spring AOP来说，切面必须注入到Spring IoC容器中，所以也必须加@Component注解，以及，表明自己是切面类的@Aspect注解。

下面我们给切面类加pointcut：

    @Pointcut("execution(* springAop.UserService.add*())")
    public void addUserPointcut(){}

@Pointcut注解表示其作用的方法addUserPointcut是一个切点，在满足切点定义的连接条件的情况下会被Spring AOP调用到，去执行相应的Advice。

@Pointcut注解的参数："execution(* springAop.UserService.add*())"定义切点表达式，通过表达式指定当前切点与什么JointPoint关联，我们这里指定为SpringAop.UserService类的以add开头的方法，前面的 * 匹配JointPoint方法的返回值，*表示任意返回值。

通过 @Pointcut注解，我们详单与定义了AOP的JointPoint和Pointcut两个特性。

接下来需要定义Advices了。

暂时只定义一个Before Advice：

@Before(value="addUserPointcut()")
    public void beforeLog(JoinPoint jp){
        System.out.println("before "+jp+" advice...");
    }

通过@Before注解指定，匹配到我们前面定义好的addUserPointcut。我们在前面的文章中说过，除了Around类型的Advice可以参与目标对象的方法调用之外，其他类型的Advice只能增强方法调用、但是没有办法参与目标对象的方法调用，目标对象的方法调用交给AOP框架完成。

虽然没有办法参与目标对象的方法调用，但是@Before Advice可以有参数JoinPoint，给Advice一个机会，能知道当前AOP的增强调用匹配到的是哪一个JoinPoint，正如我们例子中看到的，我们在Advice方法beforeLog中加了这个JointPoint参数。

准备一下启动类：

public class App {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(MyConfiguration.class);
        IUserService us = (IUserService)  applicationContext.getBean("userService");
//        UserService us = (UserService)  applicationContext.getBean("userService");
        System.out.println(us.getClass());
        us.addUser();
        us.deleteUser();
        try {
            us.updateUser();
        }catch (Exception e){

        }

运行启动类，看一下效果。

before execution(boolean springAop.IUserService.addUser()) advice...
add user in userService

Before Advice已经生效了。

其他类型的Advice

现在我们增加其他类型的Advices：

package springAop;

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

import java.util.jar.JarOutputStream;

@Aspect
@Component
public class LogManagement {
    @Pointcut("execution(* springAop.UserService.add*())")
    public void addUserPointcut(){}
    @Pointcut("execution(* springAop.UserService.update*())")
    public void updateUserPointcut(){}

    @Before(value="addUserPointcut()")
    public void beforeLog(JoinPoint jp){
        System.out.println("before "+jp+" advice...");
    }
    @After(value="addUserPointcut()")
    public void afterLog(JoinPoint jp){
        System.out.println(" after "+jp+" advice......");
    }
    @Around(value="addUserPointcut()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable{
        System.out.println(" This is around " +pjp+" ,before process...");
        Object retVal=pjp.proceed();
        System.out.println("the return value after proceed is :"+retVal);
        System.out.println(" This is around" +pjp+" ,after process...");
        return retVal;
    }

    @AfterReturning(value="addUserPointcut()")
    public void afterRreturning(JoinPoint jp) throws Throwable{
        System.out.println(" This is after returning" +jp+" ...");
    }

    @AfterThrowing(value="updateUserPointcut()")
    public void afterThrowing(JoinPoint jp) throws Throwable{
        System.out.println(" This is after throwing" +jp+" ...");
    }

}

运行启动类：

class com.sun.proxy.$Proxy34
 This is around execution(boolean springAop.IUserService.addUser()) ,before process...
before execution(boolean springAop.IUserService.addUser()) advice...
add user in userService
the return value after proceed is :true
 This is aroundexecution(boolean springAop.IUserService.addUser()) ,after process...
 after execution(boolean springAop.IUserService.addUser()) advice......
 This is after returningexecution(boolean springAop.IUserService.addUser()) ...
delete user in userService
 This is after throwingexecution(boolean springAop.IUserService.updateUser()) ...

分析一下运行结果，可以得出如下重要结论：

从Spring Ioc容器中获取到的UserService对象已经不是原对象了，而是代理对象com.sun.proxy.$Proxy34
发现代理对象是JDK Proxy实现的，这是由于我们的UserService类实现了IUserService接口，具备JDK Proxy的实现条件，如果我们去掉UserService的IUserService接口、或者在配置类中打开proxyTargetClass选项：@EnableAspectJAutoProxy(proxyTargetClass = true)，都可以更换为Cglib方式生成代理对象
一个方法上同时加了多了Advice之后的生效顺序：around（执行目标方法前）-> before -> around执行目标方法 -> after ->after returning。
额外的，篇幅原因我们就不增加测试代码了：After可以获取到JointPoint的任何返回（调用成功或发生异常），而AferRetuning只能获取到正常返回。

如果我们的一个方法有多个切面类生效的话，执行顺序就会类似于FilterChain的剥洋葱的方式。

AfterThrowing

与其他类型的Advice不同的是，某些情况下，我们在AfterThrowing Advice下可能想知道业务类具体抛出了什么样的异常，从而在AOP Advice中针对不同类型的异常做有针对性的处理。

AOP的AfterThrowing Advice提供了这个能力，修改上面例子中的AfterThrowing Advice：

    @AfterThrowing(value="updateUserPointcut()",throwing="ex")
    public void afterThrowing(JoinPoint jp,Throwable ex){
        System.out.println(" This is after throwing" +jp+" ...");
        System.out.println(ex);
    }

重新执行启动类：

 This is after throwingexecution(boolean springAop.UserService.updateUser()) ...
java.lang.RuntimeException: cant be updated...

我们在UserService的updateUser方法中抛出的异常，在AOP Advice中可以获取到，因此也就可以在AOP的Advice中做有针对性的处理。

此外，对异常的处理，比如捕获还是抛出的最终决策，是由应用程序做成的，AOP切面对于应用来说就是一个旁观者：对应用不做浸入式的处理（Around除外，Around具备浸入处理的能力，虽然不能改变JointPoint的业务逻辑，但是可以改变其运行结果、返回切面自己的结果）。

Advice获取返回值

Aop切面类的after Advice方法中可以获取到业务类的返回值，比如：

    @AfterReturning(value="addUserPointcut()",returning = "ret")
    public void afterRreturning(JoinPoint jp,Object ret) throws Throwable{
        System.out.println(" This is after returning" +jp+" ...");
        System.out.println("return :"+ret);
    }

执行启动类：

 This is after returningexecution(boolean 	   springAop.UserService.addUser()) ...
  return :true

Advice参数处理

AOP提供了切面类Advice中获取目标类JointPoint的参数的能力。

改造IUserService接口和UserService类，addUser增加一个userName参数：

    @Override
    public boolean addUser(String userName) {
        System.out.println("add user in userService:"+userName);
        return true;
    }

改造切面类，Advice接收参数：

 @Pointcut("execution(* springAop.UserService.add*(..)) && args(userName)")
    public void addUserPointcut(String userName){}

Advice做相应的改造：

    @Before(value="addUserPointcut(userName)")
    public void beforeLog(JoinPoint jp,String userName){
        System.out.println("before "+jp+" advice..."+" and userName is :"+userName);
    }

执行启动类：

before execution(boolean springAop.UserService.addUser(String)) advice... and userName is :Zhang San

Advice中获取到了应用层的JointPoint方法的参数。

OK，今天到此为止，通过实战方式重温了一遍AOP相关术语之后，有没有感觉到AOP的术语不再那么晦涩难懂了？

上一篇 Spring FrameWork从入门到NB - Spring AOP - 概念