SpringBoot@Aspect 打印访问请求和返回数据方式

springboot@aspect 打印访问请求和返回数据

为什么要用aspect， 使用aspect 可以使记录日志的功能面向切面，这样可以降低代码的耦合性。提供了两种方式对输入输出的数据进行打日志，如下：

aspect：第一种方式

@before 和 @afterreturning 来对 controller 进行切面。

输出数据：

aspect：第二种方式

@around 来对controller 进行切面。

输出数据：

两种方法都是能够对请求数据做日志监控。

第一种方式和第二种方式有一些不同，第二种方式使用的是@around 环绕的方式去做的处理，joinpoint.proceed()返回数据需要等方法执行完才能执行下面的代码，这种是阻塞式的请求，所以个人建议还是采用第一种方法比较合适。

springboot @aspect注解详情

1、添加maven依赖注解

        <!--springboot的aop-->
        <dependency>
            <groupid>org.springframework.boot</groupid>
            <artifactid>spring-boot-starter-aop</artifactid>
        </dependency>

2、添加aop类

@component
@aspect
public class journalserviceaspect {
}

3、设置切面点

    /**切面点*/
    private final string point_cut = "execution(* com.xx.xx..*(..))";
    @pointcut(point_cut)
    private void pointcut(){}

4、配置前置通知

/** 
 * 前置通知，方法调用前被调用 
 * @param joinpoint 
 */  
@before(value = point_cut)
public void before(joinpoint joinpoint){
    logger.info("前置通知");
    //获取目标方法的参数信息  
    object[] obj = joinpoint.getargs();  
    //aop代理类的信息  
    joinpoint.getthis();  
    //代理的目标对象  
    joinpoint.gettarget();  
    //用的最多 通知的签名  
    signature signature = joinpoint.getsignature();  
    //代理的是哪一个方法  
    logger.info("代理的是哪一个方法"+signature.getname());  
    //aop代理类的名字  
    logger.info("aop代理类的名字"+signature.getdeclaringtypename());  
    //aop代理类的类（class）信息  
    signature.getdeclaringtype();  
    //获取requestattributes  
    requestattributes requestattributes = requestcontextholder.getrequestattributes();  
    //从获取requestattributes中获取httpservletrequest的信息  
    httpservletrequest request = (httpservletrequest) requestattributes.resolvereference(requestattributes.reference_request);  
    //如果要获取session信息的话，可以这样写：  
    //httpsession session = (httpsession) requestattributes.resolvereference(requestattributes.reference_session);  
    //获取请求参数
    enumeration<string> enumeration = request.getparameternames();  
    map<string,string> parametermap = maps.newhashmap();  
    while (enumeration.hasmoreelements()){  
        string parameter = enumeration.nextelement();  
        parametermap.put(parameter,request.getparameter(parameter));  
    }  
    string str = json.tojsonstring(parametermap);  
    if(obj.length > 0) {  
        logger.info("请求的参数信息为："+str);
    }  
}

**注意：这里用到了joinpoint和requestcontextholder。

1）、通过joinpoint可以获得通知的签名信息，如目标方法名、目标方法参数信息等。

2）、通过requestcontextholder来获取请求信息，session信息。**

5、配置后置返回通知

/** 
 * 后置返回通知 
 * 这里需要注意的是: 
 *      如果参数中的第一个参数为joinpoint，则第二个参数为返回值的信息 
 *      如果参数中的第一个参数不为joinpoint，则第一个参数为returning中对应的参数 
 * returning：限定了只有目标方法返回值与通知方法相应参数类型时才能执行后置返回通知，否则不执行，
 *            对于returning对应的通知方法参数为object类型将匹配任何目标返回值 
 * @param joinpoint 
 * @param keys 
 */  
@afterreturning(value = point_cut,returning = "keys")  
public void doafterreturningadvice1(joinpoint joinpoint,object keys){  
    logger.info("第一个后置返回通知的返回值："+keys);  
}  
@afterreturning(value = point_cut,returning = "keys",argnames = "keys")  
public void doafterreturningadvice2(string keys){  
    logger.info("第二个后置返回通知的返回值："+keys);  
}  

6、后置异常通知

/** 
 * 后置异常通知 
 *  定义一个名字，该名字用于匹配通知实现方法的一个参数名，当目标方法抛出异常返回后，将把目标方法抛出的异常传给通知方法； 
 *  throwing:限定了只有目标方法抛出的异常与通知方法相应参数异常类型时才能执行后置异常通知，否则不执行， 
 *            对于throwing对应的通知方法参数为throwable类型将匹配任何异常。 
 * @param joinpoint 
 * @param exception 
 */  
@afterthrowing(value = point_cut,throwing = "exception")  
public void doafterthrowingadvice(joinpoint joinpoint,throwable exception){  
    //目标方法名：  
    logger.info(joinpoint.getsignature().getname());  
    if(exception instanceof nullpointerexception){  
        logger.info("发生了空指针异常!!!!!");  
    }  
}  

7、后置最终通知

/** 
 * 后置最终通知（目标方法只要执行完了就会执行后置通知方法） 
 * @param joinpoint 
 */  
@after(value = point_cut)  
public void doafteradvice(joinpoint joinpoint){ 
    logger.info("后置最终通知执行了!!!!");  
}  

8、环绕通知

/** 
 * 环绕通知： 
 *   环绕通知非常强大，可以决定目标方法是否执行，什么时候执行，执行时是否需要替换方法参数，执行完毕是否需要替换返回值。 
 *   环绕通知第一个参数必须是org.aspectj.lang.proceedingjoinpoint类型 
 */  
@around(value = point_cut)  
public object doaroundadvice(proceedingjoinpoint proceedingjoinpoint){  
    logger.info("环绕通知的目标方法名："+proceedingjoinpoint.getsignature().getname());  
    try {  
        object obj = proceedingjoinpoint.proceed();  
        return obj;  
    } catch (throwable throwable) {  
        throwable.printstacktrace();  
    }  
    return null;  
}  

以上为个人经验，希望能给大家一个参考，也希望大家多多支持。