001/* 002 * Copyright (C) 2007 The Guava Authors 003 * 004 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except 005 * in compliance with the License. You may obtain a copy of the License at 006 * 007 * http://www.apache.org/licenses/LICENSE-2.0 008 * 009 * Unless required by applicable law or agreed to in writing, software distributed under the License 010 * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express 011 * or implied. See the License for the specific language governing permissions and limitations under 012 * the License. 013 */ 014 015package com.google.common.io; 016 017import com.google.common.annotations.Beta; 018import com.google.common.annotations.GwtIncompatible; 019import com.google.common.annotations.VisibleForTesting; 020import java.io.Closeable; 021import java.io.IOException; 022import java.io.InputStream; 023import java.io.Reader; 024import java.util.logging.Level; 025import java.util.logging.Logger; 026import org.checkerframework.checker.nullness.qual.Nullable; 027 028/** 029 * Utility methods for working with {@link Closeable} objects. 030 * 031 * @author Michael Lancaster 032 * @since 1.0 033 */ 034@Beta 035@GwtIncompatible 036public final class Closeables { 037 @VisibleForTesting static final Logger logger = Logger.getLogger(Closeables.class.getName()); 038 039 private Closeables() {} 040 041 /** 042 * Closes a {@link Closeable}, with control over whether an {@code IOException} may be thrown. 043 * This is primarily useful in a finally block, where a thrown exception needs to be logged but 044 * not propagated (otherwise the original exception will be lost). 045 * 046 * <p>If {@code swallowIOException} is true then we never throw {@code IOException} but merely log 047 * it. 048 * 049 * <p>Example: 050 * 051 * <pre>{@code 052 * public void useStreamNicely() throws IOException { 053 * SomeStream stream = new SomeStream("foo"); 054 * boolean threw = true; 055 * try { 056 * // ... code which does something with the stream ... 057 * threw = false; 058 * } finally { 059 * // If an exception occurs, rethrow it only if threw==false: 060 * Closeables.close(stream, threw); 061 * } 062 * } 063 * }</pre> 064 * 065 * @param closeable the {@code Closeable} object to be closed, or null, in which case this method 066 * does nothing 067 * @param swallowIOException if true, don't propagate IO exceptions thrown by the {@code close} 068 * methods 069 * @throws IOException if {@code swallowIOException} is false and {@code close} throws an {@code 070 * IOException}. 071 */ 072 public static void close(@Nullable Closeable closeable, boolean swallowIOException) 073 throws IOException { 074 if (closeable == null) { 075 return; 076 } 077 try { 078 closeable.close(); 079 } catch (IOException e) { 080 if (swallowIOException) { 081 logger.log(Level.WARNING, "IOException thrown while closing Closeable.", e); 082 } else { 083 throw e; 084 } 085 } 086 } 087 088 /** 089 * Closes the given {@link InputStream}, logging any {@code IOException} that's thrown rather than 090 * propagating it. 091 * 092 * <p>While it's not safe in the general case to ignore exceptions that are thrown when closing an 093 * I/O resource, it should generally be safe in the case of a resource that's being used only for 094 * reading, such as an {@code InputStream}. Unlike with writable resources, there's no chance that 095 * a failure that occurs when closing the stream indicates a meaningful problem such as a failure 096 * to flush all bytes to the underlying resource. 097 * 098 * @param inputStream the input stream to be closed, or {@code null} in which case this method 099 * does nothing 100 * @since 17.0 101 */ 102 public static void closeQuietly(@Nullable InputStream inputStream) { 103 try { 104 close(inputStream, true); 105 } catch (IOException impossible) { 106 throw new AssertionError(impossible); 107 } 108 } 109 110 /** 111 * Closes the given {@link Reader}, logging any {@code IOException} that's thrown rather than 112 * propagating it. 113 * 114 * <p>While it's not safe in the general case to ignore exceptions that are thrown when closing an 115 * I/O resource, it should generally be safe in the case of a resource that's being used only for 116 * reading, such as a {@code Reader}. Unlike with writable resources, there's no chance that a 117 * failure that occurs when closing the reader indicates a meaningful problem such as a failure to 118 * flush all bytes to the underlying resource. 119 * 120 * @param reader the reader to be closed, or {@code null} in which case this method does nothing 121 * @since 17.0 122 */ 123 public static void closeQuietly(@Nullable Reader reader) { 124 try { 125 close(reader, true); 126 } catch (IOException impossible) { 127 throw new AssertionError(impossible); 128 } 129 } 130}