自定义日志阅读器——包括了一个load取Tomcat日志的分析器

最近在写往公司产品里添加Tomcat适配器，以支持Tomcat。有一些功能需要摘取到Tomcat的部分日志。没有合适的工具，也不想去网上找了，就自己写了一个。

简单的画了一下设计方案：

下面直接上代码了：

日志阅读器：

 package com.fjn.tools.log.reader;

 import java.io.File;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Scanner;

 import com.fjn.tools.log.reader.parser.CatalinaSimpleFormatterParser;

 public class LogReader {
     private String logFile;
     private List<LogFilter> logFilterChain = new LinkedList<LogFilter>();
     private final ContinueRead continueRead = new ContinueRead();
     private LogParser parser;
     private final boolean doFilter(LogRecord record) {
         for (LogFilter filter : logFilterChain) {
             if (!filter.accept(record)) {
                 return false;
             }
         }
         return true;
     }

     public void addFilter(LogFilter filter) {
         if(filter!=null){
             logFilterChain.add(filter);
         }
     }

     public final String readLogRecords(String startTime, String endTime) {
         if (parser == null) {
             return null;
         }
         StringBuilder buff = new StringBuilder();
         Scanner scanner = null;

         try {
             scanner = new Scanner(new File(logFile));

             NewLine newLine = null;
             if (startTime != null) {
                 StartTimeFilter filter = new StartTimeFilter();
                 filter.startTime = startTime;
                 addFilter(filter);
             }
             if (endTime != null) {
                 EndTimeFilter filter = new EndTimeFilter();
                 filter.endTime = endTime;
                 filter.continueRead = this.continueRead;
                 addFilter(filter);
             }
             while (scanner.hasNextLine() && continueRead.value) {
                 LogRecord record = null;
                 if (newLine == null) {
                     newLine = new NewLine();
                 }
                 if (!newLine.hasGetNewLine) {
                     newLine.line = scanner.nextLine();
                     newLine.hasGetNewLine = true;
                 }
                 record = parser.getLogRecord(scanner, newLine, continueRead);
                 if (record != null) {
                     if (doFilter(record)) {
                         buff.append(record.toString());
                     }
                 }
             }
         } catch (Exception ex) {
             // Ignore it
         } finally {
             if (scanner != null) {
                 scanner.close();
             }
         }
         return buff.toString();
     }

     public static interface LogParser {
         public LogRecord getLogRecord(Scanner scanner, NewLine newLine,
                 ContinueRead continueRead);
     }

     public static interface LogFilter {
         public boolean accept(LogRecord record);
     }

     public static abstract class LogRecord {
         public String prefix;
         public String message;
         public String threadStack;
         public String datetime;
     }

     public static class NewLine {
         public boolean hasGetNewLine = false;
         public String line = "";
     }

     public static class ContinueRead {
         public boolean value = true;
     }

     private class StartTimeFilter implements LogFilter {
         private String startTime;

         @Override
         public boolean accept(LogRecord record) {
             if (startTime == null) {
                 return true;
             }

             if (startTime.compareTo(record.datetime) <= 0) {
                 return true;
             }
             return false;
         }
     }

     private class EndTimeFilter implements LogFilter {
         private String endTime = "";
         private ContinueRead continueRead;

         @Override
         public boolean accept(LogRecord record) {
             if (endTime == null || endTime.isEmpty()) {
                 return true;
             }
             if (endTime.compareTo(record.datetime) < 0) {
                 if (continueRead.value) {
                     continueRead.value = false;
                 }
                 return false;
             }
             return true;
         }
     }

     public String getLogFile() {
         return logFile;
     }

     public void setLogFile(String logFile) {
         this.logFile = logFile;
     }

     public LogParser getParser() {
         return parser;
     }

     public void setParser(LogParser parser) {
         this.parser = parser;
     }

     public static void main(String[] args) {
         LogReader logReader=new LogReader();
         logReader.setLogFile("E:\\Program Files\\apache/tomcat/apache-tomcat-6.0.41/logs/catalina.2015-05-12.log");
         logReader.setParser(new CatalinaSimpleFormatterParser());
         System.out.println(logReader.readLogRecords("2015-10-12 01:53:10", null));
     }
 }

