Java Code Examples for java.nio.file.attribute.FileTime#toMillis()

/**
 * Gets the last modified time for a symbolic link.
 *
 * Note: symbolic links are not followed (NOFOLLOW_LINKS LinkOption)
 *
 * @param link the path to the symbolic link
 * @return last modified time of the symbolic link
 */
public static long getLastModifiedTime(String link) {
  if (nonNull(link)) {
    try {
      Path linkPath = Paths.get(link);
      if (nonNull(linkPath)) {
        FileTime fileTimeObject = Files.getLastModifiedTime(linkPath, LinkOption.NOFOLLOW_LINKS);
        if (nonNull(fileTimeObject)) {
          return fileTimeObject.toMillis();
        }
      }
    } catch (Throwable thr) {
      Log.error("Unexpected exception invoking method: %s", thr.getLocalizedMessage());
      Log.exception(thr);
    }
  }
  return 0L;
}
 

static void testTimeConversions(long from, long to, long step) {
    ZipEntry ze = new ZipEntry("TestExtraTime.java");
    for (long time = from; time <= to; time += step) {
        ze.setTime(time);
        FileTime lastModifiedTime = ze.getLastModifiedTime();
        if (lastModifiedTime.toMillis() != time) {
            throw new RuntimeException("setTime should make getLastModifiedTime " +
                    "return the specified instant: " + time +
                    " got: " + lastModifiedTime.toMillis());
        }
        if (ze.getTime() != time) {
            throw new RuntimeException("getTime after setTime, expected: " +
                    time + " got: " + ze.getTime());
        }
    }
}
 

private Path getMostRecentCheckPointFile(Path dir) throws IOException {
    Path result = null;
    long lastMod = -1;
    Files.createDirectories(dir);
    try (DirectoryStream<Path> stream = Files.newDirectoryStream(dir)) {
        for (Path path : stream) {
            if (isTableOrIndexCheckpointsFile(path)) {
                LOGGER.log(Level.FINER, "getMostRecentCheckPointFile on " + dir.toAbsolutePath() + " -> ACCEPT " + path);
                FileTime lastModifiedTime = Files.getLastModifiedTime(path);
                long ts = lastModifiedTime.toMillis();
                if (lastMod < 0 || lastMod < ts) {
                    result = path;
                    lastMod = ts;
                }
            } else {
                LOGGER.log(Level.FINER, "getMostRecentCheckPointFile on " + dir.toAbsolutePath() + " -> SKIP " + path);
            }
        }
    }
    LOGGER.log(Level.FINER, "getMostRecentCheckPointFile on " + dir.toAbsolutePath() + " -> " + result);
    return result;
}
 

static void testTimeConversions(long from, long to, long step) {
    ZipEntry ze = new ZipEntry("TestExtraTime.java");
    for (long time = from; time <= to; time += step) {
        ze.setTime(time);
        FileTime lastModifiedTime = ze.getLastModifiedTime();
        if (lastModifiedTime.toMillis() != time) {
            throw new RuntimeException("setTime should make getLastModifiedTime " +
                    "return the specified instant: " + time +
                    " got: " + lastModifiedTime.toMillis());
        }
        if (ze.getTime() != time) {
            throw new RuntimeException("getTime after setTime, expected: " +
                    time + " got: " + ze.getTime());
        }
    }
}
 

public void setTimes(byte[] bs, FileTime mtime, FileTime atime, FileTime ctime) throws IOException
{
	org.apache.hadoop.fs.Path hp = new HadoopPath(this, bs).getRawResolvedPath();
	long mtime_millis = 0;
	long atime_millis = 0;
   // Get actual value
	if (mtime == null || atime == null)
	{
		FileStatus stat = this.fs.getFileStatus(hp);
     mtime_millis = stat.getModificationTime();
		atime_millis = stat.getAccessTime();
	}
   if (mtime != null) {
     mtime_millis = mtime.toMillis();
   }
   if (atime != null) {
     atime_millis = atime.toMillis();
   }
	this.fs.setTimes(hp, mtime_millis, atime_millis);
}
 

