Struts 1.1 et DAO + problème ubuesque
Bonjour,
Je suis en train de coder une application basée sur Struts et le concept DAO/DTO + JDBC. A noter que j'ai déjà une petite expérience en Struts et en JDBC mais que c'est la première fois que j'utilise des dao (j'ai fait une autre appli plus petite avant avec juste une facade et des dto).
Donc voilà, je suis confronté à un problème ubuesque.
J'avais en effet fait une erreur de formattage sur une requête sql (oubli stupide) que j'ai corrigé.
Cependant à l'exécution, ma correction n'est pas prise en compte; et pire, il semblerait en mode débug que le programme ne passe même pas dans ma methode; mais saute directement vers l'envoi de la requête sql.
Mon Action est la suivante :
Code:
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
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
| package fr.view.taskTypeEntry;
import fr.model.typeTache.TypeTacheDAO;
import fr.model.typeTache.TypeTacheDTO;
import java.io.IOException;
import java.sql.SQLException;
import javax.naming.NamingException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.struts.action.Action;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;
public class TaskTypeEntryAction extends Action {
/**This is the main action called from the Struts framework.
* @param mapping The ActionMapping used to select this instance.
* @param form The optional ActionForm bean for this request.
* @param request The HTTP Request we are processing.
* @param response The HTTP Response we are processing.
*/
public ActionForward execute(ActionMapping mapping, ActionForm form,
HttpServletRequest request,
HttpServletResponse response) throws IOException,
ServletException {
try{
// Récupération de la référence à l'ActionForm associé à cette Action
TaskTypeEntryForm leform = (TaskTypeEntryForm) form;
Integer id_type = null;
// Récupération des données de la requête
try{
//id_type = new Integer((String)request.getParameter("id"));
id_type = new Integer(1);
}
catch(Exception e){//on tombe ici si la requête ne contient pas le paramètre
}
finally
{
TypeTacheDAO typeHandler = new TypeTacheDAO();
if(id_type != null)
{
TypeTacheDTO letype = typeHandler.getTypeTache(id_type.intValue());
leform.setLetype(letype);
leform.setId_type(id_type.intValue());
}
else {
//on va mettre une structure vide
TypeTacheDTO letype = typeHandler.createDummy();
leform.setLetype(letype);
}
}
}
catch(NamingException e) {
throw new ServletException("Error looking up home", e);
}
catch(SQLException e) {
throw new ServletException("Error looking up home", e);
}
return mapping.findForward( "success");
}
} |
La méthode du DAO dans laquelle il ne passe pas (testé en mode débug et en mettant un System.out.println)
Code:
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
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
| /**methode de récuperation des informations concernant un type tache
* ainsi que de la liste des taches associées (sans détail)
* @param id_typetache
* @return TypeTachDTO
* @throws SQLException, NamingException
*/
public TypeTacheDTO getTypeTache(int id_typetache) throws SQLException, NamingException{
// préparation de la requête
Connection connection=null;
PreparedStatement larequete = null;
ResultSet resultat = null;
StringBuffer prepare = new StringBuffer(1024);
prepare.append(GET_LIBTYPETACHE);
ArrayList params = new ArrayList();
params.add(0,new Integer(id_typetache));
TypeTacheDTO letype = null;
System.out.println(GET_LIBTYPETACHE);
try {
// Récupération du handler
DbConnection requesthandler = new DbConnection();
// Passage de la requête
resultat = requesthandler.sendRequest(prepare,params,connection,larequete);
if (resultat!=null){
// Exploitation du résultat
resultat.next();
letype = new TypeTacheDTO();
letype.setId_typeTache(resultat.getInt("id_tache"));
letype.setLibelle(resultat.getString("libelle"));
resultat.close();
larequete.close();
// Récupération de la liste des taches associées
TacheDAO tacheHandler = new TacheDAO();
Collection lestaches = tacheHandler.getTacheListByType(id_typetache);
letype.setTaches(lestaches);
}
}
catch (SQLException e)
{
throw new SQLException(e.toString());
}
finally
{
try
{
//fermeture du resultset au besoin
if(resultat !=null) resultat.close();
}
catch (SQLException x)
{
throw new SQLException(x.toString());
}
try
{
//fermeture du prepared statement
if (larequete !=null) larequete.close();
}
catch (SQLException x)
{
throw new SQLException(x.toString());
}
try
{
//release de la connexion vers le spool
if (connection!=null) connection.close();
}
catch (SQLException x)
{
throw new SQLException(x.toString());
}
}
return letype;
} |
Et ma classe de connection à la database (DbConnection)
Code:
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
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
| package fr.util;
import java.sql.Connection;
import java.sql.Date;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ResourceBundle;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.rmi.PortableRemoteObject;
import javax.sql.DataSource;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Iterator;
public class DbConnection {
/**
* Méthode d'obtention d'une connexion
* @return Connection
* @throws java.sql.SQLException
* @throws javax.naming.NamingException
*/
public static Connection getConnection() throws SQLException, NamingException {
InitContext c = InitContext.getContext();
ResourceBundle ressources = ResourceBundle.getBundle("metier");
String nomDataSource = ressources.getString("datasourcename");
DataSource ds = (DataSource) c.getInitialContext().lookup(nomDataSource);
return ds.getConnection();
}
/**
* Méthode de passage d'une requête select à la BDD
* Attention les données de l'ArrayList doivent être des classes et non des types primitifs
* int=> Integer
* boolean => Boolean
* float => Float
* Attention! Penser à fermer la connexion et le preparedStatement quand on n'a plus besoin du resultSet
* @return ResultSet
* @throws java.sql.SQLException
* @throws javax.naming.NamingException
*/
public static ResultSet sendRequest (StringBuffer statement, ArrayList params, Connection conn, PreparedStatement larequete) throws SQLException, NamingException {
ResultSet resultat = null;
try
{
conn = getConnection();
// Création de la requête
larequete = conn.prepareStatement(statement.toString());
larequete.clearParameters();
if (params!=null)
{
Iterator i = params.iterator();
int nbparam =1;
// Insertion des paramètres dans le statement
while(i.hasNext())
{
Object elem = i.next();
String classtype = elem.getClass().getName();
if(classtype.equals("java.lang.Integer")) larequete.setInt(nbparam,((Integer) elem).intValue());
if(classtype.equals("java.lang.Long")) larequete.setLong(nbparam,((Long)elem).longValue());
if(classtype.equals("java.lang.String")) larequete.setString(nbparam,(String)elem);
if(classtype.equals("java.lang.Boolean")) larequete.setBoolean(nbparam,(Boolean)elem);
if(classtype.equals("java.lang.Float")) larequete.setFloat(nbparam,(Float)elem);
if(classtype.equals("java.lang.Calendar") || classtype.equals("java.lang.GregorianCalendar"))
{
Date ladate = new Date(((Calendar)elem).getTimeInMillis());
larequete.setDate(nbparam,ladate);
}
nbparam = nbparam +1;
}
}
// execution de la requête
larequete.execute();
// recuperation du resultat
resultat = larequete.getResultSet();
}
catch (SQLException e)
{
throw new SQLException(e.toString());
}
return resultat;
}
} |
Ma classe DAO n'a rien de particulier (ce n'est pas un singleton et il n'y a pas de mécanisme de persistance dessus pour l'instant).
En debug, le serveur d'appli saute directement de TypeTacheDTO letype = typeHandler.getTypeTache(id_type.intValue()); à public static ResultSet sendRequest sans prendre en compte mes points d'arrêt dans getTypeTache.
Est ce que ce genre de sketche vous est déjà arrivé?
(pour information, je suis obligé d'utiliser Jdevelopper et OC4J 10.1.3, c'est ce qui est en vigueur dans ma boite / sent bien le bug foireux Jdev).
