Java tutorial
/******************************************************************************* * Copyright (c) 2010-2011 VIVO Harvester Team. For full list of contributors, please see the AUTHORS file provided. * All rights reserved. * This program and the accompanying materials are made available under the terms of the new BSD license which accompanies this distribution, and is available at http://www.opensource.org/licenses/bsd-license.html ******************************************************************************/ package org.vivoweb.harvester.util; import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.File; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.io.OutputStream; import java.io.OutputStreamWriter; import java.util.HashSet; import java.util.LinkedHashSet; import java.util.Set; import org.apache.commons.vfs.AllFileSelector; import org.apache.commons.vfs.FileObject; import org.apache.commons.vfs.FileSystemException; import org.apache.commons.vfs.FileType; import org.apache.commons.vfs.Selectors; import org.apache.commons.vfs.VFS; import org.slf4j.Logger; import org.slf4j.LoggerFactory; /** * Assists in common tasks using Files * @author Christopher Haines hainesc@ufl.edu */ public class FileAide { /** * SLF4J Logger */ static Logger log = LoggerFactory.getLogger(FileAide.class); /** * Set of registered temp files to delete on JVM shutdown */ static Set<String> deleteOnExitSet; /** * Resolves a FileObject relative to the execution directory * @param path the path to resolve * @return the FileObject * @throws IOException error resolving */ private static FileObject getFileObject(String path) throws IOException { if (path == null) { return null; } return VFS.getManager().resolveFile(new File("."), path); } /** * Checks if the path exists * @param path the path to resolve * @return true if exists, false otherwise * @throws IOException error resolving path */ public static boolean exists(String path) throws IOException { return getFileObject(path).exists(); } /** * Deletes the file at the given path * @param path the path to delete * @return true if deleted, false otherwise * @throws IOException error resolving path */ public static boolean delete(String path) throws IOException { FileObject file = getFileObject(path); if (!file.exists()) { return true; } if (isFolder(path)) { try { for (FileObject subFile : file.findFiles(new AllFileSelector())) { try { String subPath = subFile.getName().getPath(); if (!subPath.equals(path)) { delete(subPath); } } catch (FileSystemException e) { //log.trace(e.getMessage(), e); } } file.delete(new AllFileSelector()); } catch (FileSystemException e) { //log.trace(e.getMessage(), e); throw new IOException("Error deleting file!"); } } return file.delete(); } /** * Creates a file at the given path * @param path the path to the file to create * @throws IOException error resolving path */ public static void createFile(String path) throws IOException { getFileObject(path).createFile(); } /** * Creates a folder at the given path * @param path the path to the folder to create * @throws IOException error resolving path */ public static void createFolder(String path) throws IOException { getFileObject(path).createFolder(); } /** * Determines if a folder is at the given path * @param path the path to determine if it is a folder * @return true if a folder, false otherwise * @throws IOException error resolving path */ public static boolean isFolder(String path) throws IOException { FileType type = getFileObject(path).getType(); return (type == FileType.FOLDER || type == FileType.FILE_OR_FOLDER); } /** * Determines if a file is at the given path * @param path the path to determine if it is a file * @return true if a file, false otherwise * @throws IOException error resolving path */ public static boolean isFile(String path) throws IOException { FileType type = getFileObject(path).getType(); return (type == FileType.FILE || type == FileType.FILE_OR_FOLDER); } /** * Determines if the given path is Readable * @param path the path to determine if it is a readable * @return true if readable, false otherwise * @throws IOException error resolving path */ public static boolean isReadable(String path) throws IOException { return getFileObject(path).isReadable(); } /** * Determines if the given path is Writeable * @param path the path to determine if it is a writeable * @return true if writeable, false otherwise * @throws IOException error resolving path */ public static boolean isWriteable(String path) throws IOException { return getFileObject(path).isWriteable(); } /** * Resolves the path and gets an input stream for this file * @param path the path to resolve * @return the InputStream * @throws IOException error resolving */ public static InputStream getInputStream(String path) throws IOException { if (path == null) { return null; } return getFileObject(path).getContent().getInputStream(); } // /** // * Resolves the path and gets the contents of the file as a byte array // * @param path the path to resolve // * @return the byte array // * @throws IOException error resolving // */ // public static byte[] getContent(String path) throws IOException { // if(path == null) { // return null; // } // FileContent content = getFileObject(path).getContent(); // byte[] retVal = new byte[(int)content.getSize()]; // InputStream is = content.getInputStream(); // is.read(retVal); // return retVal; // } /** * Resolves the path and gets the contents of the file as a text string * @param path the path to resolve * @return the string * @throws IOException error resolving */ public static String getTextContent(String path) throws IOException { return getTextContent(path, null); } /** * Resolves the path and gets the contents of the file as a text string * @param path the path to resolve * @param charsetName the characterset to use * @return the string * @throws IOException error resolving */ public static String getTextContent(String path, String charsetName) throws IOException { if (path == null) { return null; } StringBuilder sb = new StringBuilder(); InputStreamReader isr; if (charsetName == null) { isr = new InputStreamReader(getInputStream(path)); } else { isr = new InputStreamReader(getInputStream(path), charsetName); } BufferedReader br = new BufferedReader(isr); String temp = null; while ((temp = br.readLine()) != null) { sb.append(temp); } return sb.toString(); } /** * Resolves the path and sets the contents of the file from a text string (overwrites existing files) * @param path the path to resolve * @param value the value to set as the text content * @throws IOException error resolving */ public static void setTextContent(String path, String value) throws IOException { setTextContent(path, value, true); } /** * Resolves the path and sets the contents of the file from a text string * @param path the path to resolve * @param value the value to set as the text content * @param overwrite overwrite an existing file * @throws IOException error resolving */ public static void setTextContent(String path, String value, boolean overwrite) throws IOException { if (path == null) { throw new IllegalArgumentException("File path must not be null"); } BufferedWriter bw = null; try { if (!overwrite && exists(path)) { throw new IOException("Failed to set file text content because file " + path + " already exists."); } createFile(path); if (!isWriteable(path)) { throw new IOException("Insufficient file system privileges to modify file " + path); } bw = new BufferedWriter(new OutputStreamWriter(getOutputStream(path))); bw.append(value); bw.close(); } catch (IOException e) { if (bw != null) { try { bw.close(); } catch (Exception ignore) { // Ignore } } throw e; } finally { if (bw != null) { try { bw.close(); } catch (Exception ignore) { // Ignore } } } } /** * Resolves the path and gets an output stream for this file * @param path the path to resolve * @return the OutputStream * @throws IOException error resolving */ public static OutputStream getOutputStream(String path) throws IOException { return getOutputStream(path, false); } /** * Resolves the path and gets an output stream for this file * @param path the path to resolve * @param append append to the file * @return the OutputStream * @throws IOException error resolving */ public static OutputStream getOutputStream(String path, boolean append) throws IOException { if (path == null) { return null; } return getFileObject(path).getContent().getOutputStream(append); } /** * Get a set of non-hidden direct children of the given path * @param path the path to search under * @return a set of non-hidden direct children * @throws IOException error resolving path */ public static Set<String> getNonHiddenChildren(String path) throws IOException { Set<String> allFileListing = new HashSet<String>(); for (FileObject file : getFileObject(path).findFiles(Selectors.SELECT_CHILDREN)) { if (!file.isHidden() && (file.getType() == FileType.FILE)) { allFileListing.add(file.getName().getBaseName()); } } return allFileListing; } /** * Get an inputstream from the first file under the given path with a matching fileName * @param path the path to search under * @param fileName the file name to match * @return an input stream to the matched file, null if none found * @throws IOException error resolving path */ public static InputStream getFirstFileNameChildInputStream(String path, String fileName) throws IOException { for (FileObject file : FileAide.getFileObject(path).findFiles(new AllFileSelector())) { if (file.getName().getBaseName().equals(fileName)) { return file.getContent().getInputStream(); } } return null; } /** * Creates an empty file in the default temporary-file directory, using the given prefix and suffix to generate its name. Invoking this method is equivalent to invoking createTempFile(prefix, suffix, null). * @param prefix The prefix string to be used in generating the file's name; must be at least three characters long. * @param suffix The suffix string to be used in generating the file's name; may be null, in which case the suffix ".tmp" will be used. * @return An abstract pathname denoting a newly-created empty file. * @throws IllegalArgumentException - If the prefix argument contains fewer than three characters. * @throws IOException - If a file could not be created. * @throws SecurityException - If a security manager exists and its SecurityManager.checkWrite(java.lang.String) method does not allow a file to be created. */ public static synchronized File createTempFile(String prefix, String suffix) throws IOException { File tempFile = File.createTempFile(prefix, suffix); if (deleteOnExitSet == null) { deleteOnExitSet = new LinkedHashSet<String>(); Runtime.getRuntime().addShutdownHook(new Thread() { @Override public void run() { synchronized (FileAide.deleteOnExitSet) { for (String fpath : FileAide.deleteOnExitSet) { try { if (!delete(fpath)) { log.warn("Failed to delete temporary file space {}, please remove manually ", fpath); } else { log.trace("Deleted temporary file space {} ", fpath); } } catch (IOException e) { log.warn("Failed to delete temporary file space {}, please remove manually ", fpath); } } FileAide.deleteOnExitSet.clear(); FileAide.deleteOnExitSet = null; } } }); } synchronized (FileAide.deleteOnExitSet) { FileAide.deleteOnExitSet.add(tempFile.getAbsolutePath()); log.trace("Allocating temporary file space {} ", tempFile.getAbsolutePath()); } return tempFile; } }