static void testTimeConversions(long from, long to, long step) {
    ZipEntry ze = new ZipEntry("TestExtraTime.java");
    for (long time = from; time <= to; time += step) {
        ze.setTime(time);
        FileTime lastModifiedTime = ze.getLastModifiedTime();
        if (lastModifiedTime.toMillis() != time) {
            throw new RuntimeException("setTime should make getLastModifiedTime " +
                    "return the specified instant: " + time +
                    " got: " + lastModifiedTime.toMillis());
        }
        if (ze.getTime() != time) {
            throw new RuntimeException("getTime after setTime, expected: " +
                    time + " got: " + ze.getTime());
        }
    }
}
 

private static long initialFileTime(File file) {
    Path path = file.toPath();
    if (Files.exists(path)) {
        try {
            BasicFileAttributes attrs = Files.readAttributes(path, BasicFileAttributes.class);
            FileTime fileTime = attrs.creationTime();
            if (fileTime.compareTo(EPOCH) > 0) {
                return fileTime.toMillis();
            }
            LOGGER.info("Unable to obtain file creation time for " + file.getAbsolutePath());
        } catch (Exception ex) {
            LOGGER.info("Unable to calculate file creation time for " + file.getAbsolutePath() + ": " + ex.getMessage());
        }
    }
    return file.lastModified();
}
 

static void testTimeConversions(long from, long to, long step) {
    ZipEntry ze = new ZipEntry("TestExtraTime.java");
    for (long time = from; time <= to; time += step) {
        ze.setTime(time);
        FileTime lastModifiedTime = ze.getLastModifiedTime();
        if (lastModifiedTime.toMillis() != time) {
            throw new RuntimeException("setTime should make getLastModifiedTime " +
                    "return the specified instant: " + time +
                    " got: " + lastModifiedTime.toMillis());
        }
        if (ze.getTime() != time) {
            throw new RuntimeException("getTime after setTime, expected: " +
                    time + " got: " + ze.getTime());
        }
    }
}
 

static void testTimeConversions(long from, long to, long step) {
    ZipEntry ze = new ZipEntry("TestExtraTime.java");
    for (long time = from; time <= to; time += step) {
        ze.setTime(time);
        FileTime lastModifiedTime = ze.getLastModifiedTime();
        if (lastModifiedTime.toMillis() != time) {
            throw new RuntimeException("setTime should make getLastModifiedTime " +
                    "return the specified instant: " + time +
                    " got: " + lastModifiedTime.toMillis());
        }
        if (ze.getTime() != time) {
            throw new RuntimeException("getTime after setTime, expected: " +
                    time + " got: " + ze.getTime());
        }
    }
}
 

/**
 * Gets the last modified time for a symbolic link.
 *
 * Note: symbolic links are not followed (NOFOLLOW_LINKS LinkOption)
 *
 * @param link the path to the symbolic link
 * @return last modified time of the symbolic link
 */
public static long getLastModifiedTime(String link) {
  if (nonNull(link)) {
    try {
      Path linkPath = Paths.get(link);
      if (nonNull(linkPath)) {
        FileTime fileTimeObject = Files.getLastModifiedTime(linkPath, LinkOption.NOFOLLOW_LINKS);
        if (nonNull(fileTimeObject)) {
          return fileTimeObject.toMillis();
        }
      }
    // p4ic4idea: Do not catch throwable unless you're really careful
    //} catch (Throwable thr) {
    } catch (Exception thr) {
      Log.error("Unexpected exception invoking method: %s", thr.getLocalizedMessage());
      Log.exception(thr);
    }
  }
  return 0L;
}
 

/**
 * Gets the last modified time for a symbolic link.
 *
 * Note: symbolic links are not followed (NOFOLLOW_LINKS LinkOption)
 *
 * @param link the path to the symbolic link
 * @return last modified time of the symbolic link
 */
