AOP面向切面编程@Aspect 注解用法

AOP简介

AOP为Aspect Oriented Programming 的缩写，意为“面向切面编程”，通过预编译方式和运行预期动态代理实现程序功能的统一维护的一种技术。AOP是OOP(面向对象)的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生泛型。 利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各个部分之间的耦合度降低，提高程序的可用性，同时提高了开发的效率。

在Spring AOP中业务仅仅关注自身的逻辑，将日志，性能统计，安全控制，事物处理，异常处理等代码从业务逻辑代码中划分出来，通过对这些行为的分离，我们希望可以将它们独立到非业务逻辑的方法中去，进而改变这些行为的时候不会影响业务逻辑。因此@Aspect注解应运而生。

相关注解及介绍

@Aspect：作用是把当前类标识为一个切面供容器读取

@Pointcut：定义切入点，Pointcut是植入Advice的触发条件。
每个Pointcut的定义包括2部分，一是表达式，二是方法签名。方法签名必须是 public及void型。
可以将Pointcut中的方法看作是一个被Advice引用的助记符，因为表达式不直观，因此我们可以通过方法签名的方式为 此表达式命名。
因此Pointcut中的方法只需要方法签名，而不需要在方法体内编写实际代码。

@Around：环绕增强，相当于MethodInterceptor(方法拦截器)
@AfterReturning：后置增强，相当于AfterReturningAdvice，方法正常退出时执行
@Before：标识一个前置增强方法，相当于BeforeAdvice的功能，相似功能的还有
@AfterThrowing：异常抛出增强，相当于ThrowsAdvice(异常通知)
@After: final增强，不管是抛出异常或者正常退出都会执行

@Pointcut注解

@Pointcut("execution(* com.cn.test.service.UserService.*())")
public void send(){
    /** 第一个*代表接受返回类型，* 代表可以接受任意返回返回值。
     *  其中UserService是类名称，可以替换为service.*通配service包下所有的类。
     *      也可以指定类的前缀或者后缀作为通配例如：*Service,通配所有以service结尾的类。
     *  最后一个*(),表示这个类下的所有方法。
     *
     *  连接起来解释就是，com.cn.test.service.UserService下的任意返回值的所有方法都被代理了。
    **/
}

@Pointcut的多种用法

作用：用来标注在方法上来定义切入点。

格式：@ 注解(value=“表达标签 (表达式格式)”)

例如：@Pointcut("execution(* com.cn.test.service.UserService.*(..))")

表达式标签（10种）

• execution：用于匹配方法执行的连接点

• within： 用于匹配指定类型内的方法执行

• this： 用于匹配当前AOP代理对象类型的执行方法；注意是AOP代理对象的类型匹配，这样就可能包括引入接口也* 类型匹配

• target： 用于匹配当前目标对象类型的执行方法；注意是目标对象的类型匹配，这样就不包括引入接口也类型匹配

• args： 用于匹配当前执行的方法传入的参数为指定类型的执行方法

• @within：用于匹配所以持有指定注解类型内的方法

• @target：用于匹配当前目标对象类型的执行方法，其中目标对象持有指定的注解

• @args： 用于匹配当前执行的方法传入的参数持有指定注解的执行

• @annotation：用于匹配当前执行方法持有指定注解的方法

• bean：Spring AOP扩展的，AspectJ没有对于指示符，用于匹配特定名称的Bean对象的执行方法10种标签组成了12种用法

查看更多关于 @Pointcut 注解的用法

代码示例

@Aspect
@Component
public class TestAop {

    // 匹配目标方法声明的类上有@Log注解
    @Pointcut("@within(com.cn.common.annotation.Log)")
    public void pc() {
    }

    // 定义目标方法的类上有@Log注解
    @Pointcut("@within(Log)")
    public void pc() {
    }

    // 目标类上有@Log注解
    @Pointcut("@target(@Log)")
    public void pc() {
    }

    // 匹配只有1个参数其类型是String类型的
    @Pointcut("args(String)")
    public void pc() {
    }

    // 目标类型必须是UserService类型的
    @Pointcut("target(com.cn.service.UserService)")
    public void pc() {
    }
}

执行顺序

1. Around（proceed之前）
2. Before
3. 切入代码
4. Around（proceed之后）
5. After

@Pointcut("execution(* com.cn.test.service.UserService.*())")
public void send(){
}

