用Aspect 做方法的后置增强@AfterReturning和异常增强@AfterThrowing

迈不过友情╰ 2023-05-22 10:27 16阅读 0赞

## 业务场景 ##

所有进入controller的请求做请求统计
    	1、用了统一异常处理方法@ControllerAdvice
    	2、统计请求的方法连接 及入参
    	3、统计方法的返回状态（200？）及参数

*正常增强* \*\*filter(JoinPoint joinPoint, Object result) \*\*

*异常增强* \*\*error(JoinPoint jp,Throwable ex) \*\*

package com.mf.gateway.filter;
    
    import com.alibaba.fastjson.serializer.SerializerFeature;
    import com.platform.service.AdminService;
    import com.platform.service.SysOperLogService;
    import com.google.common.collect.Maps;
    import org.apache.dubbo.config.annotation.Reference;
    import org.aspectj.lang.JoinPoint;
    import org.aspectj.lang.annotation.AfterReturning;
    import org.aspectj.lang.annotation.AfterThrowing;
    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.data.redis.core.RedisTemplate;
    import org.springframework.stereotype.Component;
    import org.springframework.web.context.request.RequestContextHolder;
    import org.springframework.web.context.request.ServletRequestAttributes;
    
    import javax.servlet.http.Cookie;
    import javax.servlet.http.HttpServletRequest;
    import java.io.IOException;
    import java.io.UnsupportedEncodingException;
    import java.lang.reflect.Method;
    import java.util.Arrays;
    import java.util.Enumeration;
    import java.util.List;
    import java.util.Map;
    import java.util.concurrent.atomic.AtomicLong;
    
    
    @Aspect
    @Component
    public class LogContainerResponseFilter{ 
    
        private static final Logger logger = LoggerFactory.getLogger(LogContainerResponseFilter.class);
    
        @Reference
        private SysOperLogService sysOperLogService;
    
        @Reference
        private AdminService adminService;
    
        private boolean decode = false;
    
        SerializerFeature[] features = new SerializerFeature[] { 
                SerializerFeature.QuoteFieldNames, SerializerFeature.SortField,
                SerializerFeature.DisableCircularReferenceDetect };
    
        private static final List<String> HEAD_NOT_INCLUDE = Arrays.asList("Accept", "Accept-Encoding", "Accept-Charset",
                "Accept-Language", "Connection", "Content-Encoding", "Content-Type", "Vary", "Cache-Control", "Cookie",
                "Host", "accept", "accept-encoding", "accept-charset", "accept-language", "connection", "content-encoding",
                "content-type", "vary", "cache-control", "cookie", "host","content-length");
    
        private static final AtomicLong atomicLong = new AtomicLong(0);
    
        private static List<String> specialUrl = Arrays.asList("user/login");
    
    
        @Autowired
        private RedisTemplate<String,String> redisTemplate;
    
        /** * RestResp 是controler 设置的一个统一返回对象，此处不给予代码 *Log 是一个自定义注解，对需要做统计的方法添加此注解，注解上标注方法的属性等信息 此处不给予代码 */
    
    
        @Pointcut("@annotation(com.cn.test.util.Log)") //切点是 自定义注解Log 的地址
        public void logPointCut() { 
    
        }
    
    
        @AfterReturning(value="logPointCut()",returning="result")
        public void filter(JoinPoint joinPoint, Object result) throws IOException { 
            ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
            HttpServletRequest request = attributes.getRequest();
            if (!"POST".equalsIgnoreCase(request.getMethod())){ 
                return;
            }
            MethodSignature signature = (MethodSignature) joinPoint.getSignature();
            Method method = signature.getMethod();
            Log log = method.getAnnotation(Log.class);
            if (log ==null ){ 
                return;
            }
    
            Cookie[] cookies = request.getCookies();
            
            //获取请求入参
            Map<String, String> map = getFormParameters(request);
            if (null != map && map.containsKey("password")){ 
                map.remove("password");
            }
    
            /** * 此处逻辑 就是方法正常的处理逻辑，不予赘述 * 此处处理后方执行 @ControllerAdvice逻辑 */
          
        }
    
    
        @AfterThrowing(pointcut = "logPointCut()",throwing = "ex")
        public void error(JoinPoint jp,Throwable ex) throws UnsupportedEncodingException { 
            ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
            HttpServletRequest request = attributes.getRequest();
            if (!"POST".equalsIgnoreCase(request.getMethod())){ 
                return;
            }
            MethodSignature signature = (MethodSignature) jp.getSignature();
            Method method = signature.getMethod();
            Log log = method.getAnnotation(Log.class);
            if (log ==null ){ 
                return;
            }
    
            /** * 此处逻辑 就是方法异常的处理逻辑，不予赘述 */
    
        }
    
    
    
        private Map<String, String> getFormParameters(HttpServletRequest request) { 
            Map<String ,String > paramsMap = Maps.newHashMap();
            Enumeration enu=request.getParameterNames();
            while(enu.hasMoreElements()){ 
                String paraName=(String)enu.nextElement();
                paramsMap.put(paraName ,request.getParameter(paraName));
            }
            return paramsMap;
        }
    
        private static boolean isLogin(String serverUrl){ 
            if(serverUrl.contains("user/login")){ 
                return true;
            }
            return false;
        }
    
    
    
        private static String getIpAddr(HttpServletRequest rc){ 
            if (rc == null)
            { 
                return "unknown";
            }
            String ip = rc.getHeader("x-forwarded-for");
            if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip))
            { 
                ip = rc.getHeader("Proxy-Client-IP");
            }
            if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip))
            { 
                ip = rc.getHeader("X-Forwarded-For");
            }
            if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip))
            { 
                ip = rc.getHeader("WL-Proxy-Client-IP");
            }
            if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip))
            { 
                ip = rc.getHeader("X-Real-IP");
            }
            return "0:0:0:0:0:0:0:1".equals(ip) ? "127.0.0.1" : ip;
        }
    }