偷偷摘套内射激情视频,久久精品99国产国产精,中文字幕无线乱码人妻,中文在线中文a,性爽19p

封裝SLF4J/Log4j，不再處處定義logger變量

作者：瘋狂的愛因斯坦
開發(fā) 后端
我們打印的日志通暢都帶有調用方的信息， 如類名、方法名、行數、時間等，其中類名、方法名、行數都是極其關鍵的信息，但是使用上述的方法來輸出日志的話，這三個信息都變成Logger這個類的信息，而不是調用方的信息， 這顯然是無法忍受的事。

自從開始使用日志組件后， 每個類都是這樣子的結構:

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

這是一件相當煩人事，必須對他進行封裝，使得我們能夠通過這樣的方法來調用： 

  1. public class A { 
  2.     public void methodA() { 
  3.         Logger.debug("Nice!"); 
  4.     } 
  5. }  

最簡單的版本

開始動手后，用最簡單的方法封裝出了***個版本:

  1. // cn.hjktech.slf4j.Logger 
  2. public class Logger { 
  3.     private static final org.slf4j.Logger logger = LoggerFactory.getLogger(Logger.class);; 
  4.     ... 
  5.     public static void debug(...) { 
  6.         logger.debug(...); 
  7.         ... 
  8.     } 
  9.     ... 
  10. }  

看起來很美好， 但測試后發(fā)現這種方法會有一個很嚴重的問題： 我們打印的日志通暢都帶有調用方的信息， 如類名、方法名、行數、時間等，其中類名、方法名、行數都是極其關鍵的信息，但是使用上述的方法來輸出日志的話，這三個信息都變成Logger這個類的信息，而不是調用方的信息， 這顯然是無法忍受的事。

當然不能就這樣了事，既然正常使用的方法能輸出正確的信息，那么肯定是有辦法可以實現的，我們希望最終的結果是調用Logger.debug(..)打印出來的信息都是完全正確的。

分析源碼

此時寫個demo來debug跟進一下：

  1. public class TestLog { 
  2.     @Test 
  3.     public void logTest() { 
  4.         // 在此處打斷點 
  5.         LoggerFactory.getLogger(TestLog.class).debug("看看執(zhí)行流程"); 
  6.     } 
  7. }  

發(fā)現最終輸出的日志字符串是在PatternLayout.format方法(Logback則是PatternLayoutBase.writeLoopOnConverters方法)中生成的，方法代碼如下：

  1. // Log4j 
  2. public String format(LoggingEvent event) { 
  3.     // Reset working stringbuffer 
  4.     if(sbuf.capacity() > MAX_CAPACITY) { 
  5.         sbuf = new StringBuffer(BUF_SIZE); 
  6.     } else { 
  7.         sbuf.setLength(0); 
  8.     } 
  9.  
  10.     PatternConverter c = head; 
  11.  
  12.     while(c != null) { 
  13.         c.format(sbuf, event); 
  14.         c = c.next; 
  15.     } 
  16.     return sbuf.toString(); 
  17. }  

其中head指向一個類型為PatternConverter(Logback中是: Converter)的鏈表，這個鏈表的節(jié)點是在日志類初始化的時候，根據你日志配置文件里的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 

那么這個鏈表的結構就是(括號中代表存儲的信息):

  1. DatePatternConverter(時間點)           -> LiteralPatternConverter(" ")   ->  
  2. BasicPatternConverter(LEVEL)          -> LiteralPatternConverter("[")   ->  
  3. CategoryPatternConverter(LoggerName)  -> LiteralPatternConverter("] [") ->  
  4. BasicPatternConverter(線程名)          -> LiteralPatternConverter("] (") -> 
  5. LocationPatternConverter(所在類)       -> LiteralPatternConverter(":")   ->  
  6. LocationPatternConverter(所在行)       -> LiteralPatternConverter(") -") ->  
  7. BasicPatternConverter(日志串)          -> LiteralPatternConverter("\n")  ->  

根據這個鏈表生成日志字符串類似這樣:

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

