Java 类org.apache.commons.io.monitor.FileAlterationMonitor 实例源码

/**
 * 只监控文件发送变化,如果是子目录的文件改变,则目录会变,由于没有过滤目录发生变化,则目录下的文件改变不会监控到
 * @param dir
 * @throws Exception 
 */
public void check1(String dir) throws Exception
{
    File directory = new File(dir);
    // 轮询间隔 5 秒
    long interval = TimeUnit.SECONDS.toMillis(5);
    // 创建一个文件观察器用于处理文件的格式
    IOFileFilter filter=FileFilterUtils.or(FileFilterUtils.suffixFileFilter(".class"),
            FileFilterUtils.suffixFileFilter(".jar"));
    FileAlterationObserver observer = new FileAlterationObserver(directory,filter);
    //设置文件变化监听器
    observer.addListener(new MyFileListener());
    FileAlterationMonitor monitor = new FileAlterationMonitor(interval);
    monitor.addObserver(observer);//文件观察
    monitor.start();
}

public void check2(String dir) throws Exception
    {
        File directory = new File(dir);
        // 轮询间隔 5 秒
        long interval = TimeUnit.SECONDS.toMillis(5);
        //后缀过滤器
        IOFileFilter filefilter=FileFilterUtils.or(FileFilterUtils.suffixFileFilter(".class"),
                FileFilterUtils.suffixFileFilter(".jar"));
        //子目录的后缀
        IOFileFilter subFilefilter=FileFilterUtils.or(FileFilterUtils.directoryFileFilter(),filefilter);
        //根目录和子目录变化
        IOFileFilter filter = FileFilterUtils.or(filefilter,subFilefilter);
        FileAlterationObserver observer = new FileAlterationObserver(directory,filter);
        //设置文件变化监听器
        observer.addListener(new MyFileListener());
        FileAlterationMonitor monitor = new FileAlterationMonitor(interval);
        monitor.addObserver(observer);//文件观察
        monitor.start();
//      monitor.addObserver(observer);//文件观察,如果在start后面加,则会触发所有文件创建
    }

public static void azkabanConfigFileMonitor(String[] args, Props props1) {
    try {
        props = props1;
        configFilePath = props.getString(AZKABAN_CONFIG_FILE_PATH);//配置文件路径
        long interval = props.getLong(AZKABAN_CONFIG_FILE_MONIITE_INTERVAL, 5000);//监听间隔
        String dirPath = System.getProperty("user.dir") + configFilePath;
        logger.error("azkabanConfigFileMonitor method, monitor path= " + dirPath);
        //构造观察类:主要提供要观察的文件或目录，当然还有详细信息的filter
        FileAlterationObserver observer = new FileAlterationObserver(new File(dirPath), new FileFilterImpl());
        //构造收听类
        FileListenerAdaptor listener = new FileListenerAdaptor(args);
        //为观察对象添加收听对象
        observer.addListener(listener);
        //配置Monitor，第一个参数单位是毫秒，是监听的间隔；第二个参数就是绑定我们之前的观察对象。
        FileAlterationMonitor fileMonitor = new FileAlterationMonitor(interval, new FileAlterationObserver[]{observer});
        //启动开始监听
        fileMonitor.start();
    } catch (Exception e) {
        logger.error("azkabanConfigFileMonitor method error", e);
    }

}

public void start() {
    String gamePath = Configuration.get().applicationConfiguration().get().getGamePath();

    File folder = new File(gamePath + "logs");
    this.fileHandler = new MessageFileHandler(gamePath + "logs/Client.txt");
    FileAlterationObserver observer = new FileAlterationObserver(folder);
    monitor = new FileAlterationMonitor(POLLING_INTERVAL);
    FileAlterationListener listener = new FileAlterationListenerAdaptor() {
        @Override
        public void onFileChange(File file) {
            fileHandler.parse();
        }
    };

    observer.addListener(listener);
    monitor.addObserver(observer);
    try {
        monitor.start();
    } catch (Exception e) {
        e.printStackTrace();
    }
}

public synchronized void activate() throws MojoExecutionException
{   
  IOFileFilter logFilter = FileFilterUtils.and(
          FileFilterUtils.fileFileFilter(),
          FileFilterUtils.nameFileFilter(engineLog.getName()));
  FileAlterationObserver fileObserver = new FileAlterationObserver(engineLog.getParent(), logFilter);
  fileObserver.addListener(new LogModificationListener());
  monitor = new FileAlterationMonitor(100);
  monitor.addObserver(fileObserver);
  try
  {
    monitor.start();
  }
  catch (Exception ex)
  {
    throw new MojoExecutionException("Failed to activate deploy log forwarder", ex);
  }
}

public ReloadableConfig() {
    new Thread(()->{
        long interval = TimeUnit.SECONDS.toMillis(30);
        try {
            ClassPathResource resource = new ClassPathResource(getClassPathFilePath());
            File file = resource.getFile();
            FileAlterationObserver observer = new FileAlterationObserver(file.getParentFile() , new NameFileFilter(file.getName()));
            observer.addListener(this);
            FileAlterationMonitor monitor = new FileAlterationMonitor(interval , observer);
            LOGGER.debug("监听文件:{}" , file.getPath());
            monitor.start();
        } catch (Exception e) {
            LOGGER.error("ClassPathFilePath:{}" , getClassPathFilePath());
            LOGGER.error("" , e);
        }
    }).start();
}

/**
 * Add {@link org.apache.commons.io.monitor.FileAlterationMonitor}s for the given
 * root directory and any nested subdirectories under the root directory to the given
 * {@link org.apache.commons.io.monitor.FileAlterationMonitor}.
 *
 * @param monitor a {@link org.apache.commons.io.monitor.FileAlterationMonitor}
 * @param listener a {@link org.apache.commons.io.monitor.FileAlterationListener}
 * @param rootDir root directory
 */
public static void addFileAlterationObserver(FileAlterationMonitor monitor, FileAlterationListener listener,
    File rootDir) {
  // Add a observer for the current root directory
  FileAlterationObserver observer = new FileAlterationObserver(rootDir);
  observer.addListener(listener);
  monitor.addObserver(observer);

  // List subdirectories under the current root directory
  File[] subDirs = rootDir.listFiles(new FileFilter() {
    @Override
    public boolean accept(File file) {
      return file.isDirectory();
    }
  });

  if (subDirs == null || subDirs.length == 0) {
    return;
  }

  // Recursively add a observer for each subdirectory
  for (File subDir : subDirs) {
    addFileAlterationObserver(monitor, listener, subDir);
  }
}

public JobScheduler(Properties properties)
    throws Exception {
  this.properties = properties;
  this.scheduler = new StdSchedulerFactory().getScheduler();

  this.jobExecutor = Executors.newFixedThreadPool(
      Integer.parseInt(properties.getProperty(ConfigurationKeys.JOB_EXECUTOR_THREAD_POOL_SIZE_KEY,
          Integer.toString(ConfigurationKeys.DEFAULT_JOB_EXECUTOR_THREAD_POOL_SIZE))),
      ExecutorsUtils.newThreadFactory(Optional.of(LOG), Optional.of("JobScheduler-%d")));

  this.jobConfigFileExtensions = Sets.newHashSet(Splitter.on(",").omitEmptyStrings().split(this.properties
      .getProperty(ConfigurationKeys.JOB_CONFIG_FILE_EXTENSIONS_KEY,
          ConfigurationKeys.DEFAULT_JOB_CONFIG_FILE_EXTENSIONS)));

  long pollingInterval = Long.parseLong(this.properties.getProperty(
      ConfigurationKeys.JOB_CONFIG_FILE_MONITOR_POLLING_INTERVAL_KEY,
      Long.toString(ConfigurationKeys.DEFAULT_JOB_CONFIG_FILE_MONITOR_POLLING_INTERVAL)));
  this.fileAlterationMonitor = new FileAlterationMonitor(pollingInterval);
}

