Jakarta EE

Java|Jakarta Entreprise Edition
Servlet, JSP,TagLib,JSF,Ejb et JPA

Micropofile
© M. Lahmer, v.2023
Java Entreprise Edition
•JDK 1.0
•JDK 1.1
•Décembre 98 : Java 2
Spécification
J2ME J2SE JEE
(Java 2 Micro Edition) (Java 2 Standard Editon) (Java 2 Enterprise Edition)
Implémentation SUN
J2SDK JEE SDK
(Java 2 SDK Standard Edition) (Java 2 SDK Enterprise Edition)
JEE Evolution
J2EE devient JEE
JEE devient Jakarta EE
Oracle decided to give away the rights for Java EE to the Eclipse Foundation
Objectifs de JEE
=>
Permettre aux développeurs de se
concentrer sur le développement métier en
les dégageant des services bas niveaux
(Transactions, Intégration, Équilibrage de
charge, Nommage, Persistance, Sécurité,
Clustering…)
Vue Globale depuis JEE6

Java Entreprise Edition Les APIS
les composants : Servlet, JSP, EJB

les services : JDBC, JTA/JTS, JNDI, JCA, JAAS
la communication : RMI-IIOP, JMS, Java Mail
JDBC (Java DataBase Connectivity)
Application
Interface Java pour un
accès standard à des
bases de données JDBC API
hétérogènes.
JDBC Driver
DB API
DB
JNDI (Java Naming & Directory Interface)
Java Application
API per mettant aux

applications d'accéder
aux services de naming JNDI API
d’une façon transparente
Naming Manager
JNDI Server Provider

LDAP FileSys DNS …
Driver Driver Driver
Java IDL (Java Interface Definition Language)
Utilisée pour intégrer Java et CORBA.

permet de développer des objets Java déployables
en tant que ORBs.


Java Servlets
Classe Java qui fournit un service

conversationnel (Request/
Response).
Le type de servlets le plus connu
est HTTPServlets
Web Client
Servlets
Web
Server
Bea
ns DB
JSP (Java Server Pages)
Convertis en Servlets.
Utilise la notion des tags pour inclure du code Java
dans le HTML.

JTS (Java Transaction Service)
Spécification d'implémentation d'une couche d'adaptation

vers le service de transaction objet de CORBA (OTS).
Propage les transactions en utilisant IIOP (Internet Inter-
ORB Protocol).
JTA (Java Transaction Architecture)
API Java standard pour l'accès au moniteur

transactionnel.
JDBC JMS EJB Other

s
Java Transaction API
Transaction Monitor Implementation

JavaMail
API Java pour l'accès aux serveurs de

messagerie.
Disponible pour SMTP, IMAP et POP3.
JEE
JAF (JavaBeans Activation FrameWork)
Intègre un support pour les MIME Types

pour la plate forme Java.
Utilisé par JavaMail.

JMS (Java Message Service)
API pour accès aux messages orientés

middleware.
XML (eXtensible Markup Language)
Langage pour la définition d'autres «Markup

Language».
Permet de représenter les données d'une façon unifier
pour différents métiers.
JCA (JEE Connector Architecture)
Spécification pour la communication avec les

systèmes existants tels que SAP, CICS/
COBOL, Siebel,…
EJB (Entreprise Java Bean)
Composants qui fournissent un service métier pour

des applications clientes.
Ils sont réutilisables, distribuables et que plusieurs
applications peuvent partager.

Home
Bean
Remote
EJB Container
Trois approches :
• Approche fonctionnelle.
• Approche conversationnelle.
• Approche de persistance.
Équivalent à :
• Stateless session bean
• Stateful session bean
• Entity bean
EJB (Entreprise Java Bean) : Stateless Session Bean
Fournit un « single_use service ».

