精华内容
下载资源
问答
  • 有时候,我们需要确定某些文件是否有变化而做出一些对应的动作,例如,曾经开发的一款服务器中,由于模块比较多,在运行期间有时候需要单独的输出某个模块日志,但又不可能总是开着日志。    log4j中已经实现了...

          有时候,我们需要确定某些文件是否有变化而做出一些对应的动作,例如,曾经开发的一款服务器中,由于模块比较多,在运行期间有时候需要单独的输出某个模块日志,但又不可能总是开着日志。

        

          log4j中已经实现了可以动态监控日志级别日志监视器

     

    PropertyConfigurator.configureAndWatch(properties);

     

          上面的properties是日志配置文件,例如常用的 log4j.properties ,log4j.xml。

     

      但是这是系统级别的,然后看了一下源代码,

    /*
     * Licensed to the Apache Software Foundation (ASF) under one or more
     * contributor license agreements.  See the NOTICE file distributed with
     * this work for additional information regarding copyright ownership.
     * The ASF licenses this file to You under the Apache License, Version 2.0
     * (the "License"); you may not use this file except in compliance with
     * the License.  You may obtain a copy of the License at
     * 
     *      http://www.apache.org/licenses/LICENSE-2.0
     * 
     * Unless required by applicable law or agreed to in writing, software
     * distributed under the License is distributed on an "AS IS" BASIS,
     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     * See the License for the specific language governing permissions and
     * limitations under the License.
     */
    
    // Contributors:  Mathias Bogaert
    
    package org.apache.log4j.helpers;
    
    import java.io.File;
    
    /**
     * Check every now and then that a certain file has not changed. If it has, then
     * call the {@link #doOnChange} method.
     * 
     * @author Ceki Gülcü
     * @since version 0.9.1
     */
    public abstract class FileWatchdog extends Thread {
    
    	/**
    	 * The default delay between every file modification check, set to 60
    	 * seconds.
    	 */
    	static final public long DEFAULT_DELAY = 60000;
    	/**
    	 * The name of the file to observe for changes.
    	 */
    	protected String filename;
    
    	/**
    	 * The delay to observe between every check. By default set
    	 * {@link #DEFAULT_DELAY}.
    	 */
    	protected long delay = DEFAULT_DELAY;
    
    	File file;
    	long lastModif = 0;
    	boolean warnedAlready = false;
    	boolean interrupted = false;
    
    	protected FileWatchdog(String filename) {
    		super("FileWatchdog");
    		this.filename = filename;
    		file = new File(filename);
    		setDaemon(true);
    		checkAndConfigure();
    	}
    
    	/**
    	 * Set the delay to observe between each check of the file changes.
    	 */
    	public void setDelay(long delay) {
    		this.delay = delay;
    	}
    
    	abstract protected void doOnChange();
    
    	protected void checkAndConfigure() {
    		boolean fileExists;
    		try {
    			fileExists = file.exists();
    		} catch (SecurityException e) {
    			LogLog.warn("Was not allowed to read check file existance, file:["
    					+ filename + "].");
    			interrupted = true; // there is no point in continuing
    			return;
    		}
    
    		if (fileExists) {
    			long l = file.lastModified(); // this can also throw a
    											// SecurityException
    			if (l > lastModif) { // however, if we reached this point this
    				lastModif = l; // is very unlikely.
    				doOnChange();
    				warnedAlready = false;
    			}
    		} else {
    			if (!warnedAlready) {
    				LogLog.debug("[" + filename + "] does not exist.");
    				warnedAlready = true;
    			}
    		}
    	}
    
    	public void run() {
    		while (!interrupted) {
    			try {
    				Thread.sleep(delay);
    			} catch (InterruptedException e) {
    				// no interruption expected
    			}
    			checkAndConfigure();
    		}
    	}
    }
    

     

      这是一个抽象类,子类只要实现最关心的文件内容有变化的回调方法 doOnChange 就OK。

     

      因此,在一个工程中,如果想实现模块级别的日志控制,则我们可以附件一个配置文件,在这个配置文件中指定模块的日志级别, 在log4j中指定总的级别,然后在应用中实现文件内容监控,则可以做到动态切换,实现细粒度的控制。

     

     

    展开全文
  • 有时候,我们需要确定某些文件是否有变化而做出一些对应的动作,例如,曾经开发的一款服务器中,由于模块比较多,在运行期间有时候需要单独的输出某个模块日志,但又不可能总是开着日志。log4j中已经实现了可以动态...

    有时候,我们需要确定某些文件是否有变化而做出一些对应的动作,例如,曾经开发的一款服务器中,由于模块比较多,在运行期间有时候需要单独的输出某个模块日志,但又不可能总是开着日志。

    log4j中已经实现了可以动态监控日志级别日志监视器

    PropertyConfigurator.configureAndWatch(properties);

    上面的properties是日志配置文件,例如常用的 log4j.properties ,log4j.xml。

    但是这是系统级别的,然后看了一下源代码,

    /*

    * Licensed to the Apache Software Foundation (ASF) under one or more

    * contributor license agreements. See the NOTICE file distributed with

    * this work for additional information regarding copyright ownership.

    * The ASF licenses this file to You under the Apache License, Version 2.0

    * (the "License"); you may not use this file except in compliance with

    * the License. You may obtain a copy of the License at

    *

    * http://www.apache.org/licenses/LICENSE-2.0

    *

    * Unless required by applicable law or agreed to in writing, software

    * distributed under the License is distributed on an "AS IS" BASIS,

    * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

    * See the License for the specific language governing permissions and

    * limitations under the License.

    */

    // Contributors: Mathias Bogaert

    package org.apache.log4j.helpers;

    import java.io.File;

    /**

    * Check every now and then that a certain file has not changed. If it has, then

    * call the {@link #doOnChange} method.

    *

    * @author Ceki Gülcü

    * @since version 0.9.1

    */

    public abstract class FileWatchdog extends Thread {

    /**

    * The default delay between every file modification check, set to 60

    * seconds.

    */

    static final public long DEFAULT_DELAY = 60000;

    /**

    * The name of the file to observe for changes.

    */

    protected String filename;

    /**

    * The delay to observe between every check. By default set

    * {@link #DEFAULT_DELAY}.

    */

    protected long delay = DEFAULT_DELAY;

    File file;

    long lastModif = 0;

    boolean warnedAlready = false;

    boolean interrupted = false;

    protected FileWatchdog(String filename) {

    super("FileWatchdog");

    this.filename = filename;

    file = new File(filename);

    setDaemon(true);

    checkAndConfigure();

    }

    /**

    * Set the delay to observe between each check of the file changes.

    */

    public void setDelay(long delay) {

    this.delay = delay;

    }

    abstract protected void doOnChange();

    protected void checkAndConfigure() {

    boolean fileExists;

    try {

    fileExists = file.exists();

    } catch (SecurityException e) {

    LogLog.warn("Was not allowed to read check file existance, file:["

    + filename + "].");

    interrupted = true; // there is no point in continuing

    return;

    }

    if (fileExists) {

    long l = file.lastModified(); // this can also throw a

    // SecurityException

    if (l > lastModif) { // however, if we reached this point this

    lastModif = l; // is very unlikely.

    doOnChange();

    warnedAlready = false;

    }

    } else {

    if (!warnedAlready) {

    LogLog.debug("[" + filename + "] does not exist.");

    warnedAlready = true;

    }

    }

    }

    public void run() {

    while (!interrupted) {

    try {

    Thread.sleep(delay);

    } catch (InterruptedException e) {

    // no interruption expected

    }

    checkAndConfigure();

    }

    }

    }

    这是一个抽象类,子类只要实现最关心的文件内容有变化的回调方法 doOnChange 就OK。

    因此,在一个工程中,如果想实现模块级别的日志控制,则我们可以附件一个配置文件,在这个配置文件中指定模块的日志级别, 在log4j中指定总的级别,然后在应用中实现文件内容监控,则可以做到动态切换,实现细粒度的控制。

    展开全文
  • 有时候,我们需要确定某些文件是否有变化而做出一些对应的动作,例如,曾经开发的一款服务器中,由于模块比较多,在运行期间有时候需要单独的输出某个模块日志,但又不可能总是开着日志。log4j中已经实现了可以动态...

    有时候,我们需要确定某些文件是否有变化而做出一些对应的动作,例如,曾经开发的一款服务器中,由于模块比较多,在运行期间有时候需要单独的输出某个模块日志,但又不可能总是开着日志。

    log4j中已经实现了可以动态监控日志级别日志监视器

    PropertyConfigurator.configureAndWatch(properties);

    上面的properties是日志配置文件,例如常用的 log4j.properties ,log4j.xml。

    但是这是系统级别的,然后看了一下源代码,

    /*

    * Licensed to the Apache Software Foundation (ASF) under one or more

    * contributor license agreements. See the NOTICE file distributed with

    * this work for additional information regarding copyright ownership.

    * The ASF licenses this file to You under the Apache License, Version 2.0

    * (the "License"); you may not use this file except in compliance with

    * the License. You may obtain a copy of the License at

    *

    * http://www.apache.org/licenses/LICENSE-2.0

    *

    * Unless required by applicable law or agreed to in writing, software

    * distributed under the License is distributed on an "AS IS" BASIS,

    * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

    * See the License for the specific language governing permissions and

    * limitations under the License.

    */

    // Contributors: Mathias Bogaert

    package org.apache.log4j.helpers;

    import java.io.File;

    /**

    * Check every now and then that a certain file has not changed. If it has, then

    * call the {@link #doOnChange} method.

    *

    * @author Ceki Gülcü

    * @since version 0.9.1

    */

    public abstract class FileWatchdog extends Thread {

    /**

    * The default delay between every file modification check, set to 60

    * seconds.

    */

    static final public long DEFAULT_DELAY = 60000;

    /**

    * The name of the file to observe for changes.

    */

    protected String filename;

    /**

    * The delay to observe between every check. By default set

    * {@link #DEFAULT_DELAY}.

    */

    protected long delay = DEFAULT_DELAY;

    File file;

    long lastModif = 0;

    boolean warnedAlready = false;

    boolean interrupted = false;

    protected FileWatchdog(String filename) {

    super("FileWatchdog");

    this.filename = filename;

    file = new File(filename);

    setDaemon(true);

    checkAndConfigure();

    }

    /**

    * Set the delay to observe between each check of the file changes.

    */

    public void setDelay(long delay) {

    this.delay = delay;

    }

    abstract protected void doOnChange();

    protected void checkAndConfigure() {

    boolean fileExists;

    try {

    fileExists = file.exists();

    } catch (SecurityException e) {

    LogLog.warn("Was not allowed to read check file existance, file:["

    + filename + "].");

    interrupted = true; // there is no point in continuing

    return;

    }

    if (fileExists) {

    long l = file.lastModified(); // this can also throw a

    // SecurityException

    if (l > lastModif) { // however, if we reached this point this

    lastModif = l; // is very unlikely.

    doOnChange();

    warnedAlready = false;

    }

    } else {

    if (!warnedAlready) {

    LogLog.debug("[" + filename + "] does not exist.");

    warnedAlready = true;

    }

    }

    }

    public void run() {

    while (!interrupted) {

    try {

    Thread.sleep(delay);

    } catch (InterruptedException e) {

    // no interruption expected

    }

    checkAndConfigure();

    }

    }

    }

    这是一个抽象类,子类只要实现最关心的文件内容有变化的回调方法 doOnChange 就OK。

    因此,在一个工程中,如果想实现模块级别的日志控制,则我们可以附件一个配置文件,在这个配置文件中指定模块的日志级别, 在log4j中指定总的级别,然后在应用中实现文件内容监控,则可以做到动态切换,实现细粒度的控制。

    分享到:

    18e900b8666ce6f233d25ec02f95ee59.png

    72dd548719f0ace4d5f9bca64e1d7715.png

    2012-06-21 14:55

    浏览 10938

    评论

    1 楼

    liushilang

    2012-11-07

    很好,轮廓写出来了,具体要做什么doChanage()就得自己去实现了,谢谢

    展开全文
  • Apacha common.io2.0提供了监听文件变化的功能。 功能由三个组件组成。 监听器 FileAlterationListener 用于实现文件改变时触发的行为。 观察者 FileAlterationObserver 用于观察文件的改变,通知注册的监听器执行...

    48304ba5e6f9fe08f3fa1abda7d326ab.png

    package com.jp.filemonitor;

    import org.apache.log4j.helpers.FileWatchdog;

    public class Log4jWatchdog {

    public static void main(String[] args) {

    GloablConfig gloablConfig = new GloablConfig("D:\\create_lo\\text.txt");

    gloablConfig.setDelay(10000);

    gloablConfig.start();

    while (true) {

    try {

    Thread.sleep(10000);

    } catch (InterruptedException e) {

    // TODO Auto-generated catch block

    e.printStackTrace();

    }

    }

    }

    public static class GloablConfig extends FileWatchdog{

    protected GloablConfig(String filename) {

    super(filename);

    }

    @Override

    protected void doOnChange() {

    System.out.println(filename);

    }

    }

    }

    48304ba5e6f9fe08f3fa1abda7d326ab.png

    2.common-io实现的文件夹变化的监听

    这代码网上很多,可以搜索关键字FileAlterationMonitor,FileAlterationObserver  FileAlterationObserver,这样就可以看到示例代码了。

    Apacha common.io2.0提供了监听文件变化的功能。

    功能由三个组件组成。

    监听器 FileAlterationListener

    用于实现文件改变时触发的行为。

    观察者 FileAlterationObserver

    用于观察文件的改变,通知注册的监听器执行相应的事件。

    监视器 FileAlterationMonitor

    通过一线程,每间隔一段时间调用一次注册的观察者检查文件。

    maven依赖

    commons-io

    commons-io

    2.4

    FileAlterationListener

    通过继承FileAlterationListenerAdaptor,覆盖相应事件方法。这里只重写了文件改变。还有其他事件可以查看FileAlterationListener接口看下。

    public class FileAlterationReload extendsFileAlterationListenerAdaptor {

    @Overridepublic voidonFileChange(File file) {

    System.out.println("文件改变");

    }

    }

    程序实现

    public classDemo {public static void main(String[] args) throwsException {//检查classpath下properties文件夹下的properties文件。

    FileAlterationObserver fileAlterationObserver = new FileAlterationObserver(Demo.class.getClassLoader().getResource("properties").getPath(),newPropertiesFileFilter());

    FileAlterationListener fileAlterationListener=newFileAlterationReload();//注册监听器

    fileAlterationObserver.addListener(fileAlterationListener);

    FileAlterationMonitor fileAlterationMonitor= newFileAlterationMonitor();//注册观察者

    fileAlterationMonitor.addObserver(fileAlterationObserver);//启动监听

    fileAlterationMonitor.start();//让主线程别这么快结束。

    Thread.sleep(1000000);

    }

    }

    修改properties文件夹下的properties文件时,会输出 文件改变。

    应用场景

    可以用于实现配置文件的热部署

    例子:

    3.nio实现文件夹内容变化的监听

    48304ba5e6f9fe08f3fa1abda7d326ab.png

    package com.jp.filemonitor;

    import java.io.IOException;

    import java.nio.file.FileSystems;

    import java.nio.file.Path;

    import java.nio.file.Paths;

    import java.nio.file.StandardWatchEventKinds;

    import java.nio.file.WatchEvent;

    import java.nio.file.WatchKey;

    import java.nio.file.WatchService;

    import java.util.List;

    import java.util.concurrent.ExecutorService;

    import java.util.concurrent.Executors;

    public class ResourceListener {

    private static ExecutorService fixedThreadPool = Executors.newCachedThreadPool();

    private WatchService ws;

    private String listenerPath;

    private ResourceListener(String path) {

    try {

    ws = FileSystems.getDefault().newWatchService();

    this.listenerPath = path;

    start();

    } catch (IOException e) {

    e.printStackTrace();

    }

    }

    private void start() {

    fixedThreadPool.execute(new Listner(ws,this.listenerPath));

    }

    public static void addListener(String path) throws IOException {

    ResourceListener resourceListener = new ResourceListener(path);

    Path p = Paths.get(path);

    p.register(resourceListener.ws,StandardWatchEventKinds.ENTRY_MODIFY,

    StandardWatchEventKinds.ENTRY_DELETE,

    StandardWatchEventKinds.ENTRY_CREATE);

    }

    public static void main(String[] args) throws IOException {

    ResourceListener.addListener("F:\\");

    ResourceListener.addListener("d:\\");

    }

    }

    class Listner implements Runnable {

    private WatchService service;

    private String rootPath;

    public Listner(WatchService service,String rootPath) {

    this.service = service;

    this.rootPath = rootPath;

    }

    public void run() {

    try {

    while(true){

    WatchKey watchKey = service.take();

    List> watchEvents = watchKey.pollEvents();

    for(WatchEvent> event : watchEvents){

    //TODO 根据事件类型采取不同的操作。。。。。。。

    System.out.println("["+rootPath+event.context()+"]文件发生了["+event.kind()+"]事件"+ event.count());

    }

    watchKey.reset();

    }

    } catch (InterruptedException e) {

    e.printStackTrace();

    }finally{

    System.out.println("fdsfsdf");

    try {

    service.close();

    } catch (IOException e) {

    e.printStackTrace();

    }

    }

    }

    }

    48304ba5e6f9fe08f3fa1abda7d326ab.png

    展开全文
  • 1.log4j的实现的文件内容变化监听 package com.jp.filemonitor; import org.apache.log4j.helpers.FileWatchdog; public class Log4jWatchdog { public static void main(String[] args) { ...
  • 我们在做数据接入或者文件解析的时候,...可以监听的文件信息包括文件夹/文件创建文件夹/文件删除文件夹/文件修改 (文件内容被修改和文件夹被修改都可以检测到)文件夹/文件重命名使用Java实现导入maven依赖net.co...
  • 1.log4j的实现的文件内容变化监听 package com.jp.filemonitor; import org.apache.log4j.helpers.FileWatchdog; public class Log4jWatchdog { public static void main(String[] args) { .....
  • 最近公司的一个任务需要实时监控文件系统中某个文件内容变化。由于程序本身由Java编写,因此使用了inotify- java(http://code.google.com/p/inotify-java/)。inotify-java只是对Linux中 inotify相关的内核调用...
  • java实现监听文件

    2020-07-06 15:37:26
    Tailer类的主要作用是采用线程的方式去监控日志文件的内容,简单的理解就是文件内容的跟随器,当文件内容发生变化时它就能捕获到新增内容的信息,可以理解为我们在linux服务器中常用的“tail -f”命令。 2、...
  • //1、log4j实现文件内容变化监听 //1、log4j实现文件内容变化监听 package com.wxy_beijing; import org.apache.log4j.helpers.FileWatchdog; public class Test_Log4jWatchdog { public static void ...
  • 最近由于项目需要,程序在首次运行时会加载配置文件并读取内存,形成一个常量。...//1、log4j实现文件内容变化监听 package com.wxy_beijing; import org.apache.log4j.helpers.FileWatchdog; public class Test_Lo
  • binlog 就是binary log,二进制...我们时常会碰到这样的需求,就是要监听某个表的变化,然后来做一些操作。如果该表数据只增加、不删除修改的话,要监听比较简单,可以定时去查询最新的id即可。但要有删除、修改操作...
  • java监听器的内容

    2019-07-19 11:06:09
    用于监听三种作用域对象的创建销毁及其属性修改发生变化的事件 在事件发生的前后进行一些处理的操作 就是实现servlet规范的接口,并在类中实现代码 应用场景: 统计在线人数 页面访问量的统计 应用启动时完成信息...
  • Flume安装 下载Flume安装包 ...修改配置文件 将flume-conf.properties.template、flume-env.ps1.template、flume-env.sh.template的.template后缀删除 修改内容 flume-env.sh export JAVA_HOME=D:/softs/Java/jdk1
  • java文件监听的实现(1)

    千次阅读 2013-12-23 20:57:49
    平时能用到文件的监听,通过文件的变化实现对文件内容的处理,多了不说。看下面代码,很容易看懂。(包没有引用) public class FileObserverDemo extends FileObserver { /** 监听事件 */ public static int CHANGES...
  • 在平时的开发过程中,会有很多场景需要实时监听文件变化,如下: 1、通过实时监控 mysql 的 binlog 日志实现数据同步 2、修改配置文件后,希望系统可以实时感知 3、应用系统将日志写入文件中,日志监控系统可以...
  • java---文件监听器、文件夹监听器 检测到文件夹更新,则更新缓存内容 */ public class FileListener extends FileAlterationListenerAda...
  • 应用场景:代码可以实现文件变化后的监听,如文件变化,自动重新加载文件内容,实现配置文件的热部署。代码:package com.yx.demo.filemonitor;import java.io.File;import java.lang.ref.WeakReference;import java...
  • 应用场景:代码可以实现文件变化后的监听,如文件变化,自动重新加载文件内容,实现配置文件的热部署。代码:package com.yx.demo.filemonitor;import java.io.File;import java.lang.ref.WeakReference;import java...
  • Java实现文件监控器FileMonitor发布时间:2020-08-09 16:59:29来源:ITPUB博客阅读:68作者:ckxllf应用场景:代码可以实现文件变化后的监听,如文件变化,自动重新加载文件内容,实现配置文件的热部署。代码:...
  • AbstractCursor.java文件/** *Thisisanabstractcursorclassthathandlesalotofthecommoncode *thatallcursorsneedtodealwithandisprovidedforconveniencereasons. */...
  • java源码包---java 源码 大量 实例

    千次下载 热门讨论 2013-04-18 23:15:26
     用JAVA开发的一个小型的目录监视系统,系统会每5秒自动扫描一次需要监视的目录,可以用来监视目录中文件大小及文件增减数目的变化Java日期选择控件完整源代码 14个目标文件 内容索引:JAVA源码,系统相关,日历,...
  • TextField中内容发生变化后自动更新到label中,需要监听UITextField控件变化的事件,即当UITextField中内容发生变化时立即更新到UILable控件。 1)修改ViewController.h,添加操作 [code="java"]-...
  • java源码包2

    千次下载 热门讨论 2013-04-20 11:28:17
     用JAVA开发的一个小型的目录监视系统,系统会每5秒自动扫描一次需要监视的目录,可以用来监视目录中文件大小及文件增减数目的变化Java日期选择控件完整源代码 14个目标文件 内容索引:JAVA源码,系统相关,日历...
  • Java问题排查工具单

    2020-04-20 16:58:28
    tail tail -f filename 会把 filename 文件里的最尾部的...展示倒数300行并实时监听文件内容变化 tail -300f shopbase.log grep 查找文件里符合条件的字符串 grep test f.txt 在文件f.txt中搜索test关键字 grep -...
  • 监听配置文件变化,实时读取读取配置文件内容 读取环境变量值 读取远程配置系统 (etcd Consul) 和监控配置变化 读取命令 Flag 值 读取 buffer 值 读取确切值 乍一看,未免有相见恨晚之感,可仔细一想,不免...

空空如也

空空如也

1 2 3 4 5
收藏数 88
精华内容 35
关键字:

java监听文件内容变化

java 订阅