Discussion :

[Invité]

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 :

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
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 :

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
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 :

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
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).

[OButterlin]

Pour moi également, ça sent le bug dans JDev.

Peut-être as-tu l'équivalent d'Eclipse Projet -> Clean.
Dans tous les cas, je pense qu'il faut (re)générer intégralement les classes...

[Invité]

C'était bien ca.
J'avais vidé le répertoire contenant les .class dans le sous projet métier mais pas dans celui présentation -_-"'