/**
 * reload files
 */
protected synchronized Main restart() {
    /* http://www.baeldung.com/java-watchservice-vs-apache-commons-io-monitor-library */
    if (fsObserver != null && this.monitor == null) {

        fsObserver.addListener(this);

        this.monitor = new FileAlterationMonitor(fileObservePeriod);

        monitor.addObserver(fsObserver);

        try {
            monitor.start();
            logger.info("watching file://{}", path);

            reload(fsObserver);

        } catch (Exception e) {
            logger.error("file observe {}", e);
            this.fsObserver = null;
        }

    }
    return this;
}

public static void watch(Config cfg) throws Exception {
    logger.info("Starting asset watcher...");
    long interval = 100;
    PipelineEnvironment pe = new PipelineEnvironment(cfg);
    AssetFileObserver fileObserver = new AssetFileObserver(pe);
    FileAlterationObserver jsObserver = fileObserver.observeJs();
    FileAlterationObserver cssObserver = fileObserver.observeCss();
    FileAlterationObserver imageObserver = fileObserver.observeImage();
    FileAlterationObserver templateObserver = fileObserver.observeTemplate();
    FileAlterationObserver serverTemplateObserver = fileObserver.observeServerTemplate();
    FileAlterationObserver staticAssetObserver = fileObserver.observeStaticAsset();
    FileAlterationMonitor monitor = new FileAlterationMonitor(interval);
    monitor.addObserver(jsObserver);
    monitor.addObserver(cssObserver);
    monitor.addObserver(imageObserver);
    monitor.addObserver(templateObserver);
    monitor.addObserver(serverTemplateObserver);
    monitor.addObserver(staticAssetObserver);
    monitor.start();
}

/**
 * Creates a new OpenCmsConfiguration instance, prepares the XML helper for parsing configuration files, starts
 * a FileAlterationObserver used to handle changes to configuration files.
 * @param config the project level plugin configuration data
 */
public OpenCmsConfiguration(OpenCmsPluginConfigurationData config) {
    this.config = config;

    File configurationFolder = new File(config.getWebappRoot() + CONFIGPATH);
    this.moduleConfigurationFile = new File(config.getWebappRoot() + CONFIGPATH + MODULECONFIGFILE);

    // Create an Observer for configuration changes
    FileAlterationObserver configurationChangeObserver = new FileAlterationObserver(configurationFolder);
    configurationChangeObserver.addListener(new ConfigurationAlterationListener());
    configurationChangeMonitor = new FileAlterationMonitor(5000, configurationChangeObserver);

    try {
        xmlHelper = new XmlHelper();
    }
    catch (Exception e) {
        LOG.warn("Exception during initialization of the module configuration: " + e);
    }

    parseConfiguration();
}

public DirectoryMonitor(String directorypath, long polling, String classname) {

        this.directory = new File(directorypath);
        this.trackedClassName = classname;
        this.polling = polling;

        if (!directory.isDirectory()) {
            LOG.info("Monitored directory {} not existing - creating directory", directory.getAbsolutePath());
            if (!this.directory.mkdirs()) {
                throw new IllegalStateException("Monitored directory doesn't exist and cannot be created.");
            }
        }

        // We observes all files.
        FileAlterationObserver observer = new FileAlterationObserver(directory, TrueFileFilter.INSTANCE);
        observer.checkAndNotify();
        observer.addListener(new FileMonitor());
        monitor = new FileAlterationMonitor(polling, observer);

    }

protected void init() throws Exception
{
    FileAlterationObserver observer=buildFileAlterationObserver(scriptDir);
    observer.addListener(new FileListener());
    FileAlterationMonitor monitor=new FileAlterationMonitor(updateInterval);
    monitor.addObserver(observer);
    monitor.start();
    scanResources();
}

