AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

封装SLF4J/Log4j，不再处处定义logger变量

2017-08-01 2663
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
日志服务 SLS，月写入数据量 50GB 1个月
简介：

自从开始使用日志组件后， 每个类都是这样子的结构:


 
 
    

  
  
  1. public class A { 
    2. 

  
  
  2.   public static final Logger logger = LoggerFactory.getLogger(A.class); 
    3. 

  
  
  3.  
    4. 

  
  
  4. }  
    5.

这是一件相当烦人事，必须对他进行封装，使得我们能够通过这样的方法来调用：


 
 
    

  
  
  1. public class A { 
    2. 

  
  
  2.     public void methodA() { 
    3. 

  
  
  3.         Logger.debug("Nice!"); 
    4. 

  
  
  4.     } 
    5. 

  
  
  5. }  
    6.

最简单的版本

开始动手后，用最简单的方法封装出了第一个版本:


 
 
    

  
  
  1. // cn.hjktech.slf4j.Logger 
    2. 

  
  
  2. public class Logger { 
    3. 

  
  
  3.     private static final org.slf4j.Logger logger = LoggerFactory.getLogger(Logger.class);; 
    4. 

  
  
  4.     ... 
    5. 

  
  
  5.     public static void debug(...) { 
    6. 

  
  
  6.         logger.debug(...); 
    7. 

  
  
  7.         ... 
    8. 

  
  
  8.     } 
    9. 

  
  
  9.     ... 
    10. 

  
  
  10. }  
    11.

看起来很美好， 但测试后发现这种方法会有一个很严重的问题： 我们打印的日志通畅都带有调用方的信息， 如类名、方法名、行数、时间等，其中类名、方法名、行数都是极其关键的信息，但是使用上述的方法来输出日志的话，这三个信息都变成Logger这个类的信息，而不是调用方的信息， 这显然是无法忍受的事。

当然不能就这样了事，既然正常使用的方法能输出正确的信息，那么肯定是有办法可以实现的，我们希望最终的结果是调用Logger.debug(..)打印出来的信息都是完全正确的。

分析源码

此时写个demo来debug跟进一下：


 
 
    

  
  
  1. public class TestLog { 
    2. 

  
  
  2.     @Test 
    3. 

  
  
  3.     public void logTest() { 
    4. 

  
  
  4.         // 在此处打断点 
    5. 

  
  
  5.         LoggerFactory.getLogger(TestLog.class).debug("看看执行流程"); 
    6. 

  
  
  6.     } 
    7. 

  
  
  7. }  
    8.

发现最终输出的日志字符串是在PatternLayout.format方法(Logback则是PatternLayoutBase.writeLoopOnConverters方法)中生成的，方法代码如下：


 
 
    

  
  
  1. // Log4j 
    2. 

  
  
  2. public String format(LoggingEvent event) { 
    3. 

  
  
  3.     // Reset working stringbuffer 
    4. 

  
  
  4.     if(sbuf.capacity() > MAX_CAPACITY) { 
    5. 

  
  
  5.         sbuf = new StringBuffer(BUF_SIZE); 
    6. 

  
  
  6.     } else { 
    7. 

  
  
  7.         sbuf.setLength(0); 
    8. 

  
  
  8.     } 
    9. 

  
  
  9.  
    10. 

  
  
  10.     PatternConverter c = head; 
    11. 

  
  
  11.  
    12. 

  
  
  12.     while(c != null) { 
    13. 

  
  
  13.         c.format(sbuf, event); 
    14. 

  
  
  14.         c = c.next; 
    15. 

  
  
  15.     } 
    16. 

  
  
  16.     return sbuf.toString(); 
    17. 

  
  
  17. }  
    18.

其中head指向一个类型为PatternConverter(Logback中是: Converter)的链表，这个链表的节点是在日志类初始化的时候，根据你日志配置文件里的ConversionPattern生成的，比如我的log4j.properties中是这样配置的:


 
 
    

  
  
  1. log4j.appender.SOUT_LOGGER.layout.ConversionPattern=%d{yyyy-MM-dd-HH-mm,SSS} %p [%c] [%t] (%F:%L) %l - %m%n 
    2.

