commons-io源码阅读心得

FileCleanTracker:　开启一个守护线程在后台默默的删除文件。

 /*
  * 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.
  */
 package org.apache.commons.io;

 import java.io.File;
 import java.lang.ref.PhantomReference;
 import java.lang.ref.ReferenceQueue;
 import java.util.Collection;
 import java.util.Vector;

 /**
  * Keeps track of files awaiting deletion, and deletes them when an associated
  * marker object is reclaimed by the garbage collector.
  * <p>
  * This utility creates a background thread to handle file deletion.
  * Each file to be deleted is registered with a handler object.
  * When the handler object is garbage collected, the file is deleted.
  * <p>
  * In an environment with multiple class loaders (a servlet container, for
  * example), you should consider stopping the background thread if it is no
  * longer needed. This is done by invoking the method
  * {@link #exitWhenFinished}, typically in
  * {@link javax.servlet.ServletContextListener#contextDestroyed} or similar.
  *
  * @author Noel Bergman
  * @author Martin Cooper
  * @version $Id: FileCleaner.java 490987 2006-12-29 12:11:48Z scolebourne $
  */
 public class FileCleaningTracker {
     /**
      * Queue of <code>Tracker</code> instances being watched.
      */
     ReferenceQueue /* Tracker */ q = new ReferenceQueue();
     /**
      * Collection of <code>Tracker</code> instances in existence.
      */
     final Collection /* Tracker */ trackers = new Vector();  // synchronized
     /**
      * Whether to terminate the thread when the tracking is complete.
      */
     volatile boolean exitWhenFinished = false;
     /**
      * The thread that will clean up registered files.
      */
     Thread reaper;

     //-----------------------------------------------------------------------
     /**
      * Track the specified file, using the provided marker, deleting the file
      * when the marker instance is garbage collected.
      * The {@link FileDeleteStrategy#NORMAL normal} deletion strategy will be used.
      *
      * @param file  the file to be tracked, not null
      * @param marker  the marker object used to track the file, not null
      * @throws NullPointerException if the file is null
      */
     public void track(File file, Object marker) {
         track(file, marker, (FileDeleteStrategy) null);
     }

     /**
      * Track the specified file, using the provided marker, deleting the file
      * when the marker instance is garbage collected.
      * The speified deletion strategy is used.
      *
      * @param file  the file to be tracked, not null
      * @param marker  the marker object used to track the file, not null
      * @param deleteStrategy  the strategy to delete the file, null means normal
      * @throws NullPointerException if the file is null
      */
     public void track(File file, Object marker, FileDeleteStrategy deleteStrategy) {
         if (file == null) {
             throw new NullPointerException("The file must not be null");
         }
         addTracker(file.getPath(), marker, deleteStrategy);
     }

     /**
      * Track the specified file, using the provided marker, deleting the file
      * when the marker instance is garbage collected.
      * The {@link FileDeleteStrategy#NORMAL normal} deletion strategy will be used.
      *
      * @param path  the full path to the file to be tracked, not null
      * @param marker  the marker object used to track the file, not null
      * @throws NullPointerException if the path is null
      */
     public void track(String path, Object marker) {
         track(path, marker, (FileDeleteStrategy) null);
     }

     /**
      * Track the specified file, using the provided marker, deleting the file
      * when the marker instance is garbage collected.
      * The speified deletion strategy is used.
      *
      * @param path  the full path to the file to be tracked, not null
      * @param marker  the marker object used to track the file, not null
      * @param deleteStrategy  the strategy to delete the file, null means normal
      * @throws NullPointerException if the path is null
      */
     public void track(String path, Object marker, FileDeleteStrategy deleteStrategy) {
         if (path == null) {
             throw new NullPointerException("The path must not be null");
         }
         addTracker(path, marker, deleteStrategy);
     }

     /**
      * Adds a tracker to the list of trackers.
      *
      * @param path  the full path to the file to be tracked, not null
      * @param marker  the marker object used to track the file, not null
      * @param deleteStrategy  the strategy to delete the file, null means normal
      */
     private synchronized void addTracker(String path, Object marker, FileDeleteStrategy deleteStrategy) {
         // synchronized block protects reaper
         if (exitWhenFinished) {
             throw new IllegalStateException("No new trackers can be added once exitWhenFinished() is called");
         }
         if (reaper == null) {
             reaper = new Reaper();
             reaper.start();
         }
         trackers.add(new Tracker(path, deleteStrategy, marker, q));
     }

     //-----------------------------------------------------------------------
     /**
      * Retrieve the number of files currently being tracked, and therefore
      * awaiting deletion.
      *
      * @return the number of files being tracked
      */
     public int getTrackCount() {
         return trackers.size();
     }

     /**
      * Call this method to cause the file cleaner thread to terminate when
      * there are no more objects being tracked for deletion.
      * <p>
      * In a simple environment, you don't need this method as the file cleaner
      * thread will simply exit when the JVM exits. In a more complex environment,
      * with multiple class loaders (such as an application server), you should be
      * aware that the file cleaner thread will continue running even if the class
      * loader it was started from terminates. This can consitute a memory leak.
      * <p>
      * For example, suppose that you have developed a web application, which
      * contains the commons-io jar file in your WEB-INF/lib directory. In other
      * words, the FileCleaner class is loaded through the class loader of your
      * web application. If the web application is terminated, but the servlet
      * container is still running, then the file cleaner thread will still exist,
      * posing a memory leak.
      * <p>
      * This method allows the thread to be terminated. Simply call this method
      * in the resource cleanup code, such as {@link javax.servlet.ServletContextListener#contextDestroyed}.
      * One called, no new objects can be tracked by the file cleaner.
      */
     public synchronized void exitWhenFinished() {
         // synchronized block protects reaper
         exitWhenFinished = true;
         if (reaper != null) {
             synchronized (reaper) {
                 reaper.interrupt();
             }
         }
     }

     //-----------------------------------------------------------------------
     /**
      * The reaper thread.
      */
     private final class Reaper extends Thread {
         /** Construct a new Reaper */
         Reaper() {
             super("File Reaper");
             setPriority(Thread.MAX_PRIORITY);
             setDaemon(true);
         }

         /**
          * Run the reaper thread that will delete files as their associated
          * marker objects are reclaimed by the garbage collector.
          */
         public void run() {
             // thread exits when exitWhenFinished is true and there are no more tracked objects
             while (exitWhenFinished == false || trackers.size() > 0) {
                 Tracker tracker = null;
                 try {
                     // Wait for a tracker to remove.
                     tracker = (Tracker) q.remove();
                 } catch (Exception e) {
                     continue;
                 }
                 if (tracker != null) {
                     tracker.delete();
                     tracker.clear();
                     trackers.remove(tracker);
                 }
             }
         }
     }

     //-----------------------------------------------------------------------
     /**
      * Inner class which acts as the reference for a file pending deletion.
      */
     private static final class Tracker extends PhantomReference {

         /**
          * The full path to the file being tracked.
          */
         private final String path;
         /**
          * The strategy for deleting files.
          */
         private final FileDeleteStrategy deleteStrategy;

         /**
          * Constructs an instance of this class from the supplied parameters.
          *
          * @param path  the full path to the file to be tracked, not null
          * @param deleteStrategy  the strategy to delete the file, null means normal
          * @param marker  the marker object used to track the file, not null
          * @param queue  the queue on to which the tracker will be pushed, not null
          */
         Tracker(String path, FileDeleteStrategy deleteStrategy, Object marker, ReferenceQueue queue) {
             super(marker, queue);
             this.path = path;
             this.deleteStrategy = (deleteStrategy == null ? FileDeleteStrategy.NORMAL : deleteStrategy);
         }

         /**
          * Deletes the file associated with this tracker instance.
          *
          * @return <code>true</code> if the file was deleted successfully;
          *         <code>false</code> otherwise.
          */
         public boolean delete() {
             return deleteStrategy.deleteQuietly(new File(path));
         }
     }

 }