那么現在目標很明確了，我們要使LocationPatternConverter的輸出為我們真正打印紙日的類的信息，繼續(xù)跟進到PatternConverter.format(LocationPatternConverter的父類)方法，其內部生成了一個LocationInfo對象，該類的構造方法中如下：

  1. for(int i = elements.length - 1; i >= 0; i--) { 
  2.     // 獲取第i幀的類名 
  3.     String thisClass = (String) getClassNameMethod.invoke(elements[i], noArgs); 
  4.     if(fqnOfCallingClass.equals(thisClass)) { 
  5.         // 如果類名和fqnOfCallingClass相等，則認為i + 1幀是代碼中實際調用方法的 
  6.         int caller = i + 1; 
  7.         if (caller < elements.length) { 
  8.             // 記錄實際調用類的類名 
  9.             className = prevClass; 
  10.             // 記錄實際調用的方法名 
  11.             methodName = (String) getMethodNameMethod.invoke(elements[caller], noArgs); 
  12.             // 記錄實際調用類所在的文件名 
  13.             fileName = (String) getFileNameMethod.invoke(elements[caller], noArgs); 
  14.             if (fileName == null) { 
  15.                 fileName = NA; 
  16.             } 
  17.             // 記錄調用日志方法的行數 
  18.             int line = ((Integer) getLineNumberMethod.invoke(elements[caller], noArgs)).intValue(); 
  19.             if (line < 0) { 
  20.                 lineNumber = NA; 
  21.             } else { 
  22.                 lineNumber = String.valueOf(line); 
  23.             } 
  24.             // 拼接成最終要輸出到日志的字符串， 如：TestLog.logTest(TestLog.java:14) 
  25.             StringBuffer buf = new StringBuffer(); 
  26.             buf.append(className); 
  27.             buf.append("."); 
  28.             buf.append(methodName); 
  29.             buf.append("("); 
  30.             buf.append(fileName); 
  31.             buf.append(":"); 
  32.             buf.append(lineNumber); 
  33.             buf.append(")"); 
  34.             this.fullInfo = buf.toString(); 
  35.         } 
  36.         return; 
  37.     } 
  38.     // 記錄上一幀的類名 
  39.     prevClass = thisClass; 
  40. }  

其中elements是當前方法調用棧的堆棧軌跡，這段代碼通過遍歷堆棧軌跡每一幀的類名并和fqnOfCallingClass比較，如果相符的話，則認為它的上一幀是實際調用方法。

如下圖中，fqnOfCallingClass的值是org.slf4j.impl.Log4jLoggerAdapter，而在堆棧軌跡總可以發(fā)現類的上一個幀正好是我們的實際調用類TestLog.logTest：

因此，我們現在只需要讓fqnOfCallingClass的值變成我們封裝的日志類cn.hjktech.slf4j.Logger就大功告成了。fqnOfCallingClass是LoggingEvent.getLocationInformation創(chuàng)建LocationInfo時傳入的參數，而LoggingEvent又是在Category.forcedLog方法中創(chuàng)建的，并且繼續(xù)網上追蹤，會發(fā)現fqnOfCallingClass的值最終來源于org.slf4j.impl.Log4jLoggerAdapter這個類:

  1. public final class Log4jLoggerAdapter extends MarkerIgnoringBase implements LocationAwareLogger, Serializable { 
  2.     ... 
  3.     static final String FQCN = Log4jLoggerAdapter.class.getName(); 
  4.     ... 
  5. }  

而如果沒有配合SLF4J使用時，fqnOfCallingClass的值則來源于org.apache.log4j.Logger類：

  1. public class Logger extends Category { 
  2.     ... 
  3.     private static final String FQCN = Logger.class.getName(); 
  4.     .... 
  5. }  

代理Logger類來修改FQCN

好了，現在我們只需要修改這個值就行了。***反應是使用反射去掉final修飾符，然后修改它的值，這種方法雖然對我們自己的代碼可行，但是當引入其它框架，并且其它框架也使用的Log4j時，就會導致它們的日志信息出錯，因為它們并不是調用的我們封裝的Logger工具類，它們日志的堆棧軌跡中不會有我們工具類(如cn.hjktech.slf4j.Logger)，因此我們需要另尋它法。