那么这个链表的结构就是(括号中代表存储的信息):


 
 
    

  
  
  1. DatePatternConverter(时间点)           -> LiteralPatternConverter(" ")   ->  
    2. 

  
  
  2. BasicPatternConverter(LEVEL)          -> LiteralPatternConverter("[")   ->  
    3. 

  
  
  3. CategoryPatternConverter(LoggerName)  -> LiteralPatternConverter("] [") ->  
    4. 

  
  
  4. BasicPatternConverter(线程名)          -> LiteralPatternConverter("] (") -> 
    5. 

  
  
  5. LocationPatternConverter(所在类)       -> LiteralPatternConverter(":")   ->  
    6. 

  
  
  6. LocationPatternConverter(所在行)       -> LiteralPatternConverter(") -") ->  
    7. 

  
  
  7. BasicPatternConverter(日志串)          -> LiteralPatternConverter("\n")  ->  
    8.

根据这个链表生成日志字符串类似这样:


 
 
    

  
  
  1. 2016-10-17-13-42,449 DEBUG [TestLog] [main] (TestLog.java:14) - Excuse me? 
    2.

那么现在目标很明确了，我们要使LocationPatternConverter的输出为我们真正打印纸日的类的信息，继续跟进到PatternConverter.format(LocationPatternConverter的父类)方法，其内部生成了一个LocationInfo对象，该类的构造方法中如下：


 
 
    

  
  
  1. for(int i = elements.length - 1; i >= 0; i--) { 
    2. 

  
  
  2.     // 获取第i帧的类名 
    3. 

  
  
  3.     String thisClass = (String) getClassNameMethod.invoke(elements[i], noArgs); 
    4. 

  
  
  4.     if(fqnOfCallingClass.equals(thisClass)) { 
    5. 

  
  
  5.         // 如果类名和fqnOfCallingClass相等，则认为i + 1帧是代码中实际调用方法的 
    6. 

  
  
  6.         int caller = i + 1; 
    7. 

  
  
  7.         if (caller < elements.length) { 
    8. 

  
  
  8.             // 记录实际调用类的类名 
    9. 

  
  
  9.             className = prevClass; 
    10. 

  
  
  10.             // 记录实际调用的方法名 
    11. 

  
  
  11.             methodName = (String) getMethodNameMethod.invoke(elements[caller], noArgs); 
    12. 

  
  
  12.             // 记录实际调用类所在的文件名 
    13. 

  
  
  13.             fileName = (String) getFileNameMethod.invoke(elements[caller], noArgs); 
    14. 

  
  
  14.             if (fileName == null) { 
    15. 

  
  
  15.                 fileName = NA; 
    16. 

  
  
  16.             } 
    17. 

  
  
  17.             // 记录调用日志方法的行数 
    18. 

  
  
  18.             int line = ((Integer) getLineNumberMethod.invoke(elements[caller], noArgs)).intValue(); 
    19. 

  
  
  19.             if (line < 0) { 
    20. 

  
  
  20.                 lineNumber = NA; 
    21. 

  
  
  21.             } else { 
    22. 

  
  
  22.                 lineNumber = String.valueOf(line); 
    23. 

  
  
  23.             } 
    24. 

  
  
  24.             // 拼接成最终要输出到日志的字符串， 如：TestLog.logTest(TestLog.java:14) 
    25. 

  
  
  25.             StringBuffer buf = new StringBuffer(); 
    26. 

  
  
  26.             buf.append(className); 
    27. 

  
  
  27.             buf.append("."); 
    28. 

  
  
  28.             buf.append(methodName); 
    29. 

  
  
  29.             buf.append("("); 
    30. 

  
  
  30.             buf.append(fileName); 
    31. 

  
  
  31.             buf.append(":"); 
    32. 

  
  
  32.             buf.append(lineNumber); 
    33. 

  
  
  33.             buf.append(")"); 
    34. 

  
  
  34.             this.fullInfo = buf.toString(); 
    35. 

  
  
  35.         } 
    36. 

  
  
  36.         return; 
    37. 

  
  
  37.     } 
    38. 

  
  
  38.     // 记录上一帧的类名 
    39. 

  
  
  39.     prevClass = thisClass; 
    40. 

  
  
  40. }  
    41.

