关于aop的两种方式-基于注解和基于aspectj

spring的aop确实好用，能够在不影响业务功能的情况下，实现一些低耦合的功能。

而aop又有两种常用的实现方式，一种是用aspectj表达式去匹配，实现全局的配置，表达式还可以使用与或非符号去连接，从而达到一个aop应用于多个切面多个切点。

但是这样的用法不够灵活，不够插件化，最好的方式就是开箱即用，随用随加。基于这样的需求，aop基于注解的实现方式，才是最灵活的。

基本步骤
构建自定义注解
构建注解aop的编织类(aspectj)
在配置文件中声明编织类(应用于controller的注解一定要在springmvc的配置文件声明，其他类型的编织类可在spring的配置文件里声明)
在对应的controller上应用注解，让aop抓取到该切点

tips:
1自定义注解的范围是可选的，一般用于方法级别
2在环绕通知上，返回json类型，可加上@ResponseBody，返回json，符合RestFul

具体的代码暂时没必要贴，官方文档写的很清晰。

英文一般的可以看翻译文档

https://www.gitbook.com/book/linesh/spring-mvc-documentation-linesh-translation/details

tips:

1此处配置的时候，如果是使用了spring+springMVC的模式下，需要注意spring和springMVC父子容器的问题，如果我们的@Token是标注于Controller（被@Controller或者@RestController注解标记）层的话，由于controller层是由springMVC容器来管理的，若此时我们的TokenAspect是由Spring来管理的话，由于在方法调用的时候，spring无法获取子容器的管理对象，aop就不起作用，自然@Token注解也就失效了。 所以这儿我们的aop也需要配置再springMVC的配置文件中，由SpringMVC来管理。

---

代码备份：

自定义注解

 import java.lang.annotation.ElementType;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;

 /**
  * Target指定注解的目标为方法级
  * Retention指定注解可以在运行时被获取（利用反射）
  * Created by huxingyue on 2017/8/22.
  */
 @Target(ElementType.METHOD)
 @Retention(RetentionPolicy.RUNTIME)
 public @interface TokenAnnotation {
 }

aop

 import com.sftc.tools.api.APIUtil;
 import org.aspectj.lang.ProceedingJoinPoint;
 import org.aspectj.lang.annotation.*;
 import org.springframework.core.annotation.Order;
 import org.springframework.stereotype.Component;
 import org.springframework.web.bind.annotation.ResponseBody;
 import org.springframework.web.context.request.RequestContextHolder;
 import org.springframework.web.context.request.ServletRequestAttributes;

 import javax.servlet.http.HttpServletRequest;
 import java.util.Arrays;

 import static com.sftc.tools.common.ControllerHelper.responseEntityBuilder;
 import static com.sftc.tools.common.RequestHeaderUtils.getUserBySystemAccessToken;

 /**
  * 通过AOP来验证token
  * Created by huxingyue on 2017/8/21.
  */
 @Component
 @Aspect
 @Order(10) //构建执行顺序
 public class TokenAOPHelper {
     @Before("@annotation(com.sftc.tools.common.TokenAnnotation)")
     public void beforeCheck() throws Throwable {

         System.out.println("-   -前置");
     }

     @Around(value = "@annotation(com.sftc.tools.common.TokenAnnotation)")
     @ResponseBody
     public Object aroundCheck(ProceedingJoinPoint pjp) throws Throwable {
         HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
         String system_access_token = request.getHeader("system_access_token");
         if (system_access_token == null) return APIUtil.paramErrorResponse("system_access_token missing");
         //判断system_access_token是否有效
         boolean flag = (getUserBySystemAccessToken(system_access_token) == null);
         if (flag) {
             return responseEntityBuilder(APIUtil.unauthorizedResponse("Unauthorized"));
         } else {//如果有效 则继续执行
             System.out.println("方法参数列表：");
             toString1(pjp.getArgs());
             return pjp.proceed();
         }
     }

     private void toString1(Object[] args) {
         for (Object o : args) {
             System.out.println(o.toString());
         }
     }
 }

<!-- 启动Aspectj注解模式驱动AOP --> <aop:aspectj-autoproxy proxy-target-class="true"/>