开发前端软件素材源码教程下载网站

全部
网站模板
网页特效
网站源码
素材资源
建站学院
软件工具
mysql mysql 微信 微信 小程序 苹果 dedecms 修真图
当前位置：首页 > 建站学院 > 其他教程 >  java如何实现统一打印入参出参等日志

java如何实现统一打印入参出参等日志

其他教程   发布日期：2024年10月28日   浏览次数：321次

这篇文章主要介绍“java如何实现统一打印入参出参等日志”的相关知识，小编通过实际案例向大家展示操作过程，操作方法简单快捷，实用性强，希望这篇“java如何实现统一打印入参出参等日志”文章能帮助大家解决问题。

    1.背景

    SpringBoot项目中，之前都是在controller方法的第一行手动打印 log，return之前再打印返回值。有多个返回点时，就需要出现多少重复代码，过多的非业务代码显得十分凌乱。

    本文将采用AOP 配置自定义注解实现 入参、出参的日志打印（方法的入参和返回值都采用 fastjson 序列化）。

    2.设计思路

    将特定包下所有的controller生成代理类对象，并交由Spring容器管理，并重写invoke方法进行增强(入参、出参的打印).

    3.核心代码

    3.1 自定义注解

    1. @Target(ElementType.TYPE)
    2. @Retention(RetentionPolicy.RUNTIME)
    3. @Documented
    4. @Import({InteractRecordBeanPostProcessor.class})
    5. public @interface EnableInteractRecord {
    7.     /**
    8.      * app对应controller包名
    9.      */
    10.     String[] basePackages() default {};
    12.     /**
    13.      * 排除某些包
    14.      */
    15.     String[] exclusions() default {};
    17. }

    3.2 实现BeanFactoryPostProcessor接口

    作用：获取EnableInteractRecord注解对象，用于获取需要创建代理对象的包名，以及需要排除的包名

    1. @Component
    2. public class InteractRecordFactoryPostProcessor implements BeanFactoryPostProcessor {
    4.     private static Logger logger = LoggerFactory.getLogger(InteractRecordFactoryPostProcessor.class);
    6.     private EnableInteractRecord enableInteractRecord;
    8.     @Override
    9.     public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
    10.         try {
    11.             String[] names = beanFactory.getBeanNamesForAnnotation(EnableInteractRecord.class);
    12.             for (String name : names) {
    13.                 enableInteractRecord = beanFactory.findAnnotationOnBean(name, EnableInteractRecord.class);
    14.                 logger.info("开启交互记录 ", enableInteractRecord);
    15.             }
    16.         } catch (Exception e) {
    17.             logger.error("postProcessBeanFactory() Exception ", e);
    18.         }
    19.     }
    21.     public EnableInteractRecord getEnableInteractRecord() {
    22.         return enableInteractRecord;
    23.     }
    25. }

    3.3 实现MethodInterceptor编写打印日志逻辑

    作用：进行入参、出参打印，包含是否打印逻辑

    1. @Component
    2. public class ControllerMethodInterceptor implements MethodInterceptor {
    3.     private static Logger logger = LoggerFactory.getLogger(ControllerMethodInterceptor.class);
    4.     // 请求开始时间
    5.     ThreadLocal<Long> startTime = new ThreadLocal<>();
    6.     private String localIp = "";
    8.     @PostConstruct
    9.     public void init() {
    10.         try {
    11.             localIp = InetAddress.getLocalHost().getHostAddress();
    12.         } catch (UnknownHostException e) {
    13.             logger.error("本地IP初始化失败 : ", e);
    14.         }
    15.     }
    17.     @Override
    18.     public Object invoke(MethodInvocation invocation) {
    19.         pre(invocation);
    20.         Object result;
    21.         try {
    22.             result = invocation.proceed();
    23.             post(invocation, result);
    24.             return result;
    25.         } catch (Throwable ex) {
    26.             logger.error("controller 执行异常: ", ex);
    27.             error(invocation, ex);
    28.         }
    30.         return null;
    32.     }
    34.     public void error(MethodInvocation invocation, Throwable ex) {
    35.         String msgText = ex.getMessage();
    36.         logger.info(startTime.get() + " 异常，请求结束");
    37.         logger.info("RESPONSE : " + msgText);
    38.         logger.info("SPEND TIME : " + (System.currentTimeMillis() - startTime.get()));
    39.     }
    41.     private void pre(MethodInvocation invocation) {
    42.         long now = System.currentTimeMillis();
    43.         startTime.set(now);
    44.         logger.info(now + " 请求开始");
    45.         ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
    46.         HttpServletRequest request = attributes.getRequest();
    48.         logger.info("URL : " + request.getRequestURL().toString());
    49.         logger.info("HTTP_METHOD : " + request.getMethod());
    50.         logger.info("REMOTE_IP : " + getRemoteIp(request));
    51.         logger.info("LOCAL_IP : " + localIp);
    52.         logger.info("METHOD : " + request.getMethod());
    53.         logger.info("CLASS_METHOD : " + getTargetClassName(invocation) + "." + invocation.getMethod().getName());
    55.         // 获取请求头header参数
    56.         Map<String, String> map = new HashMap<String, String>();
    57.         Enumeration<String> headerNames = request.getHeaderNames();
    58.         while (headerNames.hasMoreElements()) {
    59.             String key = (String) headerNames.nextElement();
    60.             String value = request.getHeader(key);
    61.             map.put(key, value);
    62.         }
    63.         logger.info("HEADERS : " + JSONObject.toJSONString(map));
    64.         Date createTime = new Date(now);
    65.         // 请求报文
    66.         Object[] args = invocation.getArguments();// 参数
    67.         String msgText = "";
    68.         Annotation[][] annotationss = invocation.getMethod().getParameterAnnotations();
    70.         for (int i = 0; i < args.length; i++) {
    71.             Object arg = args[i];
    72.             if (!(arg instanceof ServletRequest)
    73.                     && !(arg instanceof ServletResponse)
    74.                     && !(arg instanceof Model)) {
    75.                 RequestParam rp = null;
    76.                 Annotation[] annotations = annotationss[i];
    77.                 for (Annotation annotation : annotations) {
    78.                     if (annotation instanceof RequestParam) {
    79.                         rp = (RequestParam) annotation;
    80.                     }
    81.                 }
    82.                 if (msgText.equals("")) {
    83.                     msgText += (rp != null ? rp.value() + " = " : " ") + JSONObject.toJSONString(arg);
    84.                 } else {
    85.                     msgText += "," + (rp != null ? rp.value() + " = " : " ") + JSONObject.toJSONString(arg);
    86.                 }
    87.             }
    88.         }
    89.         logger.info("PARAMS : " + msgText);
    90.     }
    92.     private void post(MethodInvocation invocation, Object result) {
    93.         logger.info(startTime.get() + " 请求结束");
    94.         if (!(result instanceof ModelAndView)) {
    95.             String msgText = JSONObject.toJSONString(result);
    96.             logger.info("RESPONSE : " + msgText);
    97.         }
    98.         logger.info("SPEND TIME : " + (System.currentTimeMillis() - startTime.get()));
    100.     }
    103.     private String getRemoteIp(HttpServletRequest request) {
    104.         String remoteIp = null;
    105.         String remoteAddr = request.getRemoteAddr();
    106.         String forwarded = request.getHeader("X-Forwarded-For");
    107.         String realIp = request.getHeader("X-Real-IP");
    108.         if (realIp == null) {
    109.             if (forwarded == null) {
    110.                 remoteIp = remoteAddr;
    111.             } else {
    112.                 remoteIp = remoteAddr + "/" + forwarded.split(",")[0];
    113.             }
    114.         } else {
    115.             if (realIp.equals(forwarded)) {
    116.                 remoteIp = realIp;
    117.             } else {
    118.                 if (forwarded != null) {
    119.                     forwarded = forwarded.split(",")[0];
    120.                 }
    121.                 remoteIp = realIp + "/" + forwarded;
    122.             }
    123.         }
    124.         return remoteIp;
    125.     }
    127.     private String getTargetClassName(MethodInvocation invocation) {
    128.         String targetClassName = "";
    129.         try {
    130.             targetClassName = AopTargetUtils.getTarget(invocation.getThis()).getClass().getName();
    131.         } catch (Exception e) {
    132.             targetClassName = invocation.getThis().getClass().getName();
    133.         }
    134.         return targetClassName;
    135.     }
    137. }

    AopTargetUtils：

    1. public class AopTargetUtils {  
    2.   
    3.       
    4.     /** 
    5.      * 获取 目标对象 
    6.      * @param proxy 代理对象 
    7.      * @return  
    8.      * @throws Exception 
    9.      */  
    10.     public static Object getTarget(Object proxy) throws Exception {  
    11.           
    12.         if(!AopUtils.isAopProxy(proxy)) {
    13.             return proxy;//不是代理对象  
    14.         }  
    15.           
    16.         if(AopUtils.isJdkDynamicProxy(proxy)) {
    17.             return getJdkDynamicProxyTargetObject(proxy);  
    18.         } else { //cglib  
    19.             return getCglibProxyTargetObject(proxy);  
    20.         }  
    21.           
    22.           
    23.           
    24.     }  
    25.   
    26.   
    27.     private static Object getCglibProxyTargetObject(Object proxy) throws Exception {  
    28.         Field h = proxy.getClass().getDeclaredField("CGLIB$CALLBACK_0");  
    29.         h.setAccessible(true);
    30.         Object dynamicAdvisedInterceptor = h.get(proxy);  
    31.           
    32.         Field advised = dynamicAdvisedInterceptor.getClass().getDeclaredField("advised");  
    33.         advised.setAccessible(true);  
    34.           
    35.         Object target = ((AdvisedSupport)advised.get(dynamicAdvisedInterceptor)).getTargetSource().getTarget();
    36.           
    37.         return getTarget(target);
    38.     }  
    39.   
    40.   
    41.     private static Object getJdkDynamicProxyTargetObject(Object proxy) throws Exception {  
    42.         Field h = proxy.getClass().getSuperclass().getDeclaredField("h");  
    43.         h.setAccessible(true);  
    44.         AopProxy aopProxy = (AopProxy) h.get(proxy);
    45.           
    46.         Field advised = aopProxy.getClass().getDeclaredField("advised");  
    47.         advised.setAccessible(true);  
    48.           
    49.         Object target = ((AdvisedSupport)advised.get(aopProxy)).getTargetSource().getTarget();
    50.           
    51.         return getTarget(target); 
    52.     }  
    53.       
    54. }

    3.4 实现BeanPostProcessor接口

    作用：筛选出需要生成代理的类，并生成代理类，返回给Spring容器管理。

    1. public class InteractRecordBeanPostProcessor implements BeanPostProcessor {
    3.     private static Logger logger = LoggerFactory.getLogger(InteractRecordBeanPostProcessor.class);
    5.     @Autowired
    6.     private InteractRecordFactoryPostProcessor interactRecordFactoryPostProcessor;
    8.     @Autowired
    9.     private ControllerMethodInterceptor controllerMethodInterceptor;
    11.     private String BASE_PACKAGES[];//需要拦截的包
    13.     private String EXCLUDING[];// 过滤的包
    15.     //一层目录匹配
    16.     private static final String ONE_REGEX = "[a-zA-Z0-9_]+";
    18.     //多层目录匹配
    19.     private static final String ALL_REGEX = ".*";
    21.     private static final String END_ALL_REGEX = "*";
    23.     @PostConstruct
    24.     public void init() {
    25.         EnableInteractRecord ir = interactRecordFactoryPostProcessor.getEnableInteractRecord();
    26.         BASE_PACKAGES = ir.basePackages();
    27.         EXCLUDING = ir.exclusions();
    28.     }
    30.     @Override
    31.     public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
    32.         try {
    33.             if (interactRecordFactoryPostProcessor.getEnableInteractRecord() != null) {
    34.                 // 根据注解配置的包名记录对应的controller层
    35.                 if (BASE_PACKAGES != null && BASE_PACKAGES.length > 0) {
    36.                     Object proxyObj = doEnhanceForController(bean);
    37.                     if (proxyObj != null) {
    38.                         return proxyObj;
    39.                     }
    40.                 }
    41.             }
    42.         } catch (Exception e) {
    43.             logger.error("postProcessAfterInitialization() Exception ", e);
    44.         }
    45.         return bean;
    46.     }
    48.     @Override
    49.     public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
    50.         return bean;
    51.     }
    53.     private Object doEnhanceForController(Object bean) {
    54.         String beanPackageName = getBeanPackageName(bean);
    55.         if (StringUtils.isNotBlank(beanPackageName)) {
    56.             for (String basePackage : BASE_PACKAGES) {
    57.                 if (matchingPackage(basePackage, beanPackageName)) {
    58.                     if (EXCLUDING != null && EXCLUDING.length > 0) {
    59.                         for (String excluding : EXCLUDING) {
    60.                             if (matchingPackage(excluding, beanPackageName)) {
    61.                                 return bean;
    62.                             }
    63.                         }
    64.                     }
    65.                     Object target = null;
    66.                     try {
    67.                         target = AopTargetUtils.getTarget(bean);
    68.                     } catch (Exception e) {
    69.                         logger.error("AopTargetUtils.getTarget() exception", e);
    70.                     }
    71.                     if (target != null) {
    72.                         boolean isController = target.getClass().isAnnotationPresent(Controller.class);
    73.                         boolean isRestController = target.getClass().isAnnotationPresent(RestController.class);
    74.                         if (isController || isRestController) {
    75.                             ProxyFactory proxy = new ProxyFactory();
    76.                             proxy.setTarget(bean);
    77.                             proxy.addAdvice(controllerMethodInterceptor);
    78.                             return proxy.getProxy();
    79.                         }
    80.                     }
    81.                 }
    82.             }
    84.         }
    85.         return null;
    86.     }
    88.     private static boolean matchingPackage(String basePackage, String currentPackage) {
    89.         if (StringUtils.isEmpty(basePackage) || StringUtils.isEmpty(currentPackage)) {
    90.             return false;
    91.         }
    92.         if (basePackage.indexOf("*") != -1) {
    93.             String patterns[] = StringUtils.split(basePackage, ".");
    94.             for (int i = 0; i < patterns.length; i++) {
    95.                 String patternNode = patterns[i];
    96.                 if (patternNode.equals("*")) {
    97.                     patterns[i] = ONE_REGEX;
    98.                 }
    99.                 if (patternNode.equals("**")) {
    100.                     if (i == patterns.length - 1) {
    101.                         patterns[i] = END_ALL_REGEX;
    102.                     } else {
    103.                         patterns[i] = ALL_REGEX;
    104.                     }
    105.                 }
    106.             }
    107.             String basePackageRegex = StringUtils.join(patterns, "\.");
    108.             Pattern r = Pattern.compile(basePackageRegex);
    109.             Matcher m = r.matcher(currentPackage);
    110.             return m.find();
    111.         } else {
    112.             return basePackage.equals(currentPackage);
    113.         }
    114.     }
    116.     private String getBeanPackageName(Object bean) {
    117.         String beanPackageName = "";
    118.         if (bean != null) {
    119.             Class<?> beanClass = bean.getClass();
    120.             if (beanClass != null) {
    121.                 Package beanPackage = beanClass.getPackage();
    122.                 if (beanPackage != null) {
    123.                     beanPackageName = beanPackage.getName();
    124.                 }
    125.             }
    126.         }
    127.         return beanPackageName;
    128.     }
    130. }

    3.5 启动类配置注解

    1. @EnableInteractRecord(basePackages = “com.test.test.controller”,exclusions = “com.test.demo.controller”)

    以上即可实现入参、出参日志统一打印，并且可以将特定的controller集中管理，并不进行日志的打印（及不进生成代理类）。

    4.出现的问题(及其解决办法)

    实际开发中，特定不需要打印日志的接口，无法统一到一个包下。大部分需要打印的接口，和不需要打印的接口，大概率会参杂在同一个controller中，根据以上设计思路，无法进行区分。

    解决办法：

    自定义排除入参打印注解

    1. @Target(ElementType.METHOD)
    2. @Retention(RetentionPolicy.RUNTIME)
    3. @Documented
    4. public @interface ExcludeReqLog {
    5. }

    自定义排除出参打印注解

    1. @Target(ElementType.METHOD)
    2. @Retention(RetentionPolicy.RUNTIME)
    3. @Documented
    4. public @interface ExcludeRespLog {
    5. }

    增加逻辑

    1. // 1.在解析requestParam之前进行判断
    2.         Method method = invocation.getMethod();
    3.         Annotation[] declaredAnnotations = method.getDeclaredAnnotations();
    4.         boolean flag = true;
    5.         for (Annotation annotation : declaredAnnotations) {
    6.             if (annotation instanceof ExcludeReqLog) {
    7.                 flag = false;
    8.             }
    9.         }
    10.         if (!flag) {
    11.             logger.info("该方法已排除，不打印入参");
    12.             return;
    13.         }
    14. // 2.在解析requestResp之前进行判断
    15.         Method method = invocation.getMethod();
    16.         Annotation[] declaredAnnotations = method.getDeclaredAnnotations();
    17.         boolean flag = true;
    18.         for (Annotation annotation : declaredAnnotations) {
    19.             if (annotation instanceof ExcludeRespLog) {
    20.                 flag = false;
    21.             }
    22.         }
    23.         if (!flag) {
    24.             logger.info("该方法已排除，不打印出参");
    25.             return;
    26.         }

    使用方法

    1. // 1.不打印入参
    2.     @PostMapping("/uploadImg")
    3.     @ExcludeReqLog
    4.     public Result<List<Demo>> uploadIdeaImg(@RequestParam(value = "imgFile", required = false) MultipartFile[] imgFile) {
    5.         return demoService.uploadIdeaImg(imgFile);
    6.     }
    7. //2.不打印出参
    8.     @PostMapping("/uploadImg")
    9.     @ExcludeRespLog 
    10.     public Result<List<Demo>> uploadIdeaImg(@RequestParam(value = "imgFile", required = false) MultipartFile[] imgFile) {
    11.         return demoService.uploadIdeaImg(imgFile);
    12.     }

    以上就是java如何实现统一打印入参出参等日志的详细内容，更多关于java如何实现统一打印入参出参等日志的资料请关注九品源码其它相关文章！

    相关热词： java实现统一打印日志
    上一篇：讲一讲如何在一个页面中使用多个百度分享按钮，分享不同的文章
    下一篇：Servlet注解之@WebInitParam多个InitParam怎么使用

    文章分类

    IT资讯 CMS教程 服务器 数据库 前端开发 后端开发 工具使用 其他教程

    最后更新

    热门排行

    网站首页 | 关于我们 | 免责声明 | 网站建设 | 在线工具 | 网站地图

    版权声明：本站发布的资源部分自互联网，所有资源版权归原作者所有。如果有侵犯到您的权益，请联系本站删除，谢谢合作！

    Copyright 2018-2025 ©19jp.com All Rights Reserved. 陕ICP备16002142号-1