其中elements是当前方法调用栈的堆栈轨迹，这段代码通过遍历堆栈轨迹每一帧的类名并和fqnOfCallingClass比较，如果相符的话，则认为它的上一帧是实际调用方法。

如下图中，fqnOfCallingClass的值是org.slf4j.impl.Log4jLoggerAdapter，而在堆栈轨迹总可以发现类的上一个帧正好是我们的实际调用类TestLog.logTest：

因此，我们现在只需要让fqnOfCallingClass的值变成我们封装的日志类cn.hjktech.slf4j.Logger就大功告成了。fqnOfCallingClass是LoggingEvent.getLocationInformation创建LocationInfo时传入的参数，而LoggingEvent又是在Category.forcedLog方法中创建的，并且继续网上追踪，会发现fqnOfCallingClass的值最终来源于org.slf4j.impl.Log4jLoggerAdapter这个类:


 
 
    

  
  
  1. public final class Log4jLoggerAdapter extends MarkerIgnoringBase implements LocationAwareLogger, Serializable { 
    2. 

  
  
  2.     ... 
    3. 

  
  
  3.     static final String FQCN = Log4jLoggerAdapter.class.getName(); 
    4. 

  
  
  4.     ... 
    5. 

  
  
  5. }  
    6.

而如果没有配合SLF4J使用时，fqnOfCallingClass的值则来源于org.apache.log4j.Logger类：


 
 
    

  
  
  1. public class Logger extends Category { 
    2. 

  
  
  2.     ... 
    3. 

  
  
  3.     private static final String FQCN = Logger.class.getName(); 
    4. 

  
  
  4.     .... 
    5. 

  
  
  5. }  
    6.

代理Logger类来修改FQCN

好了，现在我们只需要修改这个值就行了。第一反应是使用反射去掉final修饰符，然后修改它的值，这种方法虽然对我们自己的代码可行，但是当引入其它框架，并且其它框架也使用的Log4j时，就会导致它们的日志信息出错，因为它们并不是调用的我们封装的Logger工具类，它们日志的堆栈轨迹中不会有我们工具类(如cn.hjktech.slf4j.Logger)，因此我们需要另寻它法。

既然通过反射行不通， 那么我们可以通过动态代理的方式，在构造LoggingEvent对象之前将FQCN这个参数的值给替换掉，在跟踪过程中发现Log4jLoggerAdapter最终都是调用的org.apache.log4j.Logger.log方法并将FQCN最为参数传入，因此org.apache.log4j.Logger这个类就是我们要代理的类了。

了解JDK代理的人都知道，使用的条件是被代理类必须实现某一个接口，而org.apache.log4j.Logger.log这个方法并不是来自于某一个接口，所以我们选择使用Cglib：


 
 
    

  
  
  1. // cn.hjktech.slf4j.Logger 
    2. 

  
  
  2. public class Logger { 
    3. 

  
  
  3.     private static org.slf4j.Logger logger; 
    4. 

  
  
  4.     private static final String FQCN = Logger.class.getName(); 
    5. 

  
  
  5.  
    6. 

  
  
  6.     static { 
    7. 

  
  
  7.         try { 
    8. 

  
  
  8.             Enhancer eh = new Enhancer(); 
    9. 

  
  
  9.             eh.setSuperclass(org.apache.log4j.Logger.class); 
    10. 

  
  
  10.             eh.setCallbackType(LogInterceptor.class); 
    11. 

  
  
  11.             Class c = eh.createClass(); 
    12. 

  
  
  12.             Enhancer.registerCallbacks(c, new LogInterceptor[]{new LogInterceptor()}); 
    13. 

  
  
  13.             Constructor<org.apache.log4j.Logger> constructor = c.getConstructor(String.class); 
    14. 

  
  
  14.             org.apache.log4j.Logger loggerProxy= constructor.newInstance(Logger.class.getName()); 
    15. 

  
  
  15.             ... 
    16. 

  
  
  16.         } catch (...) { 
    17. 

  
  
  17.             throw new RuntimeException("初始化Logger失败", e); 
    18. 

  
  
  18.         } 
    19. 

  
  
  19.     } 
    20. 

  
  
  20.  
    21. 

  
  
  21.     private static class LogInterceptor implements MethodInterceptor { 
    22. 

  
  
  22.         public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable { 
    23. 

  
  
  23.             // 只拦截log方法。 
    24. 

  
  
  24.             if (objects.length != 4 || !method.getName().equals("log")) 
    25. 

  
  
  25.                 return methodProxy.invokeSuper(o, objects); 
    26. 

  
  
  26.             // 替换传给log方法的第一个参数为我们自定义的FQCN 
    27. 

  
  
  27.             objects[0] = FQCN; 
    28. 

  
  
  28.             return methodProxy.invokeSuper(o, objects); 
    29. 

  
  
  29.         } 
    30. 

  
  
  30.     } 
    31. 

  
  
  31. }  
    32.

