Où fermer Java PreparedStatements et les jeux de résultats?

en Java 7, vous ne devez pas les fermer explicitement, mais utilisez gestion automatique des ressources pour vous assurer que ressources sont fermées et que les exceptions sont gérées de manière appropriée. La manipulation d'Exception fonctionne comme ceci:

Exception in try | Exception in close | Result
-----------------+--------------------+----------------------------------------
      No         |        No          | Continue normally
      No         |        Yes         | Throw the close() exception
      Yes        |        No          | Throw the exception from try block
      Yes        |        Yes         | Add close() exception to main exception
                 |                    |  as "suppressed", throw main exception

J'espère que c'est logique. Permet le code pretty, comme ceci:

private void doEverythingInOneSillyMethod(String key)
  throws MyAppException
{
  try (Connection db = ds.getConnection()) {
    db.setReadOnly(true);
    ...
    try (PreparedStatement ps = db.prepareStatement(...)) {
      ps.setString(1, key);
      ...
      try (ResultSet rs = ps.executeQuery()) {
        ...
      }
    }
  } catch (SQLException ex) {
    throw new MyAppException("Query failed.", ex);
  }
}

avant Java 7, Il est préférable d'utiliser imbriqué enfin blocs, plutôt que de tester les références pour les nuls.

l'exemple que je vais montrer pourrait sembler laid avec la nidation profonde, mais en pratique, code bien conçu ne va probablement pas créer une connexion, déclaration, et les résultats tous dans la même méthode; souvent, chaque niveau de la nidation implique de passer une ressource à une autre méthode, qui l'utilise comme une usine pour une autre ressource. Avec cette approche, les exceptions d'un close() masqueront une exception de l'intérieur du try bloc. Cela peut être surmonté, mais il en résulte encore plus de code désordre, et nécessite une classe d'exception personnalisée qui fournit le chaînage d'exception "supprimé" présent dans Java 7.

Connection db = ds.getConnection();
try {
  PreparedStatement ps = ...;
  try {
    ResultSet rs = ...
    try {
      ...
    }
    finally {
      rs.close();
    }
  } 
  finally {
    ps.close();
  }
} 
finally {
  db.close();
}

si vous roulez vraiment à la main votre propre jdbc, il devient certainement salissant. Le close() à la enfin les besoins pour obtenir enveloppé avec ses propres try catch, qui, à tout le moins, c'est moche. Vous ne pouvez pas sauter la fermeture, bien que les ressources seront dégagées lorsque la connexion est fermée (ce qui pourrait ne pas être tout de suite, si vous utilisez une piscine). En fait, l'un des points de vente principaux de l'utilisation d'un cadre (par exemple hibernate) pour gérer votre accès à la base de données est de gérer la connexion et le jeu de résultats gérer pour ne pas oublier de fermer.

vous pouvez faire quelque chose de simple comme ceci, qui au moins cache le désordre, et garantit que vous n'oubliez pas quelque chose.

public static void close(ResultSet rs, Statement ps, Connection conn)
{
    if (rs!=null)
    {
        try
        {
            rs.close();

        }
        catch(SQLException e)
        {
            logger.error("The result set cannot be closed.", e);
        }
    }
    if (ps != null)
    {
        try
        {
            ps.close();
        } catch (SQLException e)
        {
            logger.error("The statement cannot be closed.", e);
        }
    }
    if (conn != null)
    {
        try
        {
            conn.close();
        } catch (SQLException e)
        {
            logger.error("The data source connection cannot be closed.", e);
        }
    }

}

et puis,

finally {
    close(rs, ps, null); 
}

ne perdez pas votre temps à coder la gestion des exceptions de bas niveau, utilisez une API de haut niveau comme Spring-JDBC, ou un wrapper personnalisé autour des objets connection/statement/rs, pour masquer le code Trial-catch compliqué.

à noter Également:

"Lorsqu'un objet Statement est fermé, son actuel objet ResultSet, s'il existe, est également fermé. "

http://java.sun.com/j2se/1.5.0/docs/api/java/sql/Statement.html#close ()