@Around("send()")
public void articleAround(ProceedingJoinPoint pjp){

    System.out.println("article around before");
    try{
        System.out.println(pjp.proceed().toString());
    }catch (Throwable e){
        e.printStackTrace();
    }
    System.out.println(" article around after");
}

代码示例(简单)

AOP处理类

@Aspect
@Component
public class MessageAop {

    @Pointcut("execution(* com.cn.test.service.UserService.register())")
    public void sendPoint(){}

    @Before("sendPoint()")
    public void registerBefore(JoinPoint joinPoint){
        System.out.println("register before");
    }

    //execution 直接指定代理类方法，直接使用被定义为切入点的方法
    // @After("execution(* com.cn.test.service.UserService.register())")
    @After("sendPoint()")
    public void registerAfter(){
        send();
        System.out.println("register after");
    }

    // 每次用户注册都发送一条消息
    public static void send(){
        System.out.println("send Message");
    }
}

业务实现类

@Service
public class UserService {

    public void register(){
        System.out.println("user register");
    }
}

代码执行顺序

@Before  registerBefore  -> "register before"
业务代码  register()      -> "user register"
@After   send()          -> "send Message"
@After   registerAfter() -> "register after"

代码示例(日志)

自定义日志注解类

/**
 * 自定义操作日志记录注解
 *
 * @author hviger
 *
 */
