Question

我有一个包含gzip压缩日志文件的目录，每行一个事件。为了读取和处理这些实时，我创建了一个与此处列出的代码相同的WatcherService： http://docs.oracle.com/javase/tutorial/essential/io/notification.html

在processEvents（）方法中，我已添加此代码以逐行读取已添加或追加的文件：

if (kind == ENTRY_MODIFY) {
    try(BufferedReader reader = new BufferedReader(new InputStreamReader(new GZIPInputStream(Files.newInputStream(child, StandardOpenOption.READ))))) {
        String line;
        while ((line = reader.readLine()) != null) {
            System.out.println(line);
        }
    }
    catch(EOFException ex) {
        //file is empty,  so ignore until next signal
    }
    catch(Exception ex) {
        ex.printStackTrace();
    }
}

现在，正如您可以想象的那样，这对于在几毫秒内写入和关闭的文件非常有用，但是，当处理随时间附加的大文件时，这将为每个追加的内容反复读取整个文件line（假设文件被生产者刷新并同时进行同步）。

有没有什么办法可以在每次发送ENTRY_MODIFY信号时只读取此文件中的新行，或者找出文件何时完成＆＃34;？

如何处理未附加但被覆盖的文件？

Answer 1

首先，我想回答您问题的技术方面：

WatchEvent只会为您提供已更改（或创建或删除）文件的文件名，仅此而已。因此，如果您需要任何逻辑，您必须自己实现它（或者当然使用现有的库）。

如果您只想读取新行，则必须记住每个文件的位置，每当更改此文件时，您都可以移动到最后的已知位置。要获得当前位置，您可以使用Commons IO包中的CountingInputStream（积分转到[1]）。要跳到最后位置，您可以使用函数skip。

但是你使用的是GZIPInputStream，这意味着跳过不会给你带来很好的性能提升，因为跳过压缩流是不可能的。相反，GZIPInputStream跳过将解压缩流，就像您在阅读时一样，因此您只会遇到很少的性能改进（试试吧！）。

我不明白为什么你要使用压缩日志文件？为什么不用DailyRollingFileAppender编写未压缩的日志并在一天结束时压缩它，此时应用程序不再访问它？

另一种解决方案可能是保留GZIPInputStream（存储它），以便您不必再次重新读取该文件。这可能取决于您需要观察多少日志文件以确定这是否合理。

现在对您的要求提出一些问题：

您没有提及要实时查看日志文件的原因。为什么不集中日志（请参阅Centralised Java Logging）？例如，请查看logstash和此演示文稿（请参阅[2]和[3]）或scribe或splunk上的商业广告（参见[4]）。< / p>

集中日志可让您有机会根据日志数据真正做出实时反应。

[1] https://stackoverflow.com/a/240740/734687
[2] Using elasticsearch, logstash & kibana to create realtime dashboards - 幻灯片
[3] Using elasticsearch, logstash & kibana to create realtime dashboards - 视频
[4] Log Aggregation with Splunk - 幻灯片

<强>更新

首先，使用Groovy脚本生成压缩日志文件。每次我想模拟日志文件更改时，我都会从GroovyConsole启动这个脚本：

// Run with GroovyConsole each time you want new entries
def file = new File('D:\\Projekte\\watcher_service\\data\\log.gz')

// reading previous content since append is not possible
def content
if (file.exists()) {
    def inStream = new java.util.zip.GZIPInputStream(file.newInputStream())
    content = inStream.readLines()
}

// writing previous content and append new data
def random  = new java.util.Random()  
def lineCount = random.nextInt(30) + 1
def outStream = new java.util.zip.GZIPOutputStream(file.newOutputStream())

outStream.withWriter('UTF-8') { writer ->
    if (content) {
        content.each { writer << "$it\n" }
    }
    (1 .. lineCount).each {
        writer.write "Writing line $it/$lineCount\n"
    }
    writer.write '---Finished---\n'
    writer.flush()
    writer.close()
}

println "Wrote ${lineCount + 1} lines."

然后是日志文件阅读器：

import java.nio.file.FileSystems
import java.nio.file.Files
import java.nio.file.Path
import java.nio.file.Paths
import java.nio.file.StandardOpenOption
import java.util.zip.GZIPInputStream
import org.apache.commons.io.input.CountingInputStream
import static java.nio.file.StandardWatchEventKinds.*

class LogReader
{
    private final Path dir = Paths.get('D:\\Projekte\\watcher_service\\data\\')
    private watcher
    private positionMap = [:]
    long lineCount = 0

    static void main(def args)
    {
        new LogReader().processEvents()
    }

    LogReader()
    {
        watcher = FileSystems.getDefault().newWatchService()
        dir.register(watcher, ENTRY_CREATE, ENTRY_DELETE, ENTRY_MODIFY)
    }

    void processEvents()
    {
        def key = watcher.take()
        boolean doLeave = false

        while ((key != null) && (doLeave == false))
        {
            key.pollEvents().each { event ->
                def kind = event.kind()
                Path name = event.context()

                println "Event received $kind: $name"
                if (kind == ENTRY_MODIFY) {
                    // use position from the map, if entry is not there use default value 0
                    processChange(name, positionMap.get(name.toString(), 0))
                }
                else if (kind == ENTRY_CREATE) {
                    processChange(name, 0)
                }
                else {
                    doLeave = true
                    return
                }
            }
            key.reset()
            key = watcher.take()
        }
    }

    private void processChange(Path name, long position)
    {
        // open file and go to last position
        Path absolutePath = dir.resolve(name)
        def countingStream =
                new CountingInputStream(
                new GZIPInputStream(
                Files.newInputStream(absolutePath, StandardOpenOption.READ)))
        position = countingStream.skip(position)
        println "Moving to position $position"

        // processing each new line
        // at the first start all lines are read
        int newLineCount = 0
        countingStream.withReader('UTF-8') { reader ->
            reader.eachLine { line ->
                println "${++lineCount}: $line"
                ++newLineCount
            }
        }
        println "${++lineCount}: $newLineCount new lines +++Finished+++"

        // store new position in map
        positionMap[name.toString()] = countingStream.count
        println "Storing new position $countingStream.count"
        countingStream.close()
    }
}

在函数processChange中，您可以看到1）输入流的创建。包含.withReader的行会创建InputStreamReader和BufferedReader。我总是使用Grovvy，它是立体声中的Java，当你开始使用它时，你无法停止。 Java开发人员应该能够阅读它，但如果您有问题只需评论。

WatcherService尾随Gzip日志文件

1 个答案: