JDK不一样操做系统的FileSystem（Windows）下篇
前言
咱们知道不一样的操做系统有各自的文件系统，这些文件系统又存在不少差别，而Java 由于是跨平台的，因此它必需要统一处理这些不一样平台文件系统之间的差别，才能往上提供统一的入口。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复制代码
createFileExclusively方法
该方法用于建立文件，本地方法逻辑是，bash
- 将路径转成宽字符形式。
- 判断路径是否为系统保留设备名。
- 调用 CreateFileW 函数建立文件，使用了 CREATE_NEW 模式，仅仅在不存在该文件时才建立。
- 若是已经存在该文件，尽可能不抛出异常，而是返回 false，此过程还会尝试读取该文件的属性，失败则抛IO异常。
public native boolean createFileExclusively(String path)
throws IOException;
JNIEXPORT jboolean JNICALL
Java_java_io_WinNTFileSystem_createFileExclusively(JNIEnv *env, jclass cls,
jstring path)
{
HANDLE h = NULL;
WCHAR *pathbuf = pathToNTPath(env, path, JNI_FALSE);
if (pathbuf == NULL)
return JNI_FALSE;
if (isReservedDeviceNameW(pathbuf)) {
free(pathbuf);
return JNI_FALSE;
}
h = CreateFileW(
pathbuf,
GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL,
CREATE_NEW,
FILE_ATTRIBUTE_NORMAL |
FILE_FLAG_OPEN_REPARSE_POINT,
NULL);
if (h == INVALID_HANDLE_VALUE) {
DWORD error = GetLastError();
if ((error != ERROR_FILE_EXISTS) && (error != ERROR_ALREADY_EXISTS)) {
DWORD a = GetFileAttributesW(pathbuf);
if (a == INVALID_FILE_ATTRIBUTES) {
SetLastError(error);
JNU_ThrowIOExceptionWithLastError(env, "Could not open file");
}
}
free(pathbuf);
return JNI_FALSE;
}
free(pathbuf);
CloseHandle(h);
return JNI_TRUE;
}复制代码
list方法
该方法用于列出指定目录下的全部文件和目录，本地方法处理逻辑以下，并发
- 获取
java/lang/String类对象，并检查不能为NULL。 - 获取 File 对象对应的路径。
- 按照路径长度从新分配空间并将路径拷贝到 search_path。
- 经过 GetFileAttributesW 函数获取指定路径的文件属性，若是获得 INVALID_FILE_ATTRIBUTES 或若是为目录则直接返回NULL。
- 去除尾部多余的空格。
- 在路径的尾部添加
*或\*。 - 经过 FindFirstFileW 函数获取到第一个文件。
- 接着经过 while 循环和 FindNextFileW 函数不断获取下一个文件，并将获得的文件名放到字符串数组中，并且文件名不能为
.和..。 - 返回文件名数组，其中能够看到文件名数组的初始长度为16，若是超过该长度后则按照原来长度的两倍从新建立字符串数组对象，再将原数组复制到新数组中。
public native String[] list(File f);
JNIEXPORT jobjectArray JNICALL
Java_java_io_WinNTFileSystem_list(JNIEnv *env, jobject this, jobject file)
{
WCHAR *search_path;
HANDLE handle;
WIN32_FIND_DATAW find_data;
int len, maxlen;
jobjectArray rv, old;
DWORD fattr;
jstring name;
jclass str_class;
WCHAR *pathbuf;
str_class = JNU_ClassString(env);
CHECK_NULL_RETURN(str_class, NULL);
pathbuf = fileToNTPath(env, file, ids.path);
if (pathbuf == NULL)
return NULL;
search_path = (WCHAR*)malloc(2*wcslen(pathbuf) + 6);
if (search_path == 0) {
free (pathbuf);
errno = ENOMEM;
JNU_ThrowOutOfMemoryError(env, "native memory allocation failed");
return NULL;
}
wcscpy(search_path, pathbuf);
free(pathbuf);
fattr = GetFileAttributesW(search_path);
if (fattr == INVALID_FILE_ATTRIBUTES) {
free(search_path);
return NULL;
} else if ((fattr & FILE_ATTRIBUTE_DIRECTORY) == 0) {
free(search_path);
return NULL;
}
len = (int)wcslen(search_path);
while (search_path[len-1] == L' ') {
len--;
}
search_path[len] = 0;
if ((search_path[0] == L'\\' && search_path[1] == L'\0') ||
(search_path[1] == L':'
&& (search_path[2] == L'\0'
|| (search_path[2] == L'\\' && search_path[3] == L'\0')))) {
wcscat(search_path, L"*");
} else {
wcscat(search_path, L"\\*");
}
handle = FindFirstFileW(search_path, &find_data);
free(search_path);
if (handle == INVALID_HANDLE_VALUE) {
if (GetLastError() != ERROR_FILE_NOT_FOUND) {
return NULL;
} else {
rv = (*env)->NewObjectArray(env, 0, str_class, NULL);
return rv;
}
}
len = 0;
maxlen = 16;
rv = (*env)->NewObjectArray(env, maxlen, str_class, NULL);
if (rv == NULL)
return NULL;
do {
if (!wcscmp(find_data.cFileName, L".")
|| !wcscmp(find_data.cFileName, L".."))
continue;
name = (*env)->NewString(env, find_data.cFileName,
(jsize)wcslen(find_data.cFileName));
if (name == NULL)
return NULL;
if (len == maxlen) {
old = rv;
rv = (*env)->NewObjectArray(env, maxlen <<= 1, str_class, NULL);
if (rv == NULL || JNU_CopyObjectArray(env, rv, old, len) < 0)
return NULL;
(*env)->DeleteLocalRef(env, old);
}
(*env)->SetObjectArrayElement(env, rv, len++, name);
(*env)->DeleteLocalRef(env, name);
} while (FindNextFileW(handle, &find_data));
if (GetLastError() != ERROR_NO_MORE_FILES)
return NULL;
FindClose(handle);
if (len < maxlen) {
old = rv;
rv = (*env)->NewObjectArray(env, len, str_class, NULL);
if (rv == NULL)
return NULL;
if (JNU_CopyObjectArray(env, rv, old, len) < 0)
return NULL;
}
return rv;
}复制代码
createDirectory方法
该方法用来建立目录，本地方法很简单，就是获取 File 对象对应的路径，再调用 CreateDirectoryW 函数建立目录。机器学习
public native boolean createDirectory(File f);
JNIEXPORT jboolean JNICALL
Java_java_io_WinNTFileSystem_createDirectory(JNIEnv *env, jobject this,
jobject file)
{
BOOL h = FALSE;
WCHAR *pathbuf = fileToNTPath(env, file, ids.path);
if (pathbuf == NULL) {
return JNI_FALSE;
}
h = CreateDirectoryW(pathbuf, NULL);
free(pathbuf);
if (h == 0) {
return JNI_FALSE;
}
return JNI_TRUE;
}复制代码
setLastModifiedTime方法
该方法用来设置文件或目录的最后修改时间，本地方法是先获取 File 对象对应的路径，再用 CreateFileW 函数打开指定文件或目录，最后用 SetFileTime 函数设置最后修改时间。分布式
public native boolean setLastModifiedTime(File f, long time);
JNIEXPORT jboolean JNICALL
Java_java_io_WinNTFileSystem_setLastModifiedTime(JNIEnv *env, jobject this,
jobject file, jlong time)
{
jboolean rv = JNI_FALSE;
WCHAR *pathbuf = fileToNTPath(env, file, ids.path);
HANDLE h;
if (pathbuf == NULL)
return JNI_FALSE;
h = CreateFileW(pathbuf,
FILE_WRITE_ATTRIBUTES,
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL,
OPEN_EXISTING,
FILE_FLAG_BACKUP_SEMANTICS,
0);
if (h != INVALID_HANDLE_VALUE) {
LARGE_INTEGER modTime;
FILETIME t;
modTime.QuadPart = (time + 11644473600000L) * 10000L;
t.dwLowDateTime = (DWORD)modTime.LowPart;
t.dwHighDateTime = (DWORD)modTime.HighPart;
if (SetFileTime(h, NULL, NULL, &t)) {
rv = JNI_TRUE;
}
CloseHandle(h);
}
free(pathbuf);
return rv;
}复制代码
setReadOnly方法
该方法用于将指定文件设置成只读。本地方法逻辑为，函数
- 获取 File 对象对应的路径。
- 经过 GetFileAttributesW 函数获取文件属性。
- 若是文件属于超连接或者快捷方式，则先获取对应的最终路径，而后再用 GetFileAttributesW 函数获取文件属性。
- 判断不为目录的话则经过 SetFileAttributesW 函数设置文件为只读，对应标识为 FILE_ATTRIBUTE_READONLY。
public native boolean setReadOnly(File f);
JNIEXPORT jboolean JNICALL
Java_java_io_WinNTFileSystem_setReadOnly(JNIEnv *env, jobject this,
jobject file)
{
jboolean rv = JNI_FALSE;
DWORD a;
WCHAR *pathbuf = fileToNTPath(env, file, ids.path);
if (pathbuf == NULL)
return JNI_FALSE;
a = GetFileAttributesW(pathbuf);
if ((a != INVALID_FILE_ATTRIBUTES) &&
((a & FILE_ATTRIBUTE_REPARSE_POINT) != 0))
{
WCHAR *fp = getFinalPath(env, pathbuf);
if (fp == NULL) {
a = INVALID_FILE_ATTRIBUTES;
} else {
free(pathbuf);
pathbuf = fp;
a = GetFileAttributesW(pathbuf);
}
}
if ((a != INVALID_FILE_ATTRIBUTES) &&
((a & FILE_ATTRIBUTE_DIRECTORY) == 0)) {
if (SetFileAttributesW(pathbuf, a | FILE_ATTRIBUTE_READONLY))
rv = JNI_TRUE;
}
free(pathbuf);
return rv;
}复制代码
delete方法
该方法用于删除 File 对象指定路径，须要将标准路径缓存和标准路径前缀缓存都清掉，而后调用本地方法 delete0 执行删除操做。学习
public boolean delete(File f) {
cache.clear();
prefixCache.clear();
return delete0(f);
}
private native boolean delete0(File f);复制代码
本地方法先获取 File 对象对应的路径，而后再调用 removeFileOrDirectory 函数删除目录或文件。而 removeFileOrDirectory 函数的逻辑是先将指定路径文件或目录设置成 FILE_ATTRIBUTE_NORMAL，而后再用 GetFileAttributesW 函数获取文件属性，最后若是指定路径为目录则调用 RemoveDirectoryW 函数删除目录，若是是文件则调用 DeleteFileW 函数删除文件。
JNIEXPORT jboolean JNICALL
Java_java_io_WinNTFileSystem_delete0(JNIEnv *env, jobject this, jobject file)
{
jboolean rv = JNI_FALSE;
WCHAR *pathbuf = fileToNTPath(env, file, ids.path);
if (pathbuf == NULL) {
return JNI_FALSE;
}
if (removeFileOrDirectory(pathbuf) == 0) {
rv = JNI_TRUE;
}
free(pathbuf);
return rv;
}
static int
removeFileOrDirectory(const jchar *path)
{
DWORD a;
SetFileAttributesW(path, FILE_ATTRIBUTE_NORMAL);
a = GetFileAttributesW(path);
if (a == INVALID_FILE_ATTRIBUTES) {
return 1;
} else if (a & FILE_ATTRIBUTE_DIRECTORY) {
return !RemoveDirectoryW(path);
} else {
return !DeleteFileW(path);
}
}复制代码
rename方法
该方法用于重命名文件，须要将标准路径缓存和标准路径前缀缓存都清掉，而后调用本地方法 rename0 执行重命名操做。
public boolean rename(File f1, File f2) {
cache.clear();
prefixCache.clear();
return rename0(f1, f2);
}
private native boolean rename0(File f1, File f2);复制代码
本地方法分别先获取原来的文件路径和重命名的文件路径，再经过 _wrename 函数进行重命名操做。
JNIEXPORT jboolean JNICALL
Java_java_io_WinNTFileSystem_rename0(JNIEnv *env, jobject this, jobject from,
jobject to)
{
jboolean rv = JNI_FALSE;
WCHAR *frompath = fileToNTPath(env, from, ids.path);
WCHAR *topath = fileToNTPath(env, to, ids.path);
if (frompath != NULL && topath != NULL && _wrename(frompath, topath) == 0) {
rv = JNI_TRUE;
}
free(frompath);
free(topath);
return rv;
}复制代码
access方法
该方法用于检查指定路径文件或目录是否可读，这里主要是JVM层的权限检查，因此用的是 SecurityManager 安全管理器来检测。
private boolean access(String path) {
try {
SecurityManager security = System.getSecurityManager();
if (security != null) security.checkRead(path);
return true;
} catch (SecurityException x) {
return false;
}
}复制代码
listRoots方法
该方法用于获取可用的文件系统的根文件对象的数组。逻辑以下，
- 先经过 listRoots0 本地方法获取全部根文件。
- listRoots0 方法很简单，就是直接用 GetLogicalDrives 函数获取到操做系统的逻辑驱动器字符。须要注意的是 GetLogicalDrives 返回的是一个 int 类型，那么它是怎么表示驱动器字符的呢？其实也是经过位来标识，每一位对应表示一个逻辑驱动器是否存在，好比第一位若是是"1"则表示驱动器"A:"存在， 第二位若是是“1”则表示驱动器“B:”存在，以此类推。
- 获得全部驱动器字符后经过一个for循环遍历检测驱动器的访问权限，去掉无权限的驱动器，并统计一个有n个驱动器，这里只须要循环26次，由于最多就是26个大写字母。
- 实例化一个 File 数组，大小为n。
- 再次经过一个26次的循环遍历获得有权限的驱动器，根据此驱动器符号实例化一个 File 对象，添加到 File 数组中。
- 返回 File 数组。
public File[] listRoots() {
int ds = listRoots0();
int n = 0;
for (int i = 0; i < 26; i++) {
if (((ds >> i) & 1) != 0) {
if (!access((char)('A' + i) + ":" + slash))
ds &= ~(1 << i);
else
n++;
}
}
File[] fs = new File[n];
int j = 0;
char slash = this.slash;
for (int i = 0; i < 26; i++) {
if (((ds >> i) & 1) != 0)
fs[j++] = new File((char)('A' + i) + ":" + slash);
}
return fs;
}
private static native int listRoots0();
JNIEXPORT jint JNICALL
Java_java_io_WinNTFileSystem_listRoots0(JNIEnv *env, jclass ignored)
{
return GetLogicalDrives();
}复制代码
getSpace方法
该方法用于获取文件空间大小，包括总空间大小、剩余空间大小和可用空间大小，Java 层分别用 SPACE_TOTAL = 0 SPACE_FREE = 1 SPACE_USABLE = 2标识。要查询某个文件的根目录的某某空间大小则将对应的标识传入，经过 getSpace0 本地方法得到。
public long getSpace(File f, int t) {
if (f.exists()) {
return getSpace0(f, t);
}
return 0;
}
private native long getSpace0(File f, int t);复制代码
本地方法的逻辑是，
- 获取 File 对象对应的文件或目录路径。
- 经过 GetVolumePathNameW 函数获取指定路径对应的根路径。
- 经过 GetDiskFreeSpaceExW 函数将总空间大小、空闲空间大小和可用空间大小获取到。
- 根据传入的标识返回不一样的指标，好比
SPACE_TOTAL则返回总空间大小，其余相似。
JNIEXPORT jlong JNICALL
Java_java_io_WinNTFileSystem_getSpace0(JNIEnv *env, jobject this,
jobject file, jint t)
{
WCHAR volname[MAX_PATH_LENGTH + 1];
jlong rv = 0L;
WCHAR *pathbuf = fileToNTPath(env, file, ids.path);
if (GetVolumePathNameW(pathbuf, volname, MAX_PATH_LENGTH)) {
ULARGE_INTEGER totalSpace, freeSpace, usableSpace;
if (GetDiskFreeSpaceExW(volname, &usableSpace, &totalSpace, &freeSpace)) {
switch(t) {
case java_io_FileSystem_SPACE_TOTAL:
rv = long_to_jlong(totalSpace.QuadPart);
break;
case java_io_FileSystem_SPACE_FREE:
rv = long_to_jlong(freeSpace.QuadPart);
break;
case java_io_FileSystem_SPACE_USABLE:
rv = long_to_jlong(usableSpace.QuadPart);
break;
default:
assert(0);
}
}
}
free(pathbuf);
return rv;
}复制代码
getNameMax方法
该方法用于获取系统容许的最大文件名长度。在调用 getNameMax0 本地方法前会先作一些处理，若是路径时绝对路径，则获取根路径并加上 \\。
public int getNameMax(String path) {
String s = null;
if (path != null) {
File f = new File(path);
if (f.isAbsolute()) {
Path root = f.toPath().getRoot();
if (root != null) {
s = root.toString();
if (!s.endsWith("\\")) {
s = s + "\\";
}
}
}
}
return getNameMax0(s);
}
private native int getNameMax0(String path);复制代码
本地方法中经过 GetVolumeInformationW 函数获得系统容许的最大文件名长度 maxComponentLength
JNIEXPORT jint JNICALL
Java_java_io_WinNTFileSystem_getNameMax0(JNIEnv *env, jobject this,
jstring pathname)
{
BOOL res = 0;
DWORD maxComponentLength;
if (pathname == NULL) {
res = GetVolumeInformationW(NULL,
NULL,
0,
NULL,
&maxComponentLength,
NULL,
NULL,
0);
} else {
WITH_UNICODE_STRING(env, pathname, path) {
res = GetVolumeInformationW(path,
NULL,
0,
NULL,
&maxComponentLength,
NULL,
NULL,
0);
} END_UNICODE_STRING(env, path);
}
if (res == 0) {
JNU_ThrowIOExceptionWithLastError(env,
"Could not get maximum component length");
}
return (jint)maxComponentLength;
}复制代码
compare方法
该方法用于比较两个 File 对象，其实就是直接比较路径字符串。
public int compare(File f1, File f2) {
return f1.getPath().compareToIgnoreCase(f2.getPath());
}复制代码
hashCode方法
该方法用于获取 File 对象的哈希值，获取 File对象路径，再将字符串变成小写，再调用字符串的 hashCode 方法，最后与 1234321 进行异或运算，获得的值即为该文件的哈希值。
public int hashCode(File f) {
return f.getPath().toLowerCase(Locale.ENGLISH).hashCode() ^ 1234321;
}复制代码
如下是广告和相关阅读
=============广告时间===============
公众号的菜单已分为“分布式”、“机器学习”、“深度学习”、“NLP”、“Java深度”、“Java并发核心”、“JDK源码”、“Tomcat内核”等，可能有一款适合你的胃口。
鄙人的新书《Tomcat内核设计剖析》已经在京东销售了，有须要的朋友能够购买。感谢各位朋友。
=========================
相关阅读：
JDK不一样操做系统的FileSystem（Windows）上篇
JDK不一样操做系统的FileSystem（Windows）中篇
欢迎关注：
相关文章
- 1. JDK不一样操做系统的FileSystem（Windows）中篇
- 2. JDK不一样操做系统的FileSystem（Windows）上篇
- 3. JDK不一样操做系统的FileSystem（unix-like）下篇
- 4. JDK不一样操做系统的FileSystem（Windows&Unix-like）
- 5. JDK不一样操做系统的FileSystem（unix-like）中篇
- 6. JDK不一样操做系统的FileSystem（unix-like）上篇
- 7. MySQL5.7 不一样操做系统下的主从配置
- 8. linux操做系统下安装jdk
- 9. 在Windows操做系统下的gcc
- 10. 不一样内核的操做系统的备份方式
- 更多相关文章...
- • C# Windows 文件系统的操作 - C#教程
- • 操作系统（OS）平台 统计 - 浏览器信息
- • Docker容器实战(七) - 容器眼光下的文件系统
- • RxJava操作符（一）Creating Observables
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
- 1. 外部其他进程嵌入到qt FindWindow获得窗口句柄 报错无法链接的外部符号 [email protected] 无法被([email protected]@[email protected]@@引用
- 2. UVa 11524 - InCircle
- 3. The Monocycle（bfs）
- 4. VEC-C滑窗
- 5. 堆排序的应用-TOPK问题
- 6. 实例演示ElasticSearch索引查询term,match,match_phase,query_string之间的区别
- 7. 数学基础知识 集合
- 8. amazeUI 复择框问题解决
- 9. 背包问题理解
- 10. 算数平均-几何平均不等式的证明,从麦克劳林到柯西
欢迎关注本站公众号,获取更多信息
相关文章
- 1. JDK不一样操做系统的FileSystem（Windows）中篇
- 2. JDK不一样操做系统的FileSystem（Windows）上篇
- 3. JDK不一样操做系统的FileSystem（unix-like）下篇
- 4. JDK不一样操做系统的FileSystem（Windows&Unix-like）
- 5. JDK不一样操做系统的FileSystem（unix-like）中篇
- 6. JDK不一样操做系统的FileSystem（unix-like）上篇
- 7. MySQL5.7 不一样操做系统下的主从配置
- 8. linux操做系统下安装jdk
- 9. 在Windows操做系统下的gcc
- 10. 不一样内核的操做系统的备份方式