JDK不同操作系统的FileSystem（Windows）上篇

前言

    我们知道不同的操作系统有各自的文件系统，这些文件系统又存在很多差异，而Java 因为是跨平台的，所以它必须要统一处理这些不同平台文件系统之间的差异，才能往上提供统一的入口。

关于FileSystem类

    JDK 里面抽象出了一个 FileSystem 来表示文件系统，不同的操作系统通过继承该类实现各自的文件系统，比如 Windows NT/2000 操作系统则为 WinNTFileSystem，而 unix-like 操作系统为 UnixFileSystem。

    需要注意的一点是，WinNTFileSystem类 和 UnixFileSystem类并不是在同一个 JDK 里面，也就是说它们是分开的，你只能在 Windows 版本的 JDK 中找到 WinNTFileSystem，而在 Linux 版本的 JDK 中找到 UnixFileSystem，同样地，其他操作系统也有自己的文件系统实现类。

    这里分成两个系列分析 JDK 对两种（Windows 和Linux）操作系统的文件系统的实现类，先讲 Windows操作系统，对应为 WinNTFileSystem 类。 由于篇幅较长，《JDK不同操作系统的FileSystem（Windows）》分为上中下篇，此为上篇。

继承结构

--java.lang.Object
  --java.io.FileSystem
    --java.io.WinNTFileSystem

类定义

class WinNTFileSystem extends FileSystem

主要属性

• slash 表示斜杠符号。

• altSlash 与slash相反的斜杠。

• semicolon 表示分号。

• driveDirCache 表示驱动盘目录缓存。

• cache 用于缓存标准路径。

• prefixCache 用于缓存标准路径前缀。

private final char slash;    
private final char altSlash;    
private final char semicolon;    
private static String[] driveDirCache = new String[26];   
private ExpiringCache cache       = new ExpiringCache();    
private ExpiringCache prefixCache = new ExpiringCache();

主要方法

构造方法

    构造方法很简单，先通过 System.getProperties() 获取 Properties 对象，然后获取其里面的 file.separator 属性和 path.separator 属性的值， 分别赋值给相应变量，在 Windows 中这两个值分别为 \ 和 ; 。最后将斜杠 / 赋给 altSlash。

public WinNTFileSystem() {
        Properties props = GetPropertyAction.privilegedGetProperties();
        slash = props.getProperty("file.separator").charAt(0);
        semicolon = props.getProperty("path.separator").charAt(0);
        altSlash = (this.slash == '\\') ? '/' : '\\';
}

isSlash方法

    判断是不是斜杠。

private boolean isSlash(char c) {
         return (c == '\\') || (c == '/');
}

isLetter方法

    判断是不是字母。

private boolean isLetter(char c) { 
        return ((c >= 'a') && (c <= 'z')) || ((c >= 'A') && (c <= 'Z'));
}

slashify方法

    判断一个字符串是否以斜杠开头，不是则帮其开头添加斜杠，是则不作处理。

private String slashify(String p) {
        if ((p.length() > 0) && (p.charAt(0) != slash))  
             return slash + p;
        else 
             return p;
}

normalize方法

    该方法主要是对路径进行标准化，它在实现过程中依赖另外一个 normalize 方法和 normalizePrefix 方法，这两个方法都是 private 的。

    针对传入来的 path 变量，用一个 for 循环遍历每个字符，分别对以下三种情况处理， 
    1. 当遇到 altSlash 时，即 / 时，则把 path 传入另外一个 normalize 方法中进行处理，其中涉及 prev == slash 判断条件，prev 其实就是前一个字符，相等就说明两个 / 连着。 
    2. 当遇到连续两个 slash 时，即连续两个 \ 时，而且 i 还要大于1时，则把 path 传入另外一个 normalize 方法中进行处理。 
    3. 当遇到 : 字符且 i 大于1时，则把 path 传入另外一个 normalize 方法中进行处理。

    如果都不在上述情况内，则要继续判断最后一个字符是否为 slash ，如果是则还要传入另外一个 normalize 方法中进行处理。否则直接返回 path ，这时其实 path 就是以一个或两个 \ 开头且后面不再存在斜杠或反斜杠或冒号，这种情况是可以直接返回的。

