Java - 利用WatchService即時監控檔案的新增與刪除

由於最近剛好有實作在UI上面顯示Tree結構，而Tree是依據指定目錄的檔案結構做呈現，當我們在目錄內放進其他檔案後，UI上的Tree結構需要做相對應的即時更新，因此在這邊就利用了Java WatchService來實作，透過WatchService您可以先register您要監控的目錄，同時assign要監控的相對應動作，如新增、刪除等，最後就是做相對應的回饋! 而在這裡呈現的範例捨棄UI改用文字做簡單的顯示，主要專注在WatchService的使用上做說明。
#主程式 - DocumentMonitorSystem.java
先列出主程式的code
  1. public static void main(String[] args) {
  2.     // TODO Auto-generated method stub
  3.     DocumentWatchService service = DocumentWatchService.getInstance();
  4.     Scanner input = new Scanner(System.in);
  5.     boolean processing = true;
  6.     System.out.println("*****Welcone to Document Monitor System*****");
  7.     JFileChooser fc = new JFileChooser("D:\\workspace\\Java program");
  8.     fc.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
  9.     while(processing) {
  10.        System.out.println("Please enter ID:");
  11.        System.out.println("(1)List Current Documents (2)Register (3)Unregister (4)Shut down");
  12.        int select = input.nextInt();
  13.    
  14.        switch(select) {
  15.           case 1:{
  16.              service.listCurrentDocuments();
  17.              break;
  18.           }
  19.           case 2:{
  20.              int returnValue = fc.showOpenDialog(null);
  21.              if (returnValue == JFileChooser.APPROVE_OPTION) { 
  22.                 File selectedFile = fc.getSelectedFile();
  23.                 if(selectedFile.isDirectory()) {
  24.                    service.register(selectedFile);
  25.                    service.listCurrentRegisters();
  26.                 }
  27.              }
  28.              break;
  29.           }
  30.           case 3:{
  31.              if(service.listCurrentRegisters()) {
  32.                 System.out.println("Please enter ID to unregister:");
  33.                 int id = input.nextInt();
  34.                 service.unregister(id);
  35.              }else
  36.                 System.out.println("A valid registration does not exist.");
  37.              break;
  38.           }
  39.           case 4:{
  40.              service.closeService();
  41.              input.close();
  42.              processing = false;
  43.              System.out.println("Shut down...");
  44.              break;
  45.           }
  46.           default:{
  47.              System.out.println("Option '"+select+"' dose not exist");
  48.           }
  49.       }
  50.       System.out.println();
  51.    }
  52. }
這邊透過menu的選擇讓我們可以動態新增register或採取unregister哪個bind的目錄，同時可以列出目前register目錄的檔案結構做呈現，之中會再區分哪些是透過WatchService所監控到的檔案做標記!

