Cours Complet
Validation de Mot de Passe en Java
Servlet Java · Regex · Java EE
Niveau : Intermédiaire | Technologie : Java EE / Jakarta EE | Année : 2026
1. Introduction
Dans le développement d'applications web en Java, la sécurité des mots de passe est un élément
fondamental. Avant d'enregistrer un utilisateur dans la base de données, il est indispensable de
vérifier que le mot de passe respecte des règles de sécurité minimales.
Cette vérification s'effectue généralement dans une Servlet Java, qui joue le rôle de contrôleur dans
l'architecture MVC (Modèle-Vue-Contrôleur). Deux approches principales existent :
Les conditions classiques (if/else) : simples mais verbeuses pour des règles multiples.
Les expressions régulières (Regex) : concises, puissantes et très répandues en Java EE et Spring
Boot.
💡 Bonne pratique : La validation côté serveur (Servlet) est indispensable même si une validation côté
client (JavaScript) existe déjà, car un utilisateur malveillant peut contourner la validation JavaScript.
2. Rappels sur les Servlets Java
Une Servlet est une classe Java qui traite les requêtes HTTP (GET, POST, etc.) et génère des
réponses. Elle est au cœur de Java EE pour la gestion des formulaires web.
2.1 Structure de base d'une Servlet
import [Link].*;
import [Link].*;
import [Link];
@WebServlet("/inscription")
public class InscriptionServlet extends HttpServlet {
@Override
protected void doPost(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException {
// Traitement de la requête POST
}
}
2.2 Récupérer les paramètres du formulaire
Les données envoyées par un formulaire HTML sont récupérées via la méthode getParameter() :
// Récupération du mot de passe depuis le formulaire
String motDePasse = [Link]("password");
// Récupération d'autres champs
String nom = [Link]("nom");
String email = [Link]("email");
⚠️Attention : getParameter() peut retourner null si le paramètre est absent. Toujours vérifier avec une
condition null avant d'appeler des méthodes sur la chaîne.
3. Règles de Validation du Mot de Passe
Pour garantir un niveau de sécurité acceptable, les règles suivantes sont communément appliquées :
Règle Description Exemple
Longueur minimale Au moins 8 caractères password1!
Majuscule Au moins une lettre majuscule (A- Java@2026
Z)
Minuscule Au moins une lettre minuscule (a- Java@2026
z)
Chiffre Au moins un chiffre (0-9) Java@2026
Caractère spécial Au moins un parmi @#$%^&+=! Java@2026
Exemple de mot de passe valide respectant toutes ces règles :
Java@2026 // ✓ Majuscule, minuscule, chiffre, caractère spécial, 9 caractères
4. Les Expressions Régulières (Regex)
4.1 Qu'est-ce qu'une Regex ?
Une expression régulière (Regular Expression) est un patron de recherche qui décrit un ensemble
de chaînes de caractères. En Java, la classe String offre la méthode matches() qui teste si une chaîne
correspond à une regex.
4.2 La Regex de validation complète
String regex = "^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d)(?=.*[@#$%^&+=!]).{8,}$";
4.3 Décomposition détaillée de la Regex
Voici l'explication de chaque composant de cette expression régulière :
Composant Rôle Explication
^ Ancre de début La chaîne doit commencer ici
(?=.*[a-z]) Lookahead positif Vérifie qu'il existe au moins une
lettre minuscule (a à z)
(?=.*[A-Z]) Lookahead positif Vérifie qu'il existe au moins une
lettre majuscule (A à Z)
(?=.*\d) Lookahead positif Vérifie qu'il existe au moins un
chiffre (0 à 9)
(?=.*[@#$%^&+=!]) Lookahead positif Vérifie la présence d'un caractère
spécial parmi la liste
.{8,} Quantificateur La chaîne doit contenir au
minimum 8 caractères
quelconques
$ Ancre de fin La chaîne doit se terminer ici (pas
de caractères supplémentaires)
4.4 Le concept de Lookahead (?=...)
Un lookahead positif (?=...) est une assertion de largeur nulle : il vérifie qu'une condition est vraie à
partir de la position courante, sans consommer de caractères. Cela permet d'imposer plusieurs
conditions simultanément sur la même chaîne.
// Exemple de lecture de la Regex :
// ^ = début de chaîne
// (?=.*[a-z]) = quelque part dans la chaîne, il y a une minuscule
// (?=.*[A-Z]) = quelque part dans la chaîne, il y a une majuscule
// (?=.*\d) = quelque part dans la chaîne, il y a un chiffre
// (?=.*[@#$%^&+=!]) = quelque part, il y a un caractère spécial
// .{8,} = la chaîne fait au moins 8 caractères
// $ = fin de chaîne
5. Implémentation Étape par Étape
Étape 1 : Récupérer le mot de passe
Dans la méthode doPost(), on récupère le mot de passe envoyé par le formulaire HTML :
String motDePasse = [Link]("password");
// Vérification anti-null indispensable
if (motDePasse == null || [Link]()) {
[Link]("erreur", "Le mot de passe est obligatoire.");
[Link]("[Link]").forward(request, response);
return;
}
Étape 2 : Définir la Regex
String regex =
"^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d)(?=.*[@#$%^&+=!]).{8,}$";
Étape 3 : Tester le mot de passe
if ([Link](regex)) {
[Link]().println("Mot de passe valide");
} else {
[Link]().println("Mot de passe invalide");
}
6. Exemple Complet — Servlet Basique
Voici une Servlet complète qui valide le mot de passe et répond directement dans la réponse HTTP :
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
@WebServlet("/inscription")
public class InscriptionServlet extends HttpServlet {
@Override
protected void doPost(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException {
[Link]("text/html;charset=UTF-8");
String password = [Link]("password");
// Regex de validation
String regex =
"^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d)(?=.*[@#$%^&+=!]).{8,}$";
if (password != null && [Link](regex)) {
// Mot de passe valide : continuer l'inscription
[Link]().println("Inscription réussie !");
} else {
[Link]().println(
"Le mot de passe doit contenir : " +
"8 caractères minimum, une majuscule, " +
"une minuscule, un chiffre et " +
"un caractère spécial (@#$%^&+=!).");
}
}
}
7. Version Professionnelle avec Redirection JSP
Dans une architecture MVC professionnelle, on n'écrit jamais directement dans la réponse HTTP. On
passe plutôt par une page JSP (Vue) pour afficher les messages à l'utilisateur.
7.1 La Servlet (Contrôleur)
@WebServlet("/inscription")
public class InscriptionServlet extends HttpServlet {
private static final String REGEX_PASSWORD =
"^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d)(?=.*[@#$%^&+=!]).{8,}$";
@Override
protected void doPost(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException {
String nom = [Link]("nom");
String email = [Link]("email");
String password = [Link]("password");
// Validation du mot de passe
if (password == null || ) {
[Link]("erreur",
"Le mot de passe doit contenir au moins 8 caractères, " +
"une majuscule, une minuscule, un chiffre " +
"et un caractère spécial.");
[Link]("[Link]")
.forward(request, response);
return;
}
// Si valide : enregistrer en base de données, rediriger...
// [Link](nom, email, password);
[Link]("[Link]");
}
}
7.2 La page JSP (Vue)
Le fichier JSP affiche le formulaire et l'éventuel message d'erreur :
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<!DOCTYPE html>
<html lang="fr">
<head>
<meta charset="UTF-8">
<title>Inscription</title>
</head>
<body>
<h2>Créer un compte</h2>
<!-- Affichage de l'erreur si elle existe -->
<c:if test="${not empty erreur}">
<p style="color: red; font-weight: bold;">
${erreur}
</p>
</c:if>
<form method="post" action="inscription">
<label>Nom :</label>
<input type="text" name="nom" required /><br/>
<label>Email :</label>
<input type="email" name="email" required /><br/>
<label>Mot de passe :</label>
<input type="password" name="password" required />
<small>Min. 8 car., majuscule, minuscule, chiffre, spécial</small><br/>
<button type="submit">S'inscrire</button>
</form>
</body>
</html>
💡 Note : ${erreur} est une expression EL (Expression Language) de JSP. Elle affiche automatiquement
l'attribut 'erreur' positionné par [Link]() dans la Servlet. Si l'attribut est absent, rien n'est
affiché.
8. Alternative Sans Regex — Vérification Caractère par
Caractère
Pour les débutants ou pour une logique plus lisible, on peut remplacer la Regex par des conditions
et une boucle :
public static boolean validerMotDePasse(String password) {
if (password == null || [Link]() < 8) {
return false;
}
boolean aMinuscule = false;
boolean aMajuscule = false;
boolean aChiffre = false;
boolean aSpecial = false;
String specialChars = "@#$%^&+=!";
for (char c : [Link]()) {
if ([Link](c)) aMinuscule = true;
else if ([Link](c)) aMajuscule = true;
else if ([Link](c)) aChiffre = true;
else if ([Link](c) >= 0) aSpecial = true;
}
return aMinuscule && aMajuscule && aChiffre && aSpecial;
}
Cette méthode peut être appelée dans la Servlet :
if (validerMotDePasse(password)) {
// Inscription autorisée
} else {
[Link]("erreur", "Mot de passe invalide.");
[Link]("[Link]").forward(request, response);
}
9. Comparaison des Deux Approches
Critère Regex Conditions (if/for)
Lisibilité Concis (1 ligne) Verbeux mais explicite
Facilité d'apprentissage Courbe d'apprentissage Accessible aux débutants
Performance Très rapide Rapide (acceptable)
Réutilisabilité Facile (une constante) Nécessite une méthode
Flexibilité Difficile à modifier Facile à adapter
Utilisation en Java EE Standard recommandé Cas simples uniquement
Débogage Complexe Plus simple
✅ Recommandation : Utilisez la Regex pour la production (Java EE, Spring Boot). Réservez les conditions
if/for aux cas d'apprentissage ou de logique très spécifique.
10. Bonnes Pratiques
10.1 Ne jamais stocker le mot de passe en clair
Après validation, le mot de passe doit être haché (hashé) avant d'être enregistré en base de
données. On utilise BCrypt, Argon2 ou PBKDF2 :
// Avec la librairie BCrypt ([Link]:jbcrypt)
import [Link];
String passwordHache = [Link](password, [Link](12));
// Stocker passwordHache en base de données, jamais password brut
10.2 Centraliser la validation
Créez une classe utilitaire dédiée à la validation :
public class PasswordValidator {
private static final String REGEX =
"^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d)(?=.*[@#$%^&+=!]).{8,}$";
public static boolean isValid(String password) {
return password != null && [Link](REGEX);
}
public static String getRegles() {
return "Minimum 8 caractères, 1 majuscule, 1 minuscule, " +
"1 chiffre, 1 caractère spécial (@#$%^&+=!).";
}
}
10.3 Double validation client + serveur
La validation côté serveur (Servlet) est obligatoire. La validation côté client (HTML5 / JavaScript)
est un bonus pour l'expérience utilisateur :
<!-- Validation HTML5 basique -->
<input type="password" name="password"
pattern="^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@#$%^&+=!]).{8,}$"
title="8 car. min, majuscule, minuscule, chiffre, spécial"
required />
10.4 Messages d'erreur précis
Informez l'utilisateur de la règle qui n'est pas respectée, sans révéler les détails de sécurité :
// Mauvais : message générique
"Mot de passe invalide"
// Bon : message précis mais sans révéler la structure exacte
"Le mot de passe doit contenir au moins 8 caractères, "
+ "dont une majuscule, une minuscule, un chiffre "
+ "et un caractère spécial."
11. Résumé
Ce cours a couvert les points essentiels de la validation d'un mot de passe dans une Servlet Java :
Récupération du paramètre avec [Link]("password")
Validation via la Regex : ^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@#$%^&+=!]).{8,}$
Redirection vers le JSP en cas d'erreur avec [Link]() et
getRequestDispatcher().forward()
Alternative par conditions : boucle sur les caractères avec [Link]() etc.
Bonnes pratiques : hachage, centralisation, double validation, messages précis
📌 Mémo rapide — La Regex en une ligne :
^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@#$%^&+=!]).{8,}$
Cours Java EE — Validation de Mot de Passe | 2026