public String normalize(String path) { 
       int n = path.length(); 
        char slash = this.slash; 
       char altSlash = this.altSlash;
        char prev = 0;
        for (int i = 0; i < n; i++) { 
           char c = path.charAt(i); 
            if (c == altSlash) 
                return normalize(path, n, (prev == slash) ? i - 1 : i); 
            if ((c == slash) && (prev == slash) && (i > 1)) 
               return normalize(path, n, i - 1); 
           if ((c == ':') && (i > 1)) 
               return normalize(path, n, 0);
      prev = c;
    }
    if (prev == slash) return normalize(path, n, n - 1); 
          return path;
}

    往下看具体的处理逻辑，这里有三个参数，第一个是路径字符串，第二个是路径长度，第三个是路径字符串的偏移，偏移量用来表示从哪个位置开始，偏移量 off 不能小于3，这是考虑到了UNC路径。继续往下如果偏移量等于0的话则先处理前缀，这时调用 normalizePrefix 方法处理。偏移量非0的情况下则表示已经有部分已经标准化好了，将其先 append 到 StringBuilder 对象中。

    接着开始处理从偏移量开始到结尾的路径，用 while 循环遍历剩余路径中的每个字符，如果有连着都是斜杠的情况则跳过重复的斜杠，这里斜杠包括了 / 和 \ 。非斜杠的情况则直接将字符 append 到 StringBuilder 对象中，多个斜杠则只添加一个斜杠。最后 src == len 条件则表示已经到结尾了，这时要考虑一些特殊情况的处理，比如 c:\\ 、 \\ 和 \\\\。

private String normalize(String path, int len, int off) {
       if (len == 0) 
          return path; 
      if (off < 3) off = 0;   
      int src;
   char slash = this.slash;
   StringBuilder sb = new StringBuilder(len); 
     if (off == 0) {
          src = normalizePrefix(path, len, sb);
   } else {
          src = off;
          sb.append(path, 0, off);
   }
    while (src < len) {
          char c = path.charAt(src++);
              if (isSlash(c)) {
                  while ((src < len) && isSlash(path.charAt(src))) src++; 
                               if (src == len) { 
                                 int sn = sb.length(); 
                                 if ((sn == 2) && (sb.charAt(1) == ':')) {
                      sb.append(slash); 
                                       break;
                   }       
                   if (sn == 0) {
                      sb.append(slash); 
                                      break;
                  }                  
                   if ((sn == 1) && (isSlash(sb.charAt(0)))) {
                      sb.append(slash);   
                                       break;
                  }
                  break;
              } else {
                  sb.append(slash);
              }
             } else {
              sb.append(c);
          }
     } 
  return sb.toString();
}

    正常情况下，Windows的路径不会存在连着的两个斜杠（除了UNC路径可能会两个斜杠开头），同时也不会以斜杠结束。路径一般分为：目录相对路径、驱动盘相对路径、UNC绝对路径和本地绝对路径。以下两种逻辑分别处理类似c:和\\。

private int normalizePrefix(String path, int len, StringBuilder sb) {
      int src = 0;
      while ((src < len) && isSlash(path.charAt(src))) src++;
      char c;
      if ((len - src >= 2) && isLetter(c = path.charAt(src)) && path.charAt(src + 1) == ':') {
          sb.append(c);
          sb.append(':');
          src += 2;
      } else {
          src = 0; 
                 if ((len >= 2) && isSlash(path.charAt(0)) && isSlash(path.charAt(1))) {
              src = 1;
              sb.append(slash);
          }
      }
  return src;
 }

    综上处理逻辑，为帮助我们更好地理解，用以下不同路径格式看看对应的标准化后是什么样的。

 System.out.println(f.normalize("d:\\\\test\\test////"));
 System.out.println(f.normalize("d://test\\test////"));
 System.out.println(f.normalize("d://test\\test////test.txt"));
System.out.println(f.normalize("d:\\test/test\\\\"));
System.out.println(f.normalize("d:\\test/test/"));
System.out.println(f.normalize("d:/test/test//"));
System.out.println(f.normalize("test\\"));
 System.out.println(f.normalize("\\"));
System.out.println(f.normalize("/"));
System.out.println(f.normalize("c:\\"));
System.out.println(f.normalize("c:test"));
System.out.println(f.normalize("/c:/test"));
System.out.println(f.normalize("file://c:/test"));
 System.out.println(f.normalize("\\\\test\\"));
System.out.println(f.normalize("\\\\test/"));

d:\test\test
d:\test\test
d:\test\test\test.txt
d:\test\test
d:\test\test
d:\test\test
test
\
\
c:\
c:test
c:\test
file:\c:\test
\\test
\\test

