Files中的工厂
Files类中对InputStream, OutputStream以及Reader,Writer的操作封装了抽象工厂模式,抽象工厂是InputSupplier与OutputSupplier,具体工厂是Files中的newInputStreamSupplier(), newOutputStreamSupplier()等方法
而InputStream, OutputStream以及Reader,Writer则是抽象产品, 他们的各种实现和装饰器包装则为具体产品
Input与Output工厂
Files中将Input与Output(包括InputStream,OutputStream和Reader,Writer两大IO派系)的生成使用抽象工厂来实现,其中代表抽象工厂的两个类为
public interface InputSupplier<T> { T getInput() throws IOException; } public interface InputSupplier<T> { T getInput() throws IOException; }
在某些类的对Input和Output操作的工具方法则会使用这个Supplier作为形参,例如
CharStreams.newReaderSupplier(
com.google.common.io.InputSupplier<? extends java.io.InputStream> in,
java.nio.charset.Charset charset
)
这样调用CharStreams.newReaderSupplier()便可以通过传入不同的Supplier具体实现来达到多态和解耦
Files类中的具体工厂实现
Files中工厂的具体实现抽象为了一个方法,如下:
public static InputSupplier<FileInputStream> newInputStreamSupplier( final File file) { Preconditions.checkNotNull(file); return new InputSupplier<FileInputStream>() { @Override public FileInputStream getInput() throws IOException { return new FileInputStream(file); } }; } public static OutputSupplier<FileOutputStream> newOutputStreamSupplier( File file) { return newOutputStreamSupplier(file, false); } public static OutputSupplier<FileOutputStream> newOutputStreamSupplier( final File file, final boolean append) { Preconditions.checkNotNull(file); return new OutputSupplier<FileOutputStream>() { @Override public FileOutputStream getOutput() throws IOException { return new FileOutputStream(file, append); } }; } public static InputSupplier<InputStreamReader> newReaderSupplier(File file, Charset charset) { return CharStreams.newReaderSupplier(newInputStreamSupplier(file), charset); } public static OutputSupplier<OutputStreamWriter> newWriterSupplier(File file, Charset charset) { return newWriterSupplier(file, charset, false); } public static OutputSupplier<OutputStreamWriter> newWriterSupplier(File file, Charset charset) { return newWriterSupplier(file, charset, false); }
这些工厂返回的产品大致包括了FileInputStream, FileOutputStream, Reader, Writer
文件读取与写入函数
/** * 这里有意思的有些特殊文件是file.length() == 0,但是文件却有实际内容 * 所以不能直接开辟一个file.length()大小的byte[] buff来读取文件内容 * Guava的解决方法是通过一个buff[0x1000]大小的buff来逐步读取这个特殊的文件 * 将其写入到一个OutputStream以后再一次性将它out.toByteArray()并返回 * * 而对于file.length() != 0 的情况,则是直接开辟一个byte[] buff[file.length()]大小的buff * 一次性将file里的内容读取到buff中并返回,从而避免额外像读取上面说的特殊文件那样频繁的开辟小的byte[] buff */ public static byte[] toByteArray(File file) throws IOException { Preconditions.checkArgument(file.length() <= Integer.MAX_VALUE); if (file.length() == 0) { // Some special files are length 0 but have content nonetheless. return ByteStreams.toByteArray(newInputStreamSupplier(file)); } else { // Avoid an extra allocation and copy. byte[] b = new byte[(int) file.length()]; boolean threw = true; InputStream in = new FileInputStream(file); try { ByteStreams.readFully(in, b); threw = false; } finally { Closeables.close(in, threw); } return b; } } /** * 通过toByteArray()方法将文件内容包装成字符串 */ public static String toString(File file, Charset charset) throws IOException { return new String(toByteArray(file), charset.name()); } /** * 使用小buff byte[0x1000] 的方法来copy文件 * 因为直接使用InputStream不像File.length()那样可以直接获得长度 */ public static void copy(InputSupplier<? extends InputStream> from, File to) throws IOException { ByteStreams.copy(from, newOutputStreamSupplier(to)); }
另外还有很多关于文件读取和写入函数的重载方法,实现方式大同小异,只是参数变化了一下
文件比较方法
/** * 依旧是那个问题,有些特殊文件显示的文件长度为0,所以必须通过读取文件的byte内容去比较是否相等 */ public static boolean equal(File file1, File file2) throws IOException { if (file1 == file2 || file1.equals(file2)) { return true; } /* * Some operating systems may return zero as the length for files * denoting system-dependent entities such as devices or pipes, in * which case we must fall back on comparing the bytes directly. */ long len1 = file1.length(); long len2 = file2.length(); if (len1 != 0 && len2 != 0 && len1 != len2) { return false; } return ByteStreams.equal(newInputStreamSupplier(file1), newInputStreamSupplier(file2)); }
临时目录的创建
/** * Atomically creates a new directory somewhere beneath the system's * temporary directory (as defined by the {@code java.io.tmpdir} system * property), and returns its name. * * <p>Use this method instead of {@link File#createTempFile(String, String)} * when you wish to create a directory, not a regular file. A common pitfall * is to call {@code createTempFile}, delete the file and create a * directory in its place, but this leads a race condition which can be * exploited to create security vulnerabilities, especially when executable * files are to be written into the directory. * * <p>This method assumes that the temporary volume is writable, has free * inodes and free blocks, and that it will not be called thousands of times * per second. * * @return the newly-created directory * @throws IllegalStateException if the directory could not be created */ public static File createTempDir() { File baseDir = new File(System.getProperty("java.io.tmpdir")); String baseName = System.currentTimeMillis() + "-"; for (int counter = 0; counter < TEMP_DIR_ATTEMPTS; counter++) { File tempDir = new File(baseDir, baseName + counter); if (tempDir.mkdir()) { return tempDir; } } throw new IllegalStateException("Failed to create directory within " + TEMP_DIR_ATTEMPTS + " attempts (tried " + baseName + "0 to " + baseName + (TEMP_DIR_ATTEMPTS - 1) + ')'); }
Guava Doc中说到,如果直接使用File.createTempFile()会有安全问题,先介绍一下createTempFile()
public static java.io.File createTempFile(java.lang.String prefix, java.lang.String suffix, java.io.File directory) throws java.io.IOException
它的功能是创建临时文件,提供prefix和suffix以及创建的dir,文件名会使用prefix+random+suffix的形式构成,而中间的random随机数则是使LazyInitialization.random.nextLong()生成,最后使用递归的方式生成这个临时文件
createTempFile()方法的返回值是生成文件以后的抽象路径File对象
根据doc的提示,应该使用 deleteOnExit()方法来删除临时文件,deleteOnExit()的意思是在JVM停止时才删除这个文件.相当于缓存了删除命令,如果有多个文件有deleteOnExit(),他们在JVM停止时会逆序开始删除(最后调用deleteOnExit()方法的文件最先删除,类似于栈)
所谓安全问题, StackOverflow上有人提到了,加入使用createTempFile()来创建临时目录,会这么写
public static File createTempDirectory() throws IOException { final File temp; temp = File.createTempFile("temp", Long.toString(System.nanoTime())); if(!(temp.delete())) { throw new IOException("Could not delete temp file: " + temp.getAbsolutePath()); } if(!(temp.mkdir())) { throw new IOException("Could not create temp directory: " + temp.getAbsolutePath()); } return (temp); }
然后参见几位网友的讨论
按照Sarel Botha的说法,使用了 file.mkdir() 的返回值做判断后抛出异常是不会有问题的
而如果没有使用file.mkdir()的返回值做判断, 潜在的问题是在于Linux的tmp目录使用了sticky bit(只能删除用户自己创建的文件), 在多线程情况下会存在file.delete()和file.mkdir()操作的线程竞争问题.具体是什么我也没搞清楚
原帖地址: http://stackoverflow.com/questions/617414/create-a-temporary-directory-in-java
随意总而言之, 就是使用Guava提供的createTmpDir()更安全