TorrentFileWatcher(final FileAlterationListener listener, final Path monitoredFolder, final Integer interval) {
    Preconditions.checkNotNull(listener, "listener cannot be null");
    Preconditions.checkNotNull(monitoredFolder, "monitoredFolder cannot be null");
    Preconditions.checkArgument(Files.exists(monitoredFolder), "Folder '" + monitoredFolder.toAbsolutePath() + "' does not exists.");
    Preconditions.checkNotNull(interval, "interval cannot be null");
    Preconditions.checkArgument(interval > 0, "interval cannot be less than 1");
    this.listener = listener;
    this.monitoredFolder = monitoredFolder.toFile();
    this.monitor = new FileAlterationMonitor(interval);
    this.observer = new FileAlterationObserver(this.monitoredFolder, TORRENT_FILE_FILTER);

    this.observer.addListener(this.listener);
    monitor.addObserver(this.observer);
}

public void monitor(String directory, int interval) {
    FileAlterationObserver fileAlterationObserver = new FileAlterationObserver(directory, FileFilterUtils.and(FileFilterUtils.nameFileFilter(SENSITIVE_WORD_FILE_NAME)), null);
    fileAlterationObserver.addListener(this);
    FileAlterationMonitor fileAlterationMonitor = new FileAlterationMonitor(interval, fileAlterationObserver);

    try {
        fileAlterationMonitor.start();
    } catch (Exception e) {
        e.printStackTrace();
    }
}

/**

@method monitorCollection
*/
   private FileAlterationMonitor monitorCollection (String collection) throws Exception {
    // prtln ("monitorCollection() - " + collection);

    AssetCollection assetCollection = this.getCollection(collection);

       if (assetCollection == null) {
           // Test to see if monitored folder exists
           throw new RuntimeException("AssetCollection not found: " + collection);
       }

       File folder = assetCollection.getDirectory();
       if (!folder.exists())
        throw new RuntimeException("Folder not found at: " + folder);

       FileAlterationObserver observer = new FileAlterationObserver(folder);
       FileAlterationMonitor monitor =
               new FileAlterationMonitor(pollingInterval);

    FileAlterationListener listener = new AssetFileListener(collection, this);

       observer.addListener(listener);
       monitor.addObserver(observer);
       monitor.start();
       // prtln (" .. monitoring " + collection);
       return monitor;
   }

public PluginDirectoryWatcher(PluginManagerImpl pluginManager, File directory) {
    this.pluginManager = pluginManager;
    this.directory = directory;
    FileAlterationObserver observer = new FileAlterationObserver(directory);
    observer.addListener(this);
    monitor = new FileAlterationMonitor();
    monitor.addObserver(observer);
}

/**
 * Constructor.
 * @param manager the templating manager, to which event handling is delegated.
 * @param templateDir the templates directory to watch.
 * @param pollInterval the poll interval.
 * @throws IOException if there is a problem watching the template directory.
 */
public TemplateWatcher( final TemplatingManager manager, final File templateDir, final long pollInterval ) {
    this.templateDir = templateDir;

    // Register the custom helpers.
    this.handlebars.registerHelper( AllHelper.NAME, new AllHelper());
    this.handlebars.registerHelper( IsKeyHelper.NAME, new IsKeyHelper());

    // Pretty formatting
    this.handlebars.prettyPrint( true );

    // Create the observer, register this object as the event listener.
    FileFilter fileFilter = FileFilterUtils.or(
            FileFilterUtils.and(
                    FileFilterUtils.fileFileFilter(),
                    FileFilterUtils.suffixFileFilter( ".tpl" ),
                    CanReadFileFilter.CAN_READ,
                    new TemplateFileFilter(templateDir)),
            FileFilterUtils.and(
                    FileFilterUtils.directoryFileFilter(),
                    CanReadFileFilter.CAN_READ,
                    new TemplateSubDirectoryFileFilter(templateDir))
    );

    FileAlterationObserver observer = new FileAlterationObserver( this.templateDir, fileFilter );
    observer.addListener( this );

    // Create the monitor.
    this.monitor = new FileAlterationMonitor( pollInterval, observer );
    this.monitor.setThreadFactory( THREAD_FACTORY );

    this.manager = manager;
    this.logger.fine( "Template watcher is watching "
            + this.templateDir
            + " with an interval of " + pollInterval + " ms." );
}