#建立WatchService - DocumentWatchService.java
  1. public class DocumentWatchService {
  2.     private WatchService watchService = null;
  3.     private static DocumentWatchService INSTANCE = null;
  4.     private Map<Path, List<Path>> dirMapPath = new HashMap<>();
  5.     private Map<Integer, WatchKey> idMapWatchKey = new TreeMap<>();
  6.     private boolean enabled = false;
  7.     private DocumentWatchService() {
  8.     }
  9.  
  10.     public static DocumentWatchService getInstance() {
  11.        if(INSTANCE == null) {
  12.           INSTANCE = new DocumentWatchService();
  13.        }
  14.        return INSTANCE;
  15.     }
  16.  
  17.     public void register(File dir) {
  18.        try {
  19.           if(watchService == null) {
  20.              watchService = FileSystems.getDefault().newWatchService();
  21.              enableService();
  22.           }
  23.           Path path = Paths.get(dir.getAbsolutePath());
  24.           if(!dirMapPath.containsKey(path)) {
  25.              WatchKey watchkey = path.register(watchService, new Kind[] {ENTRY_CREATE, ENTRY_DELETE}, ExtendedWatchEventModifier.FILE_TREE);
  26.              dirMapPath.put(path, new ArrayList<>());
  27.              idMapWatchKey.put(dirMapPath.size(), watchkey);
  28.           }else{
  29.              System.out.println("The directory you selected has been monitored");
  30.           }
  31.        } catch (IOException e) {
  32.          // TODO Auto-generated catch block
  33.          e.printStackTrace();
  34.        }
  35.     }
  36.  
  37.     public void unregister(int id) {
  38.        WatchKey key = idMapWatchKey.get(id);
  39.        if(key != null) {
  40.           key.cancel();
  41.        }else {
  42.           System.out.println("The ID you entered does not exist");
  43.        }
  44.     }
  45.  
  46.     public boolean listCurrentRegisters() {
  47.        boolean exist = false;
  48.        System.out.println("==========List Current Registers==========");
  49.        for(Integer id : idMapWatchKey.keySet()) {
  50.           WatchKey key = idMapWatchKey.get(id);
  51.           String status = key.isValid() ? "processing" : "stop";
  52.           Path path = (Path) key.watchable();
  53.           System.out.println("("+id+")"+path.toAbsolutePath()+"("+status+")");
  54.           if(key.isValid()) {
  55.              exist = true;
  56.           }
  57.        }
  58.        return exist;
  59.     }
  60.  
  61.     public void listCurrentDocuments() {
  62.        System.out.println("==========List Current Documents==========");
  63.        for(Integer id : idMapWatchKey.keySet()) {
  64.           WatchKey key = idMapWatchKey.get(id);
  65.           Path path = (Path) key.watchable();
  66.           System.out.println("("+id+")"+path.toAbsolutePath());
  67.           File dir = path.toFile();
  68.           List<Path> mapPaths = dirMapPath.get(path);
  69.           traceFolder(dir, mapPaths, "");
  70.        }
  71.        if(dirMapPath.size() == 0) {
  72.           System.out.println("No registration exist");
  73.        }
  74.     }
  75.  
  76.     private void traceFolder(File f, List paths, String tab) {
  77.        if(f.isFile()) {
  78.           return;
  79.        }else {
  80.           for(File file : f.listFiles()) {
  81.              String selfAdd = paths.contains(file.toPath()) ? "(*)" : "";
  82.              System.out.println(tab + file.getName() + selfAdd);
  83.              traceFolder(file, paths, tab + "  ");
  84.           }
  85.        } 
  86.     }
  87.  
  88.     private void enableService() {
  89.        if(!enabled) {
  90.           new Thread("Documents Watch Service") {
  91.              @SuppressWarnings("unchecked")
  92.              @Override
  93.              public void run() {
  94.                 while (true) {
  95.                    try {
  96.                       WatchKey key = watchService.take();
  97.                       Path dir = (Path)key.watchable();
  98.                       List<WatchEvent<?>> lists = key.pollEvents();
  99.                       System.out.println();
  100.                       System.out.println();
  101.                       System.out.println("***********Document Watch Service***********");
  102.                       for (WatchEvent<?> watchEvent : lists) {
  103.                          WatchEvent<Path> watchEventPath = (WatchEvent<Path>) watchEvent;
  104.                          Kind<Path> kind = (Kind<Path>) watchEvent.kind();
  105.                          String relativePath = watchEventPath.context().toString();
  106.                          Path self = dir.resolve(relativePath);
  107.                          File file = new File(relativePath);
  108.                          System.out.println("***Kind: " + kind);
  109.                          System.out.println("***Watch Directory: " + dir);
  110.                          System.out.println("***RelativePath: " + relativePath);
  111.                          System.out.println("***Filename: " + file.getName());
  112.                          boolean hidden = file.isHidden();
  113.                          if (!hidden) {
  114.                             List pathList = dirMapPath.get(dir);
  115.                             if(ENTRY_CREATE == kind) {
  116.                                pathList.add(self);
  117.                             }else if(ENTRY_DELETE == kind) {
  118.                                pathList.remove(self);
  119.                             }
  120.                          }
  121.                       }
  122.                       System.out.println("********************************************");
  123.                       key.reset();
  124.                  } catch (InterruptedException e) {
  125.                     // TODO Auto-generated catch block
  126.                     e.printStackTrace();
  127.                  } catch (ClosedWatchServiceException e) {
  128.                     //e.printStackTrace();
  129.                     break;
  130.                  }
  131.               }
  132.            }
  133.         }.start();
  134.      }
  135.      enabled = true;
  136.   }
  137.  
  138.   public void closeService() {
  139.      if(watchService != null) {
  140.         try {
  141.            watchService.close();
  142.            watchService = null;
  143.         } catch (IOException e) {
  144.           // TODO Auto-generated catch block
  145.           e.printStackTrace();
  146.         }
  147.     }
  148.   }
  149. }
