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()) ...

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

1. 从Spring Ioc容器中获取到的UserService对象已经不是原对象了，而是代理对象com.sun.proxy.$Proxy34
2. 发现代理对象是JDK Proxy实现的，这是由于我们的UserService类实现了IUserService接口，具备JDK Proxy的实现条件，如果我们去掉UserService的IUserService接口、或者在配置类中打开proxyTargetClass选项：@EnableAspectJAutoProxy(proxyTargetClass = true)，都可以更换为Cglib方式生成代理对象
3. 一个方法上同时加了多了Advice之后的生效顺序：around（执行目标方法前）-> before -> around执行目标方法 -> after ->after returning。
4. 额外的，篇幅原因我们就不增加测试代码了：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 - 概念
下一篇 Spring FrameWork从入门到NB - Spring AOP的自我调用