Modo preferito per interrogare un database più volte?

Question

Quando si utilizza JDBC in Java, il metodo generalmente accettato di interrogare un database è acquisire una connessione, creare un'istruzione da quella connessione e quindi eseguire una query da tale istruzione.

// load driver 
Connection con = DriverManager.getConnection(..); 
Statement stmt = con.createStatement(); 
ResultSet result = stmt.executeQuery("SELECT.."); 
// ... 

Tuttavia, non sono sicuro di come trattare una seconda query per lo stesso database.

1. Può un'altra query essere eseguito in modo sicuro sullo stesso Statement oggetto, o devono un'altra dichiarazione essere creati dall'oggetto Connection al fine di eseguire un'altra query?

2. Se lo stesso Statement oggetto può essere utilizzato per più query, qual è lo scopo della classe Statement (in quanto sarebbe allora più sensato per un metodo Connection.executeQuery() di esistere)?

Answer 1

Sì, è possibile riutilizzare l'oggetto Statement, ma i ResultSet oggetti restituiti dalla executeQuery chiude già aperto di risultati.

Vedere la javadoc per la spiegazione

Per default, solo un oggetto ResultSet per oggetto Statement può essere aperto allo stesso tempo. Pertanto, se la lettura di un oggetto ResultSet è interlacciata con la lettura di un altro, ognuno deve essere stato generato da diversi oggetti Statement. Tutti i metodi di esecuzione nell'interfaccia Statement chiudono implicitamente l'oggetto ResultSet corrente di una statistica se esiste uno aperto.

Quindi la seguenti situazioni:

// load driver 
Connection con = DriverManager.getConnection(..); 
Statement stmt = con.createStatement(); 
ResultSet result = stmt.executeQuery("select .."); 
// do something with result ... or not 
ResultSet result2 = stmt.executeQuery("select ..."); 
// result is now closed, you cannot read from it anymore 
// do something with result2 
stmt.close(); // will close the resultset bound to it 

Ad esempio è possibile trovare un'implementazione open source della dichiarazione nel progetto jTDS. Nella Statement.executeQuery() method è possibile vedere una chiamata a initialize() che closes all the resultsets già aperto

protected void initialize() throws SQLException { 
    updateCount = -1; 
    resultQueue.clear(); 
    genKeyResultSet = null; 
    tds.clearResponseQueue(); 
    // FIXME Should old exceptions found now be thrown instead of lost? 
    messages.exceptions = null; 
    messages.clearWarnings(); 
    closeAllResultSets(); 
} 

Answer 2

bene, questo è il motivo per cui abbiamo il concetto di classi in programmazione orientata agli oggetti. Una classe definisce i membri costitutivi che abilitano le sue istanze allo stato e al comportamento. Qui la dichiarazione si occupa di tutto ciò che riguarda una dichiarazione SQL. Esistono così tante altre funzioni che potrebbero essere eseguite come query batch ecc.

Answer 3

A livello di codice, è possibile riutilizzare la stessa connessione e la stessa istruzione per più di una query e chiudere la dichiarazione e la connessione alla fine.

Tuttavia, questa non è una buona pratica. Le prestazioni dell'applicazione sono molto sensibili al modo in cui si accede al database. Idealmente, ogni connessione dovrebbe essere aperta per il minor tempo possibile. Quindi, le connessioni devono essere raggruppate. Passando da quello, si racchiudere ogni query in un blocco di {open connection, create a prepared statement, run query, close statement, close connection}. Questo è anche il modo in cui vengono implementati la maggior parte dei modelli SQL. Se la concorrenza lo consente, è possibile attivare più query allo stesso tempo utilizzando un pool di thread.

Answer 4

Di solito, è una dichiarazione per una query.Potrebbe non essere necessario farlo ma quando si scrive un'applicazione reale, non si desidera ripetere più volte gli stessi passaggi. Questo è contro il principale di DRY, in più sarà anche più complicato man mano che l'applicazione cresce.

È utile scrivere oggetti che gestiranno questo tipo di materiale di basso livello (ripetitivo) e fornire diversi metodi per accedere a db fornendo le query.

Answer 5

Non mi preoccuperei di creare nuove istruzioni. Tuttavia, l'apertura di una connessione al database può richiedere un uso intensivo delle risorse e l'apertura e la chiusura delle connessioni influiscono sulle prestazioni.

Lasciando le connessioni in qualche modo di autogestione di solito è piuttosto male.

Si consiglia di utilizzare connection pooling. Di solito ti lanci un commando vicino, ma stai solo restituendo quella connessione alla piscina. Quando richiedi una nuova connessione, riutilizzerà la connessione restituita in precedenza.

Si consiglia di avere istruzioni diverse per una connessione. La dichiarazione è un'implementazione e un'interfaccia. A seconda di ciò che ti serve, a volte desideri utilizzare lo CallableStatment. Alcune logiche possono essere riutilizzate quando richiesto.

Answer 6

Ho una cosa da aggiungere se si utilizza Connection e Statement in un ambiente con thread. La mia esperienza mostra che stmt.executeQuery (..) è stato salvato per l'uso in un ambiente parallelo ma con la conseguenza che ogni query viene serializzata e quindi elaborata in sequenza, senza produrre alcuna accelerazione. Quindi è meglio usare una nuova connessione (non una dichiarazione) per ogni thread.

Per un ambiente sequenziale standard, la mia esperienza ha dimostrato che il riutilizzo di istruzioni non è affatto un problema e che i ResultSet non devono necessariamente essere chiusi manualmente.