IOUtils.java
上传用户:quxuerui
上传日期:2018-01-08
资源大小:41811k
文件大小:5k
源码类别:

网格计算

开发平台:

Java

  1. /**
  2.  * Licensed to the Apache Software Foundation (ASF) under one
  3.  * or more contributor license agreements.  See the NOTICE file
  4.  * distributed with this work for additional information
  5.  * regarding copyright ownership.  The ASF licenses this file
  6.  * to you under the Apache License, Version 2.0 (the
  7.  * "License"); you may not use this file except in compliance
  8.  * with the License.  You may obtain a copy of the License at
  9.  *
  10.  *     http://www.apache.org/licenses/LICENSE-2.0
  11.  *
  12.  * Unless required by applicable law or agreed to in writing, software
  13.  * distributed under the License is distributed on an "AS IS" BASIS,
  14.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15.  * See the License for the specific language governing permissions and
  16.  * limitations under the License.
  17.  */
  18. package org.apache.hadoop.io;
  19. import java.io.*;
  20. import java.net.Socket;
  21. import org.apache.commons.logging.Log;
  22. import org.apache.hadoop.conf.Configuration;
  23. /**
  24.  * An utility class for I/O related functionality. 
  25.  */
  26. public class IOUtils {
  27.   /**
  28.    * Copies from one stream to another.
  29.    * @param in InputStrem to read from
  30.    * @param out OutputStream to write to
  31.    * @param buffSize the size of the buffer 
  32.    * @param close whether or not close the InputStream and 
  33.    * OutputStream at the end. The streams are closed in the finally clause.  
  34.    */
  35.   public static void copyBytes(InputStream in, OutputStream out, int buffSize, boolean close) 
  36.     throws IOException {
  37.     PrintStream ps = out instanceof PrintStream ? (PrintStream)out : null;
  38.     byte buf[] = new byte[buffSize];
  39.     try {
  40.       int bytesRead = in.read(buf);
  41.       while (bytesRead >= 0) {
  42.         out.write(buf, 0, bytesRead);
  43.         if ((ps != null) && ps.checkError()) {
  44.           throw new IOException("Unable to write to output stream.");
  45.         }
  46.         bytesRead = in.read(buf);
  47.       }
  48.     } finally {
  49.       if(close) {
  50.         out.close();
  51.         in.close();
  52.       }
  53.     }
  54.   }
  55.   
  56.   /**
  57.    * Copies from one stream to another. <strong>closes the input and output streams 
  58.    * at the end</strong>.
  59.    * @param in InputStrem to read from
  60.    * @param out OutputStream to write to
  61.    * @param conf the Configuration object 
  62.    */
  63.   public static void copyBytes(InputStream in, OutputStream out, Configuration conf)
  64.     throws IOException {
  65.     copyBytes(in, out, conf.getInt("io.file.buffer.size", 4096), true);
  66.   }
  67.   
  68.   /**
  69.    * Copies from one stream to another.
  70.    * @param in InputStrem to read from
  71.    * @param out OutputStream to write to
  72.    * @param conf the Configuration object
  73.    * @param close whether or not close the InputStream and 
  74.    * OutputStream at the end. The streams are closed in the finally clause.
  75.    */
  76.   public static void copyBytes(InputStream in, OutputStream out, Configuration conf, boolean close)
  77.     throws IOException {
  78.     copyBytes(in, out, conf.getInt("io.file.buffer.size", 4096),  close);
  79.   }
  80.   
  81.   /** Reads len bytes in a loop.
  82.    * @param in The InputStream to read from
  83.    * @param buf The buffer to fill
  84.    * @param off offset from the buffer
  85.    * @param len the length of bytes to read
  86.    * @throws IOException if it could not read requested number of bytes 
  87.    * for any reason (including EOF)
  88.    */
  89.   public static void readFully( InputStream in, byte buf[],
  90.       int off, int len ) throws IOException {
  91.     int toRead = len;
  92.     while ( toRead > 0 ) {
  93.       int ret = in.read( buf, off, toRead );
  94.       if ( ret < 0 ) {
  95.         throw new IOException( "Premeture EOF from inputStream");
  96.       }
  97.       toRead -= ret;
  98.       off += ret;
  99.     }
  100.   }
  101.   
  102.   /** Similar to readFully(). Skips bytes in a loop.
  103.    * @param in The InputStream to skip bytes from
  104.    * @param len number of bytes to skip.
  105.    * @throws IOException if it could not skip requested number of bytes 
  106.    * for any reason (including EOF)
  107.    */
  108.   public static void skipFully( InputStream in, long len ) throws IOException {
  109.     while ( len > 0 ) {
  110.       long ret = in.skip( len );
  111.       if ( ret < 0 ) {
  112.         throw new IOException( "Premeture EOF from inputStream");
  113.       }
  114.       len -= ret;
  115.     }
  116.   }
  117.   
  118.   /**
  119.    * Close the Closeable objects and <b>ignore</b> any {@link IOException} or 
  120.    * null pointers. Must only be used for cleanup in exception handlers.
  121.    * @param log the log to record problems to at debug level. Can be null.
  122.    * @param closeables the objects to close
  123.    */
  124.   public static void cleanup(Log log, java.io.Closeable... closeables) {
  125.     for(java.io.Closeable c : closeables) {
  126.       if (c != null) {
  127.         try {
  128.           c.close();
  129.         } catch(IOException e) {
  130.           if (log != null && log.isDebugEnabled()) {
  131.             log.debug("Exception in closing " + c, e);
  132.           }
  133.         }
  134.       }
  135.     }
  136.   }
  137.   /**
  138.    * Closes the stream ignoring {@link IOException}.
  139.    * Must only be called in cleaning up from exception handlers.
  140.    * @param stream the Stream to close
  141.    */
  142.   public static void closeStream( java.io.Closeable stream ) {
  143.     cleanup(null, stream);
  144.   }
  145.   
  146.   /**
  147.    * Closes the socket ignoring {@link IOException} 
  148.    * @param sock the Socket to close
  149.    */
  150.   public static void closeSocket( Socket sock ) {
  151.     // avoids try { close() } dance
  152.     if ( sock != null ) {
  153.       try {
  154.        sock.close();
  155.       } catch ( IOException ignored ) {
  156.       }
  157.     }
  158.   }
  159.   
  160.   /** /dev/null of OutputStreams.
  161.    */
  162.   public static class NullOutputStream extends OutputStream {
  163.     public void write(byte[] b, int off, int len) throws IOException {
  164.     }
  165.     public void write(int b) throws IOException {
  166.     }
  167.   }  
  168. }