spring-boot AOP编程示例

概述

在spring-boot中，使用面向切面的编程方法。使用aop的编程思想，可以在不修改原有代码的情况下，对原有业务逻辑进行拦截处理。

在使用aop思想编程时，一定要记住三个概念：

• 切点，想要拦截的类的方法，可以通配符来匹配所有类的方法
• 通知，表示拦截到方法后，在之前、之后，异常等哪一个时间点来执行拦截处理操作

Spring AOP编程时，使用到的注解

@Aspect 定义一个切面，不能仅仅只使用这个注解来定义一个bean，还需要借助其他的注解，如@Component，@Service等等

示例代码

package com.wisrc.zuul.aop;

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

@Aspect
@Component
public class DemoAOP {
    // 定义切点，在定义切点中，需要指定织入点
    // 通过这种方法，可以在不修改业务代码的情况下，
    // 对原有业务逻辑进行拦截处理
    // 如示例中，我们拦截所有com.wisrc.zuul.controller包下边所有类的方法
    @Pointcut("execution(public * com.wisrc.zuul.controller..*(..))")
    public void demo(){
        System.out.println("定义切点, 这段不会打印出来");
    }

    // 前置处理
    @Before(value = "demo()")
    public void demoBefore(JoinPoint jp){
        System.out.println(jp);
        System.out.println("before demo aop");
    }

    /**
     * 环绕通知时，必须返回obj，否则，response中的内容无法反馈给调用者
     * */
    @Around(value = "demo()")
    public Object aroundAop(ProceedingJoinPoint pjp) throws Throwable {
        Object obj = pjp.proceed();
        System.out.println("around aop");
        System.out.println(obj);
        return obj;
    }

    @After(value = "demo()")
    public void afterAop(JoinPoint jp) {
        System.out.println(jp);
        System.out.println("after aop");
    }

    @AfterReturning(value = "demo()")
    public void afterAopReturn(JoinPoint jp) {
        System.out.println(jp);
        System.out.println("after aop return");
    }

    @AfterThrowing(value = "demo()")
    public void afterAopThrow() {
        System.out.println("after aop throw");
    }
}

当被检测的方法被拦截到后，将会输出下边信息：

execution(String com.wisrc.zuul.controller.HandleLogger.index())
before demo aop
around aop
hello world, zuul
execution(String com.wisrc.zuul.controller.HandleLogger.index())
after aop
execution(String com.wisrc.zuul.controller.HandleLogger.index())
after aop return

带参数切入

在执行切入函数的同时，获取切点方法的参数列表，根据被切点方法的参数，进行不同的逻辑处理。由于需要获取切入点方法的参数，所有这个切面的通用型就不会很好，因为不可能所有的方法都拥有相同的参数。所以，没有必要先定义切点，再定义通知。可以在通知注解中，定义切点。

@Aspect
@Component
public class Demo2AOP {

	// 直接在通知注解中，使用execution定义切点
    @Before("execution(public * com.wisrc.zuul.services.UserIdentifyService.*(..))" + "&&" + "args(userLoginEntity)")
    public void beforeAop(UserLoginEntity userLoginEntity){
        System.out.println(userLoginEntity);
    }
}

接口定义情况：

public interface UserIdentifyService {
    LoginResultBO identify(UserLoginEntity ue);
    LoginResultBO identifyByApi(UserLoginEntity ue);
}

通过args函数获取切点处方法的参数列表。args与execution方法之间使用&&连接。
当com.wisrc.zuul.services.UserIdentifyService接口下边的方法被调用前，将会触发beforeAop方法。

通过切面编程的方式，可以在不修改原有代码的基础上，对原有业务逻辑进行处理。适用于权限管理，日志管理、安全管理、统一封装，统一解析等等场景。