Bonjour,

J'ai un programme qui fait plusieurs requêtes (select,update,insert...) tout fonctionnement correctement. Mais maintenant j'aimerais avoir une meilleure structuration de mon code.

Dans ma classe principale j'ai toutes mes requêtes en static :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
 
private static final String Q_UPDATE_1 = "UPDATE table1 SET val1 = ? WHERE id = ? ";
 
private static final String Q_SELECT_1 = "SELECT field FROM table WHERE id = ? ";
Les requêtes sont exécutées dans différentes fonctions dans un try/catch/finally, avec les "close()" qui vont bien, comme par exemple :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
public void fonction(){
//__ Variables
PreparedStatement statementSelect = null;
ResultSet queryResults = null;
try{
statementSelect = conn.prepareStatement(Q_SELECT_1);
statementSelect.setInt(1,56);
 
if ( statementSelect.execute() ){
	queryResults = statementSelect.getResultSet();
	if (queryResults != null){
		while(queryResults.next()){
                        // traitement des données
		}
	}
}
} catch (SQLException exception) {
// traitement de l'exception
} finally {
queryResults.close();
statementSelect.close();
}
}
Ayant plus d'une 20taines de requêtes la classe est illisible...

J'ai donc pensé à implémenter des fonctions "génériques" pour exécuter chaque type de requête. Prenons l'exemple de l’exécution d'un select. La fonction prendrait en paramètre, la requête ainsi qu'une liste de paramètre optionnel ( autant qu'il y a de ? dans la requête ). Et retournerai une Liste des objets trouvés par la requête.

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
 
public ArrayList<Object> executerSelect(String query, Object...objects) throws SQLException{
		//__ Variables
		PreparedStatement statementSelect = null;
		ResultSet queryResults = null;
		ArrayList<Object> listObjectResult = new ArrayList<Object>();
		int index = 0;
 
		//__ preparation de la requete
		statementSelect = getConnection.prepareStatement(query);
 
		//__ on set les paramètres
		if(objects != null){
			while(objects.length > index){
				statementSelect.setObject(index+1, objects[index]);
				index++;
			}
		}
 
		//__ execution de la requete
		if ( statementSelect.execute() ){
			queryResults = statementSelect.getResultSet();
			if (queryResults != null){
				index = 1;
				while(queryResults.next()){
					//listObjectResult.add( ??? );
				}
			}
		}
 
		//__ Fermeture
		queryResults.close();
		statementSelect.close();
 
		//__ return la liste des objects
		return listObjectResult;
 
	}
Je ne vois pas comment je pourrais retourner correctement une forme de ResultSet qui serait exploitable en retour de la fonction. Une HashMap ? Car avec une ArrayList, ca fonctionnement uniquement si une colonne de retournée. Renvoyer le ResultSet, mais comment gérer correctement la fermeture du statement et du ResultSet ?

Est-il vraiment possible d'implémenter ce genre de fonction générique ? J'aimerai vraiment m'affranchir du bloc try/catch assez conséquent pour exécuter une requête pour avoir des fonctions plus claires :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
 
public void fonction(){
 
ArrayList result1 = new ArrayList();
ArrayList result2 = new ArrayList();
 
result1 = executerSelect(Q_SELECT_1, 56);
// traitement du resultat
 
result1 = executerSelect(Q_SELECT_2, "toto", 7);
// traitement du resultat
 
}
Merci par avance pour vos idées/remarques.