精华内容
下载资源
问答
  • java监测文件变化

    2019-05-01 01:21:20
    NULL 博文链接:https://pengfeifei26.iteye.com/blog/2373564
  • 本篇文章主要介绍了Java利用WatchService监听文件变化示例,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • Java实现监听文件变化的监听器

    万次阅读 2019-01-05 16:52:09
    3、自己封装的监听器类,构造函数需要给出 监听文件目录,监听文件的类型,事件处理类对象等 package com.zane.hotupdateFiles; import org.apache.commons.io.filefilter.FileFilterUtils; import org.apache...

    1、准备 commons-io 2.0 以上版本Jar包,这里我才用 Maven 库依赖

    <dependency>
    	<groupId>commons-io</groupId>
    	<artifactId>commons-io</artifactId>
    	<version>2.4</version>
    </dependency>

    2、实现 FileAlterationListenerAdaptor 的自定义类,用来处理文件变动事件,我这里只是简单实现,可参考

    package com.zane.hotupdateFiles;
    
    import java.io.File;
    
    import org.apache.commons.io.monitor.FileAlterationListenerAdaptor;
    import org.apache.commons.io.monitor.FileAlterationObserver;
    
    /***
     * 文件变动事件处理器类
     * @author Zane
     * @Time 2019年1月5日 上午11:03:35
     */
    public class MyFileListenerAdaptor extends FileAlterationListenerAdaptor{
    	
    	@Override
    	public void onFileChange(File file) {
    		System.out.println("change.............");
    		super.onFileChange(file);
    	}
    	
    	@Override
    	public void onStart(FileAlterationObserver observer) {
    		System.out.println("start");
    		super.onStart(observer);
    	}
    	
    	@Override
    	public void onStop(FileAlterationObserver observer) {
    		System.out.println("stop");
    		super.onStop(observer);
    	}
    	
    	@Override
    	public void onDirectoryChange(File directory) {
    		System.out.println("dir change.........");
    		super.onDirectoryChange(directory);
    	}
    	
    	@Override
    	public void onDirectoryCreate(File directory) {
    		System.out.println("dir create.........");
    		super.onDirectoryCreate(directory);
    	}
    	
    	@Override
    	public void onDirectoryDelete(File directory) {
    		System.out.println("dir delete.........");
    		super.onDirectoryCreate(directory);
    	}
    }
    

    3、自己封装的监听器类,构造函数需要给出 监听文件目录,监听文件的类型,事件处理类对象等

    package com.zane.hotupdateFiles;
    
    import org.apache.commons.io.filefilter.FileFilterUtils;
    import org.apache.commons.io.monitor.FileAlterationListenerAdaptor;
    import org.apache.commons.io.monitor.FileAlterationMonitor;
    import org.apache.commons.io.monitor.FileAlterationObserver;
    
    /***
     * 自定义文件监视器,可用来实现热更配置文件/监听文件场景
     * @author Zane
     * @Time 2019年1月5日 上午10:41:12
     */
    public class MyFileAlterationMonitor {
    	
    	private String path;		// 文件夹目录
    	
    	private String fileSuffix;	// 需要监听的文件名后缀
    	
    	private long interval;		// 监听间隔
    	
    	private static final long DEFAULT_INTERVAL = 10 * 1000; // 默认监听间隔10s
    	
    	private FileAlterationListenerAdaptor listener;	// 事件处理类对象
    	
    	public MyFileAlterationMonitor(){
    		this.interval = DEFAULT_INTERVAL;
    	}
    	
    	public MyFileAlterationMonitor(String path, String fileSuffix, FileAlterationListenerAdaptor listenerAdaptor){
    		this.path = path;
    		this.fileSuffix = fileSuffix;
    		this.interval = DEFAULT_INTERVAL;
    		this.listener = listenerAdaptor;
    	}
    	
    	public MyFileAlterationMonitor(String path, String fileSuffix, long interval, FileAlterationListenerAdaptor listenerAdaptor) {
    		this.path = path;
    		this.fileSuffix = fileSuffix;
    		this.interval = interval;
    		this.listener = listenerAdaptor;
    	}
    	
    	/***
    	 * 开启监听
    	 */
    	public void start() {
    		if(path==null) {
    			throw new IllegalStateException("Listen path must not be null");
    		}
    		if(listener==null) {
    			throw new IllegalStateException("Listener must not be null");
    		}
    		
    		// 设定观察者,监听.properties文件
    		FileAlterationObserver observer = new FileAlterationObserver(path,
    				FileFilterUtils.suffixFileFilter(fileSuffix));
    
    		// 给观察者添加监听事件
    		observer.addListener(listener);
    		
    		// 开启一个监视器,监听频率是5s一次
    		// FileAlterationMonitor本身实现了 Runnable,是单独的一个线程,按照设定的时间间隔运行,默认间隔是 10s
    		FileAlterationMonitor monitor = new FileAlterationMonitor(interval);
    
    		monitor.addObserver(observer);
    
    		try {
    			monitor.start();
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    	}
    	
    	public void setPath(String path) {
    		this.path = path;
    	}
    	
    	public void setFileSuffix(String fileSuffix) {
    		this.fileSuffix = fileSuffix;
    	}
    
    	public void setAdaptor(FileAlterationListenerAdaptor listenerAdaptor) {
    		this.listener = listenerAdaptor;
    	}
    }
    

    最后进行测试

    测试代码如下,监听 properties 资源文件夹下的 .properties 文件:

    public class Test {
    	public static void main(String[] args) {
    		MyFileAlterationMonitor monitor = new MyFileAlterationMonitor(
    				Test.class.getClassLoader().getResource("properties").getPath(), 
    				".properties", 
    				new MyFileListenerAdaptor());
    		monitor.start();
    	}
    }

    测试结果:

    start
    stop
    start
    stop
    start
    change.............
    stop
    start
    stop
    start
    stop
    start
    stop
    

    结果分析:

    1、监听器本身会启动一个线程定时处理,相当于一个定时器

    2、每次运行时,都会先调用事件监听处理类的 onStart 方法,然后检查是否有变动,并调用对应事件的方法,如 onChange 文件内容改变,检查完后,再调用 onStop 方法,释放当前线程占用的CPU资源,等待下次间隔时间到了被再次唤醒运行。

    3、使用该方法,可以实现项目配置文件的热更,以及在需要监控文件的应用场景下使用

    展开全文
  • Java监听文件变化

    千次阅读 2018-09-18 14:06:00
    package com.aliyun.FileLinster... import java.io.File; import java.io.IOException; import java.nio.file.FileSystems; import java.nio.file.Path; import java.nio.file.Paths; import java.nio.file...
    package com.aliyun.FileLinster;
    
    import java.io.File;
    import java.io.IOException;
    import java.nio.file.FileSystems;
    import java.nio.file.Path;
    import java.nio.file.Paths;
    import java.nio.file.WatchEvent;
    import java.nio.file.WatchKey;
    import java.nio.file.WatchService;
    import static java.nio.file.StandardWatchEventKinds.*;
    
    public class Sample {
    
        private WatchService watcher;
    
        private Path path;
    
        public Sample(Path path) throws IOException {
            this.path = path;
            watcher = FileSystems.getDefault().newWatchService();
            this.path.register(watcher, OVERFLOW, ENTRY_CREATE, ENTRY_DELETE, ENTRY_MODIFY);
        }
    
        public void handleEvents() throws InterruptedException {
            // start to process the data files
            while (true) {
                // start to handle the file change event
                final WatchKey key = watcher.take();
    
                for (WatchEvent<?> event : key.pollEvents()) {
                    // get event type
                    final WatchEvent.Kind<?> kind = event.kind();
    
                    // get file name
                    @SuppressWarnings("unchecked")
                    final WatchEvent<Path> pathWatchEvent = (WatchEvent<Path>) event;
                    final Path fileName = pathWatchEvent.context();
    
                    if (kind == ENTRY_CREATE) {
    
                        System.out.println("ENTRY_CREATE");
                        // 说明点1
                        // create a new thread to monitor the new file
                        new Thread(new Runnable() {
                            public void run() {
                                File file = new File(path.toFile().getAbsolutePath() + "/" + fileName);
                                boolean exist;
                                long size = 0;
                                long lastModified = 0;
                                int sameCount = 0;
                                while (exist = file.exists()) {
                                    // if the 'size' and 'lastModified' attribute keep same for 3 times,
                                    // then we think the file was transferred successfully
                                    if (size == file.length() && lastModified == file.lastModified()) {
                                        if (++sameCount >= 3) {
                                            break;
                                        }
                                    } else {
                                        size = file.length();
                                        lastModified = file.lastModified();
                                    }
                                    try {
                                        Thread.sleep(500);
                                    } catch (InterruptedException e) {
                                        return;
                                    }
                                }
                                // if the new file was cancelled or deleted
                                if (!exist) {
                                    return;
                                } else {
    
                                } 
                            }
                        }).start();
                    } else if (kind == ENTRY_DELETE) {
                        System.out.println("ENTRY_DELETE");
                    } else if (kind == ENTRY_MODIFY) {
                        System.out.println("ENTRY_MODIFY");
                    } else if (kind == OVERFLOW) {
                        System.out.println("OVERFLOW");
                    }
                }
    
                // IMPORTANT: the key must be reset after processed
                if (!key.reset()) {
                    return;
                }
            }
        }
    
        public static void main(String args[]) throws IOException, InterruptedException {
            new Sample(Paths.get("D:\\T")).handleEvents();
        }
    }
    

      

    转载于:https://www.cnblogs.com/minglie/p/Sample.html

    展开全文
  • 本文中主要陈述一种实时监听文件夹中是否有文件增加的功能,可用于实际文件上传功能的开发。本文通过实例代码给大家介绍的非常详细,具有一定的参考借鉴价值,需要的朋友参考下吧
  • 今天小编就为大家分享一篇关于Java实现实时监控目录下文件变化的方法,小编觉得内容挺不错的,现在分享给大家,具有很好的参考价值,需要的朋友一起跟随小编来看看吧
  • java 监听文件或者文件夹变化的几种方式 1.log4j的实现的文件内容变化监听 package com.jp.filemonitor; import org.apache.log4j.helpers.FileWatchdog; public class Log4jWatchdog { public static void main...

    java 监听文件或者文件夹变化的几种方式

    1.log4j的实现的文件内容变化监听

    复制代码
    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();
                }
    
        }
    }
    </span><span style="color: #0000ff;">public</span> <span style="color: #0000ff;">static</span> <span style="color: #0000ff;">class</span> GloablConfig <span style="color: #0000ff;">extends</span><span style="color: #000000;"> FileWatchdog{
        </span><span style="color: #0000ff;">protected</span><span style="color: #000000;"> GloablConfig(String filename) {
            </span><span style="color: #0000ff;">super</span><span style="color: #000000;">(filename);
        }
    
        @Override
        </span><span style="color: #0000ff;">protected</span> <span style="color: #0000ff;">void</span><span style="color: #000000;"> doOnChange() {
            
            System.out.println(filename);
        }
        
    }
    

    }

    复制代码

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

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

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

    复制代码
    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();
    }
    }

    </span><span style="color: #0000ff;">private</span> <span style="color: #0000ff;">void</span><span style="color: #000000;"> start() {
        fixedThreadPool.execute(</span><span style="color: #0000ff;">new</span> Listner(ws,<span style="color: #0000ff;">this</span><span style="color: #000000;">.listenerPath));
    }
    
    </span><span style="color: #0000ff;">public</span> <span style="color: #0000ff;">static</span> <span style="color: #0000ff;">void</span> addListener(String path) <span style="color: #0000ff;">throws</span><span style="color: #000000;"> IOException {
        ResourceListener resourceListener </span>= <span style="color: #0000ff;">new</span><span style="color: #000000;"> ResourceListener(path);
        Path p </span>=<span style="color: #000000;"> Paths.get(path);
        p.register(resourceListener.ws,StandardWatchEventKinds.ENTRY_MODIFY,
            StandardWatchEventKinds.ENTRY_DELETE,
            StandardWatchEventKinds.ENTRY_CREATE);
    }
    
    
    </span><span style="color: #0000ff;">public</span> <span style="color: #0000ff;">static</span> <span style="color: #0000ff;">void</span> main(String[] args) <span style="color: #0000ff;">throws</span><span style="color: #000000;"> IOException {
        ResourceListener.addListener(</span>"F:\\"<span style="color: #000000;">);
        ResourceListener.addListener(</span>"d:\\"<span style="color: #000000;">);
    }
    

    }

    class Listner implements Runnable {
    private WatchService service;
    private String rootPath;

    </span><span style="color: #0000ff;">public</span><span style="color: #000000;"> Listner(WatchService service,String rootPath) {
        </span><span style="color: #0000ff;">this</span>.service =<span style="color: #000000;"> service;
        </span><span style="color: #0000ff;">this</span>.rootPath =<span style="color: #000000;"> rootPath;
    }
    
    </span><span style="color: #0000ff;">public</span> <span style="color: #0000ff;">void</span><span style="color: #000000;"> run() {
        </span><span style="color: #0000ff;">try</span><span style="color: #000000;"> {
            </span><span style="color: #0000ff;">while</span>(<span style="color: #0000ff;">true</span><span style="color: #000000;">){
                WatchKey watchKey </span>=<span style="color: #000000;"> service.take();
                List</span>&lt;WatchEvent&lt;?&gt;&gt; watchEvents =<span style="color: #000000;"> watchKey.pollEvents();
                </span><span style="color: #0000ff;">for</span>(WatchEvent&lt;?&gt;<span style="color: #000000;"> event : watchEvents){
                
                    </span><span style="color: #008000;">//</span><span style="color: #008000;">TODO 根据事件类型采取不同的操作。。。。。。。</span>
                    System.out.println("["+rootPath+event.context()+"]文件发生了["+event.kind()+"]事件"+<span style="color: #000000;">    event.count());  
                }
                watchKey.reset();
            }
        } </span><span style="color: #0000ff;">catch</span><span style="color: #000000;"> (InterruptedException e) {
            e.printStackTrace();
        }</span><span style="color: #0000ff;">finally</span><span style="color: #000000;">{
            System.out.println(</span>"fdsfsdf"<span style="color: #000000;">);
            </span><span style="color: #0000ff;">try</span><span style="color: #000000;"> {
                service.close();
            } </span><span style="color: #0000ff;">catch</span><span style="color: #000000;"> (IOException e) {
                e.printStackTrace();
            }
        }
        
    }
    

    }

    复制代码

     

    0
    0
    « 上一篇: 2016年国内开源maven镜像站点汇总
    » 下一篇: mybatis中GenericTokenParser的用法

    posted on 2016-09-02 09:18 xunianchong 阅读(5562) 评论(0) 编辑 收藏

    展开全文
  • java8实现一个文件目录的监听,目录中文件创建、修改、删除等操作
  • Java7对NIO进行了大的改进,新增了许多功能,接下来通过本文给大家介绍Java NIO.2 使用Path接口来监听文件、文件夹变化 ,需要的朋友可以参考下
  • 本篇文章主要介绍了Java可以如何实现文件变动的监听的示例,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 我们通常会遇到这样的需求,修改配置文件后不需要重启项目即可生效,此时我们需要去监听配置文件是否有被修改,如果发现被修改,那么我们即可重新加载配置文件。 public class Doctor { private static final ...

    我们通常会遇到这样的需求,修改配置文件后不需要重启项目即可生效,此时我们需要去监听配置文件是否有被修改,如果发现被修改,那么我们即可重新加载配置文件。

    public class Doctor {
    
    	private static final Logger LOGGER = Logger.getLogger(Doctor.class);
    
    	// update flag
    	protected static long lastModifiedDate = -1;
    
    	public static Properties PROPERTIES = new Properties();
    
    	public static void updateDoctor() {
    		new Thread(() -> {
    			try {
    				File file = new File=("F:\\doctor.properties");
    				while (true) {
    					try {
    						//如果时间戳不相等说明文件发生了修改
    						if (lastModifiedDate != file.lastModified()) {
    							//重新加载文件
    							try (FileInputStream fileInputStream = new FileInputStream(file);) {
    								PROPERTIES.load(fileInputStream);
    								//执行业务操作
    							}
    							lastModifiedDate = file.lastModified();
    						}
    					} catch (IOException e) {
    						LOGGER.error(e);
    					}
    
    					try {
    						//监听的时间间隔设置为1秒
    						Thread.sleep(1000);
    					} catch (InterruptedException e) {
    						LOGGER.error(e);
    					}
    				}
    			} catch (IOException e1) {
    				LOGGER.error(e1);
    			}
    		}).start();
    	}
    }
    

    我们只需在项目启动后调用该方法Doctor.updateDoctor();

    展开全文
  • JAVA 项目监听文件是否发生变化

    千次阅读 2016-08-05 15:01:49
    3、添加文件监听 FileMonitor、FileListener 可看资料  commons-io-2.4 package com.luwen.dai; import java.io.File; import org.apache.commons.io.monitor.FileAlterationListener; import org....
  • 程序完全基于jvm自有jar包实现,单java文件就可执行,轻量,如果想要做其他的日志处理,比如保存mysql,日志备份等,只需要实现LogProcessing接口即可,方便可扩展。 我这里是直接获取日志之后做了个转发。...
  • 基于springboot的文件夹监听和遗漏文件自动获取功能以及springboot编译的直接可运行的bat文件
  • JAVA实时监控目录下文件变化

    万次阅读 2017-12-16 14:57:06
    一、commons-io方法1、使用Commons-io的monitor下的相关类可以处理对文件进行监控,它采用的是...(4)采用线程去定时去刷新检测文件变化情况 2、引入commons-io包,需要2.0以上。<!-- https://mvnrepository.com/
  • 最近公司的一个任务需要实时监控文件系统中某个文件内容变化。由于程序本身由Java编写,因此使用了inotify- java(http://code.google.com/p/inotify-java/)。inotify-java只是对Linux中 inotify相关的内核调用...
  • java实现监听文件

    2020-07-06 15:37:26
    监听文件是否添加 当前项目需要读取日志信息,向监听日志更新的动态。 用线程的方式来监控log日志文件 我们首先要了解以下这三个类 1、Tailer类 Tailer类的主要作用是采用线程的方式去监控日志文件的内容,简单的...
  • 最近由于项目需要,程序在首次运行时会加载配置文件并读取内存,形成一个常量。...//1、log4j实现文件内容变化监听 package com.wxy_beijing; import org.apache.log4j.helpers.FileWatchdog; public class Test_Lo
  • Java目录监视器源程序 9个目标文件 内容索引:JAVA源码,综合应用,目录监视 用JAVA开发的一个小型的目录监视系统,系统会每5秒自动扫描一次需要监视的目录,可以用来监视目录中文件大小及文件增减数目的变化。...
  • Java可以如何实现文件变动的监听

    千次阅读 2018-02-08 19:23:19
    Java可以如何实现文件变动的监听 应用中使用logback作为日志输出组件的话,大部分会去配置 logback.xml 这个文件,而且生产环境下,直接去修改logback.xml文件中的日志级别,不用重启应用就可以生效 那么,这个...
  • //1、log4j实现文件内容变化监听 //1、log4j实现文件内容变化监听 package com.wxy_beijing; import org.apache.log4j.helpers.FileWatchdog; public class Test_Log4jWatchdog { public static void ...
  • JAVA监听磁盘文件状态的变化

    千次阅读 2014-11-05 16:39:54
    使用Apache的Commons-io开发包,可以实现对文件的创建,大小
  • /* * @author uv * @date 2018/12/19 17:37 */ import java.nio.file.FileSystems; import java.nio.file.Paths;...import java.nio.file.StandardWatchEventKinds;...import java.nio.file.WatchE...
  • JAVA 监控并获取日志类文件变化(新增) 使用 JDK7+(1.7之前没有的哈!?) 工具类 java.nio.file.WatchService 写来用于监控日志文件新增内容(只能检测获取新增内容哈!?中间改一手赌不出来的哈!) 要配置目录和...
  • 有木有大神知道有什么效率比较高的文件监听的方法吗?我目前用的是org.apache.commons.io.monitor.FileAlterationListener,但是会有些文件会被漏掉
  • Java中实时监控目录下文件变化的两种实现方法,一中是基于jdk7之后,java自带的文件监控工具(Watch Service),一种是使用Commons-io的monitor下的相关类可以处理对文件进行监控。 1. 基于WatchService实现文件...
  • java编写的ftp文件实时监控下载上传

    热门讨论 2016-03-22 17:06:13
    java语言编写的ftp小工具,可以按指定时间监控ftp服务器,把服务器指定目录内新产生的文件或者文件夹下载到本地指定文件夹,下载后删除数据。 也可以监控本地文件夹,把文件夹内新产生的文件或者文件夹整体上传到...
  • 监听FTP文件变化

    千次阅读 2017-10-11 16:21:56
    整个项目的数据入口是监听FTP文件变化实现的。程序通过监听FTP目录内文件的变化(查找那些文件修改日期比上次修改日期晚的,然后在数据库中没有记录的文件),把监听到新增的文件信息保存在数据库表内文件队列表,然后...
  • Java监听

    2020-12-09 20:26:20
    用于监听ServletContext,HttpSession,ServletRequest等域对象的创建,销毁及其属性修改发生变化的事件 在时间发生前后进行一些必要的操作 实现步骤 编写java类实现监听器的接口,并且实现其接口方法 在web.xml...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 77,481
精华内容 30,992
关键字:

java监听文件内容变化

java 订阅