public static long getLastModifiedTime(String link) {
  if (nonNull(link)) {
    try {
      Path linkPath = Paths.get(link);
      if (nonNull(linkPath)) {
        FileTime fileTimeObject = Files.getLastModifiedTime(linkPath, LinkOption.NOFOLLOW_LINKS);
        if (nonNull(fileTimeObject)) {
          return fileTimeObject.toMillis();
        }
      }
    } catch (Throwable thr) {
      Log.error("Unexpected exception invoking method: %s", thr.getLocalizedMessage());
      Log.exception(thr);
    }
  }
  return 0L;
}
 

/**
 * 从jar包中查找指定接口的一个实现类 非反射
 *
 * @param interfaceClass
 * @param jarPath
 * @return
 * @throws Exception
 */
public static Class findImplementFromJar(Class interfaceClass, URL jarPath) throws Exception {
    URL url = new URL("jar:" + jarPath.toString() + "!/");
    JarURLConnection jarConnection = (JarURLConnection) url.openConnection();
    JarFile jarFile = jarConnection.getJarFile();
    Enumeration<JarEntry> je = jarFile.entries();
    boolean flag = false;
    while (je.hasMoreElements()) {
        JarEntry e = je.nextElement();
        String n = e.getName();
        FileTime ft = e.getLastModifiedTime();
        if (DateUtils.addDays(new Date(), -100).getTime() - ft.toMillis() > 0) {
            LOGGER.info("jar文件时间超过100天，跳过查找实现类：" + jarFile.getName().substring(jarFile.getName().lastIndexOf("\\")) + ft.toString());
            return null;
        } else {
            if (!flag) {
                flag = true;
                LOGGER.info("在" + jarFile.getName().substring(jarFile.getName().lastIndexOf("\\")) + "中查找实现类");
            }
        }
        if (n.endsWith(".class")) {
            n = n.substring(0, n.length() - 6);
            n = n.replace('/', '.');
            Class currentClass = ClassLoader.getSystemClassLoader().loadClass(n);
            if (interfaceClass.isAssignableFrom(currentClass) && !n.equals(interfaceClass.getName())) {
                return currentClass;
            }
        }
    }
    return null;
}
 

public static long getFileCreateTime(final String filename) {
    try {
        FileTime t = Files.readAttributes(Paths.get(filename), BasicFileAttributes.class).creationTime();
        return t.toMillis();
    } catch (Exception e) {
        return -1;
    }
}
 

public boolean hasNext() {

      while (true) {
        if (!dirStreamIterator.hasNext()) {
          nextMFile = null;
          return false;
        }

        try {
          Path nextPath = dirStreamIterator.next();
          BasicFileAttributes attr = Files.readAttributes(nextPath, BasicFileAttributes.class);

          if (wantSubdirs && attr.isDirectory()) { // dont filter subdirectories
            subdirs.add(new OneDirIterator(nextPath, subdirs));
            continue;
          }

          if (!matcher.matches(nextPath)) // otherwise apply the filter specified by the specp
            continue;

          if (olderThanMillis > 0) {
            FileTime last = attr.lastModifiedTime();
            long millisSinceModified = now - last.toMillis();
            if (millisSinceModified < olderThanMillis)
              continue;
          }
          nextMFile = new MFileOS7(nextPath, attr);
          return true;

        } catch (IOException e) {
          throw new RuntimeException(e);
        }
      }
    }
 

/**
 * アーカイブされているログが最大保持世代数のときに最古の アーカイブログを削除する.
 * @param parent アーカイブログが格納されているディレクトリの親ディレクトリを示すオブジェクト
 */