private void observeConfigChanges() throws Exception
{
    if (watchConfigInterval < 0)
    {
        return;
    }

    FileAlterationListenerAdaptor listener = new FileAlterationListenerAdaptor()
    {
        @Override
        public void onFileChange(File file)
        {
            LOG.info("Config file changed: {}", configPath);
            try
            {
                readConfig(true);
            }
            catch (ConfigException e)
            {
                exitWithError("Failed to refresh config: " + e.getMessage(), false);
                return;
            }
        }
    };

    String filename = configPath.substring(configPath.lastIndexOf('/') + 1);
    String directory = configPath.substring(0, configPath.lastIndexOf('/'));

    FileAlterationObserver observer = new FileAlterationObserver(
            new File(directory),
            FileFilterUtils.nameFileFilter(filename)
    );
    observer.addListener(listener);

    FileAlterationMonitor monitor = new FileAlterationMonitor(watchConfigInterval);
    monitor.addObserver(observer);

    monitor.start();
}

/**
 * Starts the watching.
 *
 * @return the current pipeline.
 */
public Pipeline watch() {
    // Delete all error reports before starting the watcher.
    error = new File(baseDir, "target/pipeline");
    FileUtils.deleteQuietly(error);
    mojo.getLog().debug("Creating the target/pipeline directory : " + error.mkdirs());

    // Start the watching process.
    watcher = new FileAlterationMonitor(Integer.getInteger("watch.period", 2) * 1000);
    watcher.setThreadFactory(new DefensiveThreadFactory("wisdom-pipeline-watcher", mojo));
    FileAlterationObserver srcObserver = new FileAlterationObserver(new File(baseDir, "src"),
            TrueFileFilter.INSTANCE);
    PipelineWatcher listener = new PipelineWatcher(this);
    srcObserver.addListener(listener);
    watcher.addObserver(srcObserver);

    if (pomFileMonitoring) {
        FileAlterationObserver pomObserver = new FileAlterationObserver(baseDir, new FileFilter() {
            @Override
            public boolean accept(File file) {
                return file.equals(new File(baseDir, "pom.xml"));
            }
        });
        pomObserver.addListener(listener);
        watcher.addObserver(pomObserver);
    }

    try {
        mojo.getLog().info("Start watching " + baseDir.getAbsolutePath());
        watcher.start();
    } catch (Exception e) {
        mojo.getLog().error("Cannot start the watcher", e);
    }
    return this;
}

public FileSystemPoller(final FileFilter fileNameFilter, final long pollingDelayMillis) throws Exception {
    this.fileNameFilter = fileNameFilter;
    listeners = new HashMap<>();
    monitor = new FileAlterationMonitor(pollingDelayMillis);
    monitor.start();
}

@Inject
public Watcher(ObserverFactory observerFactory, FileAlterationMonitor monitor) {
    this.observerFactory = observerFactory;
    this.monitor = monitor;
}

@Bean
public FileAlterationMonitor monitor() {
    return new FileAlterationMonitor(1000);
}

/**
 * コピー元ディレクトリの監視を開始します。
 * コピー元ディレクトリ内のファイルが更新されたら、そのファイルをコピー先ディレクトリにコピーします。
 *
 * @param srcDir コピー元ディレクトリ
 * @param dstDir コピー先ディレクトリ
 * @return 0 (正常終了)
 * @thｒrows Exception
 */
