La bonne manière de gérer les connexions de base de données dans un support de taille de l'application web

Je suis en train de maintien de petites et moyennes applications web java (à l'aide de simples pages Jsp/Servlets) que stagiaire faite pour l'usage interne d'une entreprise et je vais avoir quelques problèmes avec les connexions.

Parfois juste sorti de nulle part, nous obtenez des erreurs telles que "l'Instruction est fermée" ou "la Connexion est fermée", puis l'ensemble de l'application serait juste arrêter de travailler et le serveur doit être redémarré.

Je n'ai pas beaucoup d'expérience et je n'ai personne pour les encadrer ou de m'enseigner ce qui concerne les meilleures pratiques, des modèles de conception, etc. mais je suis sûr que ce n'est pas la bonne façon de le faire. J'ai lu sur des trucs comme DALs, DAOs, et de l'Otd. Notre application a aucun de ceux-ci.

L'ensemble de l'application web (ie. les servlets) sont essentiellement remplis avec des appels semblable à la suivante:

Database db = Database.getInstance();
db.execute("INSERT INTO SomeTable VALUES (a, b, c)");
db.execute("UPDATE SomeTable SET Col = Val");

Sélectionne sont fait comme suit:

ArrayList<Model> results = Model.fetch("SELECT * FROM SomeTable");

Où le Modèle est une classe qui étend la classe HashMap et représente une seule Ligne dans une Table.

C'est le code pour Database.java et je me demandais si quelqu'un peut les choses évidentes qui sont mauvais (je suis assez sûr il y en a beaucoup), toute solution rapide qui peut être fait et certaines ressources sur les bonnes pratiques en ce qui concerne les connexions de base de données /gestion des connexions.

package classes;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.HashMap;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.sql.DataSource;
public final class Database {
public static Database getInstance() {
if (Database.instance == null) {
Database.instance = new Database();
}
return Database.instance;
}
//Returns the results for an SQL SELECT query.
public ArrayList<HashMap<String, Object>> fetch(String sql) {
ArrayList<HashMap<String, Object>> results = new ArrayList<HashMap<String, Object>>();
try {
PreparedStatement stmt = this.connection.prepareStatement(sql, ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY, ResultSet.HOLD_CURSORS_OVER_COMMIT);
ResultSet rs = stmt.executeQuery();
this.doFetch(rs, results);
stmt.close();
} catch (SQLException e) {
this.handleException(e, sql);
}
return results;
}
public ArrayList<HashMap<String, Object>> fetch(String sql, ArrayList<Object> parameters) {
ArrayList<HashMap<String, Object>> results = new ArrayList<HashMap<String, Object>>();
try {
//Bind parameters to statement.
PreparedStatement pstmt = this.connection.prepareStatement(sql, ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY, ResultSet.HOLD_CURSORS_OVER_COMMIT);
for (int i=0; i<parameters.size(); i++) {
pstmt.setObject(i+1, parameters.get(i));
}
ResultSet rs = pstmt.executeQuery();
this.doFetch(rs, results);
pstmt.close();
} catch (SQLException e) {
this.handleException(e, sql, parameters);
}
return results;
}
public int execute(String sql) {
int result = 0;
try {
Statement stmt = this.connection.createStatement();
result = stmt.executeUpdate(sql);
stmt.close();
} catch (SQLException e) {
this.handleException(e, sql);
}
return result;
}
public int execute(String sql, ArrayList<Object> parameters) {
int result = 0;
try {
PreparedStatement pstmt = this.connection.prepareStatement(sql, ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY, ResultSet.HOLD_CURSORS_OVER_COMMIT);
for (int i=0; i<parameters.size(); i++) {
if (parameters.get(i) == null) {
pstmt.setNull(i+1, java.sql.Types.INTEGER);
} else {
pstmt.setObject(i+1, parameters.get(i));
}
}
result = pstmt.executeUpdate();
pstmt.close();
} catch (SQLException e) {
this.handleException(e, sql, parameters);
}
return result;
}
public void commit() {
try {
this.connection.commit();
} catch (SQLException e) {
System.out.println("Failed to commit transaction.");
}
}
public Connection getConnection() {
return this.connection;
}
private static Database instance;
private static DataSource dataSource = null;
private Connection connection;
private Database() {
this.connect();
this.execute("SET SCHEMA " + Constant.DBSCHEMA);
}
private void connect() {
Connection connection = null;
if (dataSource == null) {
try {
InitialContext initialContext = new InitialContext();
dataSource = (DataSource)initialContext.lookup(
Constant.DEPLOYED ? Constant.PROD_JNDINAME : Constant.TEST_JNDINAME);
} catch (NamingException e) {
e.printStackTrace();
}
}
try {
connection = dataSource.getConnection();
} catch (SQLException e) {
e.printStackTrace();
}
this.connection = connection;
}
//Fetches the results from the ResultSet into the given ArrayList.
private void doFetch(ResultSet rs, ArrayList<HashMap<String, Object>> results) throws SQLException {
ResultSetMetaData rsmd = rs.getMetaData();
ArrayList<String> cols = new ArrayList<String>();           
int numCols = rsmd.getColumnCount();
for (int i=1; i<=numCols; i++) {
cols.add(rsmd.getColumnName(i));
}
while (rs.next()) {
HashMap<String, Object> result = new HashMap<String, Object>();
for (int i=1; i<=numCols; i++) {
result.put(cols.get(i-1), rs.getObject(i));
}
results.add(result);
}
rs.close();
}
private void handleException(SQLException e, String sql) {
System.out.println("SQLException " + e.getErrorCode() + ": " + e.getMessage());
System.out.println("Statement: " + sql);
ExceptionAdapter ea = new ExceptionAdapter(e);
ea.setSQLInfo(e, sql);
throw ea;
}
private void handleException(SQLException e, String sql, ArrayList<Object> parameters) {
if (parameters.size() < 100) {
System.out.println("SQLException " + e.getErrorCode() + ": " + e.getMessage());
System.out.println("PreparedStatement: " + sql.replace("?", "[?]"));
System.out.println("Parameters: " + parameters.toString());
}
ExceptionAdapter ea = new ExceptionAdapter(e);
ea.setSQLInfo(e, sql, parameters);
throw ea;
}
}

Merci!

OriginalL'auteur Connection | 2011-07-08