Java Kind类代码示例

import java.nio.file.WatchEvent.Kind; //导入依赖的package包/类
@SuppressWarnings ( "unchecked" )
private void handleEvent ( final WatchEvent<?> event )
{
    final Kind<?> kind = event.kind ();

    if ( kind == StandardWatchEventKinds.OVERFLOW )
    {
        // FIXME: full rescan
        return;
    }

    final Path path = this.path.resolve ( ( (WatchEvent<Path>)event ).context () );

    if ( kind == StandardWatchEventKinds.ENTRY_CREATE )
    {
        this.listener.event ( path, Event.ADDED );
    }
    else if ( kind == StandardWatchEventKinds.ENTRY_DELETE )
    {
        this.listener.event ( path, Event.REMOVED );
    }
    else if ( kind == StandardWatchEventKinds.ENTRY_MODIFY )
    {
        this.listener.event ( path, Event.MODIFIED );
    }
}
 

import java.nio.file.WatchEvent.Kind; //导入依赖的package包/类
/**
 * A method to register all the files which will be under the given start path to look
 * @param start the path to start the search files to be registered
 * @throws IOException 
 */
public void registerAll(Path start) throws IOException {
    try {
        // walk all folders here recursively call the below method for each folder(not file!) the variable dir is a Path Object!!!
        Kind[] events = { ENTRY_CREATE, ENTRY_DELETE, ENTRY_MODIFY};
        walkFiles( start.toFile(), events);
        
        /*Files.walk(start)
            .filter(path -> Files.isDirectory(path))
            .forEach(path -> {
            try {
                path.register(folderWatcher, events, SensitivityWatchEventModifier.HIGH);
                // System.out.println("The reg path: " + path);
            } catch (IOException ex) {
                Logger.getLogger(RealTimeFolderWatcher.class.getName()).log(Level.SEVERE, null, ex);
            }
        });*/
    } catch (IOException ex) {
        Logger.getLogger(RealTimeFolderWatcher.class.getName()).log(Level.SEVERE, null, ex);
    }
}
 

import java.nio.file.WatchEvent.Kind; //导入依赖的package包/类
@SuppressWarnings("unchecked")
@Override
public void run() {
	while (running) {
		try {
			final WatchKey watchKey = watcher.take();
			for (final WatchEvent<?> event : watchKey.pollEvents()) {
				Path changed = (Path) event.context();
				if (changed == null || event.kind() == StandardWatchEventKinds.OVERFLOW) {
					System.out.println("bad file watch event: " + event);
					continue;
				}
				changed = watchedDirectory.resolve(changed);
				for (final ListenerAndPath x : listeners) {
					if (Thread.interrupted() && !running)
						return;
					if (changed.startsWith(x.startPath)) {
						x.listener.fileChanged(changed, (Kind<Path>) event.kind());
					}
				}
			}
			watchKey.reset();
		} catch (final InterruptedException e) {}
	}
}
 

import java.nio.file.WatchEvent.Kind; //导入依赖的package包/类
/** Notify file system event. */
void processEvent() {
	while(true) {
		WatchKey signal;
		
		try {
			signal = watcher.take();
		} catch (InterruptedException e) {
			return;
		}
		
		for(WatchEvent<?> event : signal.pollEvents()) {
			Kind<?> kind = event.kind();
			
			if(kind == StandardWatchEventKinds.OVERFLOW) {
				continue;
			}
			
			Path name = (Path)event.context();
			notify(name.toAbsolutePath().toString(), kind);
		}
		
		key.reset();
	}
}
 

import java.nio.file.WatchEvent.Kind; //导入依赖的package包/类
@Override
protected boolean processEvent(Kind<?> kind, Path filename) throws IOException {
  if (!isMetadataFile(filename)) {
    return false;
  }

  LOG.trace("Handling {} event on {}", kind, filename);

  Optional<TailMetadata> tail = read(Paths.get(baseConfiguration.getLogWatcherMetadataDirectory()).resolve(filename));

  if (!tail.isPresent()) {
    return false;
  }

  synchronized (listeners) {
    for (TailMetadataListener listener : listeners) {
      listener.tailChanged(tail.get());
    }
  }
  return true;
}
 

