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\\testtest.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\testd:\test\testd:\test\test\test.txtd:\test\testd:\test\testd:\test\testtest\\c:\c:testc:\testfile:\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 JNICALLJava_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内核设计剖析》已经在京东销售了，有需要的朋友可以到进行预定。感谢各位朋友。

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

欢迎关注：

这里写图片描述