private void removeOldestArchiveLog(File parent) {
    // アーカイブファイル数が保持世代(12世代)を超える場合は、最古のファイルを削除する
    File[] files = parent.listFiles();
    File oldest = null;
    FileTime oldestTime = null;
    if (files.length >= maxIndex - minIndex + 1) {
        for (File archive : files) {
            if (null == oldest) {
                oldest = archive;
            } else {
                try {
                    FileTime archiveTime = Files.getLastModifiedTime(archive.toPath());
                    oldestTime = Files.getLastModifiedTime(oldest.toPath());
                    if (archiveTime.toMillis() < oldestTime.toMillis()) {
                        oldest = archive;
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        if (null != oldest && oldest.exists()) {
            logger.info("olddest archive file will be deleted.");
            logger.info("oldestFile Name: " + oldest.getPath() + ", timestamp: " + oldestTime.toMillis());
            logger.info("number of existing files:" + files.length + ", max number of files: "
                    + (maxIndex - minIndex + 1));
            if (oldest.delete()) {
                logger.warn("Failed to oldest archive file: " + oldest.getPath());
            }
        }
    }
}
 

@Test
public void headers() throws IOException {
  byte[] bytes = {1, 2, 3};
  Files.write(path, bytes);
  FileTime lastModified = Files.getLastModifiedTime(path);

  URL url = path.toUri().toURL();
  URLConnection conn = url.openConnection();

  // read header fields directly
  assertThat(conn.getHeaderFields()).containsEntry("content-length", ImmutableList.of("3"));
  assertThat(conn.getHeaderFields())
      .containsEntry("content-type", ImmutableList.of("application/octet-stream"));

  if (lastModified != null) {
    assertThat(conn.getHeaderFields()).containsKey("last-modified");
    assertThat(conn.getHeaderFields()).hasSize(3);
  } else {
    assertThat(conn.getHeaderFields()).hasSize(2);
  }

  // use the specific methods for reading the expected headers
  assertThat(conn.getContentLengthLong()).isEqualTo(Files.size(path));
  assertThat(conn.getContentType()).isEqualTo("application/octet-stream");

  if (lastModified != null) {
    // The HTTP date format does not include milliseconds, which means that the last modified time
    // returned from the connection may not be exactly the same as that of the file system itself.
    // The difference should less than 1000ms though, and should never be greater.
    long difference = lastModified.toMillis() - conn.getLastModified();
    assertThat(difference).isIn(Range.closedOpen(0L, 1000L));
  } else {
    assertThat(conn.getLastModified()).isEqualTo(0L);
  }
}
 

private long getCreationTime(File file) {
    try {
        BasicFileAttributes attr = Files.readAttributes(file.toPath(), BasicFileAttributes.class);
        FileTime fileTime = attr.creationTime();
        return fileTime.toMillis();
    } catch (IOException e) {
        LOGGER.error("", e);
        // handle exception
        return 0l;
    }
}
 

private boolean canUseCache() throws IOException {
    if (CACHE_FILE.exists()) {
        BasicFileAttributes attr = Files.readAttributes(CACHE_FILE.toPath(), BasicFileAttributes.class);
        FileTime fileTime = attr != null ? attr.creationTime() : null;
        Long time = fileTime != null ? fileTime.toMillis() : null;
        // Update the cache every day
        return time != null && time.compareTo(System.currentTimeMillis() - 1000 * 60 * 60 * 24) > 0;
    }

    return false;
}
 

public boolean hasNext() {
  while (true) {
    // if (debug && count % 100 == 0) System.out.printf("%d ", count);
    count++;
    if (!dirStreamIterator.hasNext()) {
      nextMFile = null;
      return false;
    }

    long now = System.currentTimeMillis();
    try {
      Path nextPath = dirStreamIterator.next();
      BasicFileAttributes attr = Files.readAttributes(nextPath, BasicFileAttributes.class);
      if (attr.isDirectory())
        continue;
      FileTime last = attr.lastModifiedTime();
      long millisSinceModified = now - last.toMillis();
      if (millisSinceModified < olderThanMillis)
        continue;
      nextMFile = new MFileOS7(nextPath, attr);
      return true;

    } catch (IOException e) {
      throw new RuntimeException(e);
    }
  }
}
 

public static Long getFileCreationTime(File file) throws IOException {
    Path p = Paths.get(file.getAbsolutePath());
    BasicFileAttributes view = Files.getFileAttributeView(p, BasicFileAttributeView.class).readAttributes();
    FileTime fileTime = view.creationTime();
    return fileTime.toMillis();
}