Cierre Java InputStreams

Question

Tengo algunas preguntas sobre el uso del método close() al usar Java InputStreams. Según lo que veo y leo de la mayoría de los desarrolladores, siempre debes llamar explícitamente a close() en un InputStream cuando ya no sea necesario. Pero, hoy en día que estaba buscando en el uso de un archivo de propiedades Java, y cada ejemplo que he encontrado tiene algo como esto:

Properties props = new Properties(); 
try { 
    props.load(new FileInputStream("message.properties")); 
    //omitted. 
} catch (Exception ex) {} 

Con el ejemplo anterior, no hay manera de llamar explícitamente a close() porque el InputStream es inalcanzable después de que se utiliza. He visto muchos usos similares de InputStreams a pesar de que parece contradecir lo que la mayoría de la gente dice sobre el cierre explícito. Leí los JavaDocs de Oracle y no menciona si el método Properties.load() cierra el InputStream. Me pregunto si esto es aceptable en general o si se prefiere hacer algo más parecido a lo siguiente:

Properties props = new Properties(); 
InputStream fis = new FileInputStream("message.properties"); 
try { 
    props.load(fis); 
    //omitted. 
} catch (Exception ex) { 
    //omitted. 
} finally { 
    try { 
     fis.close(); 
    } catch (IOException ioex) { 
     //omitted. 
    } 
} 

¿Qué camino es mejor y/o más eficiente? ¿O de verdad importa?

Answer 1

Los ejemplos de la Properties Tutorial cierran la FileInputStream explícitamente después de la carga, por lo que creo que es seguro asumir que el método load no es responsable de la misma, lo eres.

// create and load default properties 
Properties defaultProps = new Properties(); 
FileInputStream in = new FileInputStream("defaultProperties"); 
defaultProps.load(in); 
in.close(); 

Sólo como referencia, he comprobado la ejecución de Apache HarmonyProperties, y lo hace no cerrar la corriente de carga.

Answer 2

Parece que la primera muestra de código termina confiando en el método de finalización en FileInputStream para cerrar realmente el archivo. Diría que su segundo ejemplo es mejor, aunque en ambos casos el archivo se cierra.

Existen casos como las secuencias de bytes donde cerrar no hace nada y se pueden omitir, de lo contrario, creo que es mejor cerrar el archivo explícitamente en un bloque finally. Si lo abres, lo cierras.

Hay un libro en el sitio de Oracle llamado Java Platform Performance que discute finalizadores en su apéndice, que dice:

Usted es casi siempre mejor que hace su propia limpieza en lugar de depender de un finalizador. El uso de un finalizador también puede dejar recursos críticos que no se recuperarán durante un tiempo indeterminado. Si está considerando utilizar un finalizador para garantizar que los recursos importantes se liberen de manera oportuna, es posible que desee reconsiderarlo.

Answer 3

No menciona en la documentación que props.load cerraría el flujo de entrada. Debe cerrar la secuencia de entrada manualmente en un bloque finally como sugiere.

No es normal que una función cierre un InputStream. Se aplica la misma convención que con la memoria en lenguajes no recogidos de basura: si es posible, el que abre la secuencia debe cerrar la secuencia. De lo contrario, es muy fácil dejar una secuencia abierta (cree que una función va a cerrarla, pero no, o algo así ...)

Answer 4

La clase Propiedades ajusta la secuencia de entrada en un LineReader para leer las propiedades archivo. Como usted proporciona el flujo de entrada, es su responsabilidad cerrarlo.

El segundo ejemplo es una mejor manera de manejar la transmisión, por mucho, no confíe en que alguien más la cierre por usted.

Una mejora que podría hacer es utilizar IOUtils.closeQuietly()

http://commons.apache.org/io/api-1.2/org/apache/commons/io/IOUtils.html#closeQuietly(java.io.InputStream)

para cerrar el flujo, por ejemplo,:

Properties props = new Properties(); 
InputStream fis = new FileInputStream("message.properties"); 
try { 
    props.load(fis); 
    //omitted. 
} catch (Exception ex) { 
    //omitted. 
} finally { 
    IOUtils.closeQuietly(fis); 
} 

Answer 5

Déjenme agregar algo a las respuestas de otras personas.

Si puede importar Apache Commons IO, se puede hacer uso de los AutoCloseInputStream s clases siempre tan prácticos: usted envuelve su InputStream y luego sólo tiene que utilizar su instancia envuelta y se pone automáticamente cerrado tan pronto como el final de la entrada tiene se ha alcanzado o cuando la transmisión se cierra explícitamente, lo que ocurra primero.

Answer 6

Me gustaría ir con unos recursos try-con-(al menos para Java 7+):

Properties props = new Properties(); 

try(InputStream fis = new FileInputStream("message.properties")) { 
    props.load(fis); 
    //omitted. 
} catch (Exception ex) { 
    //omitted. 
} 

La estrecha() llamada debería ser llamado de forma automática cuando se sale del bloque try.

Answer 7

Si está utilizando Java 7+ puede utilizar esto:

try(InputStream is = new FileInputStream("message.properties")) { 
    // ... 
}