Gérer ses erreurs avec son DAO

**B.M.W83** · 15/08/2017, 18h52

Salut tout le monde

Je suis entrant de suivre une application de gérer les erreurs avec son DAO. Pour cela j'ai créé 2 classes d'exceptions BeanException.java (pour les erreurs lier au javaBeans que je vais créer) et DaoException (pour les exceptions lier à la communication à la BD)
la classe BeanException.java et la suivante

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
package com.Beans;
 
@SuppressWarnings("serial")
public class BeanException extends Exception {
 
	public BeanException(String message) {
		super(message);
	}
}

Et de même façon DaoException.java

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
package com.dao;
 
public class DaoException extends Exception {
 
	private static final long serialVersionUID = 1L;
 
	public DaoException(String message) {
		super(message);
	}
 
}

Ce deux classes sont différentes au type d'erreur pour récupérer l'erreur est de la BD ou de la communication de l'enregistrement soit de notre bean.
Ma classe bean contient deux champs nom et prenom et dans cette classe j'aimerai entrer un nom qui ne dépasse pas le 10 caractères. Voila le classe

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
package com.Beans;

public class Utilisateur {

	private String nom;
	private String prenom;

	public String getNom() {
		return nom;
	}

	public void setNom(String nom) throws BeanException {
		if (nom.length() > 10) {
			throw new BeanException("Le nom est trop grand ! (10 caracteres au maximim)");
		} else {
			this.nom = nom;
		}
	}

	public String getPrenom() {
		return prenom;
	}

	public void setPrenom(String prenom) {
		this.prenom = prenom;
	}

	public Utilisateur(String nom, String prenom) {
		super();
		this.nom = nom;
		this.prenom = prenom;
	}

	public Utilisateur() {
		super();
	}

}

avec le message d'erreur "le mot ne depasse pas le 10 caracteres"
Et dans le fichier UtilistaurDaoImp.java j'ai ajouté des bloque try catch et chaque bloque gère l'exception correspondant voile le code

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
 
package com.dao;
 
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
 
import com.Beans.BeanException;
import com.Beans.Utilisateur;
 
public class UtilisateurDaoImpl implements UtilisateurDao {
	private DaoFactory daoFactory;
 
	UtilisateurDaoImpl(DaoFactory daoFactory) {
		this.daoFactory = daoFactory;
	}
 
	@Override
	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("DAO_EXCEPTION (add) Impossible de communiquer avec la base de données");
		} finally {
			try {
				if (connexion != null) {
					connexion.close();
				}
			} catch (SQLException e) {
				throw new DaoException("SQL_EXCEPTION (add) Impossible de communiquer avec la base de données");
			}
		}
 
	}
 
	@Override
	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 nom = resultat.getString("nom");
				String prenom = resultat.getString("prenom");
 
				Utilisateur utilisateur = new Utilisateur();
				utilisateur.setNom(nom);
				utilisateur.setPrenom(prenom);
				utilisateurs.add(utilisateur);
			}
		} catch (SQLException e) {
			throw new DaoException("(sql_Ex lister)Impossible de communiquer avec la base de données");
		} catch (BeanException e) {
			throw new DaoException("(bean _ex Lister) 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;
	}
 
}

Et dans le contrôleur servlet ServeltDAO.java J'ai mis le code nécessaire entre les différentes exceptions

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
 
package com.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.Beans.Utilisateur;
import com.dao.*;
 
@WebServlet("/ServletDAO")
public class ServletDAO extends HttpServlet {
	private static final long serialVersionUID = 1L;
 
	private UtilisateurDao utilisateurDao;
 
	@Override
	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/index.jsp").forward(request, response);
	}
 
	protected void doPost(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		try {
			Utilisateur utilisateur = new Utilisateur();
			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/index.jsp").forward(request, response);
	}
 
}

et bien-sur j'affiche l'erreur dans le page index.jsp

Code jsp :

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
 
<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
	pageEncoding="ISO-8859-1"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
 
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8" />
<link rel="stylesheet" href="../assets/css/bootstrap.min.css" />
<link rel="stylesheet"
	href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap.min.css">
<title>Index</title>
<style type="text/css">
body {
        padding: 10px;
}
</style>
</head>
<body>
	<div class="container col-md-8 col-md-offset-2">
 
		<div class="panel panel-danger">
			<div class="panel-heading">Les erreurs</div>
			<div class="panel-body">
				<c:if test="${ !empty erreur }">
					<p style="color: red;">
						<c:out value="${erreur }"></c:out>
					</p>
				</c:if>
			</div>
		</div>
 
		<div class="panel panel-primary">
			<div class="panel-heading">Authentification</div>
			<div class="panel-body">
				<form class="form-inline" method="post">
					<div class="form-group">
						<label for="text">Nom : </label> <input type="text"
							class="form-control" id="nom" name="nom"
							placeholder="Entrer le nom">
					</div>
					<div class="form-group">
						<label for="text">Prenom : </label> <input type="text"
							class="form-control" id="prenom" name="prenom"
							placeholder="Entrer le prenom">
					</div>
					<button type="submit" class="btn btn-primary">Envoyer</button>
				</form>
			</div>
		</div>
		<div class="panel panel-success">
			<div class="panel-heading">Les utilisteurs</div>
			<div class="panel-body">
				<c:forEach items="${utilisateurs }" var="u">
 
					<ul>
						<li><c:out value="${u.nom }" /> <c:out value="${u.prenom }" />
						</li>
					</ul>
 
				</c:forEach>
 
			</div>
 
		</div>
 
	</div>
</body>
</html>