既然通過反射行不通， 那么我們可以通過動態(tài)代理的方式，在構造LoggingEvent對象之前將FQCN這個參數的值給替換掉，在跟蹤過程中發(fā)現Log4jLoggerAdapter最終都是調用的org.apache.log4j.Logger.log方法并將FQCN最為參數傳入，因此org.apache.log4j.Logger這個類就是我們要代理的類了。

了解JDK代理的人都知道，使用的條件是被代理類必須實現某一個接口，而org.apache.log4j.Logger.log這個方法并不是來自于某一個接口，所以我們選擇使用Cglib：

  1. // cn.hjktech.slf4j.Logger 
  2. public class Logger { 
  3.     private static org.slf4j.Logger logger; 
  4.     private static final String FQCN = Logger.class.getName(); 
  5.  
  6.     static { 
  7.         try { 
  8.             Enhancer eh = new Enhancer(); 
  9.             eh.setSuperclass(org.apache.log4j.Logger.class); 
  10.             eh.setCallbackType(LogInterceptor.class); 
  11.             Class c = eh.createClass(); 
  12.             Enhancer.registerCallbacks(c, new LogInterceptor[]{new LogInterceptor()}); 
  13.             Constructor<org.apache.log4j.Logger> constructor = c.getConstructor(String.class); 
  14.             org.apache.log4j.Logger loggerProxy= constructor.newInstance(Logger.class.getName()); 
  15.             ... 
  16.         } catch (...) { 
  17.             throw new RuntimeException("初始化Logger失敗", e); 
  18.         } 
  19.     } 
  20.  
  21.     private static class LogInterceptor implements MethodInterceptor { 
  22.         public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable { 
  23.             // 只攔截log方法。 
  24.             if (objects.length != 4 || !method.getName().equals("log")) 
  25.                 return methodProxy.invokeSuper(o, objects); 
  26.             // 替換傳給log方法的***個參數為我們自定義的FQCN 
  27.             objects[0] = FQCN; 
  28.             return methodProxy.invokeSuper(o, objects); 
  29.         } 
  30.     } 
  31. }  

代理defaultFactory

現在我們已經有了被代理的loggerProxy對象了，我們還需要將這個對象賦值給Log4jLoggerAdapter的logger成員變量，

logger成員變量是在Log4jLoggerAdapter的構造方法中被作為參數傳入的，它的來源如下圖：

從上圖中可以看到，LogManager.getLoggerRepository方法返回的對象中持有defaultFactory對象，因此我還需要代理這個對象，將它產生的'logger'對象替換成我們的'logger'就大功告成了，并且makeNewLoggerInstance方法是在LoggerFactory接口中定義的，所以我們只需要使用JDK的動態(tài)代理就可以完成了。實現代碼如下：

  1. static { 
  2.     try { 
  3.         ... 
  4.         LoggerRepository loggerRepository = LogManager.getLoggerRepository(); 
  5.         org.apache.log4j.spi.LoggerFactory lf = ReflectionUtil.getFieldValue(loggerRepository, "defaultFactory"); 
  6.         Object loggerFactoryProxy = Proxy.newProxyInstance( 
  7.             LoggerFactory.class.getClassLoader(), 
  8.             new Class[]{LoggerFactory.class}, 
  9.             new NewLoggerHandler(loggerProxy) 
  10.         ); 
  11.  
  12.         ReflectionUtil.setFieldValue(loggerRepository, "defaultFactory", loggerFactoryProxy); 
  13.             logger = org.slf4j.LoggerFactory.getLogger(Logger.class.getName()); 
  14.         ReflectionUtil.setFieldValue(loggerRepository, "defaultFactory", lf); 
  15.     } catch (...) { 
  16.         throw new RuntimeException("初始化Logger失敗", e); 
  17.     } 
  18. } 
  19.  
  20. private static class NewLoggerHandler implements InvocationHandler { 
  21.     private final org.apache.log4j.Logger proxyLogger; 
  22.  
  23.     public NewLoggerHandler(org.apache.log4j.Logger proxyLogger) { 
  24.         this.proxyLogger = proxyLogger; 
  25.     } 
  26.  
  27.     @Override 
  28.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
  29.         return proxyLogger; 
  30.     } 
  31. }  