public int start(final String srcDir, final String dstDir) throws Exception {
    FileAlterationObserver observer = new FileAlterationObserver(srcDir);
    int interval = NumberUtils.toInt(System.getProperty(MONITOR_INTERVAL), 1000);
    final FileAlterationMonitor monitor
            = new FileAlterationMonitor(interval);

    FileAlterationListener listener = new FileAlterationListenerAdaptor() {
        @Override
        public void onFileChange(File file) {
            if (!file.isFile()) {
                return;
            }
            String relativePath = StringUtils.substringAfter(file.getAbsolutePath(), srcDir);
            File dstFile = new File(dstDir, relativePath);
            LOG.info("コピーします {} -> {}", file.getAbsolutePath(), dstFile.getAbsolutePath());
            try {
                FileUtils.copyFile(file, dstFile);
            } catch (IOException e) {
                LOG.error("ファイルコピーに失敗 ", e);
            }
        }
    };

    observer.addListener(listener);
    monitor.addObserver(observer);
    monitor.start();

    // TODO ファイル監視方式の統一
    String continuFilePath = System.getProperty("cc.cgfile", ".cg");
    ControlFile continueFile = new ControlFile(continuFilePath, new ControlFile.Listener() {
        @Override
        public void onDelete() throws Exception {
            monitor.stop();
        }
    });
    continueFile.watch();

    while(continueFile.exists()) {
        // 制御ファイルが存在し続ける間、処理を継続
    }

    return 0;
}

private DirectoryWatcher(){
    observers = new LinkedList<FileAlterationObserver>();
    directories = new LinkedList<File>();
    monitor = new FileAlterationMonitor(2000);
    monitor.addObserver(observer);
}

/**
 * @param args
 * @throws Exception
 */
public static void main(String[] args) throws Exception {


    // 监控根目录，会递归监控子文件夹变化

    String rootDir = "D:\\download";
    // 轮询间隔 5 秒，通过重新启动 FileAlterationMonitor 实现
    long interval = TimeUnit.SECONDS.toMillis(5);


    // 创建一个文件观察器用于处理文件的格式
    // Create a FileFilter
    IOFileFilter directories = FileFilterUtils.and(FileFilterUtils.directoryFileFilter(), HiddenFileFilter.VISIBLE);
    IOFileFilter files = FileFilterUtils.and(FileFilterUtils.fileFileFilter(), FileFilterUtils.suffixFileFilter(".java"));
    IOFileFilter filter = FileFilterUtils.or(directories, files);

    // Create the File system observer and register File Listeners
    FileAlterationObserver observer = new FileAlterationObserver(rootDir, filter, null);
    observer.addListener(new FileMonitorFileListener()); //设置文件变化监听器

    //创建文件变化监听器
    FileAlterationMonitor monitor = new FileAlterationMonitor(interval, observer);

    // 开始监控
    monitor.start();

}

/**
 * Creates a new {@link CommonsIOFileMonitorServiceImpl}.
 * @param pollingInterval the polling interval
 * @param pollingTimeUnit the time unit for the polling interval.
 * @return a new {@link CommonsIOFileMonitorServiceImpl}, which wraps a
 * newly-created {@link FileAlterationMonitor}
 */
@Override
public FileMonitorService createFileMonitorService() {
    long pollingIntervalMillis = getPollingTimeUnit().toMillis(getPollingInterval());
    FileAlterationMonitor fileAlterationMonitor = new FileAlterationMonitor(pollingIntervalMillis);
    return new CommonsIOFileMonitorServiceImpl(fileAlterationMonitor);
}

/**
 * A file observer that uses the specified interval to check for file changes.
 * 
 * @param rootDirectory
 * @param ms
 */
public FileObserver(File rootDirectory, long ms) {
    this.observer = new FileAlterationObserver(rootDirectory);
    this.monitor = new FileAlterationMonitor(ms, observer);
}

/**
 * Creates a new CommonsIOFileMonitorServiceImpl.
 *
 * @param fileMonitor the file monitor
 */
public CommonsIOFileMonitorServiceImpl(FileAlterationMonitor fileMonitor) {
    this.fileMonitor = fileMonitor;
    this.directoryObservers = new ConcurrentHashMap<File, FileAlterationObserver>();
}