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

怼烎@ 2021-10-23 08:35 282阅读 0赞

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