代理defaultFactory

现在我们已经有了被代理的loggerProxy对象了，我们还需要将这个对象赋值给Log4jLoggerAdapter的logger成员变量，

logger成员变量是在Log4jLoggerAdapter的构造方法中被作为参数传入的，它的来源如下图：

从上图中可以看到，LogManager.getLoggerRepository方法返回的对象中持有defaultFactory对象，因此我还需要代理这个对象，将它产生的'logger'对象替换成我们的'logger'就大功告成了，并且makeNewLoggerInstance方法是在LoggerFactory接口中定义的，所以我们只需要使用JDK的动态代理就可以完成了。实现代码如下：


 
 
    

  
  
  1. static { 
    2. 

  
  
  2.     try { 
    3. 

  
  
  3.         ... 
    4. 

  
  
  4.         LoggerRepository loggerRepository = LogManager.getLoggerRepository(); 
    5. 

  
  
  5.         org.apache.log4j.spi.LoggerFactory lf = ReflectionUtil.getFieldValue(loggerRepository, "defaultFactory"); 
    6. 

  
  
  6.         Object loggerFactoryProxy = Proxy.newProxyInstance( 
    7. 

  
  
  7.             LoggerFactory.class.getClassLoader(), 
    8. 

  
  
  8.             new Class[]{LoggerFactory.class}, 
    9. 

  
  
  9.             new NewLoggerHandler(loggerProxy) 
    10. 

  
  
  10.         ); 
    11. 

  
  
  11.  
    12. 

  
  
  12.         ReflectionUtil.setFieldValue(loggerRepository, "defaultFactory", loggerFactoryProxy); 
    13. 

  
  
  13.             logger = org.slf4j.LoggerFactory.getLogger(Logger.class.getName()); 
    14. 

  
  
  14.         ReflectionUtil.setFieldValue(loggerRepository, "defaultFactory", lf); 
    15. 

  
  
  15.     } catch (...) { 
    16. 

  
  
  16.         throw new RuntimeException("初始化Logger失败", e); 
    17. 

  
  
  17.     } 
    18. 

  
  
  18. } 
    19. 

  
  
  19.  
    20. 

  
  
  20. private static class NewLoggerHandler implements InvocationHandler { 
    21. 

  
  
  21.     private final org.apache.log4j.Logger proxyLogger; 
    22. 

  
  
  22.  
    23. 

  
  
  23.     public NewLoggerHandler(org.apache.log4j.Logger proxyLogger) { 
    24. 

  
  
  24.         this.proxyLogger = proxyLogger; 
    25. 

  
  
  25.     } 
    26. 

  
  
  26.  
    27. 

  
  
  27.     @Override 
    28. 

  
  
  28.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
    29. 

  
  
  29.         return proxyLogger; 
    30. 

  
  
  30.     } 
    31. 

  
  
  31. }  
    32.

实现流程和最终代码

我们最终实现方案如下：

