开源日志库 Logger 的剖析针对开源的日志库 Logger 源码的全面分析

接着，createMessage方法：

private String createMessage(String message, Object... args) { 
  return args == null || args.length == 0 ? message : String.format(message, args);
}

这里就很清楚了，为什么我们用Logger.i(message, args)的时候没有写args，也就是null，也可以打印，而且是直接打印的message消息的原因。同样博主上一篇文章也提到了：

Logger.i("博主今年才%d，英文名是%s", 16, "Jerry");

像这样的可以拼接不同格式的数据的打印日志，原来实现的方式是用String.format方法，这个想必小伙伴们在开发Android应用的时候String.xml里的动态字符占位符用的也不少，应该很容易理解这个format方法的用法。

重头戏，我们把tag，打印级别，打印的消息处理好了，接下来该打印出来了：

@Override public synchronized void log(int priority, String tag, String message, Throwable throwable) {
  // 同样判断一次库配置的打印开关，为NONE则不打印日志
  if (settings.getLogLevel() == LogLevel.NONE) {    
      return;  
  }
  // 异常和消息不为空的时候，获取异常的原因转换成字符串后拼接到打印的消息中  
  if (throwable != null && message != null) {    
      message += " : " + Helper.getStackTraceString(throwable);  
  }  
  if (throwable != null && message == null) {    
      message = Helper.getStackTraceString(throwable);  
  }  
  if (message == null) {    
      message = "No message/exception is set";  
  }  
  // 获取方法数
  int methodCount = getMethodCount(); 
  // 判断消息是否为空 
  if (Helper.isEmpty(message)) {    
      message = "Empty/NULL log message";  
  }  
  // 打印日志体的上边界
  logTopBorder(priority, tag);
  // 打印日志体的头部内容  
  logHeaderContent(priority, tag, methodCount);  
  //get bytes of message with system's default charset (which is UTF-8 for Android)  
  byte[] bytes = message.getBytes();  
  int length = bytes.length;  
  // 消息字节长度小于等于4000
  if (length <= CHUNK_SIZE) {    
      if (methodCount > 0) {  
          // 方法数大于0，打印出分割线    
          logDivider(priority, tag);    
      }    
      // 打印消息内容
      logContent(priority, tag, message);
      // 打印日志体底部边界
      logBottomBorder(priority, tag);    
      return;  
  }  
  if (methodCount > 0) {    
      logDivider(priority, tag);  
  }  
  for (int i = 0; i < length; i += CHUNK_SIZE) {    
      int count = Math.min(length - i, CHUNK_SIZE);
      //create a new String with system's default charset (which is UTF-8 for Android)    
      logContent(priority, tag, new String(bytes, i, count));  
  }  
  logBottomBorder(priority, tag);
}

我们重点来看看logHeaderContent方法和logContent方法：

@SuppressWarnings("StringBufferReplaceableByString")
private void logHeaderContent(int logType, String tag, int methodCount) {  
  // 获取当前线程堆栈跟踪元素数组
  //（里面存储了虚拟机调用的方法的一些信息：方法名、类名、调用此方法在文件中的行数）
  // 这也是这个库的 “核心”
  StackTraceElement[] trace = Thread.currentThread().getStackTrace();
  // 判断库的配置是否显示线程信息  
  if (settings.isShowThreadInfo()) {
      // 获取当前线程的名称，并且打印出来，然后打印分割线    
      logChunk(logType, tag, HORIZONTAL_DOUBLE_LINE + "Thread: " + Thread.currentThread().getName());    logDivider(logType, tag);  
  }  
  String level = "";  
  // 获取追踪栈的方法起始位置
  int stackOffset = getStackOffset(trace) + settings.getMethodOffset();  
  //corresponding method count with the current stack may exceeds the stack trace. Trims the count  
  // 打印追踪的方法数超过了当前线程能够追踪的方法数，总的追踪方法数扣除偏移量(从调用日志的起算扣除的方法数)，就是需要打印的方法数量
  if (methodCount + stackOffset > trace.length) {    
      methodCount = trace.length - stackOffset - 1;  
  }  
  for (int i = methodCount; i > 0; i--) {   
      int stackIndex = i + stackOffset;    
      if (stackIndex >= trace.length) {      
          continue;    
      }    
      // 拼接方法堆栈调用路径追踪字符串
      StringBuilder builder = new StringBuilder(); 
      builder.append("║ ")        
      .append(level)     
      .append(getSimpleClassName(trace[stackIndex].getClassName()))  // 追踪到的类名
      .append(".") 
      .append(trace[stackIndex].getMethodName())  // 追踪到的方法名      
      .append(" ")        
      .append(" (")       
      .append(trace[stackIndex].getFileName()) // 方法所在的文件名
      .append(":")        
      .append(trace[stackIndex].getLineNumber())  // 在文件中的行号      
      .append(")");    
      level += "   ";    
      // 打印出头部信息
      logChunk(logType, tag, builder.toString()); 
  }
}

方法部分的拼接效果

接下来看logContent方法：

private void logContent(int logType, String tag, String chunk) {  
  // 这个作用就是获取换行符数组，getProperty方法获取的就是"\n"的意思
  String[] lines = chunk.split(System.getProperty("line.separator"));  
  for (String line : lines) {    
      // 打印出包含换行符的内容
      logChunk(logType, tag, HORIZONTAL_DOUBLE_LINE + " " + line);  
  }
}

如上图来说内容是字符串数组，本身里面是没用换行符的，所以不需要换行，打印出来的效果就是一行，但是json、xml这样的格式是有换行符的，所以打印呈现出来的效果就是：

漂亮的json显示格式

上面说了大半天，都还没看到具体的打印是啥，现在来看看logChunk方法：

private void logChunk(int logType, String tag, String chunk) {
  // 最后格式化下tag  
  String finalTag = formatTag(tag);  
  // 根据不同的日志打印类型，然后交给LogAdapter这个接口来打印
  switch (logType) {    
      case ERROR:      
          settings.getLogAdapter().e(finalTag, chunk);      
      break;    
      case INFO:      
          settings.getLogAdapter().i(finalTag, chunk);      
      break;    
      case VERBOSE:      
          settings.getLogAdapter().v(finalTag, chunk);      
      break;    
      case WARN:      
          settings.getLogAdapter().w(finalTag, chunk);      
      break;   
      case ASSERT:      
          settings.getLogAdapter().wtf(finalTag, chunk);      
      break;    
      case DEBUG:      
          // Fall through, log debug by default    
      default:            
          settings.getLogAdapter().d(finalTag, chunk);      
      break;  
  }
}

这个方法很简单，就是最后格式化tag，然后根据不同的日志类型把打印的工作交给LogAdapter接口来处理，我们来看看settings.getLogAdapter()这个方法（Settings.java文件）：

public LogAdapter getLogAdapter() {  
  if (logAdapter == null) {
      // 最终的实现类是AndroidLogAdapter
      logAdapter = new AndroidLogAdapter();  
  }  
  return logAdapter;
}

找到AndroidLogAdapter类：