使用aop环绕增强记录日志

定义LogAnnotation注解

代码

//method代表可以放在方法上
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface LogAnnotation {

    String module() default "";

    String operator() default "";

}

记录日志代码

import com.alibaba.fastjson.JSON;
import com.xpblog.utils.HttpContextUtils;
import com.xpblog.utils.IpUtils;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;
import java.lang.reflect.Method;

@Component
@Aspect //切面 定义了通知和切点的关系
@Slf4j
public class LogAspect {

    //需写加强的详细路径
    @Pointcut("@annotation(com.xpblog.common.aop.LogAnnotation)")
    public void pt(){}

    //环绕通知
    @Around("pt()")
    public Object log(ProceedingJoinPoint point) throws Throwable {
        long beginTime = System.currentTimeMillis();
        //执行方法
        Object result = point.proceed();
        //执行时长(毫秒)
        long time = System.currentTimeMillis() - beginTime;
        //保存日志
        recordLog(point, time);
        return result;

    }

    private void recordLog(ProceedingJoinPoint joinPoint, long time) {
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();
        LogAnnotation logAnnotation = method.getAnnotation(LogAnnotation.class);
        log.info("=====================log start================================");
        log.info("module:{}",logAnnotation.module());
        log.info("operation:{}",logAnnotation.operator());

        //请求的方法名
        String className = joinPoint.getTarget().getClass().getName();
        String methodName = signature.getName();
        log.info("request method:{}",className + "." + methodName + "()");

//        //请求的参数
        Object[] args = joinPoint.getArgs();
        String params = JSON.toJSONString(args[0]);
        log.info("params:{}",params);


        log.info("ip:{}", IpUtils.getIpAddr());


        log.info("excute time : {} ms",time);
        log.info("=====================log end================================");
    }

}

工具类

import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;

public class HttpContextUtils {
    public static HttpServletRequest getHttpServletRequest() {
        return ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
    }

}

port lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;

import javax.servlet.http.HttpServletRequest;

/**
 * 获取Ip
 *
 */
@Slf4j
public class IpUtils {

    /**
     * 获取IP地址
     * <p>
     * 使用Nginx等反向代理软件， 则不能通过request.getRemoteAddr()获取IP地址
     * 如果使用了多级反向代理的话，X-Forwarded-For的值并不止一个，而是一串IP地址，X-Forwarded-For中第一个非unknown的有效IP字符串，则为真实IP地址
     */
    public static String getIpAddr(HttpServletRequest request) {
        String ip = null, unknown = "unknown", seperator = ",";
        int maxLength = 15;
        try {
            ip = request.getHeader("x-forwarded-for");
            if (StringUtils.isEmpty(ip) || unknown.equalsIgnoreCase(ip)) {
                ip = request.getHeader("Proxy-Client-IP");
            }
            if (StringUtils.isEmpty(ip) || ip.length() == 0 || unknown.equalsIgnoreCase(ip)) {
                ip = request.getHeader("WL-Proxy-Client-IP");
            }
            if (StringUtils.isEmpty(ip) || unknown.equalsIgnoreCase(ip)) {
                ip = request.getHeader("HTTP_CLIENT_IP");
            }
            if (StringUtils.isEmpty(ip) || unknown.equalsIgnoreCase(ip)) {
                ip = request.getHeader("HTTP_X_FORWARDED_FOR");
            }
            if (StringUtils.isEmpty(ip) || unknown.equalsIgnoreCase(ip)) {
                ip = request.getRemoteAddr();
            }
        } catch (Exception e) {
            log.error("IpUtils ERROR ", e);
        }

        // 使用代理，则获取第一个IP地址
        if (StringUtils.isEmpty(ip) && ip.length() > maxLength) {
            int idx = ip.indexOf(seperator);
            if (idx > 0) {
                ip = ip.substring(0, idx);
            }
        }

        return ip;
    }

    /**
     * 获取ip地址
     *
     * @return
     */
    public static String getIpAddr() {
        //获取request 设置IP地址
        HttpServletRequest request = HttpContextUtils.getHttpServletRequest();
        return getIpAddr(request);
    }
}

前面我们已经介绍了AOP适用的一些业务场景以及简单的代码实现，当时我们的切点是用execution表达式来配置的，这种方式有一些局限性在里面：

• 灵活性不高，一个表达式只能切到某种同类型的方法
• 个性化不足，很难对切面切到的所有方法中的一些做一些个性化的设置

这让我想起有以前我还是一个菜鸟时接到的一个需求，要在所有接口中记录请求日志，因为项目比较老了，所以接口还是挺多的，我预估需要三天才能完成，我们老大鄙视了我一眼，然后花半小时就完成了。
今天我们就来讲讲切点的另一种配置方式：@annotation，通过@annotation配置切点，我们可以灵活的控制切到哪个方法，同时可以进行一些个性化的设置，今天我们就用它来实现一个记录所有接口请求功能吧。
首先来看看我们要实现的效果

通过结果我们可以看到，我们的自定义注解EagleEye做到了统一的记录下了请求链接、请求类型、请求IP、请求入参、请求耗时、请求返回等信息。
是不是感觉还不错呢？下面我们就来一起动手实现它吧！
添加依赖
新建一个Spring Boot项目，打开pom.xml文件添加相关Maven依赖：

自定义一个注解
我们定义了一个注解，定义注解使用@interface：

1. 定义了注解的生命周期为运行时
2. 定义了注解的作用域为方法
3. 标识该注解可以被JavaDoc记录
4. 定义注解名称为EagleEye（鹰眼，哈哈~~）
5. 定义一个元素desc，用来描述被修饰的方法

注解虽然定义好了，但是还用不了，因为没有具体的实现逻辑，接下来我们用AOP实现它。
配置AOP切面
首先我们定义切点：

我们通过@annotation来配置切点，代表我们的AOP切面会切到所有用EagleEye注解修饰的类。
接下来我们利用@Around环绕增强来实现我们的功能：

1. 首先我们先记录请求链接、接口描述、请求类型、请求IP、请求入参信息
2. 接着执行我们注解切到的原方法逻辑
3. 最后我们记录整个请求耗时、返回结果

OK，到这里，我们就完成了利用AOP自定义注解的所有步骤。
怎么使用自定义注解？
修饰Controller里的接口方法：

修饰Service里的方法：

对于需要AOP增强的方法，我们只需要：

1. 在方法上加上@EagleEye注解
2. 通过desc元素设置方法的描述

接下来启动应用，请求接口看一下控制台输出是不是像我们开头贴出的那样吧。

定义一个注解

4.3 通过AOP记录操作日志
4.3.1 自定义注解
通过自定义注解，来标示方法需不需要进行记录日志，如果该方法在访问时需要记录日志，则在该方法 上标示该注解既可。

表结构

CREATE TABLE `operation_log` (
`id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT 'ID',
`operate_class` varchar(200) DEFAULT NULL COMMENT '操作类',
`operate_method` varchar(200) DEFAULT NULL COMMENT '操作方法',
`return_class` varchar(200) DEFAULT NULL COMMENT '返回值类型',
`operate_user` varchar(20) DEFAULT NULL COMMENT '操作用户',
`operate_time` varchar(20) DEFAULT NULL COMMENT '操作时间',
`param_and_value` varchar(500) DEFAULT NULL COMMENT '请求参数名及参数值',
`cost_time` bigint(20) DEFAULT NULL COMMENT '执行方法耗时, 单位 ms',
`return_value` varchar(200) DEFAULT NULL COMMENT '返回值',
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

自定义注解

@Inherited
@Documented
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface OperateLog {
}

4.3.2 定义通知类

@Component
@Aspect
public class OperateAdvice {
private static Logger log = Logger.getLogger(OperateAdvice.class);
@Autowired
private OperationLogService operationLogService; // 添加日志的service接口
// 利用SpringAOP的环绕通知  cn.itcast.controller包下面的所有类所有方法，并且方法上面有@operateLog注解
@Around("execution(* cn.itcast.controller.*.*(..)) && @annotation(operateLog)")
public Object insertLogAround(ProceedingJoinPoint pjp , OperateLog operateLog)
throws Throwable{
System.out.println(" ************************ 记录日志 [start]
****************************** ");
OperationLog op = new OperationLog(); //记录日志的实体类
DateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
op.setOperateTime(sdf.format(new Date()));
op.setOperateUser(DataUtils.getRandStr(8)); // 操作人
op.setOperateClass(pjp.getTarget().getClass().getName());// 操作的类
op.setOperateMethod(pjp.getSignature().getName()); // 操作方法
//获取方法调用时传递的参数
Object[] args = pjp.getArgs();
op.setParamAndValue(Arrays.toString(args));
long start_time = System.currentTimeMillis();
//放行
Object object = pjp.proceed();

long end_time = System.currentTimeMillis();
op.setCostTime(end_time - start_time);
if(object != null){
op.setReturnClass(object.getClass().getName());
op.setReturnValue(object.toString());
}else{
op.setReturnClass("java.lang.Object");
op.setParamAndValue("void");
}
log.error(JsonUtils.obj2JsonString(op));
operationLogService.insert(op);// 插入日志
System.out.println(" ************************** 记录日志 [end]
*************************** ");
return object;
}
}

应用