Aop记录日志实践（获取请求参数&返回参数&环绕通知）

谁践踏了优雅 2022-10-17 00:50 464阅读 0赞

先贴一个标准Demo

1.  自定义注解或者代码中配置自己扫描的类或方法。个人觉得注解更加方便些。
    
        import java.lang.annotation.ElementType;
        import java.lang.annotation.Retention;
        import java.lang.annotation.RetentionPolicy;
        import java.lang.annotation.Target;
        
        @Target(ElementType.METHOD)
        @Retention(RetentionPolicy.RUNTIME)
        public @interface AccountOperationLog {
            String busiDesc() default ""; //业务场景
        }
    
    2.定义一个切面类，这个切面就写主要的逻辑。比如获取请求参数，响应参数。

import com.alibaba.fastjson.JSON;
    import com.alibaba.fastjson.JSONObject;
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.Signature;
    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.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Component;
    import org.springframework.web.context.request.RequestContextHolder;
    import org.springframework.web.context.request.ServletRequestAttributes;
    
    import javax.servlet.ServletOutputStream;
    import javax.servlet.http.HttpServletRequest;
    import java.lang.reflect.Method;
    import java.util.*;
    
    @Aspect
    @Component
    public class AccountOperationAspect {
    
        private final Logger logger = LoggerFactory.getLogger(AccountOperationAspect.class);
    	
        @Autowired
        private VirtualAccountOperationLogService virtualAccountOperationLogService; 
        
       //基本类型定义，用于判断请求参数的类型
        private static List typeList = new ArrayList();
        private static String[] types = {"java.lang.Integer", "java.lang.Double",
                "java.lang.Float", "java.lang.Long", "java.lang.Short",
                "java.lang.Byte", "java.lang.Boolean", "java.lang.Char",
                "java.lang.String", "int", "double", "long", "short", "byte",
                "boolean", "char", "float"};
    
        static {
            for (int i =0;i<types.length;i++){
            typeList.add(types[i]);
            }
        }
    
        @Pointcut(value = "@annotation(cn.swiftpass.vcc.order.aop.AccountOperationLog)")
        public void pointcut() {
        }
    
        @Around("pointcut()")
        public ResponeModel afterProcess(ProceedingJoinPoint joinPoint) throws Throwable{
            HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
            String ipAddr = getRemoteHost(request);
            String url = request.getRequestURL().toString();
            ResponeModel result = coreHandle(joinPoint, request);
            logger.info("请求源IP:【{}】,请求URL:【{}】,操作结果：【{}】",ipAddr,url,result);
            return result;
        }
    
        /**
         * 核心处理
         * @param joinPoint
         * @param request
         * @return
         */
        public ResponeModel coreHandle(ProceedingJoinPoint joinPoint, HttpServletRequest request) throws Throwable{
            Signature signature = joinPoint.getSignature();
            MethodSignature methodSignature = (MethodSignature) signature;
            // 通过这获取到方法的所有参数名称的字符串数组
            String[] parameterNames = methodSignature.getParameterNames();//获取到所有参数的NAME
            Object[] args = joinPoint.getArgs(); //获取到所有参数的VALUE
            StringBuilder sb = new StringBuilder();
            Map paramMap = new HashMap();
            if (parameterNames != null && parameterNames.length > 0 && args != null && args.length > 0) {
                for (int i = 0; i < parameterNames.length; i++) {
    				//考虑入参要么为基础类型参数，要么为对象类型。以下方法都适合解析出来
                    if (typeList.contains(args[i].getClass().getTypeName())){
                        //基本数据类型
                        paramMap.put(parameterNames[i],JSON.toJSONString(args[i]));
                    }else{
                        //实体类
                        paramMap = JSON.parseObject(JSON.toJSONString(args[i]));
                    }
                }
            }
            Method targetMethod = methodSignature.getMethod(); //获取到具体的被AOP的方法
            AccountOperationLog methodAnno = targetMethod.getAnnotation(AccountOperationLog.class);//获取到方法上的某个特定注解
            String methodType = methodAnno.busiDesc();//获取注解内的值
          
            if (paramMap.get(methodType)==null){
                throw new BussException(ErrorCodeConstants.VCC_NOT_PARAM);
            }
    		
            //组装数据--省略
            List<VirtualAccountEntity> logEntityList = null;
    
           
            //进入后置处理，根据controller返回结果来判断是否成功
            ResponeModel result= (ResponeModel) joinPoint.proceed();
            String respParam = postHandle(result);
            JSONObject jsonObject = JSONObject.parseObject(respParam);
            String retCode = (String) jsonObject.get("code");
            try {
                if ("0".equals(retCode)) {
                    //如果成功则需要插入数据
                    int i = virtualAccountOperationLogService.saveLog(logEntityList);
                    if (i > 0) {
                        logger.info("AOP 记录日志操作成功，操作批次号>>>>>>>>{}", retCode);
                    } else {
                        logger.info("AOP 记录日志操作失败，操作批次号>>>>>>>>{}", retCode);
                    }
                }
            }catch (Exception e){
                logger.info("插入操作日志异常");
            }
            return result;
        }
    
        /**
         * 返回数据
         * @param retVal
         * @return
         */
        private String postHandle(Object retVal) {
            if(null == retVal){
                return "";
            }
            return JSON.toJSONString(retVal);
        }
    
    
        /**
         * 获取目标主机的ip
         * @param request
         * @return
         */
        private String getRemoteHost(HttpServletRequest request) {
            String ip = request.getHeader("x-forwarded-for");
            if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
                ip = request.getHeader("Proxy-Client-IP");
            }
            if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
                ip = request.getHeader("WL-Proxy-Client-IP");
            }
            if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
                ip = request.getRemoteAddr();
            }
            return "0:0:0:0:0:0:0:1".equals(ip) ? "127.0.0.1" : ip;
        }
    
    
        /**
         * 获取随机串
         * @param length
         * @return
         */
        public static String genrateRandomCode(int length){
            StringBuffer buffer = new StringBuffer();
            Random r = new Random();
            for (int i = 0;i < length; i++){
                int number = r.nextInt(9);
                buffer.append(number);
            }
            return buffer.toString();
        }
    
    
    
    }