Logger的代码如下:


 
 
    

  
  
  1. public class Logger { 
    2. 

  
  
  2.     private static org.slf4j.Logger logger; 
    3. 

  
  
  3.     private static final String FQCN = Logger.class.getName(); 
    4. 

  
  
  4.      
    5. 

  
  
  5.     static { 
    6. 

  
  
  6.         try { 
    7. 

  
  
  7.             Enhancer eh = new Enhancer(); 
    8. 

  
  
  8.             eh.setSuperclass(org.apache.log4j.Logger.class); 
    9. 

  
  
  9.             eh.setCallbackType(LogInterceptor.class); 
    10. 

  
  
  10.             Class c = eh.createClass(); 
    11. 

  
  
  11.             Enhancer.registerCallbacks(c, new LogInterceptor[]{new LogInterceptor()}); 
    12. 

  
  
  12.  
    13. 

  
  
  13.             Constructor<org.apache.log4j.Logger> constructor = c.getConstructor(String.class); 
    14. 

  
  
  14.             org.apache.log4j.Logger loggerProxy = constructor.newInstance(Logger.class.getName()); 
    15. 

  
  
  15.  
    16. 

  
  
  16.             LoggerRepository loggerRepository = LogManager.getLoggerRepository(); 
    17. 

  
  
  17.             org.apache.log4j.spi.LoggerFactory lf = ReflectionUtil.getFieldValue(loggerRepository, "defaultFactory"); 
    18. 

  
  
  18.             Object loggerFactoryProxy = Proxy.newProxyInstance( 
    19. 

  
  
  19.                 LoggerFactory.class.getClassLoader(), 
    20. 

  
  
  20.                 new Class[]{LoggerFactory.class}, 
    21. 

  
  
  21.                 new NewLoggerHandler(loggerProxy) 
    22. 

  
  
  22.             ); 
    23. 

  
  
  23.  
    24. 

  
  
  24.             ReflectionUtil.setFieldValue(loggerRepository, "defaultFactory", loggerFactoryProxy); 
    25. 

  
  
  25.             logger = org.slf4j.LoggerFactory.getLogger(Logger.class.getName()); 
    26. 

  
  
  26.             ReflectionUtil.setFieldValue(loggerRepository, "defaultFactory", lf); 
    27. 

  
  
  27.         } catch ( 
    28. 

  
  
  28.             IllegalAccessException | 
    29. 

  
  
  29.                 NoSuchMethodException | 
    30. 

  
  
  30.                 InvocationTargetException | 
    31. 

  
  
  31.                 InstantiationException e) { 
    32. 

  
  
  32.             throw new RuntimeException("初始化Logger失败", e); 
    33. 

  
  
  33.         } 
    34. 

  
  
  34.     } 
    35. 

  
  
  35.  
    36. 

  
  
  36.     private static class LogInterceptor implements MethodInterceptor { 
    37. 

  
  
  37.         public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable { 
    38. 

  
  
  38.             // 只拦截log方法。 
    39. 

  
  
  39.             if (objects.length != 4 || !method.getName().equals("log")) 
    40. 

  
  
  40.                 return methodProxy.invokeSuper(o, objects); 
    41. 

  
  
  41.             objects[0] = FQCN; 
    42. 

  
  
  42.             return methodProxy.invokeSuper(o, objects); 
    43. 

  
  
  43.         } 
    44. 

  
  
  44.     } 
    45. 

  
  
  45.  
    46. 

  
  
  46.     private static class NewLoggerHandler implements InvocationHandler { 
    47. 

  
  
  47.         private final org.apache.log4j.Logger proxyLogger; 
    48. 

  
  
  48.  
    49. 

  
  
  49.         public NewLoggerHandler(org.apache.log4j.Logger proxyLogger) { 
    50. 

  
  
  50.             this.proxyLogger = proxyLogger; 
    51. 

  
  
  51.         } 
    52. 

  
  
  52.  
    53. 

  
  
  53.         @Override 
    54. 

  
  
  54.         public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
    55. 

  
  
  55.             return proxyLogger; 
    56. 

  
  
  56.         } 
    57. 

  
  
  57.     } 
    58. 

  
  
  58.  
    59. 

  
  
  59.     // 剩下的Logger需要封装的方法可以根据自己的需要来实现 
    60. 

  
  
  60.     // 我个人认为slf4j的api足够好用了，所以大部分只是写了一些类似下面的代码 
    61. 

  
  
  61.     public static void debug(String msg) { 
    62. 

  
  
  62.         logger.debug(msg); 
    63. 

  
  
  63.     } 
    64. 

  
  
  64. }  
    65.