il devrait suffire de ne refermer que la déclaration préparée en fin de Compte, et seulement si elle n'est pas déjà fermée. Si vous voulez être vraiment particulier cependant, fermez le jeu de résultats D'abord, pas après fermer L'État de préparation (le fermer après, comme certains des exemples ici, devrait en fait garantir une exception, puisqu'il est déjà fermé).

j'ai habituellement une méthode utilitaire qui peut fermer des choses comme ça, y compris en prenant soin de ne pas essayer de faire quoi que ce soit avec une référence nulle.

habituellement si close() jette une exception que je ne me soucie pas réellement, donc je juste enregistrer l'exception et l'avaler - mais une autre alternative serait de le convertir en un RuntimeException . Quoi qu'il en soit, je recommande de le faire dans une méthode utilitaire qui est facile à appeler, car vous pourriez bien avoir besoin de le faire dans de nombreux endroits.

notez que votre solution actuelle ne fermera pas le jeu de résultats si la fermeture du prepare Statement échoue - il est préférable d'utiliser des blocs finalement imbriqués.

si vous utilisez Java 7, vous pouvez utiliser les améliorations des mécanismes de gestion des exceptions dans les classes qui implémentent Autoclosable (i.e. PreparedStatement , Resultset )

vous pourriez également trouver cette question intéressante: jeu de résultats de fermeture en Java 7

je sais que c'est une vieille question, mais juste au cas où quelqu'un cherche la réponse, java a maintenant la solution d'essai-avec-ressources.

static String readFirstLineFromFile(String path) throws IOException {
      try (BufferedReader br =
                   new BufferedReader(new FileReader(path))) {
        return br.readLine();
    }
}

n'omettez pas d'appeler de près. Il peut causer des problèmes.

je préfère ajouter le bloc "essayer/attraper" à la fin.

probablement une vieille (bien que simple) façon de faire les choses, mais il fonctionne toujours:

public class DatabaseTest {

    private Connection conn;    
    private Statement st;   
    private ResultSet rs;
    private PreparedStatement ps;

    public DatabaseTest() {
        // if needed
    }

    public String getSomethingFromDatabase(...) {
        String something = null;

        // code here

        try {
            // code here

        } catch(SQLException se) {
            se.printStackTrace();

        } finally { // will always execute even after a return statement
            closeDatabaseResources();
        }

        return something;
    }

    private void closeDatabaseResources() {
        try {
            if(conn != null) {
                System.out.println("conn closed");
                conn.close();
            }

            if(st != null) {
                System.out.println("st closed");
                st.close();
            }

            if(rs != null) {
                System.out.println("rs closed");
                rs.close();
            }

            if(ps != null) {
                System.out.println("ps closed");
                ps.close();
            }

        } catch(SQLException se) {
            se.printStackTrace();
        }               
    }
}

en S'appuyant sur la réponse de @erickson, pourquoi ne pas simplement le faire dans un bloc try comme celui-ci?

private void doEverythingInOneSillyMethod(String key) throws MyAppException
{
  try (Connection db = ds.getConnection();
       PreparedStatement ps = db.prepareStatement(...)) {

    db.setReadOnly(true);
    ps.setString(1, key);
    ResultSet rs = ps.executeQuery()
    ...
  } catch (SQLException ex) {
    throw new MyAppException("Query failed.", ex);
  }
}

notez que vous n'avez pas besoin de créer l'objet ResultSet à l'intérieur du bloc try car ResultSet est automatiquement fermé lorsque l'objet PreparedStatement est fermé.

un objet ResultSet est automatiquement fermé lorsque l'objet Statement que généré, il est fermé, ré-exécuté, ou utilisé pour récupérer la prochaine résultat d'une séquence de résultats multiples.

référence: https://docs.oracle.com/javase/7/docs/api/java/sql/ResultSet.html

focus clause finally,

finally {
   try {
      rs.close();
      ps.close();
   } catch (Exception e) {
      // Do something
   }
}

je pense que vous devez modifier 2 points.

tout d'abord, utilisez try & catch à nouveau dans la clause fainlly.

en Second lieu, rs.close() avant de faire du ps.proche.)(

fly1997@naver.com

j'utilise ceci..

finally
{
    if (ps != null) ps.close();
    if (rs != null) rs.close();
}