在本文中,我们将讨论:
- 使用Java NIO.2监视文件系统
- 默认Java库的常见陷阱
- 设计一个简单的基于线程的文件系统监视器
- 使用以上内容,使用actor 模型设计一个反应式文件系统监视器
注意 :尽管这里所有代码示例都在Scala中,但是也可以用简单的Java重写。 为了快速熟悉Scala语法, 这是一个非常简短的Scala备忘单 。 有关面向Java程序员的Scala的更全面指南, 请查阅此文章(无需关注本文)。
对于绝对最简短的备忘单,请使用以下Java代码:
public void foo(int x, int y) {
int z = x + y
if (z == 1) {
System.out.println(x);
} else {
System.out.println(y);
}
}
等效于以下Scala代码:
def foo(x: Int, y: Int): Unit = {
val z: Int = x + y
z match {
case 1 => println(x)
case _ => println(y)
}
}
此处提供的所有代码均已获得MIT许可,并作为GitHub上的Better -Files库的一部分提供。
假设您的任务是构建一个跨平台的桌面文件搜索引擎。 您很快意识到,在对所有文件进行初始索引编制之后,您还需要快速为创建或更新的所有新文件(或目录)重新编制索引。 天真的方法是每隔几分钟重新扫描整个文件系统。 但由于大多数操作系统暴露文件系统通知API,允许应用程序员更改,例如注册回调,这将是令人难以置信的低效率ionotify在Linux中, FSEvenets在Mac和FindFirstChangeNotification在Windows中。
但是,现在您不得不处理操作系统特定的API! 幸运的是,从Java SE 7开始,我们有了一个独立于平台的抽象,用于通过WatchService API监视文件系统的更改。 WatchService API是Java NIO.2的一部分,是在JSR-51下开发的,下面是一个“ hello world”示例,使用它来监视给定的Path :
import java.nio.file._
import java.nio.file.StandardWatchEventKinds._
import scala.collection.JavaConversions._
def watch(directory: Path): Unit = {
// First create the service
val service: WatchService = directory.getFileSystem.newWatchService()
// Register the service to the path and also specify which events we want to be notified about
directory.register(service, ENTRY_CREATE, ENTRY_DELETE, ENTRY_MODIFY)
while (true) {
val key: WatchKey = service.take() // Wait for this key to be signalled
for {event <- key.pollEvents()} {
// event.context() is the path to the file that got changed
event.kind() match {
case ENTRY_CREATE => println(s"${event.context()} got created")
case ENTRY_MODIFY => println(s"${event.context()} got modified")
case ENTRY_DELETE => println(s"${event.context()} got deleted")
case _ =>
// This can happen when OS discards or loses an event.
// See: http://docs.oracle.com/javase/8/docs/api/java/nio/file/StandardWatchEventKinds.html#OVERFLOW
println(s"Unknown event $event happened at ${event.context()}")
}
}
key.reset() // Do not forget to do this!! See: http://stackoverflow.com/questions/20180547/
}
}
尽管以上是一个很好的首次尝试,但它缺少几个方面:
- 错误的设计 :上面的代码看起来不自然,您可能必须在StackOverflow上查找才能正确使用。 我们可以做得更好吗?
- 错误的设计 :该代码不能很好地处理错误。 当我们遇到无法打开的文件时会发生什么?
- 陷阱 :Java API仅允许我们监视目录中对其直接子级的更改。 它不会递归地为您查看目录 。
- 注意 :Java API 不允许我们观看单个文件 ,只能观看目录。
- 陷阱 :即使我们解决了上述问题,Java API 也不会自动开始监视在根目录下创建的新子文件或目录。
- 错误的设计 :上面实现的代码公开了基于线程的阻塞/轮询模型。 我们可以使用更好的并发抽象吗?
让我们从上述每个问题开始。
- 更好的界面 :这是我理想的界面:
abstract class FileMonitor(root: Path) {
def start(): Unit
def onCreate(path: Path): Unit
def onModify(path: Path): Unit
def onDelete(path: Path): Unit
def stop(): Unit
}
这样,我可以简单地将示例代码编写为:
val watcher = new FileMonitor(myFile) {
override def onCreate(path: Path) = println(s"$path got created")
override def onModify(path: Path) = println(s"$path got modified")
override def onDelete(path: Path) = println(s"$path got deleted")
}
watcher.start()
好的,让我们尝试使用Java Thread
修改第一个示例,以便我们可以公开“我理想的接口”:
trait FileMonitor { // My ideal interface
val root: Path // starting file
def start(): Unit // start the monitor
def onCreate(path: Path) = {} // on-create callback
def onModify(path: Path) = {} // on-modify callback
def onDelete(path: Path) = {} // on-delete callback
def onUnknownEvent(event: WatchEvent[_]) = {} // handle lost/discarded events
def onException(e: Throwable) = {} // handle errors e.g. a read error
def stop(): Unit // stop the monitor
}
这是一个非常基本的基于线程的实现:
class ThreadFileMonitor(val root: Path) extends Thread with FileMonitor {
setDaemon(true) // daemonize this thread
setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler {
override def uncaughtException(thread: Thread, exception: Throwable) = onException(exception)
})
val service = root.getFileSystem.newWatchService()
override def run() = Iterator.continually(service.take()).foreach(process)
override def interrupt() = {
service.close()
super.interrupt()
}
override def start() = {
watch(root)
super.start()
}
protected[this] def watch(file: Path): Unit = {
file.register(service, ENTRY_CREATE, ENTRY_DELETE, ENTRY_MODIFY)
}
protected[this] def process(key: WatchKey) = {
key.pollEvents() foreach {
case event: WatchEvent[Path] => dispatch(event.kind(), event.context())
case event => onUnknownEvent(event)
}
key.reset()
}
def dispatch(eventType: WatchEvent.Kind[Path], file: Path): Unit = {
eventType match {
case ENTRY_CREATE => onCreate(file)
case ENTRY_MODIFY => onModify(file)
case ENTRY_DELETE => onDelete(file)
}
}
}
上面看起来更干净! 现在,我们可以通过简单地实现onCreate(path)
, onModify(path)
, onDelete(path)
等来观看文件,而不用onModify(path)
JavaDocs的细节。
- 异常处理 :上面已经完成了。 每当我们遇到异常时,就会调用
onException
,并且调用者可以通过实现它来决定下一步该做什么。 - 递归监视 :Java API 不允许递归监视目录 。 我们需要修改
watch(file)
以递归地附加观察者:
def watch(file: Path, recursive: Boolean = true): Unit = {
if (Files.isDirectory(file)) {
file.register(service, ENTRY_CREATE, ENTRY_DELETE, ENTRY_MODIFY)
// recursively call watch on children of this file
if (recursive) {
Files.list(file).iterator() foreach {f => watch(f, recursive)}
}
}
}
- 监视 常规文件 :如前所述,Java API 仅可以监视目录 。 我们可以监视单个文件的一种方法是在其父目录上设置监视程序,并且仅当事件在文件本身上触发时才做出反应。
override def start() = {
if (Files.isDirectory(root)) {
watch(root, recursive = true)
} else {
watch(root.getParent, recursive = false)
}
super.start()
}
并且,现在在process(key)
,我们确保仅对目录或该文件做出反应:
def reactTo(target: Path) = Files.isDirectory(root) || (root == target)
而且,我们现在在dispatch
前检查:
case event: WatchEvent[Path] =>
val target = event.context()
if (reactTo(target)) {
dispatch(event.kind(), target)
}
- 自动监视新项目 :Java API 不会自动监视任何新的子文件 。 我们可以通过在触发
ENTRY_CREATE
事件时将观察者自己附加到process(key)
来解决此问题:
if (reactTo(target)) {
if (Files.isDirectory(root) && event.kind() == ENTRY_CREATE) {
watch(root.resolve(target))
}
dispatch(event.kind(), target)
}
放在一起,我们有了最终的FileMonitor.scala
:
class ThreadFileMonitor(val root: Path) extends Thread with FileMonitor {
setDaemon(true) // daemonize this thread
setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler {
override def uncaughtException(thread: Thread, exception: Throwable) = onException(exception)
})
val service = root.getFileSystem.newWatchService()
override def run() = Iterator.continually(service.take()).foreach(process)
override def interrupt() = {
service.close()
super.interrupt()
}
override def start() = {
if (Files.isDirectory(root)) {
watch(root, recursive = true)
} else {
watch(root.getParent, recursive = false)
}
super.start()
}
protected[this] def watch(file: Path, recursive: Boolean = true): Unit = {
if (Files.isDirectory(file)) {
file.register(service, ENTRY_CREATE, ENTRY_DELETE, ENTRY_MODIFY)
if (recursive) {
Files.list(file).iterator() foreach {f => watch(f, recursive)}
}
}
}
private[this] def reactTo(target: Path) = Files.isDirectory(root) || (root == target)
protected[this] def process(key: WatchKey) = {
key.pollEvents() foreach {
case event: WatchEvent[Path] =>
val target = event.context()
if (reactTo(target)) {
if (Files.isDirectory(root) && event.kind() == ENTRY_CREATE) {
watch(root.resolve(target))
}
dispatch(event.kind(), target)
}
case event => onUnknownEvent(event)
}
key.reset()
}
def dispatch(eventType: WatchEvent.Kind[Path], file: Path): Unit = {
eventType match {
case ENTRY_CREATE => onCreate(file)
case ENTRY_MODIFY => onModify(file)
case ENTRY_DELETE => onDelete(file)
}
}
}
现在,我们已经解决了所有难题,并摆脱了WatchService API的复杂性,我们仍然与基于线程的API紧密相连。 我们将使用上述类来公开一个不同的并发模型,即actor模型,而不是使用Akka设计一个反应性,动态和灵活的文件系统监视程序。 尽管Akka actor的构造不在本文讨论范围之内,但是我们将展示一个使用ThreadFileMonitor
的非常简单的ThreadFileMonitor
:
import java.nio.file.{Path, WatchEvent}
import akka.actor._
class FileWatcher(file: Path) extends ThreadFileMonitor(file) with Actor {
import FileWatcher._
// MultiMap from Events to registered callbacks
protected[this] val callbacks = newMultiMap[Event, Callback]
// Override the dispatcher from ThreadFileMonitor to inform the actor of a new event
override def dispatch(event: Event, file: Path) = self ! Message.NewEvent(event, file)
// Override the onException from the ThreadFileMonitor
override def onException(exception: Throwable) = self ! Status.Failure(exception)
// when actor starts, start the ThreadFileMonitor
override def preStart() = super.start()
// before actor stops, stop the ThreadFileMonitor
override def postStop() = super.interrupt()
override def receive = {
case Message.NewEvent(event, target) if callbacks contains event =>
callbacks(event) foreach {f => f(event -> target)}
case Message.RegisterCallback(events, callback) =>
events foreach {event => callbacks.addBinding(event, callback)}
case Message.RemoveCallback(event, callback) =>
callbacks.removeBinding(event, callback)
}
}
object FileWatcher {
type Event = WatchEvent.Kind[Path]
type Callback = PartialFunction[(Event, Path), Unit]
sealed trait Message
object Message {
case class NewEvent(event: Event, file: Path) extends Message
case class RegisterCallback(events: Seq[Event], callback: Callback) extends Message
case class RemoveCallback(event: Event, callback: Callback) extends Message
}
}
这使我们能够动态注册和删除对文件系统事件做出响应的回调:
// initialize the actor instance
val system = ActorSystem("mySystem")
val watcher: ActorRef = system.actorOf(Props(new FileWatcher(Paths.get("/home/pathikrit"))))
// util to create a RegisterCallback message for the actor
def when(events: Event*)(callback: Callback): Message = {
Message.RegisterCallback(events.distinct, callback)
}
// send the register callback message for create/modify events
watcher ! when(events = ENTRY_CREATE, ENTRY_MODIFY) {
case (ENTRY_CREATE, file) => println(s"$file got created")
case (ENTRY_MODIFY, file) => println(s"$file got modified")
}
翻译自: https://www.javacodegeeks.com/2015/12/reactive-file-system-monitoring-using-akka-actors.html