我想知道使用什么技术和/或库来实现 linux 命令“tail -f”的功能。我本质上是在寻找java.io.FileReader. 客户端代码可能如下所示：
TailFileReader lft = new TailFileReader("application.log");
BufferedReader br = new BufferedReader(lft);
String line;
try {
while (true) {
line= br.readLine();
// do something interesting with line
}
} catch (IOException e) {
// barf
}
缺少的部分是TailFileReader. 它应该能够读取文件打开之前存在的部分文件以及添加的行。
看一下Tailer类的 Apache Commons 实现。它似乎也可以处理日志轮换。
继续读取文件并等待文件为您提供更多更新的能力应该不难在自己的代码中完成。这是一些伪代码：
BufferedReader br = new BufferedReader(...);
String line;
while (keepReading) {
line = reader.readLine();
if (line == null) {
//wait until there is more of the file for us to read
Thread.sleep(1000);
}
else {
//do something interesting with the line
}
}
我假设您希望将这种类型的功能放在它自己的线程中，以便您可以休眠它并且不会影响应用程序的任何其他区域。您可能希望keepReading在 setter 中公开，以便您的主类/应用程序的其他部分可以安全地关闭线程，而无需任何其他麻烦，只需调用stopReading()或类似的东西。
检查JLogTailer，它执行此逻辑。
代码中的要点是：
public void run() {
try {
while (_running) {
Thread.sleep(_updateInterval);
long len = _file.length();
if (len < _filePointer) {
// Log must have been jibbled or deleted.
this.appendMessage("Log file was reset. Restarting logging from start of file.");
_filePointer = len;
}
else if (len > _filePointer) {
// File must have had something added to it!
RandomAccessFile raf = new RandomAccessFile(_file, "r");
raf.seek(_filePointer);
String line = null;
while ((line = raf.readLine()) != null) {
this.appendLine(line);
}
_filePointer = raf.getFilePointer();
raf.close();
}
}
}
catch (Exception e) {
this.appendMessage("Fatal error reading log file, log tailing has stopped.");
}
// dispose();
}
不久前，我在 Scala 中构建了一个简短的“tail -f”实现：tailf。它还负责文件轮换，您可以定义自己的逻辑，当它到达 EOF 或发现文件已被重命名时要做什么。
您可以看一下并将其移植到 Java，因为实际上其中没有什么复杂的。几点注意事项：主文件是Tail.scala，基本上它定义了FollowingInputStream哪个负责 EOF/rename 和follow方法，它包含FollowingInputStream在SequenceInputStream. 因此，一旦FollowingInputStream结束，就会SequenceInputStream从 an 请求下一个元素，Enumeration然后创建另一个FollowingInputStream。
我最近偶然发现了rxjava-file，它是RxJava的扩展。与其他解决方案相比，它使用了 Java 的 NIO。
import rx.Observable;
import rx.functions.Action1;
import com.github.davidmoten.rx.FileObservable;
// ... class definition omitted
public void tailLogFile() throws InterruptedException {
Observable<String> tailer = FileObservable.tailer()
.file("application.log") // absolute path
.tailText();
tailer.subscribe(
new Action1<String>() {
@Override
public void call(String line) {
System.out.println("you got line: " + line);
}
},
new Action1<Throwable>() {
@Override
public void call(Throwable e) {
System.out.println("you got error: " + e);
e.printStackTrace();
}
}
);
// this solution operates threaded, so something
// is required that prevents premature termination
Thread.sleep(120000);
}
如果您的代码只需要在 Unix 系统上运行，那么您也许可以直接脱壳并tail -f直接调用。
作为一个更复杂的替代方案，您可以查看 GNU tail 的实现并将其移植到 Java。（不过，我不确定这是否会使您的代码成为衍生作品。）
我发现了这个不错的尾部实现。
添加一名作者
来源： https ://gist.github.com/amelandri/1376896
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
/**
* Java implementation of the Unix tail command
*
* @param args[0] File name
* @param args[1] Update time (seconds). Optional. Default value is 1 second
*
* @author Luigi Viggiano (original author) http://it.newinstance.it/2005/11/19/listening-changes-on-a-text-file-unix-tail-implementation-with-java/
* @author Alessandro Melandri (modified by)
* */
public class Tail {
static long sleepTime = 1000;
public static void main(String[] args) throws IOException {
if (args.length > 0){
if (args.length > 1)
sleepTime = Long.parseLong(args[1]) * 1000;
BufferedReader input = new BufferedReader(new FileReader(args[0]));
String currentLine = null;
while (true) {
if ((currentLine = input.readLine()) != null) {
System.out.println(currentLine);
continue;
}
try {
Thread.sleep(sleepTime);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
break;
}
}
input.close();
} else {
System.out.println("Missing parameter!\nUsage: java JavaTail fileName [updateTime (Seconds. default to 1 second)]");
}
}
}
刚刚遇到了同样的问题——在这里找到了“最简单”的实现：Java Tail。
*好东西 * - 准备生产 ;)
我希望代码引用不会放弃一些许可证。
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
/**
* Java implementation of the Unix tail command
*
* @param args[0] File name
* @param args[1] Update time (seconds). Optional. Default value is 1 second
*
* @author Luigi Viggiano (original author) http://it.newinstance.it/2005/11/19/listening-changes-on-a-text-file-unix-tail-implementation-with-java/
* @author Alessandro Melandri (modified by)
* */
public class Tail {
static long sleepTime = 1000;
public static void main(String[] args) throws IOException {
if (args.length > 0){
if (args.length > 1)
sleepTime = Long.parseLong(args[1]) * 1000;
BufferedReader input = new BufferedReader(new FileReader(args[0]));
String currentLine = null;
while (true) {
if ((currentLine = input.readLine()) != null) {
System.out.println(currentLine);
continue;
}
try {
Thread.sleep(sleepTime);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
break;
}
}
input.close();
} else {
System.out.println("Missing parameter!\nUsage: java JavaTail fileName [updateTime (Seconds. default to 1 second)]");
}
}
}
这是一个可以用作指针的短篇小说：
出于同样的原因，我在工作中编写了 TailingInputStream。它基本上使用 File 并按需刷新其内容，并检查内部缓冲区是否发生了显着变化（4kB 内存标记 IIRC），然后执行 tail -f 的操作。有点hacky，是的，但它完美地工作并且不会与Threads或任何类似的东西混淆 - 它至少一直兼容到1.4.2。
也就是说，它比 ReverseInputStream 容易得多，它从文件的结尾到开始，并且如果文件被即时更新并没有死......