最后在controller使用注解即可。

实际业务场景：由于存在敏感操作，要记录一个业务的操作日志。这个业务可以通过多种场景触发数据变更。下面就贴图。

自定义注解：（要根据业务来定义，可以定义多个字段）

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mjc0MDU0MA_size_16_color_FFFFFF_t_70][]

AOP配置类核心方法

public ResponeModel coreHandle(ProceedingJoinPoint joinPoint, HttpServletRequest request) throws Throwable{
        Signature signature = joinPoint.getSignature();
        MethodSignature methodSignature = (MethodSignature) signature;
        // 通过这获取到方法的所有参数名称的字符串数组
        String[] parameterNames = methodSignature.getParameterNames();
        Object[] args = joinPoint.getArgs();
        StringBuilder sb = new StringBuilder();
        Map paramMap = new HashMap();
        if (parameterNames != null && parameterNames.length > 0 && args != null && args.length > 0) {
            for (int i = 0; i < parameterNames.length; i++) {
                if (typeList.contains(args[i].getClass().getTypeName())){
                    //基本数据类型
                    paramMap.put(parameterNames[i],JSON.toJSONString(args[i]));
                }else{
                    //实体类
                    paramMap = JSON.parseObject(JSON.toJSONString(args[i]));
                }
            }
        }
    
        Method targetMethod = methodSignature.getMethod();
        AccountOperationLog methodAnno = targetMethod.getAnnotation(AccountOperationLog.class);
        String methodType = methodAnno.methodType().getmethodType();
        String coreparams = methodAnno.Coreparams();
        int busiScopeCode= methodAnno.busiScope().getCode();
        if (paramMap.get(coreparams)==null){
            throw new BussException(ErrorCodeConstants.VCC_NOT_PARAM);
        }
        //先查询下旧数据
        List<VirtualAccountEntity> oldEntity = getVirtualAccountEntity(coreparams, busiScopeCode,paramMap);//得到了真实要处理的实体类
    
        Map<String,Object> dataMap = new HashMap();
        for (VirtualAccountEntity tempEntity:oldEntity){
            dataMap.put(tempEntity.getId().toString(),tempEntity);
        }
        //进入后置处理，根据controller返回结果来判断是否成功
        ResponeModel result= (ResponeModel) joinPoint.proceed();
        String respParam = postHandle(result);
        JSONObject jsonObject = JSONObject.parseObject(respParam);
        String retCode = (String) jsonObject.get("code");
        try {
            if ("0".equals(retCode)) {
                //如果成功则需要插入数据，新数据
                List<VirtualAccountEntity> newEntity = getVirtualAccountEntity(coreparams, busiScopeCode, paramMap);//得到了真实要处理的实体类
                List<VirtualAccountOperationLogEntity> logEntityList = new ArrayList<>();
                String operCode = genrateRandomCode(8);
                for (VirtualAccountEntity tempInsertEntity : newEntity) {
                    VirtualAccountOperationLogEntity logEntity = new VirtualAccountOperationLogEntity();
                    logEntity.setAccountNumber(tempInsertEntity.getAccountNumber());
                    logEntity.setBuyerNo(tempInsertEntity.getBuyerNo());
                    logEntity.setFundingAccountNumber(tempInsertEntity.getFundingAccountNumber());
                    logEntity.setNewString(JSON.toJSONString(tempInsertEntity));//新值
                    logEntity.setProxyPoolId(tempInsertEntity.getProxyPoolId());
                    logEntity.setOperationTime(new Date());
                    logEntity.setOperatorCode(operCode);
                    logEntity.setOperatorUserName(SecurityUtils.getLoginName());
                    logEntity.setOperatorUserId(SecurityUtils.getUserId().toString());
                    logEntity.setType(methodType);
                    logEntity.setTemplateNo(tempInsertEntity.getTemplateNo());
                    logEntity.setName(methodAnno.busiDesc());
                    if ("UPDATE".equals(methodType)) {
                        //如果是更新操作，则需要插入之前的数据
                        logEntity.setOldString(JSON.toJSONString(dataMap.get(tempInsertEntity.getId().toString())));
                    }
                    logEntityList.add(logEntity);
                }
                int i = virtualAccountOperationLogService.saveLog(logEntityList);
                if (i > 0) {
                    logger.info("AOP 记录电子卡日志操作成功，操作批次号>>>>>>>>{}", operCode);
                } else {
                    logger.info("AOP 记录电子卡日志操作失败，操作批次号>>>>>>>>{}", operCode);
                }
            }
        }catch (Exception e){
            logger.info("插入电子卡操作日志异常");
        }
    
        return result;
    }

最终在controller层使用

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mjc0MDU0MA_size_16_color_FFFFFF_t_70 1][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mjc0MDU0MA_size_16_color_FFFFFF_t_70]: /images/20221014/9647dd9d42a949a1b146dcb55abf4b5e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mjc0MDU0MA_size_16_color_FFFFFF_t_70 1]: /images/20221014/c74d4bac72084070909b3ee152798fd5.png