Designe pattern DAO complexe

Version imprimable

Bonjour,
Je choisis de travailler avec le design pattern DAO, c'est plus complexe que la "bidouille" en jdbc classique mais les possibilitées d'extention de bascule d'une base MySQL ou ORACLE ou autre est plus facile.
La rigueur imposée par cette technique rends l'encodage difficile mais offre un code plus ordonnée et malléable suivant les bases en exploitation.
j'ai choisis 4 java beans pour séparer le code mais c'est mieux organisé:
1/ Bean Daoexeption.java

Code:

1
2
3
4
5
6
7
package com.boticiel.dao;
 
public class DaoException extends Exception {
    public DaoException(String message) {
        super(message);
    }
}

2/DaoFactory.java qui gére la connection avec la base via le driver JDBC :

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
package com.boticiel.dao;
 
 
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
 
public class DaoFactory {
    private String url;
    private String username;
    private String password;
 
    DaoFactory(String url, String username, String password) {
        this.url = url;
        this.username = username;
        this.password = password;
    }
 
    public static DaoFactory getInstance() {
        try {
            Class.forName("com.mysql.jdbc.Driver");
        } catch (ClassNotFoundException e) {
        }
 
        DaoFactory instance = new DaoFactory(
                "jdbc:mysql://localhost:3306/javaee", "root", "");
        return instance;
    }
 
 
    public Connection getConnection() throws SQLException {
        Connection connexion = DriverManager.getConnection(url, username, password);
        connexion.setAutoCommit(false);
        return connexion; 
    }
 
    // Récupération du Dao
    public UtilisateurDao getUtilisateurDao() {
        return new UtilisateurDaoImpl(this);
    }
}

3/ UtilisateurDao.java ou de décrit le nom des méthodes sans les implémenter :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package com.boticiel.dao;
 
import java.util.List;
 
import com.boticiel.forms.Utilisateur;
 
public interface UtilisateurDao {
 
 
	void ajouter( Utilisateur utilisateur ) throws DaoException;
    List<Utilisateur> lister() throws DaoException;
    void mise_a_jour( Utilisateur utilisateur ) throws DaoException;
    void supprimer( Utilisateur utilisateur ) throws DaoException;
 
}

4/ UtilisateurDaoImpl.java ou j'implémente mes méthodes (ici j'ai pleins d'erreurs)

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
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
package com.boticiel.dao;
 
 
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
 
import com.boticiel.forms.BeanException;
import com.boticiel.forms.Utilisateur;
 
 
 
public class UtilisateurDaoImpl implements UtilisateurDao {
 
 
private DaoFactory daoFactory;
public String operand;
 
 
UtilisateurDaoImpl(DaoFactory daoFactory) {
this.daoFactory = daoFactory;
 
 
switch (operand) {	
 
 
case "ajouter":
	 { 
 
    public void ajouter(Utilisateur utilisateur) throws DaoException {
        Connection connexion = null;
        PreparedStatement preparedStatement = null;
 
        try {
            connexion = daoFactory.getConnection();
            preparedStatement = connexion.prepareStatement("INSERT INTO noms(nom, prenom) VALUES(?, ?);");
            preparedStatement.setString(1, utilisateur.getNom());
            preparedStatement.setString(2, utilisateur.getPrenom());
 
            preparedStatement.executeUpdate();
            connexion.commit();
        } catch (SQLException e) {
            try {
                if (connexion != null) {
                    connexion.rollback();
                }
            } catch (SQLException e2) {
            }
            throw new DaoException("Impossible de communiquer avec la base de données");
        }
        finally {
            try {
                if (connexion != null) {
                    connexion.close();  
                }
            } catch (SQLException e) {
                throw new DaoException("Impossible de communiquer avec la base de données");
            }
        }
 
    }
 
	 } }
case "lister": {
    public List<Utilisateur> lister() throws DaoException {
        List<Utilisateur> utilisateurs = new ArrayList<Utilisateur>();
        Connection connexion = null;
        Statement statement = null;
        ResultSet resultat = null;
 
        try {
            connexion = daoFactory.getConnection();
            statement = connexion.createStatement();
            resultat = statement.executeQuery("SELECT nom, prenom FROM noms;");
 
            while (resultat.next()) {
            	String id = resultat.getString("id");
            	String nom = resultat.getString("nom");
                String prenom = resultat.getString("prenom");
 
                Utilisateur utilisateur = new Utilisateur();
                //utilisateur.setId(id);
                utilisateur.setNom(nom);
                utilisateur.setPrenom(prenom);
 
                utilisateurs.add(utilisateur);
            }
        } catch (SQLException e) {
            throw new DaoException("Impossible de communiquer avec la base de données");
        } catch (BeanException e) {
            throw new DaoException("Les données de la base sont invalides");
        }
        finally {
            try {
                if (connexion != null) {
                    connexion.close();  
                }
            } catch (SQLException e) {
                throw new DaoException("Impossible de communiquer avec la base de données");
            }
        }
        return utilisateurs;
    }
}
} 
case "mise_a_jour": {   
    public void mise_a_jour(Utilisateur utilisateur) throws DaoException {
        Connection connexion = null;
        PreparedStatement preparedStatement = null;
        //String paramId = request.getParameter("id");
        try {
            connexion = daoFactory.getConnection();
            preparedStatement = connexion.prepareStatement("UPDATE noms SET nom = ?, prenom = ? WHERE id = ?");
 
  		   preparedStatement.setString(1, utilisateur.getNom());
  		   preparedStatement.setString(2, utilisateur.getPrenom());
  		   preparedStatement.setInt(3, utilisateur.getId());
 
            preparedStatement.executeUpdate();
            connexion.commit();
        } catch (SQLException e) {
            try {
                if (connexion != null) {
                    connexion.rollback();
                }
            } catch (SQLException e2) {
            }
            throw new DaoException("Impossible de communiquer avec la base de données");
        }
        finally {
            try {
                if (connexion != null) {
                    connexion.close();  
                }
            } catch (SQLException e) {
                throw new DaoException("Impossible de communiquer avec la base de données");
            }
          }
        }
}
} 
case "supprimer": {
		public void supprimer(Utilisateur utilisateur) throws DaoException {
            Connection connexion = null;
            PreparedStatement preparedStatement = null;
            //String paramId = request.getParameter("id");
            try {
                connexion = daoFactory.getConnection();
                preparedStatement = connexion.prepareStatement("Delete * WHERE id = ?");
 
 
                preparedStatement.executeUpdate();
                connexion.commit();
            } catch (SQLException e) {
                try {
                    if (connexion != null) {
                        connexion.rollback();
                    }
                } catch (SQLException e2) {
                }
                throw new DaoException("Impossible de communiquer avec la base de données");
            }
            finally {
                try {
                    if (connexion != null) {
                        connexion.close();  
                    }
                } catch (SQLException e) {
                    throw new DaoException("Impossible de communiquer avec la base de données");
                }
            }
 
    }
 
  }

La servlet Db-Dao.java ou je pence avair fait un maivais chois d'encodage de la méthode Dopost() (ici j'ai pleins d'erreurs)

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
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
package com.boticiel.servlets;
 
 
import java.io.IOException;
 
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
import com.boticiel.forms.Utilisateur;
import com.boticiel.dao.*;
 
 
@WebServlet("/Db_dao")
 
public class Db_dao extends HttpServlet {
    private static final long serialVersionUID = 1L;
    private UtilisateurDao utilisateurDao;
 
    public void init() throws ServletException {
        DaoFactory daoFactory = DaoFactory.getInstance();
        this.utilisateurDao = daoFactory.getUtilisateurDao();
    }
 
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        try {
            request.setAttribute("utilisateurs", utilisateurDao.lister());
        }
        catch (DaoException e) {
            request.setAttribute("erreur", e.getMessage());
        }
 