Lorsque j’exécute le programme un message d'erreur que Les données de la base sont invalides je ne sais pas ou du le problème malgré que au début le programme affiche tout les utilisateurs qui ont été enregistrer dans la base de données et l'ajout des données sont (avant la modification de gestion des erreurs)
je vais importer tout le programme

**PhilippeGibault** · 20/12/2019, 11h35

Il y a tellement de chose que je ne sais pas par où commencer.

Déjà, une BDD est sensé toujours être cohérente. Si on tente d'insérer une connerie, la BDD est sensé envoyé bouler. La longueur des champs doivent être spécifié en BDD (VAARCHAR(10) par exemple.

Ensuite, on vérifie avant que l'on peut insérer ou pas une donnée en BDD.

Je conseille de changer le contrat de la façon suivant:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
public interface UtilisateurDao{
 
    void ajouter(Utilisateur utilisateur) throws DaoException, BeanException;
 
    List<Utilisateur> lister() throws DaoException; 
 
}

Comme ça, si on tente de rentrer des Utilisateurs avec des erreurs, on jettera un BeanException, et on ne sollicitera pas la BDD.

On différentie mieux les rôles, avec un POJO qui est juste là pour donner la description d'un concept, et la DAO pour manipuler le concept en BDD. Si la DAO remarque que l'on ne peut pas insérer le concept, il envoie une exception pour spécifier une erreur.

Pour lister, l'erreur ne peut donc venir que de la BDD (selon le grand principe que dans une BDD relationnelle, une donnée est toujours cohérente.

De fait, le POJO devient bien plus simple:

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
 
package com.Beans;
 
public class Utilisateur {
 
	private String nom;
	private String prenom;
 
       public Utilisateur(String nom, String prenom) {
		this.nom = nom;
		this.prenom = prenom;
	}
 
	public Utilisateur() {
	}
 
	public String getNom() {
		return nom;
	}
 
	public void setNom(String nom) {
		this.nom = nom;
	}
 
	public String getPrenom() {
		return prenom;
	}
 
	public void setPrenom(String prenom) {
		this.prenom = prenom;
	}
}

On a un vrai POJO.

Pour la DAO, je vais faire une autre remarque, histoire de simplifier le code, il serait souhaitable d'utiliser les try-with-ressources ( https://www.baeldung.com/java-try-with-resources ) histoire de réduire le nombre de lignes de code (1 ligne de code = 1 ligne de code à maintenir.

Soit:

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
 
package com.dao;
 
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
 
import com.Beans.BeanException;
import com.Beans.Utilisateur;
 
public class UtilisateurDaoImpl implements UtilisateurDao {
	private DaoFactory daoFactory;
 
	UtilisateurDaoImpl(DaoFactory daoFactory) {
		this.daoFactory = daoFactory;
	}
 
	@Override
	public void ajouter(Utilisateur utilisateur) throws DaoException, BeanException {
 
               //Ici, du code qui vérifie 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();
		} catch (SQLException e) {
			throw new DaoException("DAO_EXCEPTION (add) Impossible de communiquer avec la base de données");
		} 
 
	}
 
	@Override
	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 nom = resultat.getString("nom");
				String prenom = resultat.getString("prenom");
 
				Utilisateur utilisateur = new Utilisateur();
				utilisateur.setNom(nom);
				utilisateur.setPrenom(prenom);
				utilisateurs.add(utilisateur);
			}
		} catch (SQLException e) {
			throw new DaoException("(sql_Ex lister)Impossible de communiquer avec la base de données");
		} 
		return utilisateurs;
	}
 
}

Reste à vérifier l'utilisateur. Là, 2 Solutions:
1) Solution1, un code pur et dur.
Comme:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
if (utilisateur.getNom()!= null && utilisateur.getNom().length() > 10) {
			throw new BeanException("Le nom est trop grand ! (10 caracteres au maximim)");
		}

Car oui, il faut aussi éviter le NullPointerException. Pour ma part, ça m'étonne que le nom puisse être null. Je m'étonne aussi qu'il n'y ait aucune vérification sur le prénom.

2) utiliser Hibernate Validator ou JSR 303 ( https://jmdoudoux.developpez.com/cou...dation_donnees ).
On annote le POJO. L'avantage, c'est que l'on peut vérifier encore plus de truc, avec très peu de lignes de codes.

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
 
public class Utilisateur {
 
        @NotNull
        @NotBlank
        @Size(max=10)
	private String nom;
 
        @NotNull
        @NotBlank
        @Size(max=10)
	private String prenom;
 
      //Getter, setter, constructeur
}

En 3 lignes de codes (les annotations), il est possible de vérifier les propriétés importantes.
Il est aussi possible de personnaliser le message:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
@NotNull(message="Le nom est null")

La vérification se fait donc à partir d'un code standard hibernate validation dont voici un exemple (De J.M Doudoux):

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
 
PersonneBean personne = new PersonneBean(null, null, new GregorianCalendar(
        2065, Calendar.JANUARY, 18).getTime());
 
    ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
    Validator validator = factory.getValidator();
 
    Set<ConstraintViolation<PersonneBean>> constraintViolations = 
      validator.validate(personne);
 
    if (constraintViolations.size() > 0 ) {
      System.out.println("Impossible de valider les donnees du bean : ");
      for (ConstraintViolation<PersonneBean> contraintes : constraintViolations) {
        System.out.println(contraintes.getRootBeanClass().getSimpleName()+
           "." + contraintes.getPropertyPath() + " " + contraintes.getMessage());
      }
    } else {
      System.out.println("Les donnees du bean sont valides");
    }

Cordialement.

Gérer ses erreurs avec son DAO

Persistance des données Java

Discussions similaires

Partager

Partager