prefixLength方法

    该方法主要是获取路径前缀的长度。按照顺序看下逻辑，获取第一个第二个字符，如果都为 slash ，即两个\，则为 UNC 路径，形如 \\test，返回2；如果第二个字符不是\则为驱动盘相对路径，形如\test，返回1；当第一个字符为字母且第二个为:时，如果第三个字符为\，则为本地绝对路径，形如c:\test，返回3；如果第三个字符为非\，则为目录相对路径，形如c:test；最后则为相对路径，形如test。

public int prefixLength(String path) {
        char slash = this.slash; 
       int n = path.length();
         if (n == 0) return 0; 
       char c0 = path.charAt(0); 
       char c1 = (n > 1) ? path.charAt(1) : 0; 
       if (c0 == slash) { 
            if (c1 == slash) return 2;  
            return 1;                   
        }
        if (isLetter(c0) && (c1 == ':')) {
                       if ((n > 2) && (path.charAt(2) == slash))
                           return 3;               
            return 2;                   
        }
     return 0;                       
    }

getUserPath方法

    通过 System 获取 user.dir 属性作为用户路径。

private String getUserPath() {
        return normalize(System.getProperty("user.dir"));
}

getDrive方法

    获取驱动盘，先获取路径头部长度，再截取驱动盘。

private String getDrive(String path) { 
       int pl = prefixLength(path); 
        return (pl == 3) ? path.substring(0, 2) : null;
}

driveIndex方法

    获取驱动盘的索引值，按照字母顺序，比如 a 或 A 则索引值为0。

private static int driveIndex(char d) { 
        if ((d >= 'a') && (d <= 'z')) return d - 'a'; 
       if ((d >= 'A') && (d <= 'Z')) return d - 'A';
        return -1;
}

getDriveDirectory方法

    获取指定驱动盘下的工作目录，每个驱动盘都有工作目录。可以看到有两个 getDriveDirectory 方法，其中一个本地方法，实现需要本地方法来支持。其中逻辑是先根据驱动盘获取对应的驱动盘索引，然后再将索引加一并通过本地方法获取对应驱动盘当前工作目录，这里还会将其缓存起来，方便后面查询。

private native String getDriveDirectory(int drive);
     private String getDriveDirectory(char drive) {
         int i = driveIndex(drive); 
         if (i < 0) return null;
     String s = driveDirCache[i];
     if (s != null) return s;
     s = getDriveDirectory(i + 1);
     driveDirCache[i] = s;
   return s;
 }

    本地的实现如下，主要看函数 currentDir，先通过操作系统的API函数 GetDriveTypeW 判断是否为不合格的驱动盘类型，这其中参数都是用宽字符。接着通过 _wgetdcwd 函数获取指定驱动器上的当前工作目录的完整路径，同时去掉驱动盘和冒号，返回给 Java 层一个表示当前工作目录路径的字符串。

JNIEXPORT jobject JNICALL
Java_java_io_WinNTFileSystem_getDriveDirectory(JNIEnv *env, jobject this,
                                               jint drive)
{
    jstring ret = NULL;
    jchar *p = currentDir(drive);
    jchar *pf = p;
       if (p == NULL) return NULL;
       if (iswalpha(*p) && (p[1] == L':')) p += 2;
    ret = (*env)->NewString(env, p, (jsize)wcslen(p));
    free (pf);
    return ret;
}

WCHAR*
currentDir(int di) {
    UINT dt;
    WCHAR root[4];
    root[0] = L'A' + (WCHAR)(di - 1);
    root[1] = L':';
    root[2] = L'\\';
    root[3] = L'\0';
    dt = GetDriveTypeW(root);
        if (dt == DRIVE_UNKNOWN || dt == DRIVE_NO_ROOT_DIR) {
         return NULL;
    } else { 
         return _wgetdcwd(di, NULL, MAX_PATH);
    }
}

resolve方法

    有两个resolve方法。

    第一个 resolve 方法主要是针对传入的两个参数，一个是父路径一个是子路径，对它们进行解析然后得到一个新路径。此过程需要考虑两个路径的格式。逻辑如下： 
    1. 先分别获取父路径长度和子路径长度。 
    2. 根据父路径判断是否为目录相对路径，形如c:的。 
    3. 若子路径以 slash 即\开头，则可能是 UNC 路径，这时要丢弃它的头部，所以子路径从第2的位置开始；也可能是驱动盘相对路径，这时丢弃它的头部，子路径从第1的位置开始；最后如果子路径为两个 slash 即 \\时，则直接返回父路径，当然父路径如果以 slash 结尾也要将其去掉。 
    4. 此时确定好了父路径的长度、父路径的结束位置、子路径的长度和子路径的开始位置，就可以得到最终的新路径的长度了。 
    5. 根据上述的长度和位置信息将父路径和子路径合并，返回一个新的路径。