        this.getServletContext().getRequestDispatcher("/WEB-INF/db_dao.jsp").forward(request, response);
    }
 
 
    public void doPost( HttpServletRequest request, HttpServletResponse response ) throws ServletException, IOException {
    	Utilisateur utilisateur = new Utilisateur();
    	public String operand;    	
    	String operand = request.getParameter("operand");
    	switch (operand) {	
 
 
    	case "ajouter":
    		 {     	
    	public void ajouter(Utilisateur utilisateurDao){
    	try {
 
            //utilisateur.setId( Integer.parseInt(paramId) );
            utilisateur.setId(request.getParameter.toString(Integer.parseInt("id")));
            utilisateur.setNom(request.getParameter("nom"));
            utilisateur.setPrenom(request.getParameter("prenom"));
            utilisateurDao.ajouter(utilisateur);
            request.setAttribute("utilisateurs", utilisateurDao.lister());
        }
        catch (Exception e) {
            request.setAttribute("erreur", e.getMessage());
        }
        this.getServletContext().getRequestDispatcher("/WEB-INF/db_dao.jsp").forward(request, response);
 
    	}
    		 }
        case "lister":
       		 {     	
    	public void lister(Utilisateur utilisateur){
    	  try {
              request.setAttribute("utilisateurs", utilisateurDao.lister());
          }
          catch (DaoException e) {
              request.setAttribute("erreur", e.getMessage());
          }
 
          this.getServletContext().getRequestDispatcher("/WEB-INF/db_dao.jsp").forward(request, response);
    	}
       		 }	
        case "supprimer":
   		 {     	
    	public void supprimer(Utilisateur utilisateur){
        	try {
 
                utilisateur.setId( Integer.parseInt(paramId) );
                utilisateur.setId(request.getParameter.toString(Integer.parseInt("id")));
                utilisateurDao.supprimer(utilisateur);
 
                request.setAttribute("utilisateurs", utilisateurDao.supprimer());
            }
            catch (Exception e) {
                request.setAttribute("erreur", e.getMessage());
            }
            this.getServletContext().getRequestDispatcher("/WEB-INF/db_dao.jsp").forward(request, response);
 
        	}
   		 }
   		 case "mise_a_jour":
		 {     	
    	public void mise_a_jour(Utilisateur utilisateur){
        	try {
 
                utilisateur.setId( Integer.parseInt(paramId) );
                utilisateur.setId(request.getParameter.toString(Integer.parseInt("id")));
                utilisateur.setNom(request.getParameter("nom"));
                utilisateur.setPrenom(request.getParameter("prenom"));
                utilisateurDao.ajouter(utilisateur);
                request.setAttribute("utilisateurs", utilisateurDao.mise_a_jour());
            }
            catch (Exception e) {
                request.setAttribute("erreur", e.getMessage());
            }
            this.getServletContext().getRequestDispatcher("/WEB-INF/db_dao.jsp").forward(request, response);
 
        	}  
		 }
    }

5/ enfin la JSP ou je m'en sort bien ;

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
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>base de donnée DAO</title>
</head>
<body>
base de donnée DAO
 
 
  <%@ include file="menu.jsp" %>
     <c:if test="${ !empty erreur }"><p style="color:red;"><c:out value="${ erreur }" /></p></c:if>
    <form method="post" action="db_dao">
    	<p>
    		<label for="id">Index :</label>
    		<input type="text" name="id" id="id" />
    	</p>
 
        <p>
            <label for="nom">Nom : </label>
            <input type="text" name="nom" id="nom" />
        </p>
        <p>
            <label for="prenom">Prénom : </label>
            <input type="text" name="prenom" id="prenom" />
        </p>
   		<select id="operand" name="operand" >
  		<option value="lister">lister</option>
  		<option value="mise_a_jour">mise a jour</option>
  		<option value="supprimer">supprimer</option>
  		<option value="ajouter">ajouter</option>
  		<input type="submit"name="Submit" value="db_dao"></p>
</select>    
 
    </form>
    <ul>
        <c:forEach var="utilisateur" items="${ utilisateurs }">
            <li><c:out value="${ utilisateur.id }" /><c:out value="${ utilisateur.prenom }" /> <c:out value="${ utilisateur.nom }" /></li>
        </c:forEach>
    </ul>    
</html>

J'utilise un "CASE" pour différencier les 4 requête conventionnelles (select,update,insert,delete).
Si vous voulez m'aider je préfère du code source pour expliquer mes erreurs que des phrases peudo philosophique/technique, c'est important pour moi !
J'utilise aussi la JSTL pour contrer la faille XSS de Dotnet ASP.

Bonne lecture
Philippe

21/08/2017, 08h17
joel.drigo
Salut,

IL aurait été préférable que tu nous donnes les erreurs rencontrées mais en tout cas celles qui me sautent aux yeux sont :
1. Dans la méthode post :
  
  Code:
  
  public String operand;
  
  La portée (le mot clef public) est nécessaire pour une variable de classe, mais ne doit pas être indiquée pour une variable locale. Sutout que juste après tu déclares correctement la variable :
  
  Code:
  
  String operand = request.getParameter("operand");
  
  La première des deux lignes doit être supprimée.
2. Code:
  
  1 2 3 4 case "ajouter": { public void ajouter(Utilisateur utilisateurDao){ try {
  Avec public void ajouter(Utilisateur utilisateurDao){, tu déclares une méthode, dans le code d'une méthode (doPost). Ceci est impossible en Java.
  Supprime simplement cette ligne (et bien sûr l'accolade fermante correspondante).
  Tu pourrais faire une méthode, à part de la méthode doPost, et l'appeler dans le case du switch, mais te faudrait passer en paramètre l'objet request et response, en plus de l'utilisateur, puisque tu les utilises dans ton code.
3. Code:
  
  utilisateurDao.ajouter(utilisateur);
  
  utilisateurDao est du type Utilisateur, qui n'a pas de méthode ajouter. C'est l'interface UtilisateurDao qui a cette méthode. En supprimant la déclaration de méthode, ce ne sera plus le paramètre de celle-ci qui sera utilisé mais bien la variable de classe déclarée dans DB_dao par private UtilisateurDao utilisateurDao;, donc une variable du bon type.
4. Code:
  
  1 2 utilisateur.setId( Integer.parseInt(paramId) ); utilisateur.setId(request.getParameter.toString(Integer.parseInt("id")));
  La première ligne provoque une erreur parce qu'il n'existe pas de variable paramId.
  La seconde parce qu'il manque les parenthèses pour l'appel de la méthode getParameter. Les ajouter provoquera une erreur parce que la méthode toString() de String (le type de retour de getParametre()) n'a pas de paramètre. Et si jamais c'était le cas Integer.parseInt("id") planterait à l'exécution parce que id n'est pas un int.
  Le code c'est (je suppose que setId prend un int en paramètre parce que tu fais un Integer.parseInt :
  Code:
  
  1 2 int paramId = Integer.parseInt(request.getParameter("id")); utilisateur.setId(paramId);
  Mais ceci va te causer une autre erreur, parce qu'on ne peut pas déclarer la même variable (= de même nom) dans les différents case d'un switch. Pour éviter le souci, tu peux te passer de la variable :
  
  Code:
  
  utilisateur.setId(Integer.parseInt(request.getParameter("id"));
5. les autres erreurs dans la méthode sont similaires (si j'en n'ai pas loupé).
6. Ceci ne te provoque pas d'erreur pour l'instant, mais ça va poser un problème à l'exécution : il manque les breaks dans le switch.
  Dans :
  Code:
  
  1 2 3 4 5 6 switch(var) { case "A": System.out.println("A"); case "B": System.out.println("B"); }
  si var vaut "A", ça t'affichera :
  A B
  Il faut ajouter un break pour l'éviter :
  Code:
  
  1 2 3 4 5 6 7 switch(var) { case "A": System.out.println("A"); break; case "B": System.out.println("B"); }
  En résumé, tous les cas suivant le cas qui matche sont exécutés.
Pour la classe UtilisateurDAOImpl, c'est le même genre d'erreurs, mais la correction est l'inverse. Tu as fait un switch dans le constructeur avec une variable qui n'existe pas (operand), avec des méthode déclarées dans les cases. Il faut bien déclarer les méthodes, mais dans la classe, pas dans le constructeur et le switch ne sert à rien ici. Les méthodes seront appelées dans le switch de la méthode doPost() et correspondent aux méthodes définies par l'interface UtilisateurDao.

Par ailleurs, tu devrais passer l'exception SQL avec ta DaoException, sinon tu ne sauras jamais distinguer les différentes erreurs (tu n'auras toujours qu'un simple message "Impossible de communiquer avec la base de données"), ce qui te donnera des difficultés pour trouver une solution à des problèmes de base de données.
Code:

1 2 3 4 5 public class DaoException extends Exception { public DaoException(String message, Throwable cause) { super(message, cause); } }
et dans le throw :
Code:

1 2 3 } catch (SQLException e) { throw new DaoException("Impossible de communiquer avec la base de données",e); }

bonjour joel.drigo,

J'ai essayé de faire pour le mieux de ma compréhension sur tes explications j'ai pas tout assimilé mais mon code a moins d'erreurs !
comme je le disait dans le premier post je préfère des morceau de code a un pseudo langage technique.
voici mon code ou j'ai annoté oû Eclipse me renvoi des erreurs c'est a dire quand il souligne en rouge les mots codés.
La servlet avec les switch et case break :

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
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
package com.boticiel.servlets;
 
 
import java.io.IOException;
 
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
import com.boticiel.forms.Utilisateur;
import com.boticiel.dao.*;
 
 
@WebServlet("/Db_dao")
 
public class Db_dao extends HttpServlet {
    private static final long serialVersionUID = 1L;
    private UtilisateurDao utilisateurDao;
 
    public void init() throws ServletException {
        DaoFactory daoFactory = DaoFactory.getInstance();
        this.utilisateurDao = daoFactory.getUtilisateurDao();
    }
 
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        try {
            request.setAttribute("utilisateurs", utilisateurDao.lister());
        }
        catch (DaoException e) {
            request.setAttribute("erreur", e.getMessage());
        }
 
        this.getServletContext().getRequestDispatcher("/WEB-INF/db_dao.jsp").forward(request, response);
    }
 
 
    public void doPost( HttpServletRequest request, HttpServletResponse response ) throws ServletException, IOException {
    	Utilisateur utilisateur = new Utilisateur();
    	private String operand;    	//erreur sur operand
    	String operand = request.getParameter("operand");	//erreur sur operand
    	switch (operand) {	
 
 
    	case "ajouter":
    		 {     	
 
    	try {
 
            //utilisateur.setId( Integer.parseInt(paramId) );
    		int paramId = Integer.parseInt(request.getParameter.toString("id"));	//erreur sur .getParameter
    		utilisateur.setId(paramId);
            utilisateur.setNom(request.getParameter("nom"));
            utilisateur.setPrenom(request.getParameter("prenom"));
            private UtilisateurDao utilisateurDao; // erreur sur utilisateurDao;
            request.setAttribute("utilisateurs", utilisateurDao.ajouter()); //erreur ajouter
        }
        catch (Exception e) {
            request.setAttribute("erreur", e.getMessage());
        }
        this.getServletContext().getRequestDispatcher("/WEB-INF/db_dao.jsp").forward(request, response);
 
    	}
    		 }
    	break;
        case "lister":
       		 {     	
    	public void lister(Utilisateur utilisateur){ // erreur sur utilisateur le dernier
    	  try {
              request.setAttribute("utilisateurs", utilisateurDao.lister());
          }
          catch (DaoException e) {
              request.setAttribute("erreur", e.getMessage());
          }
 
          this.getServletContext().getRequestDispatcher("/WEB-INF/db_dao.jsp").forward(request, response);
    	}
    	break; }
 
        case "supprimer": // erreur sur supprimer
   		 {     	
    	public void supprimer(Utilisateur utilisateur){// erreur sur utilisateur le dernier
        	try {
 
                utilisateur.setId( Integer.parseInt(paramId) ); // erreur (paramId)
                utilisateur.setId(Integer.parseInt(request.getParameter.toString("id")));// erreur sur getParameter
                utilisateurDao.supprimer(utilisateur);
 
                request.setAttribute("utilisateurs", utilisateurDao.supprimer()); // erreur sur .supprimer
            }
            catch (Exception e) {
                request.setAttribute("erreur", e.getMessage());
            }
            this.getServletContext().getRequestDispatcher("/WEB-INF/db_dao.jsp").forward(request, response);
 
        	}
    	break; }
 
        case "mise_a_jour": // ereur sur mise_a_jour
		 {     	
    	public void mise_a_jour(Utilisateur utilisateur){// erreur sur le dernier utilisateur
        	try {
 
        		utilisateur.setId(Integer.parseInt(request.getParameter.toString("id")));// erreur sur getParameter
                utilisateur.setId(request.getParameter.toString(Integer.parseInt("id")));// erreur sur getParameter
                utilisateur.setNom(request.getParameter("nom"));
                utilisateur.setPrenom(request.getParameter("prenom"));
                utilisateurDao.ajouter(utilisateur);
                request.setAttribute("utilisateurs", utilisateurDao.mise_a_jour()); // erreur sur mise_a_jour
            }
            catch (Exception e) {
                request.setAttribute("erreur", e.getMessage());
            }
            this.getServletContext().getRequestDispatcher("/WEB-INF/db_dao.jsp").forward(request, response);
 
        	}  
 
		 }

Mon java bean et l'implémentation des méthodes

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
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
package com.boticiel.dao;
 
 
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
 
import com.boticiel.forms.BeanException;
import com.boticiel.forms.Utilisateur;
 
 
 
public class UtilisateurDaoImpl implements UtilisateurDao {// erreur sur UtilisateurDaoImpl
 
 
private DaoFactory daoFactory;
public String operand;
 
 
UtilisateurDaoImpl(DaoFactory daoFactory) {
this.daoFactory = daoFactory;
 
 
 
 
 
    public void ajouter(Utilisateur utilisateur) throws DaoException { // erreur sur ajouter et utilisateur
        Connection connexion = null;
        PreparedStatement preparedStatement = null;
 
        try {
            connexion = daoFactory.getConnection();
            preparedStatement = connexion.prepareStatement("INSERT INTO noms(nom, prenom) VALUES(?, ?);");
            preparedStatement.setString(1, utilisateur.getNom());
            preparedStatement.setString(2, utilisateur.getPrenom());
 
            preparedStatement.executeUpdate();
            connexion.commit();
        } catch (SQLException e) {
            try {
                if (connexion != null) {
                    connexion.rollback();
                }
            } catch (SQLException e2) {
            }
            public class DaoException extends Exception {
                public DaoException(String message, Throwable cause) {
                    super(message, cause);
                }
            }
        }
        finally {
            try {
                if (connexion != null) {
                    connexion.close();  
                }
            } catch (SQLException e) {
            	public class DaoException extends Exception {
            	    public DaoException(String message, Throwable cause) {
            	        super(message, cause);
            	    }
            	}
            }
 
 
    }
 
 
    public List<Utilisateur> lister() throws DaoException {// erreur sur lister() throws DaoException 
        List<Utilisateur> utilisateurs = new ArrayList<Utilisateur>();
        Connection connexion = null;
        Statement statement = null;
        ResultSet resultat = null;
 
        try {
            connexion = daoFactory.getConnection();
            statement = connexion.createStatement();
            resultat = statement.executeQuery("SELECT nom, prenom FROM noms;");
 
            while (resultat.next()) {
            	String id = resultat.getString("id");
            	String nom = resultat.getString("nom");
                String prenom = resultat.getString("prenom");
 
                Utilisateur utilisateur = new Utilisateur();
                //utilisateur.setId(id);
                utilisateur.setNom(nom);
                utilisateur.setPrenom(prenom);
 
                utilisateurs.add(utilisateur);
            }
        } catch (SQLException e) {
        	public class DaoException extends Exception {
        	    public DaoException(String message, Throwable cause) {
        	        super(message, cause);
        	    }
        	}
        } catch (BeanException e) {
        	public class DaoException extends Exception {
        	    public DaoException(String message, Throwable cause) {
        	        super(message, cause);
        	    }
        	}
        }
        finally {
            try {
                if (connexion != null) {
                    connexion.close();  
                }
            } catch (SQLException e) {
            	public class DaoException extends Exception {
            	    public DaoException(String message, Throwable cause) {
            	        super(message, cause);
            	    }
            	}
            }
        }
        return utilisateurs;
 
 
} }
 
    public void mise_a_jour(Utilisateur utilisateur) throws DaoException {// erreur sur le dernier utilisateur
        Connection connexion = null;
        PreparedStatement preparedStatement = null;
        //String paramId = request.getParameter("id");
        try {
            connexion = daoFactory.getConnection();
            preparedStatement = connexion.prepareStatement("UPDATE noms SET nom = ?, prenom = ? WHERE id = ?");
 
  		   preparedStatement.setString(1, utilisateur.getNom());
  		   preparedStatement.setString(2, utilisateur.getPrenom());
  		   preparedStatement.setInt(3, utilisateur.getId());
 
            preparedStatement.executeUpdate();
            connexion.commit();
        } catch (SQLException e) {
            try {
                if (connexion != null) {
                    connexion.rollback();
                }
            } catch (SQLException e2) {
            }
            public class DaoException extends Exception {
                public DaoException(String message, Throwable cause) {
                    super(message, cause);
                }
            }
        }
        finally {
            try {
                if (connexion != null) {
                    connexion.close();  
                }
            } catch (SQLException e) {
            	public class DaoException extends Exception {
            	    public DaoException(String message, Throwable cause) {
            	        super(message, cause);
            	    }
            	}
            }
          }
        }
}
 
 
		public void supprimer(Utilisateur utilisateur) throws DaoException {
            Connection connexion = null;
            PreparedStatement preparedStatement = null;
            //String paramId = request.getParameter("id");
            try {
                connexion = daoFactory.getConnection();
                preparedStatement = connexion.prepareStatement("Delete * WHERE id = ?");
 
 
                preparedStatement.executeUpdate();
                connexion.commit();
            } catch (SQLException e) {
                try {
                    if (connexion != null) {
                        connexion.rollback();
                    }
                } catch (SQLException e2) {
                }
                public class DaoException extends Exception {// erreur sur DaoException
                    public DaoException(String message, Throwable cause) {
                        super(message, cause);
                    }
                }
            }
            finally {
                try {
                    if (connexion != null) {
                        connexion.close();  
                    }
                } catch (SQLException e) {
                	public class DaoException extends Exception {// erreur sur DaoException
                	    public DaoException(String message, Throwable cause) {
                	        super(message, cause);
                	    }
                	}
                }
            }
 
    }

Il faut que je métraise le design pattern DAO car je vais bientôt travailler sur des projets concrets, c'est une technique séduisante car elle offre la bascule de base de données de tout les éditeurs de ces derniers.
je passe ma certification java EE et j'utiliserais ce design pattern !

Cordialement
Philippe

22/08/2017, 01h45
joel.drigo
Citation:

Envoyé par philo71

comme je le disait dans le premier post je préfère des morceau de code a un pseudo langage technique.

Je t'ai donné des morceaux de code et ce que tu daignes appeler un "pseudo langage techinique" ce sont les explications pour que tu comprennes pourquoi ce que tu as écrit est erroné afin que tu ne refasses pas les mêmes erreurs. Si je te donne du code prêt à copier ça ne sert à rien et ce n'est pas le but de ce forum.

Au sujet de :
Code:

1 2 private String operand; //erreur sur operand String operand = request.getParameter("operand"); //erreur sur operand
Je t'ai déjà répondu. "private" n'a rien à faire dans une méthode. Et tu déclares 2 fois la variables operand. Un nom de variable ne peut être qu'unique dans une portée.

Pareil pour

Code:

int paramId = Integer.parseInt(request.getParameter.toString("id")); //erreur sur .getParameter

j'ai déjà répondu. getParameter() est une méthode, donc avec () après, sinon ce serait une attribut de la classe et il n'y en a aucun qui s'appelle getParameter(). Et la méthode getParameter() prend un paramètre (le nom du paramètre à lire, donc "id"). Je t'ai même donné la correction exactement.
Code:

1 2 3 private UtilisateurDao utilisateurDao; // erreur sur utilisateurDao; request.setAttribute("utilisateurs", utilisateurDao.ajouter()); //erreur ajouter
Déjà répondu pour private. Et avec UtilisateurDao utilisateurDao; tu déclares une variable mais tu ne lui donnes aucune valeur ( = avec quelque chose derrière), donc tu ne peux pas écrire utilisateurDao.ajouter() parce qu'on ne peut pas appeler une méthode sur une variable sans valeur.

[code]
public void lister(Utilisateur utilisateur){ // erreur sur utilisateur le dernier
[/code ]
Déjà répondu aussi : on ne peut pas déclarer une méthode dans une méthode. public void lister(Utilisateur utilisateur) déclare une méthode public de type void et de nom lister avec un paramètre de type Utilisateur nommé utilisateur.

J'arrête là parce que
1. la plupart des erreurs sont les mêmes (méthode dans méthode en particulier)
2. Lorsqu'il y a beaucoup d'erreurs du type que tu fais, le compilateur ne comprend plus rien et a tendance à voir des erreurs là où il n'y en a pas. Corrige déjà les erreurs que je t'ai signalées et on verra après.

Citation:

la plupart des erreurs sont les mêmes (méthode dans méthode en particulier)

J'ai bien cherché mais je en vois pas de méthode dans les méthodes, ou alors il faut faire autrement en coupant le code en module de class mais dur a gérer pour un si petit programme, je ne sais quoi te dire, sinon en m'aidant par un exemple d'erreur de codage...

Citation:

Lorsqu'il y a beaucoup d'erreurs du type que tu fais, le compilateur ne comprend plus rien et a tendance à voir des erreurs là où il n'y en a pas. Corrige déjà les erreurs que je t'ai signalées et on verra après.

je n'ai plus beaucoups d'erreurs, mais je crois que tu veux me dire que je fait des erreurs de portés de variable ou de méthode...

enfin je te joint mon code avec quelques corrections.

le bean DAO

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
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
package com.boticiel.dao;
 
 
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
 
import com.boticiel.forms.BeanException;
import com.boticiel.forms.Utilisateur;
 
 
 
public class UtilisateurDaoImpl implements UtilisateurDao {// erreur sur UtilisateurDaoImpl
 
 
private DaoFactory daoFactory;
public String operand;
 
 
UtilisateurDaoImpl(DaoFactory daoFactory) {
this.daoFactory = daoFactory;
 
 
 
 
 
    public void ajouter(Utilisateur utilisateur) throws DaoException { // erreur sur ajouter et utilisateur
        Connection connexion = null;
        PreparedStatement preparedStatement = null;
 
        try {
            connexion = daoFactory.getConnection();
            preparedStatement = connexion.prepareStatement("INSERT INTO noms(nom, prenom) VALUES(?, ?);");
            preparedStatement.setString(1, utilisateur.getNom());
            preparedStatement.setString(2, utilisateur.getPrenom());
 
            preparedStatement.executeUpdate();
            connexion.commit();
        } catch (SQLException e) {
            try {
                if (connexion != null) {
                    connexion.rollback();
                }
            } catch (SQLException e2) {
            }
            public class DaoException extends Exception {
                public DaoException(String message, Throwable cause) {
                    super(message, cause);
                }
            }
        }
        finally {
            try {
                if (connexion != null) {
                    connexion.close();  
                }
            } catch (SQLException e) {
            	public class DaoException extends Exception {
            	    public DaoException(String message, Throwable cause) {
            	        super(message, cause);
            	    }
            	}
            }
 
 
    }
 
 
    public List<Utilisateur> lister() throws DaoException {// erreur sur lister() throws DaoException 
        List<Utilisateur> utilisateurs = new ArrayList<Utilisateur>();
        Connection connexion = null;
        Statement statement = null;
        ResultSet resultat = null;
 
        try {
            connexion = daoFactory.getConnection();
            statement = connexion.createStatement();
            resultat = statement.executeQuery("SELECT nom, prenom FROM noms;");
 
            while (resultat.next()) {
            	String id = resultat.getString("id");
            	String nom = resultat.getString("nom");
                String prenom = resultat.getString("prenom");
 
                Utilisateur utilisateur = new Utilisateur();
                //utilisateur.setId(id);
                utilisateur.setNom(nom);
                utilisateur.setPrenom(prenom);
 
                utilisateurs.add(utilisateur);
            }
        } catch (SQLException e) {
        	public class DaoException extends Exception {
        	    public DaoException(String message, Throwable cause) {
        	        super(message, cause);
        	    }
        	}
        } catch (BeanException e) {
        	public class DaoException extends Exception {
        	    public DaoException(String message, Throwable cause) {
        	        super(message, cause);
        	    }
        	}
        }
        finally {
            try {
                if (connexion != null) {
                    connexion.close();  
                }
            } catch (SQLException e) {
            	public class DaoException extends Exception {
            	    public DaoException(String message, Throwable cause) {
            	        super(message, cause);
            	    }
            	}
            }
        }
        return utilisateurs;
 
 
} }
 
    public void mise_a_jour(Utilisateur utilisateur) throws DaoException {// erreur sur le dernier utilisateur
        Connection connexion = null;
        PreparedStatement preparedStatement = null;
        //String paramId = request.getParameter("id");
        try {
            connexion = daoFactory.getConnection();
            preparedStatement = connexion.prepareStatement("UPDATE noms SET nom = ?, prenom = ? WHERE id = ?");
 
  		   preparedStatement.setString(1, utilisateur.getNom());
  		   preparedStatement.setString(2, utilisateur.getPrenom());
  		   preparedStatement.setInt(3, utilisateur.getId());
 
            preparedStatement.executeUpdate();
            connexion.commit();
        } catch (SQLException e) {
            try {
                if (connexion != null) {
                    connexion.rollback();
                }
            } catch (SQLException e2) {
            }
            public class DaoException extends Exception {
                public DaoException(String message, Throwable cause) {
                    super(message, cause);
                }
            }
        }
        finally {
            try {
                if (connexion != null) {
                    connexion.close();  
                }
            } catch (SQLException e) {
            	public class DaoException extends Exception {
            	    public DaoException(String message, Throwable cause) {
            	        super(message, cause);
            	    }
            	}
            }
          }
        }
}
 
 
		public void supprimer(Utilisateur utilisateur) throws DaoException {
            Connection connexion = null;
            PreparedStatement preparedStatement = null;
            //String paramId = request.getParameter("id");
            try {
                connexion = daoFactory.getConnection();
                preparedStatement = connexion.prepareStatement("Delete * WHERE id = ?");
 
 
                preparedStatement.executeUpdate();
                connexion.commit();
            } catch (SQLException e) {
                try {
                    if (connexion != null) {
                        connexion.rollback();
                    }
                } catch (SQLException e2) {
                }
                public class DaoException extends Exception {// erreur sur DaoException
                    public DaoException(String message, Throwable cause) {
                        super(message, cause);
                    }
                }
            }
            finally {
                try {
                    if (connexion != null) {
                        connexion.close();  
                    }
                } catch (SQLException e) {
                	public class DaoException extends Exception {// erreur sur DaoException
                	    public DaoException(String message, Throwable cause) {
                	        super(message, cause);
                	    }
                	}
                }
            }
 
    }
 
 
}

la servlet

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
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
package com.boticiel.servlets;
 
 
import java.io.IOException;
 
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
import com.boticiel.forms.Utilisateur;
import com.boticiel.dao.*;
 
 
@WebServlet("/Db_dao")
 
public class Db_dao extends HttpServlet {
    private static final long serialVersionUID = 1L;
    private UtilisateurDao utilisateurDao;
 
    public void init() throws ServletException {
        DaoFactory daoFactory = DaoFactory.getInstance();
        this.utilisateurDao = daoFactory.getUtilisateurDao();
    }
 
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        try {
            request.setAttribute("utilisateurs", utilisateurDao.lister());
        }
        catch (DaoException e) {
            request.setAttribute("erreur", e.getMessage());
        }
 
        this.getServletContext().getRequestDispatcher("/WEB-INF/db_dao.jsp").forward(request, response);
    }
 
 
    public void doPost( HttpServletRequest request, HttpServletResponse response ) throws ServletException, IOException {
    	Utilisateur utilisateur = new Utilisateur();
    	    	//erreur sur operand
    	String operand = request.getParameter("operand");	//erreur sur operand
    	switch (operand) {	
 
 
    	case "ajouter":
    		 {     	
 
    	try {
 
            //utilisateur.setId( Integer.parseInt(paramId) );
    		int paramId = Integer.parseInt(request.getParameter.toString("id"));	//erreur sur .getParameter
    		utilisateur.setId(paramId);
            utilisateur.setNom(request.getParameter("nom"));
            utilisateur.setPrenom(request.getParameter("prenom"));
            private UtilisateurDao utilisateurDao; // erreur sur utilisateurDao;
            request.setAttribute("utilisateurs", utilisateurDao.ajouter()); //erreur ajouter
        }
        catch (Exception e) {
            request.setAttribute("erreur", e.getMessage());
        }
        this.getServletContext().getRequestDispatcher("/WEB-INF/db_dao.jsp").forward(request, response);
 
    	}
    		 }
    	break;
        case "lister":
       		 {     	
    	public void lister(Utilisateur utilisateur){ // erreur sur utilisateur le dernier
    	  try {
              request.setAttribute("utilisateurs", utilisateurDao.lister());
          }
          catch (DaoException e) {
              request.setAttribute("erreur", e.getMessage());
          }
 
          this.getServletContext().getRequestDispatcher("/WEB-INF/db_dao.jsp").forward(request, response);
    	}
    	 }break;
 
        case "supprimer": // erreur sur supprimer
   		 {     	
    	public void supprimer(Utilisateur utilisateur){// erreur sur utilisateur le dernier
        	try {
 
                utilisateur.setId( Integer.parseInt(paramId) ); // erreur (paramId)
                utilisateur.setId(Integer.parseInt(request.getParameter.toString("id")));// erreur sur getParameter
                utilisateurDao.supprimer(utilisateur);
 
                request.setAttribute("utilisateurs", utilisateurDao.supprimer()); // erreur sur .supprimer
            }
            catch (Exception e) {
                request.setAttribute("erreur", e.getMessage());
            }
            this.getServletContext().getRequestDispatcher("/WEB-INF/db_dao.jsp").forward(request, response);
 
        	}
    	 }break;
 
        case "mise_a_jour": // ereur sur mise_a_jour
		 {     	
    	public void mise_a_jour(Utilisateur utilisateur){// erreur sur le dernier utilisateur
        	try {
 
        		utilisateur.setId(Integer.parseInt(request.getParameter.toString("id")));// erreur sur getParameter
                utilisateur.setId(request.getParameter.toString(Integer.parseInt("id")));// erreur sur getParameter
                utilisateur.setNom(request.getParameter("nom"));
                utilisateur.setPrenom(request.getParameter("prenom"));
                utilisateurDao.ajouter(utilisateur);
                request.setAttribute("utilisateurs", utilisateurDao.mise_a_jour()); // erreur sur mise_a_jour
            }
            catch (Exception e) {
                request.setAttribute("erreur", e.getMessage());
            }
            this.getServletContext().getRequestDispatcher("/WEB-INF/db_dao.jsp").forward(request, response);
 
        	}  
 
		 }
}}

Kinds Regards

Citation:

Envoyé par philo71

J'ai bien cherché mais je en vois pas de méthode dans les méthodes, ou alors il faut faire autrement en coupant le code en module de class mais dur a gérer pour un si petit programme, je ne sais quoi te dire, sinon en m'aidant par un exemple d'erreur de codage...

Voici un extrait de ton code (j'ai supprimé des lignes pour que ça soit plus visible)
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 public void doPost( HttpServletRequest request, HttpServletResponse response ) throws ServletException, IOException { /** lignes supprimées **/ switch (operand) { case "ajouter": /** lignes supprimées **/ break; case "lister": { public void lister(Utilisateur utilisateur){ // erreur sur utilisateur le dernier /** lignes supprimées **/ } }break; /** lignes supprimées **/ }
Ce qui suit est une déclaration de méthode :
Code:

1 2 3 public void doPost( HttpServletRequest request, HttpServletResponse response ) throws ServletException, IOException { /** du code **/ }
Ce qui suit est aussi une déclaration de méthode :
Code:

1 2 3 public void lister(Utilisateur utilisateur){ // erreur sur utilisateur le dernier /** du code **/ }
Or si tu regardes bien ton code, tu verras que la déclaration de la méthode lister est à l'intérieur de la méthode doPost (entre les accolades de sa définition) !

Pour simplifier, tu écris :
Code:

1 2 3 4 5 6 public void doPost() { public void lister() { } }
Ce qui est impossible en Java. Cela n'a pas de sens.

Ce qui suit oui :
Code:

1 2 3 4 5 6 7 8 9 10 11 // déclaration d'une méthode appelée doPost public void doPost() { lister(); // appel de la méthode lister() } // déclaration d'une méthode appelée lister public void lister() { }
Ensuite, dans le reste du code tu fais :
Code:

1 2 3 4 5 6 7 8 9 10 11 try { if (connexion != null) { connexion.rollback(); } } catch (SQLException e2) { } public class DaoException extends Exception { public DaoException(String message, Throwable cause) { super(message, cause); } }
La partie :
Code:

1 2 3 4 5 public class DaoException extends Exception { public DaoException(String message, Throwable cause) { super(message, cause); } }
Déclare une classe public. Or, si on peut déclarer une classe dans une méthode, on ne peut la déclarer de portée public. Si elle est dans une méthode, elle est automatiquement de portée locale, et donc ne peut être d'une autre portée. De toute manière, dans tous les cas, tu ne peux avoir le mot public directement dans le scope local d'une méthode. En d'autres termes, si tu as le mot clef public dans une méthode, c'est que ce n'est pas ça qu'il fallait faire.

Attention, entre parenthèses, on peut écrire un truc comme ça, dans le corps d'une classe :
Code:

1 2 3 4 5 6 7 8 9 10 public void foo() { class Machin { public void bar() { } } }
Dans ce code, on a une méthode s'appelant foo, qui déclare une classe locale à cette méthode s'appelant Machin, qui elle a une méthode publique s'appelant bar. La méthode bar n'est donc pas déclarée dans la méthode foo(), mais dans la classe Machin, qui elle est déclarée dans la méthode foo.
Vois-tu la différence ?

Pour en revenir à ton :
Code:

1 2 3 4 5 6 7 8 9 10 11 try { if (connexion != null) { connexion.rollback(); } } catch (SQLException e2) { } public class DaoException extends Exception { public DaoException(String message, Throwable cause) { super(message, cause); } }
Le but est de soulever une exception de type DaoException lorsqu'une SQLException survient, donc premièrement, ça se fait dans le catch. Et ensuite, pour soulever une exception, on ne déclare pas une classe dans la ligne de code, mais on fait un throw suivi d'une instance de l'exception voulue.

Le code suivant c'est la déclaration de la classe :
Code:

1 2 3 4 5 public class DaoException extends Exception { public DaoException(String message, Throwable cause) { super(message, cause); } }
Ceci doit être mis dans fichier DaoException.java (il y a d'autres solutions, mais je n'en parlerais pas pour éviter d'introduire plus de confusion).
Ensuite dans ton catch, il suffit de faire :
Code:

1 2 3 4 5 6 7 8 try { if (connexion != null) { connexion.rollback(); } } catch (SQLException e2) { throw new DaoException("Il y a eu une erreur lors du rollback", e2); // on lance une DaoException }

J'ai compris mes erreurs suite a tes précieux conseils sur les méthodes dans les méthodes !
traité les execeptions SQL.
voici mon code :

DaoExecptions

Code:

1
2
3
4
5
6
7
8
package com.boticiel.dao;
 
 
	 public class DaoException extends Exception {
         public DaoException(String message, Throwable cause) {
             super(message, cause);
         }
     }

utilisateurDaoIplm

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
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
package com.boticiel.dao;
 
 
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
 
import com.boticiel.forms.BeanException;
import com.boticiel.forms.Utilisateur;
 
 
 
public class UtilisateurDaoImpl implements UtilisateurDao {// erreur sur UtilisateurDaoImpl
 
 
private DaoFactory daoFactory;
public String operand;
 
 
UtilisateurDaoImpl(DaoFactory daoFactory) {
this.daoFactory = daoFactory;
 
 
 
 
 
    public void ajouter(Utilisateur utilisateur) throws DaoException { // erreur sur ajouter et utilisateur
        Connection connexion = null;
        PreparedStatement preparedStatement = null;
 
        try {
            connexion = daoFactory.getConnection();
            preparedStatement = connexion.prepareStatement("INSERT INTO noms(nom, prenom) VALUES(?, ?);");
            preparedStatement.setString(1, utilisateur.getNom());
            preparedStatement.setString(2, utilisateur.getPrenom());
 
            preparedStatement.executeUpdate();
            connexion.commit();
        } catch (SQLException e) {
            try {
                if (connexion != null) {
                    connexion.rollback();
                }
            } catch (SQLException e2) {
            }
            public class DaoException extends Exception {
                public DaoException(String message, Throwable cause) {
                    super(message, cause);
                }
            }
        }
        finally {
            try {
                if (connexion != null) {
                    connexion.close();  
                }
            } catch (SQLException e) {
 
            }
 
 
    }
 
 
    public List<Utilisateur> lister() throws DaoException {// erreur sur lister() throws DaoException 
        List<Utilisateur> utilisateurs = new ArrayList<Utilisateur>();
        Connection connexion = null;
        Statement statement = null;
        ResultSet resultat = null;
 
        try {
            connexion = daoFactory.getConnection();
            statement = connexion.createStatement();
            resultat = statement.executeQuery("SELECT nom, prenom FROM noms;");
 
            while (resultat.next()) {
            	String id = resultat.getString("id");
            	String nom = resultat.getString("nom");
                String prenom = resultat.getString("prenom");
 
                Utilisateur utilisateur = new Utilisateur();
                //utilisateur.setId(id);
                utilisateur.setNom(nom);
                utilisateur.setPrenom(prenom);
 
                utilisateurs.add(utilisateur);
            }
        } catch (SQLException e) {
 
        	}
 
 
 
        finally {
            try {
                if (connexion != null) {
                    connexion.close();  
                }
            } catch (SQLException e) {
 
            	}
            }
        }
        return utilisateurs;
 
 
} }
 
    public void mise_a_jour(Utilisateur utilisateur) throws DaoException {
        Connection connexion = null;
        PreparedStatement preparedStatement = null;
        //String paramId = request.getParameter("id");
        try {
            connexion = daoFactory.getConnection();
            preparedStatement = connexion.prepareStatement("UPDATE noms SET nom = ?, prenom = ? WHERE id = ?");
 
  		   preparedStatement.setString(1, utilisateur.getNom());
  		   preparedStatement.setString(2, utilisateur.getPrenom());
  		   preparedStatement.setInt(3, utilisateur.getId());
 
            preparedStatement.executeUpdate();
            connexion.commit();
        } catch (SQLException e) {
            try {
                if (connexion != null) {
                    connexion.rollback();
                }
            } catch (SQLException e2) {
            }
 
 
        }
        finally {
            try {
                if (connexion != null) {
                    connexion.close();  
                }
            } catch (SQLException e) {
 
            	}
            }
 
        }
 
 
 
		public void supprimer(Utilisateur utilisateur) throws DaoException {
            Connection connexion = null;
            PreparedStatement preparedStatement = null;
            //String paramId = request.getParameter("id");
            try {
                connexion = daoFactory.getConnection();
                preparedStatement = connexion.prepareStatement("Delete * WHERE id = ?");
 
 
                preparedStatement.executeUpdate();
                connexion.commit();
            } catch (SQLException e) {
                try {
                    if (connexion != null) {
                        connexion.rollback();
                    }
                } catch (SQLException e2) {
                }
 
 
            }
            finally {
                try {
                    if (connexion != null) {
                        connexion.close();  
                    }
                } catch (SQLException e) {
 
                	}
                }
 
 
    }

la servlet blindée d'erreurs

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
94
95
96
97
98
package com.boticiel.servlets;
 
 
import java.io.IOException;
 
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
import com.boticiel.forms.Utilisateur;
import com.boticiel.dao.*;
 
 
@WebServlet("/Db_dao")
 
public class Db_dao extends HttpServlet {
    private static final long serialVersionUID = 1L;
    private UtilisateurDao utilisateurDao1;
 
    public void init() throws ServletException {
        DaoFactory daoFactory = DaoFactory.getInstance();
        this.utilisateurDao1 = daoFactory.getUtilisateurDao();
    }
 
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
 
    	try {
            request.setAttribute("utilisateurs", utilisateurDao1.lister());{
        }
        catch (DaoException e) {
            request.setAttribute("erreur", e.getMessage());
        }
 
        this.getServletContext().getRequestDispatcher("/WEB-INF/db_dao.jsp").forward(request, response);
    }
 
 
    public void doPost( HttpServletRequest request, HttpServletResponse response ) throws ServletException, IOException {
    	Utilisateur utilisateur = new Utilisateur();
 
    	String operand = request.getParameter("operand");	
    	switch (operand) {	
 
 
    	case "ajouter":
    		 {     	
    			ajouter(); // une erreur sur ajouter
    			  try {  request.setAttribute("utilisateurs", utilisateurDao1.ajouter()); 
    			  }
    			  catch (Exception e) {
    			      request.setAttribute("erreur", e.getMessage());
    			  }
    			this.getServletContext().getRequestDispatcher("/WEB-INF/db_dao.jsp").forward(request, response);
 
    		 }
    	break;
        case "lister":
        		lister(); // une erreur sur lister
        		  try {  request.setAttribute("utilisateurs", utilisateurDao1.lister()); 
        		  }
        		  catch (Exception e) {
        		      request.setAttribute("erreur", e.getMessage());
        		  }
        		this.getServletContext().getRequestDispatcher("/WEB-INF/db_dao.jsp").forward(request, response);
    	 }break;
 
        case "supprimer":  // des erreurs sur    case "supprimer":
   		 {     	
   			 	supprimer();
   			  try {  request.setAttribute("utilisateurs", utilisateurDao1.supprimer()); 
   			}
   			catch (Exception e) {
   			    request.setAttribute("erreur", e.getMessage());
   			}
   			 	this.getServletContext().getRequestDispatcher("/WEB-INF/db_dao.jsp").forward(request, response);
    	 }break;
 
        case "mise_a_jour": // des erreur sur  case "mise_a_jour":
		 {     	
			 	mise_a_jour(); // une erreur sur mise_a_jour
			 	  try {  request.setAttribute("utilisateurs", utilisateurDao1.mise_a_jour(utilisateur));{ // une erreur sur setAttribute
			 	 }
			 	 catch (Exception e) {
			 	     request.setAttribute("erreur", e.getMessage());
			 	 }
			 	this.getServletContext().getRequestDispatcher("/WEB-INF/db_dao.jsp").forward(request, response);
		 }break;
 
 
    }     	
 
 
public class DaoException extends Exception { // une erreur sur DaoException
    public DaoException(String message, Throwable cause) {
        super(message, cause);}
    }

Il me reste trois semaines pour boucler un autre projet final qui me servira de CERTIF, et rendre des comptes à mes supérieures.
J'espère arriver a la maitrîse parfaites du pattern DAO !

Très cordialement
Philippe

25/08/2017, 03h30
joel.drigo

Pense bien à travailler la notion de pool. Même si ce n'est pas une notion forcément inhérente au pattern DAO, c'est un indispensable pour une production réelle.

bonjour, j'ai corrigé mes erreurs de brackets sous <drjava> . j'ai toujours des problèmes avec des méthodes que je ne comprens pas mais j'ai mis des commentaires sur les erreurs avec la complexion d'eclipse luna. apparamment mon programme fait pas le lien entre la descriptions des méthodes et leurs implémentations. comment vous dire par manque d'expériences que je suis dans une impasse dont je n'arrive pas a me sortir de cette dernière sans aide !

voici le code :
UtilisateurDaoImpl.java

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
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
package com.boticiel.dao;
 
 
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
 
import com.boticiel.forms.BeanException;
import com.boticiel.forms.Utilisateur;
 
 
 
public  class UtilisateurDaoImpl implements UtilisateurDao {
	// error on UtilisateurDaoImpl >> The type UtilisateurDaoImpl must implement the inherited abstract method UtilisateurDao.lister()
 
private DaoFactory daoFactory;
public String operand;
 
 
UtilisateurDaoImpl(DaoFactory daoFactory) {
this.daoFactory = daoFactory;
 
class DaoException extends Exception {
    public DaoException(String message, Throwable cause) {
        super(message, cause);
    }
 
};   
 
public void ajouter(Utilisateur utilisateur) throws DaoException { // errors on ajouter>>void is an invalid type for the variable ajouter
	//and utilisateur>>Syntax error, insert ";" to complete LocalVariableDeclarationStatement
Connection connexion = null;
PreparedStatement preparedStatement = null;
 
try {
    connexion = daoFactory.getConnection();
    preparedStatement = connexion.prepareStatement("INSERT INTO noms(nom, prenom) VALUES(?, ?);");
    preparedStatement.setString(1, utilisateur.getNom());
    preparedStatement.setString(2, utilisateur.getPrenom());
 
    preparedStatement.executeUpdate();
    connexion.commit();
} catch (SQLException e) {
    try {
        if (connexion != null) {
            connexion.rollback();
        }
    } catch (SQLException e2) {
    }         
 
    finally {
        try {
            if (connexion != null) {
                connexion.close();  
            }
 
         catch (SQLException e) {
 
        }
    }
 
 
 
 
}
 
 
 
 
}
}; 
 
public List<Utilisateur> lister() throws DaoException {// error on lister() throws DaoException >> Syntax error on tokens, delete these tokens
 
 List<Utilisateur> utilisateurs = new ArrayList<Utilisateur>();
    Connection connexion = null;
    Statement statement = null;
    ResultSet resultat = null;
 
    try {
        connexion = daoFactory.getConnection();
        statement = connexion.createStatement();
        resultat = statement.executeQuery("SELECT nom, prenom FROM noms;");
 
        while (resultat.next()) {
         String id = resultat.getString("id");
         String nom = resultat.getString("nom");
            String prenom = resultat.getString("prenom");
 
            Utilisateur utilisateur = new Utilisateur();
            //utilisateur.setId(id);
            utilisateur.setNom(nom);
            utilisateur.setPrenom(prenom);
 
            utilisateurs.add(utilisateur);
        }
    } catch (SQLException e) {
 
     }
 
 
 
    finally {
        try {
            if (connexion != null) {
                connexion.close();  
            }
        } catch (SQLException e) {
 
         }
        }
 
    return utilisateurs;
 
 
};
 
 
public void mise_a_jour(Utilisateur utilisateur) throws DaoException { 
	// error '(' WW Syntax error on token "(", ; expected
	// error on utilisateur>>Syntax error, insert ";" to complete LocalVariableDeclarationStatement
 
	Connection connexion = null;
    PreparedStatement preparedStatement = null;
    //String paramId = request.getParameter("id");
    try {
        connexion = daoFactory.getConnection();
        preparedStatement = connexion.prepareStatement("UPDATE noms SET nom = ?, prenom = ? WHERE id = ?");
 
   preparedStatement.setString(1, utilisateur.getNom());
   preparedStatement.setString(2, utilisateur.getPrenom());
   preparedStatement.setInt(3, utilisateur.getId());
 
        preparedStatement.executeUpdate();
        connexion.commit();
    } catch (SQLException e) {
        try {
            if (connexion != null) {
                connexion.rollback();
            }
        } catch (SQLException e2) {
        }
 
 
    }
    finally {
        try {
            if (connexion != null) {
                connexion.close();  
            }
        } catch (SQLException e) {
 
         }
        }
 
};
public void supprimer(Utilisateur utilisateur) throws DaoException {
	// error on '(' >> Syntax error on token "(", ; expected
	// error on utilisateur >>Syntax error, insert ";" to complete LocalVariableDeclarationStatement
        Connection connexion = null;
        PreparedStatement preparedStatement = null;
        //String paramId = request.getParameter("id");
        try {
            connexion = daoFactory.getConnection();
            preparedStatement = connexion.prepareStatement("Delete * WHERE id = ?");
 
 
            preparedStatement.executeUpdate();
            connexion.commit();
        } catch (SQLException e) {
            try {
                if (connexion != null) {
                    connexion.rollback();
                }
            } catch (SQLException e2) {
            }
 
 
        }
        finally {
            try {
                if (connexion != null) {
                    connexion.close();  
                }
            } catch (SQLException e) {
 
             }
            }
 
};
 
}
 
 
 
}

La servlet Db_dao

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
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
package com.boticiel.servlets;
 
 
import java.io.IOException;
 
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
import com.boticiel.forms.Utilisateur;
import com.boticiel.dao.*;
 
 
@WebServlet("/Db_dao")
 
public class Db_dao extends HttpServlet {
    private static final long serialVersionUID = 1L;
    private UtilisateurDao utilisateurDao1;
 
    public void init() throws ServletException {
        DaoFactory daoFactory = DaoFactory.getInstance();
        this.utilisateurDao1 = daoFactory.getUtilisateurDao();
    }
 
 protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
 
        try {
               request.setAttribute("utilisateurs", utilisateurDao1.lister());{
            // one error one }
           catch (DaoException e) {
               request.setAttribute("erreur", e.getMessage());
           }
 
           this.getServletContext().getRequestDispatcher("/WEB-INF/db_dao.jsp").forward(request, response);
 
 
 
 
               }// error on '('
        }
 }
 
 
 
 
 
public void doPost( HttpServletRequest request, HttpServletResponse response ) throws ServletException, IOException {
     Utilisateur utilisateur = new Utilisateur();
 
     String operand = request.getParameter("operand"); 
     switch (operand) { 
 
 
 
  case "ajouter":
       {      
       ajouter(); // une error on  ajouter : The method ajouter() is undefined for the type Db_dao
         try {  request.setAttribute("utilisateurs", utilisateurDao1.ajouter()); // error .ajouter : The method ajouter(Utilisateur) in the type UtilisateurDao is not applicable for the arguments ()
         }
         catch (Exception e) {
             request.setAttribute("erreur", e.getMessage());
         }
       this.getServletContext().getRequestDispatcher("/WEB-INF/db_dao.jsp").forward(request, response);
 
       };
     break;
 
   case "lister":
            {
            lister(); // une error on lister : The method lister() is undefined for the type Db_dao
            try {  request.setAttribute("utilisateurs", utilisateurDao1.lister()); 
            }
            catch (Exception e) {
                request.setAttribute("erreur", e.getMessage());
            }
 
            this.getServletContext().getRequestDispatcher("/WEB-INF/db_dao.jsp").forward(request, response);
      }
      break;
   case "supprimer": 
      {      
        supprimer(); // error on "supprimer": The method supprimer() is undefined for the type Db_dao
        try {  request.setAttribute("utilisateurs", utilisateurDao1.supprimer()); // error on .supprimer :The method supprimer(Utilisateur) in the type UtilisateurDao is not applicable for the arguments ()
      }
      catch (Exception e) {
          request.setAttribute("erreur", e.getMessage());
      }
        this.getServletContext().getRequestDispatcher("/WEB-INF/db_dao.jsp").forward(request, response);
      }break;
    case "mise_a_jour": 
      {     
     mise_a_jour(); // one error on mise_a_jour : The method mise_a_jour() is undefined for the type Db_dao
     {  
     try {  request.setAttribute("utilisateurs", utilisateurDao1.mise_a_jour(utilisateur));{ // une error on setAttribute :he method setAttribute(String, Object) in the type ServletRequest is not applicable for the arguments (String, void)
      }// error on '}' : Syntax error, insert "}" to complete Block
      catch (Exception e) {
          request.setAttribute("erreur", e.getMessage());
      }
     this.getServletContext().getRequestDispatcher("/WEB-INF/db_dao.jsp").forward(request, response);
     }
     } 
     break;
 
    }    
 
 
 
} // error on '('  >> Syntax error on token "}", delete this token
}   
 
 
 
 
 
 
 
	public class DaoException extends Exception { // one error on DaoException :Illegal modifier for the local class DaoException; only abstract or final is permitted
    public DaoException(String message, Throwable cause) {
        super(message, cause);}
    }
 
 
 
}

Cordialement
philippe

Citation:

Envoyé par philo71

d'eclipse luna

Pourquoi utiliser une version si ancienne ?
error on UtilisateurDaoImpl >> The type UtilisateurDaoImpl must implement the inherited abstract method UtilisateurDao.lister()
Le message me semble clair : il y a une méthode dnas UtilisateurDao (la méthode lister()) qui n'est pas implémentée dans UtilisateurDaoImpl.
Lorsqu'on implémente une interface ou qu'on étend une classe abstraite :

soit on doit implémenter toutes les méthodes de l'interface, ou de la classe abstraite
soit la classe d'implémentation doit être abstraite (et on ne pourra pas l'instancier : en résumé, on repouse l'implémentation des méthodes non implémentée vers une sous classe qui, elle, les implémentera

Elle doit être définie avec exactement les mêmes paramètres et type de retour, sinon le compilateur considera que ce n'est pas la même méthode.
Il se peut également qu'il y ait d'autres problèmes, comme des méthodes mal fermées, qui trompent le compilateur : si tu as bien écrit la méthode, elle ne sera peut-être pas vue en tant que telle, et tu auras ce message ici (et un autre ailleurs).

Si tu dois "attendre" pour l'implémenter, pour travailler sur un autre aspect, tu peux au plus simple écrire la méthode de manière à ce qu'elle envoie une UnsupportedOperationException. Le premier avantage est que tu n'as pas besoin d'écrire d'autre code dans la méthode, ni dans l'appelant, et le second est que si tu oublies de le faire, tu auras une belle stacktrace qui te le rappellera quand tu testeras ton programme.
// errors on ajouter>>void is an invalid type for the variable ajouter
C'est toujours le même problème que tu as à chaque fois : tu déclares une méthode dans une méthode. Comme tu es dans une méthode, le compilateur se dit "il y a plublic void ajouter", on cherche à déclarer une variable, et son type est void, ce qui n'est pas autorisé, donc je le dis".

Voici ton code (j'ai marqué en rouge et grossi l'accolade qui démarre le corps de la méthode :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 UtilisateurDaoImpl(DaoFactory daoFactory) { this.daoFactory = daoFactory; // ici tu déclares une classe locale à la méthode class DaoException extends Exception { public DaoException(String message, Throwable cause) { super(message, cause); } }; // ici c'est la fin de la classe locale // et plaf, une déclaration de méthode public void ajouter(Utilisateur utilisateur) throws DaoException { // errors on ajouter>>void is an invalid type for the variable ajouter //and utilisateur>>Syntax error, insert ";" to complete LocalVariableDeclarationStatement Connection connexion = null;
Au passage, la classe DAOException étant locale au constructeur, elle ne sera pas visible ailleurs (dans d'autres méthodes, ou d'autres classes).

A priori la correction ce serait :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 UtilisateurDaoImpl(DaoFactory daoFactory) { this.daoFactory = daoFactory; }// on ferme le constructeur du coup la classe DaoException devient une classe interne (à la classe UtilisateurDaoImpl) et ne pourra donc être utilisée qu'à l'intérieur de celle-ci. Il faudrait la déclarer ailleurs dans son propre fichier en tant que classe publique, ou en tant que classe public static si tu la laisse là (mais ce serait plus logique du coup de la mettre plutôt dans UtilisateurDao) class DaoException extends Exception { public DaoException(String message, Throwable cause) { super(message, cause); } }; et ainsi on a une déclaration de méthode bien placée, dans le corps d'une classe public void ajouter(Utilisateur utilisateur) throws DaoException { Connection connexion = null; PreparedStatement preparedStatement = null; /**...**/
Au passage, j'en profite pour une remarque au sujet de ce code :
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 public void ajouter(Utilisateur utilisateur) throws DaoException { // errors on ajouter>>void is an invalid type for the variable ajouter //and utilisateur>>Syntax error, insert ";" to complete LocalVariableDeclarationStatement Connection connexion = null; PreparedStatement preparedStatement = null; try { connexion = daoFactory.getConnection(); preparedStatement = connexion.prepareStatement("INSERT INTO noms(nom, prenom) VALUES(?, ?);"); preparedStatement.setString(1, utilisateur.getNom()); preparedStatement.setString(2, utilisateur.getPrenom()); preparedStatement.executeUpdate(); connexion.commit(); } catch (SQLException e) { try { if (connexion != null) { connexion.rollback(); } } catch (SQLException e2) { } finally { try { if (connexion != null) { connexion.close(); } catch (SQLException e) { } } } } };
Une bonne indentation est une aide précieuse pour repérer les accolades qui manquent ou qui sont en trop :
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 public void ajouter(Utilisateur utilisateur) throws DaoException { Connection connexion = null; PreparedStatement preparedStatement = null; try { connexion = daoFactory.getConnection(); preparedStatement = connexion.prepareStatement("INSERT INTO noms(nom, prenom) VALUES(?, ?);"); preparedStatement.setString(1, utilisateur.getNom()); preparedStatement.setString(2, utilisateur.getPrenom()); preparedStatement.executeUpdate(); connexion.commit(); } catch (SQLException e) { // l'accolade fermante ferme le try try { if (connexion != null) { connexion.rollback(); } // ferme le if } catch (SQLException e2) { } // ferme le catch finally { // on voit tout de suite que le finally n'est pas au bon niveau (il ne sera pas exécuté en cas d'exception sur l'update, donc la connection ne sera pas fermée : il manque donc une accolade fermante juste avant cette ligne try { if (connexion != null) { connexion.close(); } // ferme le if // on voit tout de suite qu'il y a un souci avec le catch : il ne correspond pas au try : il manque une accolade fermante juste avant catch (SQLException e) { } // ferme le catch } // ferme le finally, enfin devrait, parce que ne ferme rien à cause du problème précédent } // devrait fermer le catch, mais on voit que ce n'est pas en face, toujours à cause des erreurs précédentes } ; // ferme le bloc de méthode // au passage le ; n'est pas nécessaire en fin de méthode : s'il y a des erreurs dans la classe, il se peut même que ça fasse tourner le compilateur en bourrique et qu'il te signale des erreurs au mauvais endroit, ou les mauvaises erreurs
Les autres erreurs dans le classe sont probablements dues à l'un des précédents : lorsqu'il y a trop de souci d'accolades, le compilateur ne comprend pluis rien et signale des erreurs là où il n'y en a pas (elles sont ailleurs).
Dans l'autre classe :
Code:

1 2 3 request.setAttribute("utilisateurs", utilisateurDao1.lister());{ // one error one } catch (DaoException e) {
L'accolade ouvrante rouge n'est pas fermée par la bleue : la bleue est dans un commentaire, elle ne compte donc pas pour une accolade.
du coup tu as une accolade ouvrante, puis un catch : c'est un cas impossible, d'où erreur de compilation
Alors tu vas peut-être me dire qu'en fait c'est juste que quand tu as ajouté le commentaire pour me montrer l'erreur tu n'as pas fait attention que tu m'étais l'accolade fermante dans le commentaire et qu'en fait le code c'est :
Code:

1 2 3 4 5 6 try { request.setAttribute("utilisateurs", utilisateurDao1.lister());{ } catch (DaoException e) { request.setAttribute("erreur", e.getMessage()); }
Et là, du coup, on a bien une accolade fermante juste avant le catch, mais il y a toujours l'accolade ouvrante à la fin de la ligne juste avant, du coup l'accolade fermante ne ferme pas le try, mais l'accolade ouvrante de la ligne d'avant, formant juste un bloc vide. Ce code avec une indentation correcte :
Code:

1 2 3 4 5 6 try { request.setAttribute("utilisateurs", utilisateurDao1.lister()); {} catch (DaoException e) { request.setAttribute("erreur", e.getMessage()); }
Et là on voit tout de suite qu'il y a un souci, parce qu'on devrait avoir le catch au même niveau que le try :
Code:

1 2 3 4 5 6 try { request.setAttribute("utilisateurs", utilisateurDao1.lister()); } catch (DaoException e) { request.setAttribute("erreur", e.getMessage()); }
ou (personnellement je préfère)
Code:

1 2 3 4 5 try { request.setAttribute("utilisateurs", utilisateurDao1.lister()); } catch (DaoException e) { request.setAttribute("erreur", e.getMessage()); }
On repère bien par les alignements quels sont les instructions et blocs au même niveau.
Code:

}// error on '('

Puis là tout d'un coup, tu as une accolade fermante, qui ferme rien, d'où erreur.

Code:

ajouter(); // une error on ajouter : The method ajouter() is undefined for the type Db_dao

pareil, le message est éloquent : la méthode ajouter() n'existe pas dans Db_dao, parce que c'est dans UtilisateurDao/UtilisateurDaoImpl qu'elle existe.

Code:

try { request.setAttribute("utilisateurs", utilisateurDao1.ajouter()); // error .ajouter : The method ajouter(Utilisateur) in the type UtilisateurDao is not applicable for the arguments ()

Ici tu appelles bien la méthode ajouter() sur une variable du type UtilisateurDao, qui a bien cette méthode (au passage, tu vois ici comment corriger l'erreur précédente). Seulement la méthode ajouter est déclarée comme ça :

Code:

void ajouter( Utilisateur utilisateur ) throws DaoException;

Il y a donc un paramètre à passer et c'est ce que le mesage te dit clairement : is not applicable for the arguments () = n'est pas applicable pour les arguments "rien du tout", parce qu'il faut passer un argument de type Utilisateur.

Les autres erreurs ne sont que des répétions d'autres erreurs décrites ci-dessus, ou leurs conséquences (le compilateur croit qu'il y a des erreurs là où il n'y en a pas).

bonjour

j'ai quelque erreur encore mais cela va mieux, j'ai compris tes explications,voici l'erreur que j'ai dans l'implémentation de mes méthodes.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 while (resultat.next()) { String id = resultat.getString("id"); String nom = resultat.getString("nom"); String prenom = resultat.getString("prenom"); Utilisateur utilisateur = new Utilisateur(); utilisateur.setId(Integer.parseInt(request.getParameter("id"))); // erreur sur request //utilisateur.toString(setId(id)); utilisateur.setNom(nom); utilisateur.setPrenom(prenom); utilisateurs.add(utilisateur); }
ici tu m'as deja expliqué des choses mais j'ai pas tout assimilé.

sinon,
erreur sur une classe :
Code:

1 2 3 4 5 public class DaoException extends Exception { // erreur sur DaoException public DaoException(String message, Throwable cause) { super(message, cause); }};
Sinon,
au niveau de la servlet je n'arrive pas a faire le lien entre la déclaration des méthodes et l'appel de cette implémentation !
par exemple :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 case "ajouter": { try { request.setAttribute("utilisateurs", utilisateurDao1.ajouter()); // erreur sur.ajouter : } catch (Exception e) { request.setAttribute("erreur", e.getMessage()); } this.getServletContext().getRequestDispatcher("/WEB-INF/db_dao.jsp").forward(request, response); }; break;
Tu m'as déja tout expliqué en gros mais je n'est pas encore la vision globale de ce designe patern DAO/jdbc.
l'appelant de mes méthodes est en erreur pour les 4 cas SQL (select,update,insert,delete).

Cordialement
Philippe