• Guava Files 源码分析(一)


    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()更安全

    未完待续 ... 

  • 相关阅读:
    【STM32F429开发板用户手册】第11章 STM32F429移植SEGGER的硬件异常分析
    【STM32F407开发板用户手册】第11章 STM32F407移植SEGGER的硬件异常分析
    【STM32F429开发板用户手册】第10章 STM32F429的FLASH,RAM和栈使用情况(map和htm文件)
    【STM32F407开发板用户手册】第10章 STM32F407的FLASH,RAM和栈使用情况(map和htm文件)
    【STM32F4029开发板用户手册】第9章 STM32F429重要知识点数据类型,变量和堆栈
    手写Mybatis插件
    Mybatis插件原理和整合Spring
    深入分析代理模式
    Mybatis源码(五)
    Mybatis源码(六)
  • 原文地址:https://www.cnblogs.com/zemliu/p/3316030.html
Copyright © 2020-2023  润新知