ReflectionUtil的代码如下：


 
 
    

  
  
  1. public class ReflectionUtil { 
    2. 

  
  
  2.     public static <T> T getFieldValue(@NotNull Object object, 
    3. 

  
  
  3.                                       @NotNull String fullName) throws IllegalAccessException { 
    4. 

  
  
  4.         return getFieldValue(object, fullName, false); 
    5. 

  
  
  5.     } 
    6. 

  
  
  6.  
    7. 

  
  
  7.     public static <T> T getFieldValue(@NotNull Object object, 
    8. 

  
  
  8.                                       @NotNull String fieldName, 
    9. 

  
  
  9.                                       boolean traceable) throws IllegalAccessException { 
    10. 

  
  
  10.         Field field; 
    11. 

  
  
  11.         String[] fieldNames = fieldName.split("\\."); 
    12. 

  
  
  12.         for (String targetField : fieldNames) { 
    13. 

  
  
  13.             field = searchField(object.getClass(), targetField, traceable); 
    14. 

  
  
  14.             if (field == null) 
    15. 

  
  
  15.                 return null; 
    16. 

  
  
  16.  
    17. 

  
  
  17.             object = getValue(object, field); 
    18. 

  
  
  18.         } 
    19. 

  
  
  19.  
    20. 

  
  
  20.         return (T) object; 
    21. 

  
  
  21.     } 
    22. 

  
  
  22.  
    23. 

  
  
  23.     private static Field searchField(Class c, String targetField, boolean traceable) { 
    24. 

  
  
  24.         do { 
    25. 

  
  
  25.             Field[] fields = c.getDeclaredFields(); 
    26. 

  
  
  26.             for (Field f : fields) { 
    27. 

  
  
  27.                 if (f.getName().equals(targetField)) { 
    28. 

  
  
  28.                     return f; 
    29. 

  
  
  29.                 } 
    30. 

  
  
  30.             } 
    31. 

  
  
  31.             c = c.getSuperclass(); 
    32. 

  
  
  32.             traceable = traceable && c != Object.class; 
    33. 

  
  
  33.         } while (traceable); 
    34. 

  
  
  34.  
    35. 

  
  
  35.         return null; 
    36. 

  
  
  36.     } 
    37. 

  
  
  37.  
    38. 

  
  
  38.     private static <T> T getValue(Object target, Field field) throws IllegalAccessException { 
    39. 

  
  
  39.         if (!field.isAccessible()) 
    40. 

  
  
  40.             field.setAccessible(true); 
    41. 

  
  
  41.         return (T) field.get(target); 
    42. 

  
  
  42.     } 
    43. 

  
  
  43.  
    44. 

  
  
  44.     public static boolean setFieldValue(@NotNull Object target, 
    45. 

  
  
  45.                                         @NotNull String fieldName, 
    46. 

  
  
  46.                                         @NotNull Object value) throws IllegalAccessException { 
    47. 

  
  
  47.         return setFieldValue(target, fieldName, value, false); 
    48. 

  
  
  48.     } 
    49. 

  
  
  49.  
    50. 

  
  
  50.     public static boolean setFieldValue(@NotNull Object target, 
    51. 

  
  
  51.                                         @NotNull String fieldName, 
    52. 

  
  
  52.                                         @NotNull Object value, 
    53. 

  
  
  53.                                         boolean traceable) throws IllegalAccessException { 
    54. 

  
  
  54.         Field field = searchField(target.getClass(), fieldName, traceable); 
    55. 

  
  
  55.         if (field != null) 
    56. 

  
  
  56.             return setValue(field, target, value); 
    57. 

  
  
  57.         return false; 
    58. 

  
  
  58.     } 
    59. 

  
  
  59.  
    60. 

  
  
  60.     private static boolean setValue(Field field, Object target, Object value) throws IllegalAccessException { 
    61. 

  
  
  61.         if (!field.isAccessible()) 
    62. 

  
  
  62.             field.setAccessible(true); 
    63. 

  
  
  63.         field.set(target, value); 
    64. 

  
  
  64.         return true; 
    65. 

  
  
  65.     } 
    66. 

  
  
  66. }  
    67.

