自定义日志阅读器——包括了一个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));
    }
}

接下来是一个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 + "
";
        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("
");
            } else {
                messageBuilder.append(lineN).append("
");
            }
        }

        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 "));
    }
}

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

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

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