實現流程和最終代碼

我們最終實現方案如下：

Logger的代碼如下:

  1. public class Logger { 
  2.     private static org.slf4j.Logger logger; 
  3.     private static final String FQCN = Logger.class.getName(); 
  4.      
  5.     static { 
  6.         try { 
  7.             Enhancer eh = new Enhancer(); 
  8.             eh.setSuperclass(org.apache.log4j.Logger.class); 
  9.             eh.setCallbackType(LogInterceptor.class); 
  10.             Class c = eh.createClass(); 
  11.             Enhancer.registerCallbacks(c, new LogInterceptor[]{new LogInterceptor()}); 
  12.  
  13.             Constructor<org.apache.log4j.Logger> constructor = c.getConstructor(String.class); 
  14.             org.apache.log4j.Logger loggerProxy = constructor.newInstance(Logger.class.getName()); 
  15.  
  16.             LoggerRepository loggerRepository = LogManager.getLoggerRepository(); 
  17.             org.apache.log4j.spi.LoggerFactory lf = ReflectionUtil.getFieldValue(loggerRepository, "defaultFactory"); 
  18.             Object loggerFactoryProxy = Proxy.newProxyInstance( 
  19.                 LoggerFactory.class.getClassLoader(), 
  20.                 new Class[]{LoggerFactory.class}, 
  21.                 new NewLoggerHandler(loggerProxy) 
  22.             ); 
  23.  
  24.             ReflectionUtil.setFieldValue(loggerRepository, "defaultFactory", loggerFactoryProxy); 
  25.             logger = org.slf4j.LoggerFactory.getLogger(Logger.class.getName()); 
  26.             ReflectionUtil.setFieldValue(loggerRepository, "defaultFactory", lf); 
  27.         } catch ( 
  28.             IllegalAccessException | 
  29.                 NoSuchMethodException | 
  30.                 InvocationTargetException | 
  31.                 InstantiationException e) { 
  32.             throw new RuntimeException("初始化Logger失敗", e); 
  33.         } 
  34.     } 
  35.  
  36.     private static class LogInterceptor implements MethodInterceptor { 
  37.         public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable { 
  38.             // 只攔截log方法。 
  39.             if (objects.length != 4 || !method.getName().equals("log")) 
  40.                 return methodProxy.invokeSuper(o, objects); 
  41.             objects[0] = FQCN; 
  42.             return methodProxy.invokeSuper(o, objects); 
  43.         } 
  44.     } 
  45.  
  46.     private static class NewLoggerHandler implements InvocationHandler { 
  47.         private final org.apache.log4j.Logger proxyLogger; 
  48.  
  49.         public NewLoggerHandler(org.apache.log4j.Logger proxyLogger) { 
  50.             this.proxyLogger = proxyLogger; 
  51.         } 
  52.  
  53.         @Override 
  54.         public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
  55.             return proxyLogger; 
  56.         } 
  57.     } 
  58.  
  59.     // 剩下的Logger需要封裝的方法可以根據自己的需要來實現 
  60.     // 我個人認為slf4j的api足夠好用了，所以大部分只是寫了一些類似下面的代碼 
  61.     public static void debug(String msg) { 
  62.         logger.debug(msg); 
  63.     } 
  64. }  