测试


 
 
    

  
  
  1. public class TestLog { 
    2. 

  
  
  2.  
    3. 

  
  
  3.     @Test 
    4. 

  
  
  4.     public void logTest() { 
    5. 

  
  
  5.         Logger.debug((Marker)null, "这是调用封装的Logger输出日志"); 
    6. 

  
  
  6.         LoggerFactory.getLogger(TestLog.class).info("常规方法输出日志"); 
    7. 

  
  
  7.     } 
    8. 

  
  
  8. }  
    9.

输出结果：


 
 
    

  
  
  1. 2016-10-19-15-00,308 DEBUG [cn.hjktech.slf4j.Logger] [main] (TestLog.java:13) TestLog.logTest(TestLog.java:13) - 这是调用封装的Logger输出日志  
    2. 

  
  
  2. 2016-10-19-15-00,311 INFO [TestLog] [main] (TestLog.java:14) TestLog.logTest(TestLog.java:14) - 常规方法输出日志  
    3.



作者：疯狂的爱因斯坦

来源：51CTO

文章标签：
日志服务
监控
Apache
Java
关键词：
slf4j Log4j
slf4j日志服务
日志服务logger
Log4j slf4j
封装日志服务
相关实践学习
日志服务之使用Nginx模式采集日志
本文介绍如何通过日志服务控制台创建Nginx模式的Logtail配置快速采集Nginx日志并进行多维度分析。
行者武松
目录
相关文章
蓝染-惣右介
|
12天前
|
XML 安全 Java
【日志框架整合】Slf4j、Log4j、Log4j2、Logback配置模板
本文介绍了Java日志框架的基本概念和使用方法，重点讨论了SLF4J、Log4j、Logback和Log4j2之间的关系及其性能对比。SLF4J作为一个日志抽象层，允许开发者使用统一的日志接口，而Log4j、Logback和Log4j2则是具体的日志实现框架。Log4j2在性能上优于Logback，推荐在新项目中使用。文章还详细说明了如何在Spring Boot项目中配置Log4j2和Logback，以及如何使用Lombok简化日志记录。最后，提供了一些日志配置的最佳实践，包括滚动日志、统一日志格式和提高日志性能的方法。
蓝染-惣右介
119 30
【日志框架整合】Slf4j、Log4j、Log4j2、Logback配置模板
理想shi做条咸鱼
|
4月前
|
存储 SQL Java
Spring Boot使用slf4j进行日志记录
本节课主要对 slf4j 做了一个简单的介绍，并且对 Spring Boot 中如何使用 slf4j 输出日志做了详细的说明，着重分析了 logback.xml 文件中对日志相关信息的配置，包括日志的不同级别...
理想shi做条咸鱼
196 0
mzlogin
|
22天前
|
Java 程序员 API
Android｜集成 slf4j + logback 作为日志框架
做个简单改造，统一 Android APP 和 Java 后端项目打印日志的体验。
mzlogin
86 1
dream_ready
|
1月前
|
数据采集 监控 Java
SpringBoot日志全方位超详细手把手教程，零基础可学习 日志如何配置及SLF4J的使用......
本文是关于SpringBoot日志的详细教程，涵盖日志的定义、用途、SLF4J框架的使用、日志级别、持久化、文件分割及格式配置等内容。
dream_ready
130 0
SpringBoot日志全方位超详细手把手教程，零基础可学习 日志如何配置及SLF4J的使用......
阿里云开发者
|
3月前
|
存储 监控 Java
Java日志通关（三） - Slf4j 介绍
作者日常在与其他同学合作时，经常发现不合理的日志配置以及五花八门的日志记录方式，后续作者打算在团队内做一次Java日志的分享，本文是整理出的系列文章第三篇。
阿里云开发者
61 7
阿里云开发者
|
3月前
|
存储 监控 Java
Java日志通关（三） - Slf4j 介绍
作者日常在与其他同学合作时，经常发现不合理的日志配置以及五花八门的日志记录方式，后续作者打算在团队内做一次Java日志的分享，本文是整理出的系列文章第三篇。
阿里云开发者
94 8
萝卜丝丸子
|
3月前
|
Java 应用服务中间件 HSF
Java应用结构规范问题之AllLoggers接口获取异常日志的Logger实例的问题如何解决
Java应用结构规范问题之AllLoggers接口获取异常日志的Logger实例的问题如何解决
萝卜丝丸子
30 3
阿里云开发者
|
3月前
|
JavaScript Java API
Java日志通关（二） - Slf4j+Logback 整合及排包
作者日常在与其他同学合作时，经常发现不合理的日志配置以及五花八门的日志记录方式，后续作者打算在团队内做一次Java日志的分享，本文是整理出的系列文章第二篇。
阿里云开发者
486 8
服务端技术栈
|
3月前
|
消息中间件 监控 搜索推荐
OpenFeign日志组件Logger原理与应用
该文章详细解释了如何在OpenFeign中配置并使用请求和响应的GZIP压缩功能。
服务端技术栈
124 2
VipSoft
|
3月前
|
Java
OpenFeign 各种用法、 logger 日志记录
OpenFeign 各种用法、 logger 日志记录
VipSoft
53 0

