file-io finally - java prova finalmente a bloccare per chiudere il flusso




try catch (7)

Sì, è goffo, brutto e confuso. Una possibile soluzione è quella di usare Commons IO che offre un metodo closeQuietly .

C'è una serie di domande nella colonna "Correlata" nella parte destra di questa pagina che sono in realtà duplicati, vi consiglio di dare un'occhiata a questi per altri modi di affrontare questo problema.

Voglio chiudere il mio stream nel blocco finally, ma lancia una IOException quindi sembra che dovrò nidificare un altro blocco try nel mio blocco finally per chiudere lo stream. È il modo giusto per farlo? Sembra un po 'goffo.

Ecco il codice:

 public void read() {
    try {
        r = new BufferedReader(new InputStreamReader(address.openStream()));
        String inLine;
        while ((inLine = r.readLine()) != null) {
            System.out.println(inLine);
        }
    } catch (IOException readException) {
        readException.printStackTrace();
    } finally {
        try {
            if (r!=null) r.close();
        } catch (Exception e){
            e.printStackTrace();
        }
    }


}

Sembra un po 'goffo.

È. Almeno la prova di java7 con le risorse risolve questo.

Pre java7 puoi creare una funzione closeStream che la inghiotte:

public void closeStream(Closeable s){
    try{
        if(s!=null)s.close();
    }catch(IOException e){
        //Log or rethrow as unchecked (like RuntimException) ;)
    }
}

Oppure metti alla prova ... finalmente all'interno del try catch:

try{
    BufferedReader r = new BufferedReader(new InputStreamReader(address.openStream()));
    try{

        String inLine;
        while ((inLine = r.readLine()) != null) {
            System.out.println(inLine);
        }
    }finally{
        r.close();
    }
}catch(IOException e){
    e.printStackTrace();
}

È più prolisso e un'eccezione alla fine ne nasconderà uno nel tentativo ma è semanticamente più vicino alle try-with-resources introdotte in Java 7.


public void enumerateBar() throws SQLException {
    Statement statement = null;
    ResultSet resultSet = null;
    Connection connection = getConnection();
    try {
        statement = connection.createStatement();
        resultSet = statement.executeQuery("SELECT * FROM Bar");
        // Use resultSet
    }
    finally {
        try {
            if (resultSet != null)
                resultSet.close();
        }
        finally {
            try {
                if (statement != null)
                    statement.close();
            }
            finally {
                connection.close();
            }
        }
    }
}

private Connection getConnection() {
    return null;
}

source . Questo esempio è stato utile per me.


Inoltre, se stai utilizzando Java 7, puoi utilizzare try-with-resources :

try(BufferedReader r = new BufferedReader(new InputStreamReader(address.openStream()))) {
    String inLine;
    while ((inLine = r.readLine()) != null) {
        System.out.println(inLine);
    }
} catch(IOException readException) {
    readException.printStackTrace();
}           

In Java 7 puoi farlo ...

try (BufferedReader r = new BufferedReader(...)){
     String inLine;
     while ((inLine = r.readLine()) != null) {
          System.out.println(inLine);
     }
} catch(IOException e) {
   //handle exception
}
  • La dichiarazione di una variabile nel blocco try richiede l'implementazione di AutoCloseable .
  • La dichiarazione di una variabile nel blocco try limita anche il suo ambito al blocco try.
  • Qualsiasi variabile dichiarata nel blocco try verrà automaticamente chiamata close() quando viene close() il blocco try.

Si chiama prova con le risorse .


Il tuo approccio all'interno è finalmente corretto. Se il codice che si chiama in un blocco finally può generare un'eccezione, assicurarsi di gestirlo o registrarlo. Non lasciarlo mai fuoriuscire dal blocco finale.

All'interno del blocco catch stai ingoiando l'eccezione - che non è corretta.

Grazie...


Usando questa libreria , è una riga:

String data = IO.from(new File("data.txt")).toString();




java file-io stream try-catch finally