Cours JEE
Présentation
Architecture JEE :
Pour déployer un projet jee il faut qu’il respecte une certaine architecture
META INF : dossier qui contient les fichiers de configuration
Bien sûr, voici une explication détaillée de JEE (Java Enterprise Edition) avec des exemples :
Introduction à JEE :
Java Enterprise Edition (JEE) est une plateforme de développement d'applications
d'entreprise basée sur la plateforme Java Standard Edition (JSE). Elle fournit des API pour
développer des applications web, des applications client-serveur et des applications
distribuées à grande échelle. La plateforme JEE est basée sur une architecture multi-niveaux,
dans laquelle les différents composants sont déployés sur différents serveurs.
Les composants de JEE :
Les composants de JEE sont des éléments clés pour le développement d'applications web et
d'applications d'entreprise. Voici une liste des principaux composants de JEE :
Servlets : Les servlets sont des classes Java qui permettent de gérer les requêtes HTTP
d'une application web. Les servlets sont déployées sur un serveur d'applications qui
prend en charge les appels aux servlets et la gestion des sessions.
@WebServlet("/hello")
public class HelloServlet extends HttpServlet {
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.getWriter().println("Hello, World!");
}
}
JSP (JavaServer Pages) : JSP est une technologie de présentation qui permet de
générer des pages web dynamiques. Les JSP sont des fichiers HTML qui contiennent
des éléments de code Java et des balises JSP.
<html>
<head><title>My JSP Page</title></head>
<body>
<% String name = request.getParameter("name"); %>
<h1>Hello <%= name %>!</h1>
</body>
</html>
EJB (Enterprise JavaBeans) : Les EJB sont des composants d'entreprise qui
permettent de déployer des applications distribuées à grande échelle. Ils fournissent
des services de transactions, de sécurité et de gestion de la persistance.
@Stateless
public class BookService {
@PersistenceContext(unitName="BookPU")
private EntityManager entityManager;
public void createBook(Book book) {
entityManager.persist(book);
}
// other methods
}
JPA (Java Persistence API) : JPA est une API de persistance des données qui permet de
gérer les données d'une application en utilisant des objets Java plutôt que des
requêtes SQL.
@Entity
@Table(name="books")
public class Book implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy=GenerationType.IDENTITY)
private Long id;
private String title;
private String author;
// getters and setters
}
public class BookController {
@PersistenceContext(unitName="BookPU")
private EntityManager entityManager;
public List<Book> getBooks() {
return entityManager.createQuery("select b from Book b").getResultList();
}
// other methods
}
JSF (JavaServer Faces) : JSF est une technologie de présentation pour les applications
web Java. Elle permet de créer des interfaces utilisateur en utilisant des composants
réutilisables.
<h:form>
<h:inputText value="#{bookController.newBook.title}" required="true" />
<h:inputText value="#{bookController.newBook.author}" required="true" />
<h:commandButton value="Add Book" action="#{bookController.createBook}" />
</h:form>
Exemple d'application :
Pour illustrer l'utilisation des composants de JEE, voici un exemple d'application simple de
gestion de livres :
La page d'accueil affiche une liste de livres, ainsi qu'un formulaire pour ajouter un nouveau
livre.
Lorsque l'utilisateur ajoute un nouveau livre, les données sont envoyées au serveur via une
servlet, qui utilise l'API de persistance JPA pour enregistrer les données dans la base de
données.
La page de détails d'un livre utilise les JSP pour afficher les informations détaillées d'un livre,
ainsi qu'un formulaire pour modifier les informations.
Lorsque l'utilisateur modifie les informations d'un livre, les données sont envoyées au
serveur via une servlet, qui utilise l'API de persistance JPA pour mettre à jour les données
dans la base de données.
Voici un exemple de code pour la servlet de gestion des livres :
@WebServlet("/books")
public class BookServlet extends HttpServlet {
@PersistenceContext(unitName="BookPU")
private EntityManager entityManager;
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
List<Book> books = entityManager.createQuery("select b from Book b").getResultList();
request.setAttribute("books", books);
request.getRequestDispatcher("/books.jsp").forward(request, response);
}
protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
String title = request.getParameter("title");
String author = request.getParameter("author");
Book book = new Book();
book.setTitle(title);
book.setAuthor(author);
entityManager.persist(book);
response.sendRedirect(request.getContextPath() + "/books");
}
}
Et voici un exemple de code pour la JSP d'affichage des livres :
<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<title>Book List</title>
</head>
<body>
<h1>Book List</h1>
<table>
<thead>
<tr>
<th>Title</th>
<th>Author</th>
</tr>
</thead>
<tbody>
<c:forEach items="${books}" var="book">
<tr>
<td>${book.title}</td>
<td>${book.author}</td>
</tr>
</c:forEach>
</tbody>
</table>
<form method="post" action="${pageContext.request.contextPath}/books">
<label for="title">Title:</label>
<input type="text" id="title" name="title" required>
<label for="author">Author:</label>
<input type="text" id="author" name="author" required>
<button type="submit">Add Book</button>
</form>
</body>
</html>
En utilisant les différents composants de JEE, il est possible de développer des applications
d'entreprise robustes et évolutives.
JSP :
Page html qui contient le code java : Il y a 3 types de balises qu’on peut mettre
<%! %> : on met la des variables et des méthodes
<%= %> : on affiche
<% %> :on fait des traitements