import java.nio.file.WatchEvent.Kind; //导入依赖的package包/类
private void processWatchEvent(final Kind<Path> watchEventKind, final Path path) {
    final String dropboxPathLower = PathUtil.extractDropboxPath(localDir, path)
            .toLowerCase(Locale.getDefault());
    if (globalOperationsTracker.isTracked(dropboxPathLower)) {
        LOG.trace("Path already tracked. Skipping: {}", () -> path);
    } else {
        final LocalFolderChangeType changeType = LocalFolderChangeType
                .fromWatchEventKind(watchEventKind);

        final LocalFolderData localPathChange = new LocalFolderData(path,
                changeType);

        LOG.trace("Local event {} on path {}", changeType, path);

        try {
            localPathChanges.put(localPathChange);
        } catch (final Exception ex) {
            LOG.error("Interrupted", ex);
        }
    }
}
 

import java.nio.file.WatchEvent.Kind; //导入依赖的package包/类
public static void main(String[] args) throws Throwable {
    String tempDirPath = "/tmp";
    System.out.println("Starting watcher for " + tempDirPath);
    Path p = Paths.get(tempDirPath);
    WatchService watcher = 
        FileSystems.getDefault().newWatchService();
    Kind<?>[] watchKinds = { ENTRY_CREATE, ENTRY_MODIFY };
    p.register(watcher, watchKinds);
    mainRunner = Thread.currentThread();
    new Thread(new DemoService()).start();
    while (!done) {
        WatchKey key = watcher.take();
        for (WatchEvent<?> e : key.pollEvents()) {
            System.out.println(
                "Saw event " + e.kind() + " on " + 
                e.context());
            if (e.context().toString().equals("MyFileSema.for")) {
                System.out.println("Semaphore found, shutting down watcher");
                done = true;
            }
        }
        if (!key.reset()) {
            System.err.println("Key failed to reset!");
        }
    }
}
 

import java.nio.file.WatchEvent.Kind; //导入依赖的package包/类
public void watch(
        final Path dir,
        final Kind<Path>[] kinds) throws IOException {

    WatchService service = FileSystems.getDefault().newWatchService();
    // Rationale for SensitivityWatchEventModifier.HIGH: 
    // http://stackoverflow.com/questions/9588737/is-java-7-watchservice-slow-for-anyone-else
    dir.register(
            service,
            kinds,
            SensitivityWatchEventModifier.HIGH);

    m_logger.info("Watching directory: {}", dir);
    m_watcher = new WatcherThread(service, m_eventBus);
    m_watcher.start(); // Start watcher thread
}
 

import java.nio.file.WatchEvent.Kind; //导入依赖的package包/类
EphemeralFsWatchKey(
        EphemeralFsWatchService watchService, 
        EphemeralFsPath watchable,
        INode iNode,
        EphemeralFsFileSystem fs,
        Kind<?>... events) {
    this.watchService = watchService;
    if(!watchable.isAbsolute()) {
        throw new IllegalArgumentException("path must be absolute");
    }
    this.watchable = watchable;
    this.iNode = iNode;
    this.fs = fs;
    interestOps = new HashSet<>();
    for(Kind<?> event : events) {
        interestOps.add(event);
    }
            
}
 

import java.nio.file.WatchEvent.Kind; //导入依赖的package包/类
private void processEvent(Path dir, WatchEvent<Path> event) {
    // Context for directory entry event is the file name of entry
    Path relChild = event.context();
    Path child = dir.resolve(relChild);

    Kind<Path> kind = event.kind();

    if(kind == ENTRY_MODIFY) {
        handleModification(child, externalInitiator);
    } else if(kind == ENTRY_CREATE) {
        handleCreation(child, externalInitiator);
    } else if(kind == ENTRY_DELETE) {
        model.delete(child, externalInitiator);
    } else {
        throw new AssertionError("unreachable code");
    }
}
 

import java.nio.file.WatchEvent.Kind; //导入依赖的package包/类
/**
 * Precondition: Event and child must not be null.
 * @param kind type of the event (create, modify, ...)
 * @param source Identifies the related file.
 */