IOUtils: 通用的io工具类。

　　主要有：

　　toByteArray(InputStream/Reader/String)方法：将输入流拷贝到相应的输出流，然后调用输出流的toByteArray()方法返回；

　　toCharArray(InputStream/Reader)方法：将输入流拷贝到相应的输出流，然后调用输出流的toCharArray()方法返回；

　　toString(InputStream/Reader/byte[])方法：将输入流拷贝到StringWriter，然后调用StringWriter.toString()方法返回；

　　readLines(InputStream/Reader)方法：将输入流中的每一行存入list容器中，然后返回list;

　　contentEquals(InputStream/Reader)方法：比较俩个输入流的内容是否一致;

CopyUtils: 拷贝输入流内容到输出流的工具类。

FileUtils: 通用的文件工具类。

FileSystemUtils: 通用的文件系统工具类。

　　freeSpaceKb(String path)方法： 获取系统(windows/unix)下的某个路径下的空间值，单位KB。通过执行命令：'dir /-c' on Windows and 'df' on *nix.

FilenameUtils: 通用的文件名和文件路径工具类。

　　normalize(String filename)方法：格式化文件名；

　　getPrefixLength(String filename)方法：获取文件名前缀的长度；

　　getPrefix(String filename)方法：获取文件名前缀；

　　getPath(String filename)方法：获取文件名路径；

　　getPathNoEndSeparator(String filename)方法：获取文件名路径不带最后分隔符；

　　getFullPath(String filename)方法：获取文件名对应的全路径；

　　wildcardMatch(String filename, String wildcardMatcher)方法：文件名与某个通配符字符串是否匹配；

一系列的FileFilter，都继承了AbstractFileFilter，它实现了IOFileFilter，IOFileFilter继承了FileFilter和FilenameFilter。

　　如：AgeFileFilter 可以过滤某些早于、等于或者晚于某个时间的文件或文件列表。

 File dir = new File(".");
 // We are interested in files older than one day
 long cutoff = System.currentTimeMillis() - (24 * 60 * 60 * 1000);
 String[] files = dir.list( new AgeFileFilter(cutoff) );
    for ( int i = 0; i < files.length; i++ ) {
    System.out.println(files[i]);
 }

　　　　AndFileFilter 将几个其它的文件过滤器做逻辑与操作，可以获取符合这几个文件过滤器的文件或文件列表。

　　　　WildcardFileFilter 文件通配符过滤器，可以获取文件名匹配某个设定的通配符的文件。

 File dir = new File(".");
 FileFilter fileFilter = new WildcardFileFilter("*test*.java~*~");
 File[] files = dir.listFiles(fileFilter);
 for (int i = 0; i < files.length; i++) {
     System.out.println(files[i]);
 }

一系列的IO output/input类：

　　如：CountingInputStream 可以记录输入流读取的字节数；

　　　　ByteArrayOutputStream 将输出流的数据写到字节数组中；

　　　　CountingOutputStream 记录输出流输出的字节数。