Try-catch-enfin et puis à nouveau un essai de capture

Question

J'ai souvent rencontré des situations comme: -

 try{ 
     ...
     stmts
     ...
} 
catch(Exception ex) {
     ... 
     stmts
     ... 
} finally {
     connection.close // throws an exception
}
 

qui a encore besoin d'un bloc try-catch enfin à l'intérieur.

Quelle est la meilleure pratique pour surmonter cela?

Answer 1

Écrivez une classe SQLUtils qui contient les méthodes static closeQuietly qui interceptent et consignent ces exceptions, puis utilisez-les de manière appropriée.

Vous vous retrouverez avec quelque chose qui se lit comme ceci:

 public class SQLUtils 
{
  private static Log log = LogFactory.getLog(SQLUtils.class);

  public static void closeQuietly(Connection connection)
  {
    try
    {
      if (connection != null)
      {
        connection.close();
      }
    }
    catch (SQLExcetpion e)
    {
      log.error("An error occurred closing connection.", e);
    }
  }

  public static void closeQuietly(Statement statement)
  {
    try
    {
      if (statement!= null)
      {
        statement.close();
      }
    }
    catch (SQLExcetpion e)
    {
      log.error("An error occurred closing statement.", e);
    }
  }

  public static void closeQuietly(ResultSet resultSet)
  {
    try
    {
      if (resultSet!= null)
      {
        resultSet.close();
      }
    }
    catch (SQLExcetpion e)
    {
      log.error("An error occurred closing result set.", e);
    }
  }
}
 

Et votre code client sera quelque chose comme:

 Connection connection = null;
Statement statement = null;
ResultSet resultSet = null;
try 
{
  connection = getConnection();
  statement = connection.prepareStatement(...);
  resultSet = statement.executeQuery();

  ...
}
finally
{
  SQLUtils.closeQuietly(resultSet);
  SQLUtils.closeQuietly(statment);
  SQLUtils.closeQuietly(connection);
}
 

Answer 2

Comme d'autres l'ont mentionné, statique closeQuietly utilitaire est le chemin à parcourir. Une chose à ajouter - si vous êtes dans le monde de l' java.io plutôt que d' java.sql il y a ensuite une interface utile pour exactement cet effet - java.io.Fermer

Toutes les données sources et les puits en java.io d'implémenter cette interface - tous les cours d'eau, les canaux, les écrivains et les lecteurs. De cette façon, vous pouvez créer un utilitaire unique pour faire face à la même "d'exception sur close()" question sans nécessiter de nombreuses versions surchargées.

par exemple

public class IoUtils {

  public static closeQuietly (Closeable closeable) {
    try {
      closeable.close();
    } catch (IOException logAndContinue) {
      ...
    }
  }

}

Answer 3

Je l'ai généralement fait de cette façon:

 try {
    try {
        ..
        stmts
        ...
    }
    finally {
       connection.close():
    }
} catch (Exception ex) {
     ..
     stmts
     ..    
}
 

Je n'utilisais généralement cela que lorsque je n'utilisais pas une bibliothèque qui s'occupait de cette plomberie pour moi.

Comme le souligne Imagist , ce n'est pas techniquement le même que le dernier se déroulera avant la capture, mais je pense que cela résout le problème que vous tentiez de résoudre.

Answer 4

Commons-io a également closeQuietly () pour les flux d'entrée et de sortie. Je l'utilise tout le temps. Cela rend votre code beaucoup plus lisible.

Answer 5

N'hésitez pas à réessayer ... attrapez enfin l'intérieur.