private void handleEvent(Kind<Path> kind, Path source) {
	try {
		if(PathUtils.isFileHidden(source)){
			return;
		}
		if (kind.equals(ENTRY_CREATE)) {
			addNotifyEvent(new NotifyFileCreated(source));
		} else if (kind.equals(ENTRY_MODIFY)) {
			addNotifyEvent(new NotifyFileModified(source));
		} else if (kind.equals(ENTRY_DELETE)) {
			addNotifyEvent(new NotifyFileDeleted(source));
		} else if (kind.equals(OVERFLOW)) {
			// error - overflow... should not happen here (continue if such an event occurs).
			// handled already
			logger.warn("Overflow event from watch service. Too many events?");
		} else {
			logger.warn("Unknown event received");
		}
	} catch (InterruptedException iex) {
		// put into queue failed
		logger.info("Handling event interrupted.", iex);
	}
}
 

import java.nio.file.WatchEvent.Kind; //导入依赖的package包/类
public Watcher(final BiConsumer<Kind<?>, Path> listener, final Path... dirs)
        throws IOException {
  this.watcher = FileSystems.getDefault().newWatchService();
  this.keys = new HashMap<WatchKey, Path>();
  this.listener = listener;
  for (Path dir : dirs) {
    registerAll(dir);
  }

  this.scanner = new Thread(() -> {
    boolean process = true;
    while (!stopped && process) {
      process = processEvents();
    }
  }, "HotswapScanner");

  scanner.setDaemon(true);
}
 

import java.nio.file.WatchEvent.Kind; //导入依赖的package包/类
@SuppressWarnings("unchecked")
@Test
public void registerTreeRecursive() throws Exception {
  new MockUnit(Injector.class, Env.class, WatchService.class, FileEventOptions.class, Path.class,
      WatchEvent.Kind.class, WatchEvent.Modifier.class, WatchKey.class)
      .expect(newThread)
      .expect(registerTree(true, false))
      .expect(takeInterrupt)
      .run(unit -> {
        FileMonitor monitor = new FileMonitor(unit.get(Injector.class), unit.get(Env.class),
            unit.get(WatchService.class),
            ImmutableSet.of(unit.get(FileEventOptions.class)));
        unit.captured(ThreadFactory.class).get(0).newThread(monitor);
      }, unit -> {
        unit.captured(Runnable.class).get(0).run();
        unit.captured(FileVisitor.class).get(0).preVisitDirectory(unit.get(Path.class), null);
      });
}
 

import java.nio.file.WatchEvent.Kind; //导入依赖的package包/类
@Test
public void registerTree() throws Exception {
  new MockUnit(Injector.class, Env.class, WatchService.class, FileEventOptions.class, Path.class,
      WatchEvent.Kind.class, WatchEvent.Modifier.class, WatchKey.class)
      .expect(newThread)
      .expect(registerTree(false, false))
      .expect(takeInterrupt)
      .run(unit -> {
        FileMonitor monitor = new FileMonitor(unit.get(Injector.class), unit.get(Env.class),
            unit.get(WatchService.class),
            ImmutableSet.of(unit.get(FileEventOptions.class)));
        unit.captured(ThreadFactory.class).get(0).newThread(monitor);
      }, unit -> {
        unit.captured(Runnable.class).get(0).run();
      });
}
 

import java.nio.file.WatchEvent.Kind; //导入依赖的package包/类
@Test
public void registerTreeErr() throws Exception {
  new MockUnit(Injector.class, Env.class, WatchService.class, FileEventOptions.class, Path.class,
      WatchEvent.Kind.class, WatchEvent.Modifier.class, WatchKey.class)
      .expect(newThread)
      .expect(registerTree(false, true))
      .expect(takeInterrupt)
      .run(unit -> {
        FileMonitor monitor = new FileMonitor(unit.get(Injector.class), unit.get(Env.class),
            unit.get(WatchService.class),
            ImmutableSet.of(unit.get(FileEventOptions.class)));
        unit.captured(ThreadFactory.class).get(0).newThread(monitor);
      }, unit -> {
        unit.captured(Runnable.class).get(0).run();
      });
}