java EE
Support de révision Java EE
Table des matières
Introduction à Java EE
Architecture MVC
Servlets
JSP (Java Server Pages)
Gestion des sessions
Communication entre composants
Persistance des données
Design Patterns
Déploiement d'applications
Introduction à Java EE
Définition et évolution
Java EE (Enterprise Edition), renommé Jakarta EE depuis 2019, est une plateforme de
développement pour applications d'entreprise.
Évolution historique:
J2EE (1999-2003): Servlet, JSP, EJB 1-2, JMS
Java EE 5 (2006): EJB 3, JPA, JSF, JAX-WS
Java EE 6 (2009): JAX-RS, Bean Validation, Web Profile
Java EE 7 (2013): JBatch, WebSocket, JSON-P, Concurrency
Java EE 8 (2017): Java SE 8, JSON-B, Security
Jakarta EE (2019+): Transfert à la Fondation Eclipse
Structure d'un projet Java EE
/src : Code source Java
/WebContent ou /webapp : Ressources web (HTML, JSP, CSS, JS)
/WEB-INF : Configuration et classes compilées (invisible au client)
web.xml : Descripteur de déploiement
/classes : Classes Java compilées
/lib : Bibliothèques JAR
Architecture MVC
Principes du MVC
Modèle (Model): Données et logique métier
Vue (View): Interface utilisateur
Contrôleur (Controller): Coordination et traitement des requêtes
Implémentation en Java EE
Modèle: Classes POJO Java
Vue: Pages JSP
Contrôleur: Servlets
Architecture en couches (n-tiers)
1. Couche présentation: Interface utilisateur (JSP, HTML)
2. Couche contrôleur: Gestion des requêtes (Servlets)
3. Couche métier: Logique business (Services)
4. Couche d'accès aux données: Persistance (DAO, Repository)
5. Couche base de données: Stockage (SGBD)
Servlets
Bases des Servlets
Composants Java qui traitent les requêtes HTTP
Héritent de HttpServlet
Configurés dans web.xml ou avec annotations ( @WebServlet )
Cycle de vie
public void init() throws ServletException { /* Initialisation */ }
public void service(HttpServletRequest req, HttpServletResponse resp) { /*
Traitement */ }
public void destroy() { /* Nettoyage */ }
Méthodes HTTP principales
protected void doGet(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
// Traitement des requêtes GET
}
protected void doPost(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
// Traitement des requêtes POST
}
Exemple complet de Servlet
@WebServlet("/login")
public class LoginServlet extends HttpServlet {
@Override
protected void doPost(HttpServletRequest request, HttpServletResponse
response)
throws ServletException, IOException {
String username = request.getParameter("username");
String password = request.getParameter("password");
UserService userService = new UserService();
User user = userService.authenticate(username, password);
if (user != null) {
HttpSession session = request.getSession();
session.setAttribute("user", user);
response.sendRedirect("dashboard.jsp");
} else {
request.setAttribute("errorMessage", "Identifiants invalides");
RequestDispatcher dispatcher =
request.getRequestDispatcher("login.jsp");
dispatcher.forward(request, response);
}
}
}
Manipulation des requêtes
// Récupération des paramètres
String param = request.getParameter("name");
String[] values = request.getParameterValues("options");
// Entêtes HTTP
String userAgent = request.getHeader("User-Agent");
Enumeration<String> headerNames = request.getHeaderNames();
// Attributs de requête
request.setAttribute("message", "Bonjour");
String message = (String) request.getAttribute("message");
Manipulation des réponses
// Type de contenu
response.setContentType("text/html;charset=UTF-8");
// Redirection
response.sendRedirect("autre-page.jsp");
// Envoi de données
PrintWriter out = response.getWriter();
out.println("<html><body>Bonjour</body></html>");
JSP (Java Server Pages)
Structure d'une JSP
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8" %>
<%@ page import="java.util.Date, com.example.model.User" %>
<!DOCTYPE html>
<html>
<head>
<title>Ma page JSP</title>
</head>
<body>
<h1>Bienvenue sur ma page</h1>
<p>Date actuelle: <%= new Date() %></p>
</body>
</html>
Types de tags JSP
1. Directives: <%@ ... %>
<%@ page import="java.util.List" %>
<%@ include file="header.jsp" %>
2. Scriptlets: <% ... %>
<%
for (int i = 0; i < 5; i++) {
out.println("<p>Ligne " + i + "</p>");
}
%>
3. Expressions: <%= ... %>
<p>Bonjour, <%= user.getName() %></p>
4. Déclarations: <%! ... %>
<%!
private int compteur = 0;
public String formatName(String name) {
return name.toUpperCase();
}
%>
5. Commentaires: <%-- ... --%>
<%-- Ce commentaire n'apparaîtra pas dans le HTML --%>
Objets implicites en JSP
request : L'objet HttpServletRequest
response : L'objet HttpServletResponse
session : L'objet HttpSession
application : L'objet ServletContext
out : L'objet JspWriter (pour écrire dans la réponse)
pageContext : L'objet PageContext (pour accéder à d'autres objets)
config : L'objet ServletConfig
page : Référence à l'instance de servlet (équivalent à this )
exception : L'objet Exception (disponible dans les pages d'erreur)
Affichage des données dans JSP
<%-- Récupération des données depuis la requête --%>
<%
User user = (User) request.getAttribute("user");
List<Product> products = (List<Product>) request.getAttribute("products");
%>
<%-- Affichage des données --%>
<h2>Informations utilisateur</h2>
<p>Nom: <%= user.getName() %></p>
<p>Email: <%= user.getEmail() %></p>
<h2>Liste des produits</h2>
<ul>
<% for (Product product : products) { %>
<li><%= product.getName() %> - <%= product.getPrice() %> €</li>
<% } %>
</ul>
Gestion des sessions
Création et récupération
// Création d'une session ou récupération si elle existe
HttpSession session = request.getSession();
// Récupération uniquement si elle existe (sinon null)
HttpSession session = request.getSession(false);
Manipulation des attributs
// Ajout d'attributs
session.setAttribute("user", user);
session.setAttribute("lastAccess", new Date());
// Récupération d'attributs
User user = (User) session.getAttribute("user");
Date lastAccess = (Date) session.getAttribute("lastAccess");
// Suppression d'attributs
session.removeAttribute("temporaryData");
Gestion du cycle de vie
// Informations sur la session
String sessionId = session.getId();
long creationTime = session.getCreationTime();
long lastAccessTime = session.getLastAccessedTime();
// Configuration du timeout (en secondes)
session.setMaxInactiveInterval(1800); // 30 minutes
// Destruction de la session
session.invalidate();
Utilisation dans JSP
<%-- Vérifie si l'utilisateur est connecté --%>
<% User sessionUser = (User) session.getAttribute("user"); %>
<% if (sessionUser != null) { %>
<p>Bienvenue, <%= sessionUser.getName() %></p>
<a href="logout">Se déconnecter</a>
<% } else { %>
<p>Vous n'êtes pas connecté</p>
<a href="login.jsp">Se connecter</a>
<% } %>
Communication entre composants
Forward vs Redirect
Forward (transfert interne au serveur)
RequestDispatcher dispatcher = request.getRequestDispatcher("/page.jsp");
dispatcher.forward(request, response);
Redirect (nouvelle requête du navigateur)
response.sendRedirect("page.jsp");
Différences principales
Forward Redirect
Même requête Nouvelle requête
URL ne change pas URL change
Les attributs de requête sont conservés Les attributs de requête sont perdus
Plus rapide (une seule requête) Moins rapide (deux requêtes)
request.getRequestDispatcher().forward() response.sendRedirect()
Portée des attributs
1. Request (requête)
Durée de vie: durée de la requête (conservés lors d'un forward, perdus lors d'un
redirect)
request.setAttribute("message", "Bonjour");
2. Session (session utilisateur)
Durée de vie: session utilisateur (plusieurs requêtes)
session.setAttribute("user", user);
3. Application (contexte de servlet)
Durée de vie: cycle de vie de l'application
getServletContext().setAttribute("config", appConfig);
Persistance des données
JDBC (Java Database Connectivity)
// Connexion à la base de données
Connection connection = null;
try {
connection = DriverManager.getConnection(
"jdbc:mysql://localhost:3306/mydb", "username", "password");
// Création d'une requête préparée
PreparedStatement stmt = connection.prepareStatement(
"SELECT * FROM users WHERE username = ? AND active = ?");
stmt.setString(1, "john");
stmt.setBoolean(2, true);
// Exécution et traitement des résultats
ResultSet rs = stmt.executeQuery();
while (rs.next()) {
int id = rs.getInt("id");
String name = rs.getString("name");
Date birthDate = rs.getDate("birth_date");
// Traitement des données...
}
// Insertion de données
PreparedStatement insertStmt = connection.prepareStatement(
"INSERT INTO users (username, email, password) VALUES (?, ?, ?)");
insertStmt.setString(1, "alice");
insertStmt.setString(2, "alice@example.com");
insertStmt.setString(3, hashedPassword);
int rowsAffected = insertStmt.executeUpdate();
} catch (SQLException e) {
e.printStackTrace();
} finally {
// Fermeture des ressources
if (connection != null) {
try { connection.close(); } catch (SQLException e) {
e.printStackTrace(); }
}
}
Opérations CRUD
Create (Création)
String sql = "INSERT INTO products (name, price, category) VALUES (?, ?, ?)";
PreparedStatement stmt = connection.prepareStatement(sql);
stmt.setString(1, product.getName());
stmt.setDouble(2, product.getPrice());
stmt.setString(3, product.getCategory());
int rowsInserted = stmt.executeUpdate();
Read (Lecture)
String sql = "SELECT * FROM products WHERE id = ?";
PreparedStatement stmt = connection.prepareStatement(sql);
stmt.setInt(1, productId);
ResultSet rs = stmt.executeQuery();
if (rs.next()) {
// Lire les données du ResultSet
}
Update (Mise à jour)
String sql = "UPDATE products SET name = ?, price = ? WHERE id = ?";
PreparedStatement stmt = connection.prepareStatement(sql);
stmt.setString(1, product.getName());
stmt.setDouble(2, product.getPrice());
stmt.setInt(3, product.getId());
int rowsUpdated = stmt.executeUpdate();
Delete (Suppression)
String sql = "DELETE FROM products WHERE id = ?";
PreparedStatement stmt = connection.prepareStatement(sql);
stmt.setInt(1, productId);
int rowsDeleted = stmt.executeUpdate();
Design Patterns
Singleton
Garantit qu'une classe n'a qu'une seule instance et fournit un point d'accès global.
public class DatabaseConnection {
private static DatabaseConnection instance;
private Connection connection;
private DatabaseConnection() throws SQLException {
// Initialisation de la connexion
connection =
DriverManager.getConnection("jdbc:mysql://localhost:3306/mydb", "user",
"pass");
}
public static synchronized DatabaseConnection getInstance() throws
SQLException {
if (instance == null || instance.getConnection().isClosed()) {
instance = new DatabaseConnection();
}
return instance;
}
public Connection getConnection() {
return connection;
}
}
// Utilisation
Connection conn = DatabaseConnection.getInstance().getConnection();
DAO (Data Access Object)
Isole la logique d'accès aux données de la logique métier.
// Interface DAO
public interface UserDAO {
User findById(int id);
List<User> findAll();
boolean insert(User user);
boolean update(User user);
boolean delete(int id);
}
// Implémentation
public class UserDAOImpl implements UserDAO {
@Override
public User findById(int id) {
User user = null;
try (Connection conn =
DatabaseConnection.getInstance().getConnection();
PreparedStatement stmt = conn.prepareStatement("SELECT * FROM
users WHERE id = ?")) {
stmt.setInt(1, id);
try (ResultSet rs = stmt.executeQuery()) {
if (rs.next()) {
user = new User();
user.setId(rs.getInt("id"));
user.setUsername(rs.getString("username"));
user.setEmail(rs.getString("email"));
}
}
} catch (SQLException e) {
e.printStackTrace();
}
return user;
}
@Override
public List<User> findAll() {
List<User> users = new ArrayList<>();
try (Connection conn =
DatabaseConnection.getInstance().getConnection();
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery("SELECT * FROM users")) {
while (rs.next()) {
User user = new User();
user.setId(rs.getInt("id"));
user.setUsername(rs.getString("username"));
user.setEmail(rs.getString("email"));
users.add(user);
}
} catch (SQLException e) {
e.printStackTrace();
}
return users;
}
@Override
public boolean insert(User user) {
try (Connection conn =
DatabaseConnection.getInstance().getConnection();
PreparedStatement stmt = conn.prepareStatement(
"INSERT INTO users (username, email, password) VALUES (?, ?,
?)")) {
stmt.setString(1, user.getUsername());
stmt.setString(2, user.getEmail());
stmt.setString(3, user.getPassword());
return stmt.executeUpdate() > 0;
} catch (SQLException e) {
e.printStackTrace();
return false;
}
}
// Autres méthodes...
}
MVC (Model-View-Controller)
Structure une application en trois composants distincts.
// Modèle (Model)
public class User {
private int id;
private String username;
private String email;
private String password;
// Getters et Setters
}
// Contrôleur (Controller)
@WebServlet("/users")
public class UserController extends HttpServlet {
private UserService userService = new UserService();
@Override
protected void doGet(HttpServletRequest request, HttpServletResponse
response)
throws ServletException, IOException {
List<User> users = userService.getAllUsers();
request.setAttribute("users", users);
RequestDispatcher dispatcher = request.getRequestDispatcher("/WEB-
INF/views/userList.jsp");
dispatcher.forward(request, response);
}
}
// Vue (View) - userList.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<!DOCTYPE html>
<html>
<head>
<title>Liste des utilisateurs</title>
</head>
<body>
<h1>Liste des utilisateurs</h1>
<table>
<tr>
<th>ID</th>
<th>Nom d'utilisateur</th>
<th>Email</th>
</tr>
<c:forEach items="${users}" var="user">
<tr>
<td>${user.id}</td>
<td>${user.username}</td>
<td>${user.email}</td>
</tr>
</c:forEach>
</table>
</body>
</html>
Déploiement d'applications
Structure d'un fichier WAR
META-INF/ : Métadonnées
MANIFEST.MF : Informations sur l'application
WEB-INF/ : Configuration et classes
web.xml : Descripteur de déploiement
classes/ : Classes Java compilées
lib/ : Bibliothèques JAR
Ressources web: HTML, JSP, CSS, JavaScript, images
Configuration avec web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
version="4.0">
<display-name>Mon Application</display-name>
<!-- Configuration des servlets -->
<servlet>
<servlet-name>UserServlet</servlet-name>
<servlet-class>com.example.controller.UserServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>UserServlet</servlet-name>
<url-pattern>/users</url-pattern>
</servlet-mapping>
<!-- Configuration des filtres -->
<filter>
<filter-name>AuthFilter</filter-name>
<filter-class>com.example.filter.AuthenticationFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>AuthFilter</filter-name>
<url-pattern>/secure/*</url-pattern>
</filter-mapping>
<!-- Configuration des sessions -->
<session-config>
<session-timeout>30</session-timeout>
</session-config>
<!-- Page d'accueil -->
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
<!-- Pages d'erreur -->
<error-page>
<error-code>404</error-code>
<location>/error/404.jsp</location>
</error-page>
<error-page>
<exception-type>java.lang.Exception</exception-type>
<location>/error/error.jsp</location>
</error-page>
</web-app>
Configuration avec annotations
@WebServlet("/users")
public class UserServlet extends HttpServlet {
// ...
}
@WebFilter("/secure/*")
public class AuthenticationFilter implements Filter {
// ...
}
@WebListener
public class AppContextListener implements ServletContextListener {
// ...
}
Déploiement sur Tomcat
1. Générer le fichier WAR
Via IDE (Eclipse, IntelliJ)
Via Maven: mvn package
2. Méthodes de déploiement
Copier le WAR dans le dossier webapps de Tomcat
Utiliser l'interface d'administration Tomcat Manager
Déployer via IDE (Eclipse, IntelliJ)
Configuration de connexion à la base de données
// Fichier properties
jdbc.url=jdbc:mysql://localhost:3306/mydb
jdbc.username=user
jdbc.password=pass
jdbc.driver=com.mysql.cj.jdbc.Driver
// Chargement des propriétés
Properties props = new Properties();
try (InputStream input =
getClass().getClassLoader().getResourceAsStream("db.properties")) {
props.load(input);
String url = props.getProperty("jdbc.url");
String user = props.getProperty("jdbc.username");
String password = props.getProperty("jdbc.password");
String driver = props.getProperty("jdbc.driver");
Class.forName(driver);
connection = DriverManager.getConnection(url, user, password);
} catch (IOException | ClassNotFoundException | SQLException e) {
e.printStackTrace();
}
Ce support de révision couvre les concepts essentiels de Java EE nécessaires pour
comprendre l'architecture des applications web et mettre en œuvre les opérations CRUD.
Bonne révision !
