SpringBoot初学习——Aop

依赖

除了Spring Boot项目必须依赖以外，还需要添加额外的依赖

<!--            spring boot aop                  -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

HttpAspect类

package com.vi.blog.aspect;

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


@Aspect
@Component
public class HttpAspect {

    private static final Logger logger = LoggerFactory.getLogger(HttpAspect.class);

   /* @Before("execution(public * com.vi.blog.controller.PeopleController.*(..))")
    public void before() {
        logger.info("before");
    }

    @After("execution(public * com.vi.blog.controller.PeopleController.*(..))")
    public void after() {
        logger.info("after");
    }*/

    /**
     * 上下两种写法都可以，但推荐下面这种写法，更加简洁
     */

    /**
     * 切点，即需要增强的方法
     */
    @Pointcut("execution(public * com.vi.blog.controller.PeopleController.*(..))")
    public void log() {
    }

    @Before("log()")
    public void doBefore() {
        logger.info("before");
    }

    @After("log()")
    public void doAfter() {
        logger.info("after");
    }

    @AfterReturning(returning = "object", pointcut = "log()")
    public void afterReturning(Object object) {
        logger.info("response={}", object);
    }

    @Around("log()")
    public Object arround(ProceedingJoinPoint pjp) {
        logger.info("【注解：Around . 环绕前】方法环绕start.....");
        try {
            Object o =  pjp.proceed();//如果不执行这句，会不执行切面的Before方法及controller的业务方法
            logger.info("【注解：Around. 环绕后】方法环绕proceed，结果是 :" + o);
            return o;
        } catch (Throwable e) {
            e.printStackTrace();
            return null;
        }
    }
}

Controller类

package com.vi.blog.controller;

import com.vi.blog.domain.People;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.validation.Valid;

@RestController
public class PeopleController {

    private static final Logger logger = LoggerFactory.getLogger(PeopleController.class);

    @PostMapping("/people/add")
    public String add(@Valid People people, BindingResult bindingResult) {
        logger.info("正在执行方法");
        if (bindingResult.hasErrors()) {
            return bindingResult.getFieldError().getDefaultMessage();
        } else {
            return "添加成功，" + people;
        }
    }
}

使用Postman测试

控制台效果

增强方式

有前置增强，后置增强，环绕增强等。具体如下：

方式	含义
Before	前置增强，在切点执行前执行
After	后置增强，在切点执行后执行
AfterReturning	在切点执行后执行，并且可以使用切点返回的对象
AfterThrowing	在切点发生异常后执行
Around	环绕增强，在切点前后执行（和其他几种增强的使用方式不太一样）