热门文章

最新文章

  • 1
    SQLServer数据库日志清理 清除sqlserver2005日志 - sk
  • 2
    MapReduce对交易日志进行排序的Demo(MR的二次排序)
  • 3
    Windows登录类型及安全日志解析
  • 4
    rman RMAN-06059: expected archived log not found
  • 5
    Enterprise Library 2.0 Hands On Lab 翻译（4）：日志应用程序块（一）
  • 6
    python 合并当天tomcat异常日志
  • 7
    innodb重做日志缓冲
  • 8
    ORA-16038: log 3 sequence# 103 cannot be archived
  • 9
    MySQL的innodb_flush_log_at_trx_commit配置值的设定
  • 10
    httpd服务之部署AWStats日志分析系统
  • 1
    《手把手教你》系列基础篇（八十八）-java+ selenium自动化测试-框架设计基础-Log4j 2实现日志输出-下篇（详解教程）
    43
  • 2
    《手把手教你》系列基础篇（八十七）-java+ selenium自动化测试-框架设计基础-Log4j 2实现日志输出-上篇（详解教程）
    47
  • 3
    《手把手教你》系列基础篇（八十六）-java+ selenium自动化测试-框架设计基础-Log4j实现日志输出（详解教程）
    54
  • 4
    必知的技术知识：Java日志框架：logback详解
    63
  • 5
    Java日志框架的纷争演进与传奇故事
    36
  • 6
    写个代码扫描插件，再也不怕 log4j 等问题
    37
  • 7
    SpringBoot系列之切换log4j日志框架
    41
  • 8
    信息打点-语言框架&开发组件&FastJson&Shiro&Log4j&SpringBoot等
    28
  • 9
    【JAVA日志】关于日志系统的架构讨论
    47
  • 10
    【JAVA日志框架大全】一文快速讲透JAVA日志体系
    219

    • 相关课程

    更多
  • 基于MongoDB构建实时日志分析平台
  • 日志服务SLS实现云产品可观测
  • 日志服务 SLS 可观测数据分析平台介绍
  • 大数据知识图谱系列—基于ELK+Flink日志全观测最佳实践
  • 场景实践-基于阿里云Quick BI 对MOOC网站日志分析

    • 相关电子书

    更多
  • PostgresChina2018_赖思超_PostgreSQL10_hash索引的WAL日志修改版final
  • Kubernetes下日志实时采集、存储与计算实践
  • 日志数据采集与分析对接

    • 相关实验场景

    更多
  • 通过日志服务实现云资源OSS的安全审计
  • 如何将OSS数据导入至SLS中进行分析
  • 日志服务之使用Nginx模式采集日志
  • 日志服务之数据清洗与入湖
  • 揭秘如何通过日志服务实现个人敏感信息保护
    • 下一篇
    阿里云OSS设置跨域访问