public String resolve(String parent, String child) { 
       int pn = parent.length();
        if (pn == 0) return child; 
        int cn = child.length(); 
        if (cn == 0) return parent;
    String c = child;
    int childStart = 0; 
       int parentEnd = pn;
       boolean isDirectoryRelative = 
               pn == 2 && isLetter(parent.charAt(0)) && parent.charAt(1) == ':'; 
       if ((cn > 1) && (c.charAt(0) == slash)) { 
           if (c.charAt(1) == slash) {
         childStart = 2;
       } else if (!isDirectoryRelative) {
         childStart = 1;
       }
       if (cn == childStart) { 
           if (parent.charAt(pn - 1) == slash) 
                        return parent.substring(0, pn - 1);  
              return parent;
       }
    }
    if (parent.charAt(pn - 1) == slash)
            parentEnd--;
    int strlen = parentEnd + cn - childStart;
    char[] theChars = null; 
    if (child.charAt(childStart) == slash || isDirectoryRelative) {
            theChars = new char[strlen];
            parent.getChars(0, parentEnd, theChars, 0);
            child.getChars(childStart, cn, theChars, parentEnd);
    } else {
            theChars = new char[strlen + 1];
                     parent.getChars(0, parentEnd, theChars, 0);
            theChars[parentEnd] = slash;
           child.getChars(childStart, cn, theChars, parentEnd + 1);
    }
   return new String(theChars);
}

    第二个 resolve 方法传入的是 File，主要是根据 File 对应的不同类型路径解析处理然后返回。 
    1. 获取路径头部。 
    2. 如果头部长为2且以\开头，此时为 UNC 路径，直接返回路径。 
    3. 如果头部长为3，则为本地绝对路径，直接返回路径。 
    4. 如果长度为0，则为相对路径，返回用户路径+此相对路径。 
    5. 如果长度为1，则为驱动盘相对路径，此时尝试根据用户路径获取驱动盘，存在驱动盘则返回驱动盘+此路径，不存在驱动盘则说明用户路径是一个 UNC 路径，返回用户路径+此路径。 
    6. 如果头部长度为2，则为目录相对路径。此时先获取用户路径，再根据用户路径获取对应驱动盘，如果路径以驱动盘开头，则直接返回用户路径+去掉驱动盘后的路径。如果继续往下则通过 getDriveDirectory 获取指定驱动盘的工作目录，将驱动盘+:+工作目录+路径等拼接起来得到最终的新路径，然后还要用安全管理器检查是否有读的权限。

public String resolve(File f) { 
        String path = f.getPath();
    int pl = f.getPrefixLength();
    if ((pl == 2) && (path.charAt(0) == slash)) 
           return path;                       
    if (pl == 3)            return path;                        
    if (pl == 0)            return getUserPath() + slashify(path); 
    if (pl == 1) {                          
       String up = getUserPath(); 
            String ud = getDrive(up);
            if (ud != null) return ud + path; 
              return up + path;                   
    }
    if (pl == 2) {                
       String up = getUserPath();
             String ud = getDrive(up);
            if ((ud != null) && path.startsWith(ud)) 
               return up + slashify(path.substring(2));
       char drive = path.charAt(0); 
           String dir = getDriveDirectory(drive);
             String np;
             if (dir != null) { 
               String p = drive + (':' + dir + slashify(path.substring(2)));
         SecurityManager security = System.getSecurityManager(); 
         try {  
                  if (security != null) security.checkRead(p);
         } catch (SecurityException x) { 
                    throw new SecurityException("Cannot resolve path " + path);
         }  
      return p;
     }     
   return drive + ":" + slashify(path.substring(2)); 
  } 
   throw new InternalError("Unresolvable path: " + path);
}

以下是广告

========广告时间========

鄙人的新书《Tomcat内核设计剖析》已经在京东销售了，有需要的朋友可以到 https://item.jd.com/12185360.html 进行预定。感谢各位朋友。

为什么写《Tomcat内核设计剖析》

=========================