springboot中定义切面

1.基础概念
1、切面(Aspect)
首先要理解‘切’字，需要把对象想象成一个立方体，传统的面向对象变成思维，类定义完成之后（封装）。每次实例化一个对象，对类定义中的成员变量赋值，就相当于对这个立方体进行了一个定义，定义完成之后，那个对象就在那里，不卑不亢，不悲不喜，等着被使用，等着被回收。

面向切面编程则是指，对于一个我们已经封装好的类，我们可以在编译期间或在运行期间，对其进行切割，把立方体切开，在原有的方法里面添加（织入）一些新的代码，对原有的方法代码进行一次增强处理。而那些增强部分的代码，就被称之为切面，如下面代码实例中的通用日志处理代码，常见的还有事务处理、权限认证等等。

2、切入点(PointCut)
要对哪些类中的哪些方法进行增强，进行切割，指的是被增强的方法。即要切哪些东西。

3、连接点(JoinPoint)
我们知道了要切哪些方法后，剩下的就是什么时候切，在原方法的哪一个执行阶段加入增加代码，这个就是连接点。如方法调用前，方法调用后，发生异常时等等。

4、通知(Advice)
通知被织入方法，改如何被增强。定义切面的具体实现。那么这里面就涉及到一个问题，空间（切哪里）和时间（什么时候切，在何时加入增加代码），空间我们已经知道了就是切入点中定义的方法，而什么时候切，则是连接点的概念，如下面实例中，通用日志处理（切面），@Pointcut规则中指明的方法即为切入点，@Before、@After是连接点，而下面的代码就是对应通知。

@Before(“cutMethod()”)
public void begin() {
System.out.println("@Before lingyejun blog logger : begin");
}
5、目标对象(Target Object)
被一个或多个切面所通知的对象，即为目标对象。

6、AOP代理对象(AOP Proxy Object)
AOP代理是AOP框架所生成的对象，该对象是目标对象的代理对象。代理对象能够在目标对象的基础上，在相应的连接点上调用通知。

7、织入(Weaving)
将切面切入到目标方法之中，使目标方法得到增强的过程被称之为织入。

2.实例
（1）依赖包

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

（2）自定义注解

@Target({ElementType.METHOD,ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Log {
    //模块
    String title() default "";
    //业务
    BusinessType businessType() default BusinessType.OTHER;
    //操作人类别
    OperatorType operatorType() default OperatorType.MANAGE;
    //是否保存请求的参数
    boolean isSaveRequestData() default true;

}

（3）切面

@Component
@Aspect
@Slf4j
public class LogAspect {

    @Pointcut("@annotation(com.mysuper.demo.annotation.Log)")
    public void logPointCut(){

    }

    //处理完请求后执行
    @AfterReturning(pointcut = "logPointCut()",returning = "jsonResult")
    public void doAfterReturning(JoinPoint joinPoint,Object jsonResult){
        log.info("注意，这个模块有所操作");
        handleLog(joinPoint,null,jsonResult);
    }

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

    public void handleLog(final JoinPoint joinPoint,final Exception e, Object jsonResult){

        Log controllerLog = getAnnotation(joinPoint);
        if(controllerLog == null){
            return;
        }

        //获取当前登录用户
        LoginUser loginUser = SpringUtils.getBean(TokenService.class).getLoginUser(ServletUtils.getRequest());

        //数据库日志
        SysOperLog operLog = new SysOperLog();
        operLog.setStatus(BusinessStatus.SUCCESS.ordinal());

        //请求的地址
        String ip = IpUtils.getIpAddr(ServletUtils.getRequest());
        operLog.setOperIp(ip);

        //返回参数
        operLog.setJsonResult(JSON.toJSONString(jsonResult));
        operLog.setOperUrl(ServletUtils.getRequest().getRequestURI());

        if(loginUser != null){
            operLog.setOperName(loginUser.getUsername());
        }

        if(e != null){
            operLog.setStatus(BusinessStatus.FAIL.ordinal());
            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);
        // 保存数据库
        AsyncManager.me().execute(AsyncFactory.recordOper(operLog));
    }

    //获取注解中对方法得描述信息
    public void getControllerMethodDescription(JoinPoint joinPoint,Log log,SysOperLog operLog){

        //设置action动作
        operLog.setBusinessType(log.businessType().ordinal());
        //设置标题
        operLog.setTitle(log.title());
        //设置操作人类别
        operLog.setOperatorType(log.operatorType().ordinal());
        // 是否需要保存request，参数和值
        if (log.isSaveRequestData())
        {
            // 获取参数的信息，传入到数据库中。
            setRequestValue(joinPoint, operLog);
        }

    }

    //获取注解
    public Log getAnnotation(JoinPoint joinPoint){
        Signature signature = joinPoint.getSignature();
        MethodSignature methodSignature = (MethodSignature) signature;
        Method method = methodSignature.getMethod();
        if(method != null){
            return method.getAnnotation(Log.class);
        }
        return null;
    }

    //获取请求的参数，存放到log中
    private void setRequestValue(JoinPoint joinPoint,SysOperLog operLog){
        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 (int i = 0; i < paramsArray.length; i++)
            {
                if (!isFilterObject(paramsArray[i]))
                {
                    Object jsonObj = JSON.toJSON(paramsArray[i]);
                    params += jsonObj.toString() + " ";
                }
            }
        }
        return params.trim();
    }

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

（4）应用

@RestController
public class LoginController {

    @Autowired
    private ISysLoginService sysLoginService;


    @Log(title = "登录模块",businessType = BusinessType.OTHER)
    @RequestMapping("/login")
    public AjaxResult login(@RequestBody LoginBody loginBody){
        AjaxResult ajaxResult = new AjaxResult();
        String token =  sysLoginService.Login(loginBody.getUsername(),loginBody.getPassword(),loginBody.getCode(),loginBody.getUuid());
        ajaxResult.put(Constants.TOKEN,token);
        return ajaxResult;
    }

}