+新增register -- 選擇2
首先透過主程式register一個目錄做監控後，隨即呼叫enableService(); 此時啟用執行緒開始WatchService的服務，當下程式會停在watchService.take();這一行!
另外這裡要特別提到的是ExtendedWatchEventModifier.FILE_TREE這個參數，它可以解決access denied的error。對照下面的檔案結構，當WatchService監控了A目錄，它只會針對這層目錄下的內容發生監控的event，若A目錄下的B目錄有檔案的增減還得另外再register這B目錄，如此類推! 可是當您在Windows欲刪除A目錄時，若B目錄被register，這時候Windows就會跳出access denied的error! 因此在register時指定這個參數，只要註冊A目錄後就可以了，其他下層目錄都會發生新增與刪除的event，也不會跳出access denied的error!
A folder
   -- B folder
      -- BB file
   -- C file
PS. 相關說明請見Stack Overflow，這樣看來它只會發生在Windows且是乎是Java的bug

再來要說明的是register當下
#變數dirMapPath會記錄被註冊目錄對應的List，List紀錄新增檔案的Path
#變數idMapWatchKey會記錄當下ID編號對應的WatchKey，註冊產生的key都是唯一的

+執行unregister -- 選擇3
這邊只要呼叫WatchKey的cancel();即可，以後呼叫isValid()就會是false

+列出Register目錄下的Document -- 選擇1
若要取得當時註冊的Path，可以透過WatchKey呼叫watchable();取得
在此呼叫traceFolder做遞迴印出現在的檔案結構，若有標註*表示透過WatchService監控所增加的檔案

+新增、刪除檔案 in 監控的目錄
新增目錄或檔案，此時List<WatchEvent<?>> lists = key.pollEvents();會回傳一組lists，進入迴圈後在WatchEvent可以得到event's kind，另event's context會得到檔案相對路徑，目錄裡還有檔案的話會依序進行追蹤產生相對應event!

刪除目錄或檔案，這比較單純，它並不會依序追蹤被你刪的內容有哪些，如刪除A目錄，若目錄下還有很多層目錄，這裡WatchEvent也僅有一筆事件，那就是得知A目錄被刪除了而已!

比較特別的是若您是更新檔案名稱或移動檔案，此時會先產生delete event，再來是create event，並沒有單純的modify event。而若您有註冊ENTRY_MODIFY，這時會產生三筆event，對照前面所述，最後會產生modify event，由於當您更新檔案，它所存在的目錄修改日期就會進行更新，因此它並不是針對檔案本身，而是檔案所在的目錄! 從這裡可以看出，我們無從得知這筆delete event與create event是否有關係，我們只單純的知道一個檔案被刪掉，另一個檔案被產生出來!

最後DEMO如下：
#選擇register的目錄
#列出目前被監控的目錄&手動新增檔案至目錄內
#列出目前的Document分佈
#手動刪除aaaa目錄
此時不會產生刪除bbbb.txt檔案的event
#修改檔名from cccc.txt to cccc222.txt

留言

張貼留言