ReflectionUtil的代碼如下：

  1. public class ReflectionUtil { 
  2.     public static <T> T getFieldValue(@NotNull Object object, 
  3.                                       @NotNull String fullName) throws IllegalAccessException { 
  4.         return getFieldValue(object, fullName, false); 
  5.     } 
  6.  
  7.     public static <T> T getFieldValue(@NotNull Object object, 
  8.                                       @NotNull String fieldName, 
  9.                                       boolean traceable) throws IllegalAccessException { 
  10.         Field field; 
  11.         String[] fieldNames = fieldName.split("\\."); 
  12.         for (String targetField : fieldNames) { 
  13.             field = searchField(object.getClass(), targetField, traceable); 
  14.             if (field == null) 
  15.                 return null; 
  16.  
  17.             object = getValue(object, field); 
  18.         } 
  19.  
  20.         return (T) object; 
  21.     } 
  22.  
  23.     private static Field searchField(Class c, String targetField, boolean traceable) { 
  24.         do { 
  25.             Field[] fields = c.getDeclaredFields(); 
  26.             for (Field f : fields) { 
  27.                 if (f.getName().equals(targetField)) { 
  28.                     return f; 
  29.                 } 
  30.             } 
  31.             c = c.getSuperclass(); 
  32.             traceable = traceable && c != Object.class; 
  33.         } while (traceable); 
  34.  
  35.         return null; 
  36.     } 
  37.  
  38.     private static <T> T getValue(Object target, Field field) throws IllegalAccessException { 
  39.         if (!field.isAccessible()) 
  40.             field.setAccessible(true); 
  41.         return (T) field.get(target); 
  42.     } 
  43.  
  44.     public static boolean setFieldValue(@NotNull Object target, 
  45.                                         @NotNull String fieldName, 
  46.                                         @NotNull Object value) throws IllegalAccessException { 
  47.         return setFieldValue(target, fieldName, value, false); 
  48.     } 
  49.  
  50.     public static boolean setFieldValue(@NotNull Object target, 
  51.                                         @NotNull String fieldName, 
  52.                                         @NotNull Object value, 
  53.                                         boolean traceable) throws IllegalAccessException { 
  54.         Field field = searchField(target.getClass(), fieldName, traceable); 
  55.         if (field != null) 
  56.             return setValue(field, target, value); 
  57.         return false; 
  58.     } 
  59.  
  60.     private static boolean setValue(Field field, Object target, Object value) throws IllegalAccessException { 
  61.         if (!field.isAccessible()) 
  62.             field.setAccessible(true); 
  63.         field.set(target, value); 
  64.         return true; 
  65.     } 
  66. }  

測試 

  1. public class TestLog { 
  2.  
  3.     @Test 
  4.     public void logTest() { 
  5.         Logger.debug((Marker)null, "這是調用封裝的Logger輸出日志"); 
  6.         LoggerFactory.getLogger(TestLog.class).info("常規(guī)方法輸出日志"); 
  7.     } 
  8. }  

輸出結果：

  1. 2016-10-19-15-00,308 DEBUG [cn.hjktech.slf4j.Logger] [main] (TestLog.java:13) TestLog.logTest(TestLog.java:13) - 這是調用封裝的Logger輸出日志  
  2. 2016-10-19-15-00,311 INFO [TestLog] [main] (TestLog.java:14) TestLog.logTest(TestLog.java:14) - 常規(guī)方法輸出日志  
責任編輯：龐桂玉 來源： segmentfault
javalog4jslf4j
相關推薦

2020-01-07 10:06:26

Slf4jLog4JLogback

2023-01-11 21:22:32

Java服務器

2024-03-01 16:52:02

SLF4J日志框架

2013-02-20 09:42:34

JavaLogbackSLF4J

2023-10-28 16:19:18

Android日志

2022-02-15 17:51:38

Log4j漏洞網絡安全

2022-02-13 16:18:57

JetBrainsIntelliJLog4j

2022-03-25 13:42:15

Log4j漏洞網絡安全

2023-10-07 10:08:54

2021-12-14 23:44:26

漏洞Log4j項目

2022-03-30 11:29:53

漏洞補丁Spring

2009-06-12 17:03:51

JBoss和log4j

2020-11-04 12:33:08

Log4j 2日志Logback

2025-05-26 08:50:00

SLF4JMDC全鏈路追蹤

2025-01-20 08:10:00

微服務架構SLF4J

2021-03-15 18:47:25

日志開發(fā)源碼

2022-12-30 08:31:27

MDC查詢日志

2009-07-08 14:33:46

Java日志框架Log4J

2021-12-23 09:47:36

Log4jRCE漏洞DoS漏洞

2022-01-10 11:54:54

FTCLog4j聯邦貿易委員會
點贊
收藏

51CTO技術棧公眾號