面相切面的编程 AOP（动态代理）@Aspect

Spring支持面相切面的编程,并且把应用业务逻辑和系统分开，可以很方便的实现对程序进行权限拦截和运行监控等功能，AOP 适合那些具有横切逻辑的应用场景，比如性能监测 、访问控制 、事务管理以及日志记录等，尤其业务代码淹没在重复性的非业务性的代码之中时。

相关注解

@Aspect:作用是把当前类标识为一个切面供容器读取
@Pointcut：Pointcut是植入Advice的触发条件。每个Pointcut的定义包括2部分，一是表达式，二是方法签名。方法签名必须是 public及void型。可以将Pointcut中的方法看作是一个被Advice引用的助记符，因为表达式不直观，因此我们可以通过方法签名的方式为 此表达式命名。因此Pointcut中的方法只需要方法签名，而不需要在方法体内编写实际代码。
@Around：环绕增强，相当于MethodInterceptor
@AfterReturning：后置增强，相当于AfterReturningAdvice，方法正常退出时执行
@Before：标识一个前置增强方法，相当于BeforeAdvice的功能，相似功能的还有
@AfterThrowing：异常抛出增强，相当于ThrowsAdvice
@After: final增强，不管是抛出异常或者正常退出都会执行

AOP

1 连接点（Joinpoint）
一个类或者一段程序代码拥有一些具有边界性质的特定点，这些代码中的特定点被称为 “ 连接点 ” 。 Spring 仅支持方法的连接点织入增强，这些连接点为：

1)在方法调用前。
2)在方法调用后。
3)方法抛出异常时。
4)方法调用前后（环绕）。

连接点由两个信息来确定：方法标识的程序执行点（使用切点定位）和相对位置标识的方位（在增强类型中定义）。
2 切点（Pointcut )
AOP 通过切点来定位连接点，一个切点可以匹配多个连接点。

在 Spring 中，切点是由 org.springframework.aop.Pointcut 接口类来描述的，它使用类和方法作为连接点的查询条件， Spring AOP 的规则引擎会解析切点所设定的查询条件，找到对应的连接点 。连接点是方法执行前 、执行后等包含方位信息的具体程序执行点， 而切点只是定位到某个方法上， 必须再提供方位信息，才能定位到具体的连接点上。

3 增强（Advice )
增强是织入目标类连接点上的一段程序逻辑代码 。 在 Spring 中，增强除了用于描述一段程序代码外，还拥有另一个和连接点相关的信息，这便是执行点的方位 。 结合执行点的方位信息和切点信息，就可以找到特定的连接点。 正是因为增强既包含用于添加到目标连接点上的一段执行逻辑，又包含用于特定连接点的方位信息，所以 Spring 提供的增强接口都是带方位名的，比如 BeforeAdvice 等。

AOP 织入增强方式：
动态代理织入 在运行期为目标类添加增强生成子类的方式。 Spring

4 代理（Proxy）
一个类被 AOP 织入增强后，就产生了一个结果类，它融合了原类和增强逻辑的代理类 。 根据不同的代理方式，代理类可能是与原类具有相同接口的类，也可能是原类的子类。

5 切面（Aspect）
切面由切点和增强组成 。 它既包括横切逻辑的定义，又包括连接点的定义信息。 Spring AOP 是负责实施切面的框架，它将切面所定义的横切逻辑织入切面所指定的连接点中 。

示例：

/**
 * 日志记录输出切面
 */
@Component
@Aspect
public class LogAop {
    private final Logger logger = LoggerFactory.getLogger(getClass());

    @Pointcut("execution(* com.*.*.controller..*.*(..))")
    public void recordLog(){}


    /**
     * 日志记录，记录访问url， 访问方式，参数和返回值
     * @param joinPoint
     * @return
     * @throws Throwable
     */
    @Around("recordLog()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable{
        Object result = null;
        RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = ((ServletRequestAttributes)requestAttributes).getRequest();
        // 记录下请求内容
        logger.info("################URL : " + request.getRequestURL().toString());
        logger.info("################HTTP_METHOD : " + request.getMethod());
        logger.info("################THE ARGS OF THE CONTROLLER : " + Arrays.toString(joinPoint.getArgs()));
        logger.info("################CLASS_METHOD : " + joinPoint.getSignature().getDeclaringTypeName() + "." + joinPoint.getSignature().getName());
        result = joinPoint.proceed();
        logger.info("################RETURN : " + result);
        return result;
    }
}

/**
 * token验证切面
 */
@Aspect
@Component
public class ValidateTokenAspect extends BaseController {

    private final Logger logger = LoggerFactory.getLogger(getClass());

    @Pointcut("@annotation(com.givenera.pc.annotation.TokenRequired)")
    public void validateToken(){}

    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 验证token
     * @param joinPoint
     * @return
     * @throws Throwable
     */
    @Around("validateToken()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable{
        Object result = null;
        RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = ((ServletRequestAttributes)requestAttributes).getRequest();
        String token = request.getHeader("token");

        String userId = (String) redisTemplate.opsForValue().get(token);

        if(StringUtils.isEmpty(userId)) {
            return error(ApiError.USER_LOOUT_OR_TIMEOUT.code, ApiError.USER_LOOUT_OR_TIMEOUT.message);
        }
        redisTemplate.delete(token);
        redisTemplate.opsForValue().set(token, userId, 30, TimeUnit.MINUTES);
        result = joinPoint.proceed();
        return result;
    }
}

/**
 * 参数验证切面
 */
@Component
@Aspect
public class ValidateAop {
    @Pointcut("execution(* com.*.*.controller..*.*(..))")
    public void aopMethod(){}


    /**
     * 参数验证
     * @param joinPoint
     * @return
     * @throws Throwable
     */
    @Around("aopMethod()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable{
        BindingResult bindingResult = null;

        for(Object arg:joinPoint.getArgs()){
            if(arg instanceof BindingResult){
                if(((BindingResult) arg).getAllErrors().size() > 0) {
                    throw new Exception(((BindingResult) arg).getAllErrors().get(0).getDefaultMessage());
                }
            }
        }
        return joinPoint.proceed();
    }
}

/**
 * 切面表达式详解  
 * 也可以使用自定义注解@Pointcut("@annotation(com.givenera.pc.annotation.TokenRequired)") 
 */
execution(
    modifier-pattern?  //修饰符
    ret-type-pattern  //返回类型
    declaring-type-pattern?  //方法模式
    name-pattern(param-pattern)  //参数模式
    throws-pattern?  //异常模式
)

/*
整个表达式可以分为五个部分：

 1、execution(): 表达式主体。

 2、第一个*号：表示返回类型，*号表示所有的类型。

 3、包名：表示需要拦截的包名，后面的两个句点表示当前包和当前包的所有子包，com.sample.service.impl包、子孙包下所有类的方法。

 4、第二个*号：表示类名，*号表示所有的类。

 5、*(..):最后这个星号表示方法名，*号表示所有的方法，后面括弧里面表示方法的参数，两个句点表示任何参数。
*/
@pointcut("execution(* com.sample.service.impl..*.*(..))")