Ne maintien pas un état relatif au client.
Ne survie pas aux crashes du serveur.
A une très courte durée de vie (relative à la durée de
l‘exécution d'une méthode).
Deux instances du même stateless EJB sont
identiques.

EJB (Entreprise Java Bean) : Stateful Session Bean
Fournit un mode conversationnel avec l'application

cliente.
Maintien l‘état de l'EJB par rapport au client.
Ne survie pas aux crashes du serveur.
A une durée relativement courte (la durée d'une
session utilisateur).
Chaque instance du même EJB est différente des
autres.
EJB (Entreprise Java Bean) : Entity Bean
Représente la persistance des données.

Survie aux crashes du serveur.
Une instance de l'EJB représente une copie des
données de la base de données.

Jakarta Entreprise Edition

Micro Profile
Jakarta Servlet et Jsp
Structure d’une application Web maven
en JEE
src/main/java : codes source java sous

forme de packages
target : codes compiles .class, .jar, .war
resources :
-css
-js
webapp :
-WEB-INF : web.xml
- front-end : les pages html, xhtml,jsp, …
#pom.xml Sep 13, 2022 : 10.0.0
<dependency>
<groupId>jakarta.platform</groupId>
<artifactId>jakarta.jakartaee-web-api</artifactId>
<version>9.0.0</version>
<scope>provided</scope>
</dependency>
 

Cycle de vie d’une servlet
Une servlet est une classe Java qui implémente les primitives du
protocole HTTP
init
service(
destroy(
Servlet
Une servlet simple
package estm.dsic;
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
@WebServlet(name = "UserServlet", urlPatterns = "/userServlet",
initParams={
@WebInitParam(name="name", value="Not provided"),
@WebInitParam(name="email", value="Not provided")}))
public class UserServlet extends HttpServlet {
public void doGet(HttpServletRequest request,
HttpServletResponse response)
throws IOException, ServletException{
response.setContentType("text/html");
PrintWriter out = response.getWriter();
out.println("<html>");
out.println("<head>");
out.println("<title>première servlet</title>");
out.println("</head>");
out.println("<body>");
out.println("<h1>Salam a tous in jakarta ee </h1>");
out.println("</body>");
out.println("</html>"); }}

Déploiement d’une servlet

Il est possible de paramétrer la servlet dans web.xml:
<web-app version="5.0"
xmlns=« https://jakarta.ee/xml/ns/jakartaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="https://jakarta.ee/xml/ns/jakartaee https://jakarta.ee/xml/ns/jakartaee/web-app_5_0.xsd"
>
<servlet>
<servlet-name>
userServlet
</servlet-name>
<servlet-class>
estm.dsic.UserServlet
</servlet-class>
<init-param>
<param-name>name</param-name>
<param-value>NotProvided</param-value>
</init-param>
</servlet>
<servlet-mapping>
<servlet-name>userServlet</servlet-name>
<url-pattern>/userServlet</url-pattern>
</servlet-mapping>
</web-app>

HttpServletRequest/HttpServletResponse
HttpSServletRequest
getParameter(paramName), getParameteres(),getRequestDispatcher()
getAttribute(attName), getAttributes(),setAttribute(name,value),
getServletContext(), getCookies(), getSession(), getContentLength,
getContentType
HttpServletResponse
addCookie(Cookie cookie), sendError(int sc),sendRedirect(String url)
sendError(int sc,String msg), getWriter(), setCharacterEncoding,
setContentLength, setContentType, setLocale

Modèle MVC
HTML/Servlet
Deux principaux tags peuvent être utilisés pour mettre en

œuvre un formulaire HTML Form et Input
Le tag <Form>…</Form> permet de délimiter l'espace d'un
formulaire
Deux paramètres sont importants pour la suite du cours
Action :indique quelle est la ressource chargée de traiter les
données
Method : indique la méthode de soumission des données du
formulaire au serveur
POST : les données sont stockées dans le corps de la requête
HTTP. C'est la méthode que nous préférerons utiliser
GET : les données sont concaténées à la suite de l'URL.
Cette dernière étant passée dans l'en-tête de la requête
HTTP

HTML/Servlet (2)
<INPUT> Permet d'introduire un champ de saisie (zone de

texte, zone de mot de passe, cases à cocher, …).
Pour connaître la nature du composant de saisie on
utilise les paramètres
■ Name permet de nommer le composant afin de retrouver la
donnée associée dans la requête HTTP.

■ Type : permet de définir la nature du composant de saisie.
Parmi les types les plus courants, on retrouve : text,

password, checkbox, radio, hidden, submit, button, reset et
file.
■ Value : permet de spécifier la valeur initiale pour ce
composant
HTML/Servlet (3)
<!DOCTYPE html>
<html>
<head>
<title>Context and Initialization Servlet Parameters</title>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
</head>
<body>
<h2>Please fill the form below:</h2>
<form action="${pageContext.request.contextPath}/userServlet" method="post">
<label for="name"><strong>Name:</strong></label>
<input type="text" name="name" id="name">
<label for="email"><strong>Email:</strong></label>
<input type="text" name="email" id="email">
<input type="submit" value="Send">
</form>
</body>
</html>
Vue MyServlet UserBean DataBase
Gestion des erreurs
Redéfinir une erreur HTTP

<error-page>
<error-code> 404 </error-code>
<Location> /ErrorHandler </location>
</error-page>
Redirection d’une erreur spécifique

<error-page>
<Exception-type>
javax.servlet.ServletException
</Exception-type>
<Location> /ErrorHandler </Location>
</error-page>
Un seul gestionnaire d’erreurs pour toutes les exceptions

<Error-page>
<Exception-type> java.lang.Throwable </Exception-type>
<Location> / ErrorHandler </ location>
</Error-page>

Cookies
Les cookies sont des objets stockés chez le client pour

maintenir sont état.
Il existe deux types de cookies :
persistantes (indépendantes de la session client)
non persistantes (dépendent de la session client)
Cookies
C’est la classe javax.servlet.http.Cookie deux constructeurs

sont disponibles :
Cookie(String name, String value)
Cookie()
Pour ajouter une cookie chez le client on utilise la méthode
addCookie(Cookie ck) de l’objet response
Pour récupérer les cookies de chez le client on utlise la
méthode public Cookie[] getCookies() de l’objet request
Cookie ck=new Cookie("user", "lahmer");
response.addCookie(ck);
Cookie ck[]=request.getCookies();
for(int i=0;i<ck.length;i++){
out.print("<br>"+ck[i].getName()+" "+ck[i].getValue());}

DataSource et JNDI
Fichier context.xml de Tomcat

<?xml version="1.0" encoding="UTF-8"?>
<Context> Fichier web.xml
<Resource <resource-ref>
name="jdbc/dbname" <res-ref-name>jdbc/dbname
</res-ref-name>
driverClassName="Driver"
<res-type>
url="jdbc:mysql:dbname" javax.sql.DataSource</res-type>
type="javax.sql.DataSource" <res-auth>Container</res-auth>
username="user" </resource-ref>
password="password" Context ctx = new InitialContext();
auth="Container"
DataSource ds = (DataSource)ctx.lookup(
maxActive="8" />
</Context> "java:comp/env/jdbc/dbname");
Connection conn = ds.getConnection();

JSP (Java Server Page)
Combinaison entre java et html pour la production de site web

dynamique
Est une solution sun pour concurrencer ASP et PHP
Le code JSP peut être intégrer dans du HTML, DHTML, XML et WML
Le code JSP est compilé en servlet puis exécuté par un moteur de
Servlet type Tomcat de jakarta
La compilation se fait lors du premier appel de la page JSP (plus de
temps pour l'affichage)

Scriptlet JSP
Directives de la forme<%@ ... %> elles sont placées au

début de la page : import et des propriétés supplémentaires
Scriptlets
■ Expressions de la forme <%= expr %> pour afficher chez le
client la valeur de expr

■ Scriptlets de la forme <% code %> pour la déclaration de
variables de fonctions (syntaxe java).

■ Déclarations de la forme <%! code %> code statique
■ Du commentaires <%-- ... --%>
Actions standards
■ Exemple: <jsp:useBean> ... </jsp:useBean>
Des variables comme request, response, out et d’autres

Directives
Elles ont la forme :
<%@ name attribute1="...", attribute2="..." ... %>
Spécifie les propriétés page

page
include Inclure un fichier
taglib
Spécifier un tag personnalisé

Directives: exemples
Importer des packages

■ <%@ page import="java.util.*,java.sql.*" %> Ou
■ <%@ page import="java.util.*" %>
<%@ page import="java.sql.*" %>
<%@ page contentType="text/plain" %> type (MIME) le

contenu de la page retournée.
<%@ page session="false" %> précise que la page ne

participe pas à une session. La variable session n'est plus
accessible. Le défaut est true ;
<%@ errorPage="Erreur.html"%> précise que la page à

retourner en cas d'exception est Erreur.html (URL relatif) ;
<%@ isErrorPage="true" %> précise que la page est une

page d'erreur associée une autre JSP.

Directives supplémentaires
<%@ extends="A" %> précise que la servlette générée doit

étendre la classe A plutôt que de celle définie par défaut dans le
moteur de JSP.
<%@ info="Information" %> définit le message retourné

par la méthode getServletInfo() ;
Inclure un fichier
■ <%@ include file="header.html" %>
■ On peut spécifier le chemin par rapport à la page jsp
Redirection
■ <jsp:forward page="page.jsp" /> redirige la requête vers
une autre ressource :
■ .jsp, servlet, …

Expressions de script
Pour les expression de la forme <%= expr %>, expr est évalué puis
affiché sous forme de chaîne de caractère dans la sortie standard out.
Dans une servlet il peut être équivalent à :
PrintWriter out = response.getWriter();
...
out.print(expr);
Exemples
<%= “Salut” %>

Le nom est <%= request.getParameter("name") %>
La date est <%= new java.util.Date() %>
 

 
 

Déclaration
Pour une déclaration <%! declarations %> . Les variables

déclarées sont placées à l'exterieure de la méthode _jspService().
Typiquement se sont des variables ou des méthodes d'instance.
Déclaration d'une variable
<%! private int count = 0; %>

...
The count is <%= count++ %>.
Déclaration d'une méthode
<%!
private int toInt(String s){
return Integer.parseInt(s);}
%>
 
 

 
 
 

Persistance des variables
<html>
<body><center>
<%!int compteur=0;%>
<%int t=0;%>
<h1>Variable persistante :<%=compteur++%> </h1>
<hr>
<h2>Variable non persistante :<%=t++%> </h2>
</center>
</body>
</html>
La valeur de la variable compteur s'incrémente à chaque appel de la

page, alors que le contenue de t reste invariant
Le contenue d'une variable persistante est réinitialisé une fois on
change le contenue de la page ou on redémarre Tomcat
Traitement des paramètres d'une page HTML
<html>
<head><title>Test Jsp</title></head>
<body>
<h1>JSP Processing form with GET</h1>
<form action="Form.jsp" method="GET">
Login: <input type="text" name="login"><br />
Password: <input type="text" name="passwd">
<p><input type="submit" name="button"
value="Valider"></p>
</form>
</body>
</html>
 
 
 
 
 
 
 
 
 
 
 
Les Objets implicites
request de type HttpServletRequest ;
response de type HttpServletResponse ;
out de type JspWriter, sous-type de PrintWriter ;
session de type HttpSession ;
application de type ServletContext ;
config de type ServletConfig ;
pageContext de type PageContext (permet de partager des données
entre pages) ;
page équivalent à this
exception définie dans une page jsp d'erreur pour le traitement des
erreurs
Par défaut la méthode service d'une page jsp est multithread. Donc il e
indispensable d'appliquer un mécanisme de synchronisation sur les obje
partagés
<% synchronized (application) {
SharedObject foo = (SharedObject)
application.getAttribute("sharedObject");
foo.update(someValue);
application.setAttribute("sharedObject",foo);}
%>

Gestion des erreurs
L'appel de la page d'erreur se fait dans une page qui peut

générer des erreurs
■ <%@ page errorPage="errorpage.jsp" %>

4 </h:panelGrid>
5 </h:form>
6
7 <h:form id="form_2">
8 <h:commandButton id="button">
9 <f:ajax render=":form1:panel_1 panel_2" />
10 </h:commandButton>
11 <h:panelGrid id="panel_2">
12 
13 </h:panelGrid>
14 </h:form>
JSF : AJAX : demo
<f:ajax execute="input-component-id" render="output-

component-id" />
<html xmlns="http://www.w3.org/1999/xhtml"
xmlns:h="http://java.sun.com/jsf/html"
xmlns:f="http://java.sun.com/jsf/core">
<h:form>
<h:inputText id="inputName" value="#{user.login}"></h:inputText>
<h:commandButton value="valider">
<f:ajax execute="inputName" render="outputMessage" />
</h:commandButton>
<h:outputText id="outputMessage"
value="#{user.login!=null ? user.welcomeMessage : ' '}" />
</h:form>
</html>

JSF : Gestion des messages
•Dans une application professionnelle, la gestion des messages

(warning, info, error) est un composant essentiel dans l’interaction
avec le client (Internationalisation).
•En JSF, les messages sont des ressources qu’ont peut gérer par le
ressource bundle.
•On met tous les messages qui peuvent être générés par l’application
dans un fichier messages.properties.
•Po u r l ’ i n t e r n a t i o n a l i s a t i o n , o n c r é e u n a u t r e f i c h i e r
messages.properties_en (contenant la traduction) relatif à la langue
utilisé
•Le format d’une ligne du fichier peut être comme suit :
E0001= "message erreur 1"
I0001 = "message information 1" - {0} et {1}

Demo messages
faces-config.xml
<application>
<resource-bundle>
<base-name>estm.dsic.business.messages</base-name>
<var>msg</var>
</resource-bundle>
</application>
*.xhtml
<f:loadBundle basename="estm.dsic.business.messages" var=« msg"/>
<h:outputText value=« #{msg[‘E0001']}/>
<h:outputText value=« #{msg.E0001}/>
<h:outputFormat value=« #{msg[‘I0001']}>
• <f:param value="param0" />
<f:param value="param1" />
</h:outputFormat>

Liberty [cdi-3.0, faces-3.0,JDBC-4.3]

pom.xml
Server.xml jakarta.jakartaee-web-api
<plugin>
<featureManager>
<groupId>io.openliberty.tools</groupId>
<feature>jdbc-4.3</feature>
</featureManager> <artifactId>liberty-maven-plugin</artifactId
<library id="jdbcLib"> <configuration>
<fileset dir="jdbc" <copyDependencies>
includes="*.jar"/> <dependencyGroup>
</library>
<dataSource jndiName="jdbc/myDB"> <location>jdbc</location>
<jdbcDriver libraryRef="jdbcLib"/> <dependency>
<properties serverName="localhost" <groupId>mysql</groupId>
portNumber="3306" <artifactId>mysql-connector-j
databaseName="myDb" </artifactId>
user="exampleUser"
password="examplePassword"/> </dependency>
</dataSource> </dependencyGroup>
</copyDependencies>
@Resource(lookup = "jdbc/myDB") </configuration>
DataSource myDB; </plugin>
@Resource
DataSource myDB;

Jakartaee-9.1/api
[
appAuthentication-2.0, appAuthorization-2.0, appClientSupport-2.0,
appSecurity-4.0, batch-2.0, beanValidation-3.0, cdi-3.0, concurrent-2.0,
connectors-2.0, connectorsInboundSecurity-2.0, distributedMap-1.0,
enterpriseBeans-4.0, enterpriseBeansHome-4.0, enterpriseBeansLite-4.0,
enterpriseBeansPersistentTimer-4.0, enterpriseBeansRemote-4.0,
expressionLanguage-4.0,
faces-3.0, jakartaee-9.1, jdbc-4.2, jndi-1.0, json-1.0, jsonb-2.0, jsonp-2.0,
mail-2.0, managedBeans-2.0,
mdb-4.0, messaging-3.0, messagingClient-3.0, messagingSecurity-3.0,
messagingServer-3.0,
pages-3.0, persistence-3.0, persistenceContainer-3.0, restConnector-2.0,
restfulWS-3.0, restfulWSClient-3.0, servlet-5.0, ssl-1.0, transportSecurity-1.0,
webProfile-9.1, websocket-2.0, xmlBinding-3.0, xmlWS-3.0
Ressource Oriented Web Service

REST
• Les services REST sont utilisés pour développer des architectures

orientées ressources (ROA)
• REST est l’acronyme de REpresentational State Transfert
• Concept introduit en 2000 dans la thèse de Roy FIELDING
• Ce n’est pas un format pas un protocole est non plus un standard
• Permet l’envoi de messages sans enveloppe SOAP et dans un encodage

libre (XML, JSON, binaire, simple texte)
• Une Ressource « Any information that can be named can be a resource »

REST principe
• Basé sur HTTP comme protocole de Transport application
• Chaque Ressource est identifiée par une URI http://api.domain.com/users
• L’accès à une ressource se fait par l’une des méthodes HTTP:
• GET : Récupérer une ressource http://api.domain.com/users/lahmer
• POST : Ajouter une ressource http://api.domain.com/users/estm
• PUT : Modifier une ressource http://api.domain.com/users/estm?nom=new&..
• DELETE : Supprimer une ressource http://api.domain.com/users/estm/
• Les données retournées peuvent prendre plusieurs format
•Text
•XML
•JSON
•Binaire

REST vs. SOAP

Rest en JAX-RS
• Créer la classe service POJO avec annotation @GET, @POST,
@PUT, @DELETE
import javax.ws.rs.GET;
//Context de l’application sous Wildfly
import javax.ws.rs.Path; import javax.ws.rs.ApplicationPath;
import javax.ws.rs.Produces; import javax.ws.rs.core.Application;
@Path("services") @ApplicationPath("/api")
public class jaxrsServices { public class RsApp extends Application{
@GET
}
@Path("/hello")
@Produces(value="text/plain") URL
http://localhost:8080/Projet/api/services/hello
public String getHello()
{
return "SALAM";}}
Rest en JAX-RS Côté Client
• Plusieurs types de clients peuvent être implémentés en utilisant

• HttpURLConnection (java.net)
• HttpClient de apache org.apache.http.impl.client

• Client javax.ws.rs.client.Client;
public static void main(String[] args) {
Client client=ClientBuilder.newClient();
WebTarget target = client.target("http://localhost:8080/jaxrs/rest/services/hello");
Response response = target.request().buildGet().invoke();
System.out.println(response.readEntity(String.class));
}

Annotations Jax-rs @QueryParam
@QueryParam
Permet d'associer un paramètre de la requête à un champ ou un paramètre
d'une méthode
@DefaultValue("defaultValue") Permet de spécifier la valeur par
défaut
@GET
@Path("/json")
@Produces(MediaType.APPLICATION_JSON)
public Client getjsonHello(@DefaultValue("lahmer")@QueryParam("nom")
String nom){
return L.get(nom);//L de type Vector}
L’accès se fait par URL: http://machine/api/json?nom=lahmer
Annotations Jax-rs @PathParam
@PathParam
Dans l’annotation « @Path », il est possible de mettre des
parties variables entre accolades {}. Ils peuvent alors être
récupérés comme paramètres de la méthode avec l’annotation
« @PathParam »
@DELETE
@Path("/delete/{userId}")
public boolean deleteUser(@PathParam("userId") String
userId)
{..}
L’accès se fait par URL: http://machine/rest/delete/1
Annotations Jax-rs @FormParam
@FormParam
Permet de récupérer directement les paramètres depuis un
formulaire html.
<form action="add" methode="post">
<input name="nom" typte=text/>
….
</form>
@POST
@Path("/add/")
public boolean addUser(@FormParam("nom") String nom)
{..}
URL: http://machine/rest/add
Java Persistance API
« JPA »
94
 
JPA Les principes
❖ JEE propose une couche d’abstraction par dessus JDBC pour la persistence des données appelée
JPA
❖ JPA précise les modalités de fonctionnement d’un ORM (Object Relationnel Mapping) Java à base
des annotations
❖ Plusieurs implémentations JPA qui supporte la version 3.0 :
❖ Eclipse Link
<dependency>
<groupId>org.eclipse.persistence</groupId>
<artifactId>org.eclipse.persistence.jpa</artifactId>
</dependency>
❖ OpenJpa
❖ Hibernate
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-core-jakarta</artifactId>
</dependency>
❖ Les entités dans les spécifications de l'API Java Persistence permettent d'encapsuler les données
d'une occurrence d'une ou plusieurs tables.
❖ Généralement, elle représente une table dans une base de données relationnelle, et chaque
instance de l'entité correspond à une ligne dans cette table.
95
Entity JPA
import java.io.Serializable;
Annotation Description
import javax.persistence.* @Entity Declares the class as an
@Entity entity
public class Mesure implements @Table Specifies details of the table
Serializable { such as name
private static final long @NamedQuery Specifies a predefined
serialVersionUID = 1L; database query that is run
@Id by an EntityManager
@GeneratedValue(strategy = instance.
GenerationType.IDENTITY) @Id Declares the primary key of
private Long id; the entity
@Column() @GeneratedValue Specifies the strategy used
private double cm; for generating the value of
@Column(name="litre") the primary key. The
strategy =
private double l;
GenerationType.AUTO
//getters
@Column Specifies that the field is
//setters
mapped to a column in the
}
database table.
96
Persistence.xml
Chemin : Projet/src/main/resources/META-INF/persistence.xml
<persistence xmlns="https://jakarta.ee/xml/ns/persistence"
xsi:schemaLocation="https://jakarta.ee/xml/ns/persistence
https://jakarta.ee/xml/ns/persistence/persistence_3_0.xsd"
version="3.0">
<persistence-unit name="mydb" transaction-type="JTA">
<jta-data-source>jdbc/mydb</jta-data-source>
<exclude-unlisted-classes>false</exclude-unlisted-classes>
<properties>
<property name="jakarta.persistence.schema-generation.database.action"
value="create"/>
</properties>
</persistence-unit>
</persistence>
Les valeurs possibles sont :

- create : creation du schemas lors du déploiement
- drop : suppression schemas lors du déploiement
- none : le schemas de la base ne sera pas créer

97
- drop-and-create : suppression et creation lors de chaque déploiement

Les Relations JPA

4 types de relations à définir entre les entités de la JPA:
• One to One
• Many to One
• One to Many
• Many to Many
Chacune de ces relations peut être unidirectionnelle ou

bidirectionnelle sauf one-to-many et many-to-one qui sont par
définition mutuellement bidirectionnelles
98

Relation: Many to One

@Entity @Entity
@Table(name="EMP") public class Department
public class Employee { {
@Id
@Id
private int id;
private int id;
@ManyToOne private String dname;
@JoinColumn (name="DEPT_ID")
private Department d;
// getters & setters
...
}
// getters & setters
...
}
EMP DEPARTMENT
ID DEPT_ID ID DNAME
PK FK PK
99
Relation: One to One

@Entity
@Entity
@Table(name = "users")
@Entity
public class User {
@Table(name = "address")
@Id
public class Address {
@GeneratedValue(strategy =
@Id
GenerationType.AUTO)
@GeneratedValue(strategy =
@Column(name = "id")
GenerationType.AUTO)
private Long id;
@Column(name = "id")
@OneToOne(cascade =
private Long id;
CascadeType.ALL)
@OneToOne(mappedBy = "address")
@JoinColumn(name = "address_id",
private User user;
referencedColumnName = "id")
//... getters and setters
private Address address;
}
// ... getters and setters
}
100
Relation: Many to Many
@Entity @Entity
@Table(name="EMP") public class Project {
public class Employee { @Id
@Id
private int id;
private int id;
@JoinTable(name="EMP_PROJ",
private String name;
joinColumns=
@JoinColumn(name="EMP_ID"),
@ManyToMany(mappedBy="p")
inverseJoinColumns= private Collection<Employee> e;
@JoinColumn(name="PROJ_ID")) // getters & setters
@ManyToMany ...
private Collection<Project> p; }
}
EMP EMP_PROJ PROJECT

ID NAME SALARY EMP_ID PROJ_I ID NAME
D
PK PK,FK1 PK,FK2 PK
101
Héritage : single table

Cette stratégie aplatit la hiérarchie de classes dans une seule table contenant
tous les attributs de la hiérarchie. Les spécialisations sont différenciées
par un discriminateur.
Employee
EMP -id
-name
PK ID -startDate
NAME
START_DATE
DAILY_RATE
TERM
VACATION
EMP_TYPE
ContractEmployee
NurunEmployee
-dailyRate
-term -vacation
102
Héritage: joined table

Cette stratégie imite la hiérarchie de classes dans plusieurs table
reliées. Ici aussi un discriminateur est nécessaire.
ContractEmployee Employee
PK,F ID -id
-name
K DAILY_RATE
-startDate
TERM
EMP
PK ID
NAME
START_DATE
EMP_TYPE
NurunEmployee
PK,F ID
K VACATIO ContractEmployee
N -dailyRate
NurunEmployee
-term -vacation
103
Entity Manager: le cœur de la JPA
Les entités, une fois annotées, ne peuvent se persister de par

elles-mêmes.
Elles ont besoins d’un engin, qui lui, performera les opérations sur
la base de données, en concordance avec les mappings définis dans
les annotations.
C’est le role de Entity Manager qui permet de lire et rechercher
des données ainsi les mettre à jour (ajout, modification,
suppression).
L'EntityManager est donc au coeur de toutes les actions de
persistance.
– Étape 1: mettre la main sur une instance EntityManager
– Étape 2: persister nos POJO
104

Entity Manager
@Transactionnal
Class Dao {
@PersistenceContext(name = "jpa-unit")
EntityManager em;
//Insert
User u = new user();
em.persist(u);
//Search, update
User u = em.find(user.class, 1);u.setName("new Name »);
em.merge(u)
And remove
em.remove(u);
//Select
Query q = em.createQuery("SELECT u FROM user u");
List<user> userList = q.getResultList();
}
105
Queries: NamedQueries
On peut sauvegarder des gabarits de requête dans nos entités.
C’est ce qu’on appelle une NamedQuery. Ceci permet :
❖ La réutilisation de la requête
❖ D’externaliser les requête du code.
@Entity
@NamedQuery(name="myQuery", query="Select o from MyPojo o")
public class MyPojo { … }
public class MyService {

public void myMethod() {
…
List results = em.createNamedQuery("myQuery").getResultList();
…
}
}
106

Jakarta EE

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Jakarta EE

Transféré par

Droits d'auteur :

Formats disponibles

Java|Jakarta Entreprise Edition

Servlet, JSP,TagLib,JSF,Ejb et JPA

Java Entreprise Edition

Java Entreprise Edition

J2EE devient JEE

JEE devient Jakarta EE

Java Entreprise Edition

Vue Globale depuis JEE6

les composants : Servlet, JSP, EJB

Java Entreprise Edition

JDBC (Java DataBase Connectivity)

JNDI (Java Naming & Directory Interface)

API per mettant aux

JNDI Server Provider

Java Entreprise Edition

Java IDL (Java Interface Definition Language)

Utilisée pour intégrer Java et CORBA.

Java Entreprise Edition

Classe Java qui fournit un service

Java Entreprise Edition

JSP (Java Server Pages)

Java Entreprise Edition

JTS (Java Transaction Service)

Spécification d'implémentation d'une couche d'adaptation

Java Entreprise Edition

JTA (Java Transaction Architecture)

API Java standard pour l'accès au moniteur

JDBC JMS EJB Other

Transaction Monitor Implementation

API Java pour l'accès aux serveurs de

JAF (JavaBeans Activation FrameWork)

Intègre un support pour les MIME Types

Java Entreprise Edition

JMS (Java Message Service)

API pour accès aux messages orientés

XML (eXtensible Markup Language)

Langage pour la définition d'autres «Markup

Java Entreprise Edition

JCA (JEE Connector Architecture)

Spécification pour la communication avec les

EJB (Entreprise Java Bean)

Composants qui fournissent un service métier pour

Java Entreprise Edition

EJB (Entreprise Java Bean)

EJB (Entreprise Java Bean)

Java Entreprise Edition

EJB (Entreprise Java Bean) : Stateless Session Bean

Fournit un « single_use service ».

Java Entreprise Edition

EJB (Entreprise Java Bean) : Stateful Session Bean

Fournit un mode conversationnel avec l'application

Java Entreprise Edition

EJB (Entreprise Java Bean) : Entity Bean

Représente la persistance des données.

Jakarta Entreprise Edition

src/main/java : codes source java sous

Cycle de vie d’une servlet

Déploiement d’une servlet

Deux principaux tags peuvent être utilisés pour mettre en

<INPUT> Permet d'introduire un champ de saisie (zone de

donnée associée dans la requête HTTP.

Parmi les types les plus courants, on retrouve : text,

Vue MyServlet UserBean DataBase

Gestion des erreurs