@Target({ ElementType.PARAMETER, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Log
{
    /**
     * 模块
     */
    public String title() default "";

    /**
     * 功能
     */
    public BusinessType businessType() default BusinessType.OTHER;

    /**
     * 操作人类别
     */
    public OperatorType operatorType() default OperatorType.MANAGE;

    /**
     * 是否保存请求的参数
     */
    public boolean isSaveRequestData() default true;

    /**
     * 是否保存响应的参数
     */
    public boolean isSaveResponseData() default true;
}

/**
 * 业务操作类型
 *
 * @author hviger
 */
public enum BusinessType
{
    /**
     * 其它
     */
    OTHER,
    /**
     * 新增
     */
    INSERT,
    /**
     * 修改
     */
    UPDATE,
    /**
     * 删除
     */
    DELETE,
    /**
     * 导出
     */
    EXPORT,
    /**
     * 导入
     */
    IMPORT,
}

/**
 * 操作人类别
 *
 * @author hviger
 */
public enum OperatorType
{
    /**
     * 其它
     */
    OTHER,
    /**
     * 后台用户
     */
    MANAGE,
    /**
     * 手机端用户
     */
    MOBILE
}

AOP处理类

/**
 * 操作日志记录处理
 *
 * @author hviger
 */
@Aspect
@Component
public class LogAspect
{
    private static final Logger log = LoggerFactory.getLogger(LogAspect.class);

    /**
     * 处理完请求后执行
     *
     * @param joinPoint 切点
     */
    @AfterReturning(pointcut = "@annotation(controllerLog)", returning = "jsonResult")
    public void doAfterReturning(JoinPoint joinPoint, Log controllerLog, Object jsonResult)
    {
        handleLog(joinPoint, controllerLog, null, jsonResult);
    }

    /**
     * 拦截异常操作
     *
     * @param joinPoint 切点
     * @param e 异常
     */
    @AfterThrowing(value = "@annotation(controllerLog)", throwing = "e")
    public void doAfterThrowing(JoinPoint joinPoint, Log controllerLog, Exception e)
    {
        handleLog(joinPoint, controllerLog, e, null);
    }

    protected void handleLog(final JoinPoint joinPoint, Log controllerLog, final Exception e, Object jsonResult)
    {
        try
        {
            // 获取当前的用户
            LoginUser loginUser = SecurityUtils.getLoginUser();

            // *========数据库日志=========*//
            SysOperLog operLog = new SysOperLog();
            operLog.setStatus("SUCCESS");
            // 请求的地址
            String ip = IpUtils.getIpAddr(ServletUtils.getRequest());
            operLog.setOperIp(ip);
            operLog.setOperUrl(ServletUtils.getRequest().getRequestURI());
            if (loginUser != null)
            {
                operLog.setOperName(loginUser.getUsername());
            }
            // 记录异常信息
            if (e != null)
            {
                operLog.setStatus("FAIL");
                operLog.setErrorMsg(StringUtils.substring(e.getMessage(), 0, 2000));
            }
            // 设置方法名称
            String className = joinPoint.getTarget().getClass().getName();
            String methodName = joinPoint.getSignature().getName();
            operLog.setMethod(className + "." + methodName + "()");
            // 设置请求方式
            operLog.setRequestMethod(ServletUtils.getRequest().getMethod());
            // 处理设置注解上的参数
            getControllerMethodDescription(joinPoint, controllerLog, operLog, jsonResult);
            // 异步保存到数据库，代码实现省略
            AsyncManager.me().execute(AsyncFactory.recordOper(operLog));
        }
        catch (Exception exp)
        {
            // 记录本地异常日志
            log.error("==前置通知异常==");
            log.error("异常信息:{}", exp.getMessage());
            exp.printStackTrace();
        }
    }
    /**
     * 获取注解中对方法的描述信息 用于Controller层注解
     *
     * @param log 日志
     * @param operLog 操作日志
     * @throws Exception
     */
    public void getControllerMethodDescription(JoinPoint joinPoint, Log log, SysOperLog operLog, Object jsonResult) throws Exception
    {
        // 设置action动作
        operLog.setBusinessType(log.businessType().ordinal());
        // 设置标题
        operLog.setTitle(log.title());
        // 设置操作人类别
        operLog.setOperatorType(log.operatorType().ordinal());
        // 是否需要保存request，参数和值
        if (log.isSaveRequestData())
        {
            // 获取参数的信息，传入到数据库中。
            setRequestValue(joinPoint, operLog);
        }
        // 是否需要保存response，参数和值
        if (log.isSaveResponseData() && StringUtils.isNotNull(jsonResult))
        {
            operLog.setJsonResult(StringUtils.substring(JSON.toJSONString(jsonResult), 0, 2000));
        }
    }

    /**
     * 获取接口请求的参数，添加到log对象中
     *
     * @param operLog 操作日志
     * @throws Exception 异常
     */
    private void setRequestValue(JoinPoint joinPoint, SysOperLog operLog) throws Exception
    {
        String requestMethod = operLog.getRequestMethod();
        if (HttpMethod.PUT.name().equals(requestMethod) || HttpMethod.POST.name().equals(requestMethod))
        {
            String params = argsArrayToString(joinPoint.getArgs());
            operLog.setOperParam(StringUtils.substring(params, 0, 2000));
        }
        else
        {
            Map<?, ?> paramsMap = (Map<?, ?>) ServletUtils.getRequest().getAttribute(HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE);
            operLog.setOperParam(StringUtils.substring(paramsMap.toString(), 0, 2000));
        }
    }

    /**
     * 参数拼装
     */
    private String argsArrayToString(Object[] paramsArray)
    {
        String params = "";
        if (paramsArray != null && paramsArray.length > 0)
        {
            for (Object o : paramsArray)
            {
                if (StringUtils.isNotNull(o) && !isFilterObject(o))
                {
                    try
                    {
                        Object jsonObj = JSON.toJSON(o);
                        params += jsonObj.toString() + " ";
                    }
                    catch (Exception e)
                    {
                    }
                }
            }
        }
        return params.trim();
    }

    /**
     * 判断是否需要过滤的对象。
     *
     * @param o 对象信息。
     * @return 如果是需要过滤的对象，则返回true；否则返回false。
     */
    @SuppressWarnings("rawtypes")
    public boolean isFilterObject(final Object o)
    {
        return o instanceof MultipartFile || o instanceof HttpServletRequest || o instanceof HttpServletResponse || o instanceof BindingResult;
    }
}

使用方式添加@Log注解

@RestController
public class TestController{

    @Log(title = "用户信息", businessType = BusinessType.INSERT)
    @PostMapping("/add")
    public AjaxResult add(@Validated @RequestBody User user)
    {
        return null;
    }

    @Log(title = "用户信息", businessType = BusinessType.EXPORT)
    @PostMapping("/export")
    public void export(HttpServletResponse response, User user)
    {
        //......
    }
}

JoinPoint连接点

• 封装了代理方法信息的对象，若用不到则可以忽略不写；

• 如果需要使用被代理类的方法的信息，就加入JoinPoint；

• JoinPoint参数的值是由框架富裕，必须是第一个位置的参数。

方法中的参数JoinPoint为连接点对象，它可以获取当前切入方法的参数、代理类等信息，因此可以记录一些信息，验证一些信息等；