LogReader

接下来是一个Tomcat日志分析器：

package com.fjn.tools.log.reader.parser;

import java.util.LinkedList;
import java.util.List;
import java.util.Scanner;
import java.util.StringTokenizer;

import com.fjn.tools.log.reader.LogReader.ContinueRead;
import com.fjn.tools.log.reader.LogReader.LogParser;
import com.fjn.tools.log.reader.LogReader.LogRecord;
import com.fjn.tools.log.reader.LogReader.NewLine;

public class CatalinaSimpleFormatterParser implements LogParser {

    @Override
    public LogRecord getLogRecord(Scanner scanner, NewLine newLine,
            ContinueRead continueRead) {
        String line1 = newLine.line;
        if (!line1.matches(SimpleFormatterLogRecord.prefixPattern)) {
            newLine.hasGetNewLine = false;
            return null;
        }
        boolean toNextRecord = false;
        String nextLine = null;
        List<String> messageLines = new LinkedList<String>();
        while (!toNextRecord) {
            if (scanner.hasNextLine()) {
                nextLine = scanner.nextLine();
                if (!nextLine.matches(SimpleFormatterLogRecord.prefixPattern)) {
                    messageLines.add(nextLine);
                } else {
                    toNextRecord = true;
                    newLine.hasGetNewLine = true;
                    newLine.line = nextLine;
                    break;
                }
            } else {
                break;
            }
        }
        SimpleFormatterLogRecord record = new SimpleFormatterLogRecord();
        record.prefix = line1 + "\n";
        StringBuilder messageBuilder = new StringBuilder();
        StringBuilder threadStackBuilder = new StringBuilder();
        boolean toThreadStack = false;
        for (String lineN : messageLines) {
            if (!toThreadStack
                    && lineN.matches(SimpleFormatterLogRecord.threadStackStartPattern)) {
                toThreadStack = true;
            }
            if (toThreadStack) {
                threadStackBuilder.append(lineN).append("\n");
            } else {
                messageBuilder.append(lineN).append("\n");
            }
        }

        record.message = messageBuilder.toString();
        record.threadStack = threadStackBuilder.toString();

        StringTokenizer stk = new StringTokenizer(record.prefix);
        String date = stk.nextToken();
        String time = stk.nextToken();
        record.datetime = dateTimeFormat(date + " " + time);

        return record;
    }

    private class SimpleFormatterLogRecord extends LogRecord {
        private static final String prefixPattern = "^(\\d{4}-\\d{1,2}-\\d{1,2} \\d{1,2}:\\d{1,2}:\\d{1,2} ).*";
        private static final String threadStackStartPattern = "^((\\w+\\.)*\\w*Exception: ).*";

        public String toString() {
            return this.prefix + this.message + this.threadStack;
        }
    }

    private static String dateTimeFormat(String datetime){
        StringTokenizer stk = new StringTokenizer(datetime, "- :");
        int i = 0;
        StringBuilder dateTimeBuilder = new StringBuilder();
        while (stk.hasMoreTokens()) {
            i++;
            String token = stk.nextToken();
            if (i < 7 && token.length() < 2) {
                token = "0" + token;
            }
            if (i < 3) {
                token += "-";
            } else if (i < 4) {
                token += " ";
            } else if (i < 6) {
                token += ":";
            }
            dateTimeBuilder.append(token);
        }
        return dateTimeBuilder.toString();
    }

    public static void main(String[] args) {
        System.out.println(dateTimeFormat("2015-5-12 1:53:10 "));
    }
}

CatalinaSimpleFormatterLogParser

1) 如果想要分析其它格式的日志，只需要做相应的扩展LogParser就行了。

2) 如果想要只找包含某些关键字的日志，只需要扩展LogFilter就可以了。

3) 如果想要取得某个时间段的日志，只需要指定相应的startTime,endTime参数就可以了。