L’environnement Java EE

Principes, fonctions, utilisation

F. Boyer, Présentation pour la filière M2PGI 2009/2010,

Université Joseph Fourier

Sources
Cours de Pascal Déchamboux (FT R&D) pour l’école d’été ICAR 2003 à Autrans
Cours de Lionel Seinturier (LIFL) http://www2.lifl.fr/~seinturi/middleware/ejb3.pdf
 Sommaire

Introduction
Approche à composants
u Packaging
u Gestion externalisée des dépendances
Modèles de programmation Java EE
u Clients
u Composants session
u Composants entité
u Composants mdb
Fonctions avancées
u Timers
u Gestion des transactions
u Gestion de la sécurité
Conclusion

© 2009, F. Boyer 2
 Introduction

© 2009, F. Boyer 3
 Java EE pour quoi faire ?

Infrastructure « serveur » pour le support

d’applications Web ou d’entreprise
u E-commerce, SI, plateformes de services audio-visuel, telecoms,
etc

Support de QoS : transaction, sécurité

Connexion standard à des systèmes d’information
externes (accès au « legacy »)
Architecture multi-tiers
u Architecture client léger (basée « browser »)
u Architecture client lourd (GUI avancées)

© 2009, F. Boyer 4
 Architectures usuelles

Navigateur
Application Tiers Terminal
Web
Cliente Client Client
(Pages HTML)

Composants
de Tiers
présentation : Web
Servlet HTTP
+ Pages JSP
Serveur
Java EE
Composants Composants
d’entreprises : d’entreprises :
EJB (logique EJB (logique Tiers
métier + métier + Métier
données) données)

Tiers Serveur
Base de données Base de données « EIS » Base de données

© 2009, F. Boyer 5
 Java EE sous l’œil de Darwin !

Standard en évolution/maturation depuis 1997/1998

(J2EE 1.0, …, 1.3, 1.4, Java EE depuis 2006)
Au départ support d’applications Web n-tiers
(architecture décentralisée)
u Présentation : Servlet (principalement HTTP)
u Logique métier : EJB
u Gestion de données : JDBC

Vers une infrastructure de support standard pour EAI

u Facteurs de rationalisation majeur (JTA/JTS, JMS, JCA, WS)
u Évolution de produits existants vers Java EE

© 2009, F. Boyer 6
 Ce que définit Java EE

Spécification
u Programmation, assemblage, déploiement
u Serveur et services

Implantation de référence opérationnelle

Suite de tests de conformance
u Certification Sun
u Accès au processus de certification payant (cher !!)
u Lourd (> 20.000 tests)

© 2009, F. Boyer 7
 Vue générale de l’architecture Java EE

Application J2EE

RMI
Container
WS Container Web Containers EJB Connecteurs
Container Client Container J2EE Serveur
CLIENT LOURD

ORB (RMI, Corba)

Serveur de noms

SAX,DOM,XSLT)
Sécurité (JAAS)
Mail (JavaMail)
SGBD (JDBC)
Web (Servlet,

MOM (JMS)

Connecteurs
Transaction

XML (JAXP,
(JTA, JTS)
JSP, JSF)
(JNDI)

(JCA)
HTTP

RMI

WS

SERVEUR J2EE
CLIENT LEGER
Bases de Données
(Oracle, …)
© 2009, F. Boyer 8
 Configurations possibles d’un
serveur Java EE : clients lourds

Application Application
Cliente Cliente
Application Java EE :
Architecture centralisée Services (jdbc, EJB
mail, jca, etc)
Services (jdbc,
mail, jca, etc)

Application Application
Cliente Cliente

Application Java EE : EJB EJB EJB

Architecture client/serveur
Services (jdbc, Services (jdbc, Services (jdbc,
mail, jca, etc) mail, jca, etc) mail, jca, etc)

© 2009, F. Boyer 9
 Configurations possibles d’un
serveur Java EE : clients Web

Navigateurs Navigateurs
(HTML, WML) (HTML, WML)

Application Java EE : Servlet Servlet

Architecture Web
/ Services (jdbc, EJB
Serveur centralisé mail, jca, etc)
Services (jdbc,
mail, jca, etc)

Navigateurs Navigateurs
(HTML, WML) (HTML, WML)
Application Java EE :
Architecture Web Servlet Servlet
/
Serveur réparti
EJB EJB EJB

Services (jdbc, Services (jdbc, Services (jdbc,

mail, jca, etc) mail, jca, etc) mail, jca, etc)

© 2009, F. Boyer 10
 Offre importante

Offre commerciale
u IBM / WebSphere (n° 1)
u BEA / WebLogic
u Sun One
u Oracle 9i Application Server
u Et aussi Borland Entreprise Server, Macromedia / Jrun, SAP Web
Application Server, Iona / Orbix E2A
Offre « open source »
u JBoss (Red Hat)
u JOnAS (ObjectWeb)
u GlassFish (Sun)
u …

© 2009, F. Boyer 11
 Vers Java EE 5

Simplification du développement
u Relâchement des contraintes / programmation des composants
u Utilisation des annotations amenées par Java SE 5

Enrichissement fonctionnel
u Amélioration du support du tiers de présentation avec Ajax / Flex
u Support complet des Web Services
v Sessions exposables avec RMI ou avec Web Services
u Amélioration du support des objets persistants avec Java
Persistence API (un grand pas vers JDO!)

© 2009, F. Boyer 12
 Approche à composants
Définition
Packaging
Gestion externalisée des dépendances
- Inversion de contrôle
- Conteneurs
- Définition et programmation des composants

© 2009, F. Boyer 13
 Notion de composant

Szyperski 2002

A component is a unit of composition with

contractually specified interfaces and explicit
dependancies only. A software component can be
deployed independantly and is subject to
composition by third parties.

© 2009, F. Boyer 14
 Composants Java EE

Composants applicatifs (code métier)

u Potentiellement répartis, transactionnels et sécurisés

Différents profils
u Session Beans (EJB)
v Instances dédiées à un contexte d’interaction client particulier
v Avec / sans état
u Message Driven Bean (EJB)
v Instances réagissant à l’arrivée de messages asynchrones
u Entity Beans
v Instances partagées représentant les données de l’entreprise
u Servlets
v Composants de présentation

© 2009, F. Boyer 15
 Exemple d’application: Inscription à
une conférence

Navigateur Web ENTITY

(par exemple, Participant, etc
formulaire
HTML de SERVLET SESSION
récupération des d’inscription d’inscription
informations liées
à un participant) Topic Inscription

Application MDB de
…
client signalisation
"lourd" à un
Envoi d’un
secrétariat
e-mail

© 2009, F. Boyer 16
 Packaging de l'application

Application ICAR
u Application JEE
Application ICAR
u Packaging : icar.ear
Présentation ICAR u Contient 2 archives
Servlet/JSP Module de présentation
+
u Spécifique à ICAR
Ressources de présentation
(images, etc.) u Packaging : icarweb.war
Module métier
Métier "école thématique"
u Gestion d'une école thématique
EJB u Non spécifique à l'école ICAR
+ (réutilisable)
Classes persistantes
u Packaging : ecole_them.jar
u Contient code des EJB et des
composants persistants
© 2009, F. Boyer 17
 Package "icar.ear"

Contenu de l'archive Contenu de "application.xml" :

<application>
"icar.ear" :
<display-name>ICAR'06</display-name>
<description>Gestion de l'école ICAR 06
META-INF/ </description>
MANIFEST.MF <module>
application.xml <web>
<web-uri>icarweb.war</web-uri>
icarweb.war
<context-root>icar06</context-root>
ecole_them.jar
</web>
</module>
<module>
<ejb>ecole_them.jar</ejb>
</module>
</application>

© 2009, F. Boyer 18
 Package "webicar.war"

Contenu de l'archive Contenu de "web.xml" :

"webicar.war" : <web-app>
<servlet>
META-INF/ <servlet-name>ICAR'06</servlet-name>
MANIFEST.MF <servlet-class>
WEB-INF/ org.icar.servlet.TraiteFormulaireInscr
web.xml </servlet-class>
classes/ </servlet>
org/ <servlet-mapping>
icar/ <servlet-name>ICAR'06</servlet-name>
servlet/ <url-pattern>/inscr/traitform</url-pattern>
*.class </servlet-mapping>
<ejb-ref>
<ejb-ref-name>ejb/Inscription</ejb-ref-
name>
...
</ejb-ref>
</web-app>

© 2009, F. Boyer 19
 Package "ecole_them.jar"

Contenu de l'archive Contenu de "ejb-jar.xml" (pas obligatoire en

"ecole_them.jar" EJB3.0) :
(persistence.xml, cf. <ejb-jar>
section persistance) : <enterprise-beans>
<session>
META-INF/ <ejb-name>Inscription</ejb-name>
MANIFEST.MF <ejb-class>
ejb-jar.xml org.ecole.lib.IncriptionBean</ejb-class>
persistence.xml <session-type>Stateless</session-type>
org/ <transaction-type>Container</transaction-
type>
ecole/
...
api/
</session>
*.class
</enterprise-beans>
lib/
</ejb-jar>
*Bean.class
persistance/
*.class

© 2009, F. Boyer 20
 Gestion externalisée des
dépendances

Dépendances d’un composant (client, servlet

vers :

u un autre EJB
v Exemple: Servlet d’inscription à EJB Inscription

u les services / ressources de l’infrastructure

v Exemple: service de transaction

u les propriétés de l’application

v Exemple: NbMaxParticipants

© 2009, F. Boyer 21
 Inversion de contrôle

Principe de mise en œuvre des dépendances externalisées

u Les dépendances ne sont pas gérées par les composants
u Elles sont gérées par l’infrastructure J2EE, au travers des conteneurs

Recherche d’une indépendance maximale du code applicatif

u Vision toutefois non systématique, car les définitions de dépendances sont
spécifiques au type de liaison (par exemple, ejb, ressource, etc.)

© 2009, F. Boyer 22
 Inversion de contrôle (2)

Indépendance des modules

logiciels
u Pas de liaison statique entre COMPOSANT
APPLICATIF
modules de code applicatif
(composants)

…
CONTENEUR
u Pas de liaison statique entre
modules de code applicatif et
services plate-forme
u Eviter l’utilisation de code SERVICE 1
…
SERVICE 2
« technique » dans le code
applicatif SERVICE N

© 2009, F. Boyer 23
 Rôle d’un conteneur

Gestion des dépendances

u Vers des EJB
u Vers des services de l'infrastructure
u Vers des propriétés

Gestion du cycle de vie des composants

u Démarrage, arrêt
u Activation, passivation

© 2009, F. Boyer 24
 Principe de mise en oeuvre des
conteneurs

Injection
u Injection des propriétés
u Injection des dépendances entre composants
u Injection des dépendances entre composants et services de l'infrastructure

Interception
u Interception des appels vers/depuis les composants
v Pour gérer les appels aux services non fonctionnels

Callbacks applicatifs
u Spécialisation de la gestion des dépendances et du cycle de vie (création, destruction,
activation, passivation)

Utilisation d'un contexte propre à chaque composant (données de

contrôle)
u Sécurité, Transactions, Contexte de Nommage

© 2009, F. Boyer 25
 Principe du conteneur Java EE

CONTENEUR
Cycle de vie

EJB2.1: gestion des

dépendances faite par
CODE APPLICATIF

Interface

dépendances
Gestion des
des intercepteurs

dépendances
« local »

Gestion des
Instance
de
composant
Interface EJB3.0: gestion des
« remote » dépendances injectée
dans les composants
Contexte
Bean session (EJB3.0)

Services non fonctionnels

© 2009, F. Boyer 26
 Principaux conteneurs Java EE

Conteneur d'applications clientes (client "lourd")

Conteneur d'applications serveurs (déployées dans

un serveur Java EE)
u Conteneur Web (de "servlet")
u Conteneur d'EJB

Conteneur de persistance
u Indépendant de JEE
u Intégré par le conteneur EJB
u Basé sur les principes des composants (JPA)

© 2009, F. Boyer 27
 Gestion externalisée des
dépendances

Programmation d’un composant client, servlet, EJB :

u Code Java (POJO)

v Interfaces d’accès aux instances
v Implantation des interfaces

u Méta-information
v Définition des dépendances
v Sous forme d’annotations
v Surchargées par des descripteurs XML optionnels

© 2009, F. Boyer 28
 Dépendances vers une propriété, un
EJB ou une ressource

Dépendance entre un nom local dans le code (ex: le nom d’une

variable) et une propriété, un EJB ou une ressource
u Dépendance définie par la méta-information

Définition d’une dépendance

u Vers une propriété
v Donne la valeur de la propriété
u Vers un composant du même ear
v Désignation à l'aide du nom local du composant
v Vers un composant extérieur ou vers une ressource
v Désignation à l'aide d'un nom global JNDI (mappedName)
Par défaut
u Le nom local d’un composant est celui de son interface (sauf si attribut name
défini)
u Le nom global d’un composant est celui de son interface (sauf si attribut
mappedName redéfini)

© 2009, F. Boyer 29
 Définition de dépendances vers une
propriété

// Code du composant
…
class InscriptionBean implements Inscription {
@Resource private int maxPart = 120; // maximum de participants

<!– descripteur optionnel à

<session>
<ejb-name>InscriptionBean</ejb-name>
<ejb-class> InscriptionBean</ejb-class>
…
<env-entry>
<description>Nombre maximum de participants</description>
</env-entry-value>150</env-entry-value>
<injection-target>maxPart</injection-target>
</env-entry> …
</session>

© 2009, F. Boyer 30
 Définition de dépendances vers un
EJB (principe)

// Code du composant (par exemple un servlet) contenant la

dépendance
@EJB(name="../ecole_them.jar#InscriptionBean")
private Inscription inscr;

// Ou si le composant référencé et le référençant sont dans le

même package
@EJB private Inscription inscr;

<!– descripteur optionnel à

<ejb-ref>
…
<ejb-link>../ecole_them.jar#InscriptionTest</ejb-link>
<injection-target>inscr</injection-target>
</ejb-ref>

© 2009, F. Boyer 31
 Définition de dépendances vers une
usine à connexions JDBC

// Code du composant contenant la dépendance

@Resource (mappedName="java:/JdbcInscriptions")
javax.sql.DataSource BdInscriptions;

<!– descripteur optionnel à

<resource-ref>
<description>BD pour ICAR</description>
…
<mapped-name>java:/JdbcInscriptionsTest</mapped-name>
<injection-target> BdInscriptions </injection-target>
</resource-ref>

© 2009, F. Boyer 32
 Définition de dépendances vers une
ressource JMS

// Code du composant contenant la dépendance en EJB3.0

@Resource(mappedName="java:/TopicInscriptions09")
javax.jms.Topic topicInscription;

<!– descripteur optionnel à

<resource-env-ref>
<description>Topic pour processus d’inscription</description>
<mapped-name>java:/TopicInscriptions10</mapped-name>
<injection-target>topicInscription</injection-target>
</resource-env-ref>

© 2009, F. Boyer 33
 Accès au contexte d'un composant

// Accès au contexte d'un composant en EJB3.0

…
class InscriptionBean implements Inscription {
@Resource private SessionContext ctxt; // le contexte du composant
…
}

// Accès au contexte d'un composant en EJB2.1

class InscriptionBean implements Inscription, … {

private SessionContext ctxt; // le contexte du composant

void setSessionContext(SessionContext c) {
ctxt = c;
}
…
}
© 2009, F. Boyer 34
 Modèles de programmation des
composants Java EE

- Composants EJB
Session
Orienté message

- Composants Entity

© 2009, F. Boyer 35
 Une conception classique J2EE

Tiers présentation Tiers métier

EJB façade session

Navigateur servlet
Web servlet Entité
servlet EJB session Entité
EJB session Entité
Entité

Client lourd

Data Transfer Objects

Bases de Données

Exemple: EJB Session ProductInfos fournit

getProduct(productName,..) à ProductDTO

© 2009, F. Boyer 36
 Bean Session

Stateful / Stateless
u Annotation @Stateful / @Stateless (javax.ejb)

Interface locale / distante / Web service

u Annotation @Local / @Remote / @WebService

Stateful associés de façon unique à un client particulier

u Typiquement : caddie
u @Remove définit la méthode de fin du bean (EJB3.0)
u Sinon destruction automatique au bout d’un délai d’inactivité

Manipulation par méthodes métier

Comportement transactionnel spécifique à chaque méthode

© 2009, F. Boyer 37
 Bean Session (interface Remote)

package ecole_them;
import javax.ejb.Remote;

@Remote
public interface Inscription {
public void enregistre(String nom, …);
public void confirme();
public … infos(String nom);
}

© 2009, F. Boyer 38
 Bean Session (interface WebService)

package ecole_them;
import javax.ejb.*;

// Only for stateless beans

@WebService (targetNameSpace=« urn:InscService »);
@Stateless
public class InscriptionBean implements Inscription {
@WebMethod
@WebResult(name=« UserId »)
public void enregistre(
@WebParam(name=« UserName ») {
...
}
..

Accès (ex): http://host:8080/InscService/InscriptionBean/enregistre?UserName=Paul

© 2009, F. Boyer 39
 Bean Session (Implantation)

package ecole_them;
import javax.ejb.*;

@Stateless
public class InscriptionBean implements Inscription {

public void enregistre(String nom) {...}

@Remove
public void confirme() {...}
...
}
..

© 2009, F. Boyer 40
 Dépendance vers un bean session depuis un
composant local (même ear)

package ecole_them;
import javax.ejb.*;

public class InscriptionServlet extends HttpServlet {

@EJB
private Inscription inscription;

public void service(HttpServletRequest req,

HttpServletRespons resp) {
name = …;
resp.setContentType(“text/html”);
PrintWriter out = resp.getWriter();
inscription.enregistre(name);
out.println(
“<html><body>Inscription enregistrée>/body></html>”);
}
}
...
© 2009, F. Boyer 41
 Dépendance vers un bean session
depuis un client distant

« Container » client Java EE

u Un client a un environnement (contexte)
u Il peut référencer des composants et ressources Java EE
u Il a accès aux transactions (javax.Transaction.UserTransaction)

import javax.ejb.*;

public class ClientDistant {

...
Context ctx = new javax.naming.InitialContext();
Inscription inscription = (Inscription)
ctx.lookup(Inscription.class.getName());
inscription.enregistre(name);
...
}
...
© 2009, F. Boyer 42
 Patrons de programmation des
Beans Session

Bean Session Façade

u Présenter aux clients une unique interface (limite les dépendances
des clients vers le tiers métier)
u Le bean façade délègue les traitements

Data Transfer Objects (DTO)

u Limiter les dépendances entre les tiers métier et présentation
u Clarifier le contrat entre ces deux tiers

© 2009, F. Boyer 43
 Bean Session (DTO)

package ecole_them;
import javax.ejb.Remote;

@Remote
public interface Inscription {
public void enregistre(String nom);
public void confirme();
public ParticipantDTO infos(String nom);
}

class ParticipantDTO { // objet de transfert de données entre

public String nom; // tiers métier et client
public Date date;
...
}

© 2009, F. Boyer 44
 Entity Beans

Composants métier représentant des données

persistantes, en base relationnelle

Accès via jdbc

Gestion du mapping objet-relationnel (standard JPA)

© 2009, F. Boyer 45
 Mapping objet-relationnel

Notion de « clé primaire » Serveur Java EE

u Nom persistant qui désigne 1 instance Instance de
BD composant

Sélection d'entités persistantes

u Requêtes (nommées ou dynamiques)
u Implémentées en EJBQL (~OQL) ejbCreate
ejbRemove Clé Primaire ejbLoad
u Retourne une entité ou une collection ejbStore
d'entités
Dépendances entre les données en Base de
base à injectées dans les beans Données
entités
Instance BD

© 2009, F. Boyer 46
 Mapping avec la base de données

Chaque classe de bean entité est associée à une table

u Par défaut, le nom de la table est le nom de la classe
u Sauf si annotation @Table(name=…)

Deux modes de définition des colonnes des tables (donc des

attributs persistants)
u Mode "field" à annote les attributs
u Mode "property" à annote les méthodes getter/setter
u Par défaut, le nom de la colonne est le nom de l’attribut
u Sauf si annotation @Column(name=…)

© 2009, F. Boyer 47
 Mapping avec la base de données

Types supportés pour les attributs

u Types primitifs (et leurs "wrappers"), String, Date, etc.
u Données binaires
@Lob
private byte[] picture;
u Références d'entité (relation ?-1)
u Collections de références d'entité (relation ?-n)

Colonne de jointure
u @JoinColumn(name=".. ", referencedColumnName=" .. ")
Table de jointure
Nom de l’attribut dans la classe
u @JoinTable

© 2009, F. Boyer 48
 Fichier de définition des unités de
persistance : "persistence.xml"

<persistence>
<persistence-unit name="DonneesInscriptions">
<jta-data-source>jdbcInscriptions</jta-data-source>
<properties>
<property name="hibernate.hbm2ddl.auto" value="create-drop" />
...
</persistence-unit>
</persistence>

© 2009, F. Boyer 49
 API du système de persistance

EntityManager représente le gestionnairedu mapping (CRUD

operations)
u Create, Read, Update, Delete
u Select (renvoie une entité ou une List / Collection Java)
u Attribut de type javax.persistence.EntityManager annoté par
@PersistenceContext

Query représente une requête EBJQL (définition et exécution)

u Pré-compilée si nommée

© 2009, F. Boyer 50
 Programmation d'un Entity Bean

POJO avec annotations (javax.persistence.*)

u Capacités d’héritage

Annotations de classes
u @Entity pour définir une classe correspondant à un bean entité
u @NameQuery pour associer une requête nommée à ce bean

Annotations de méthode ou d’attribut

u @Id pour définir une clé primaire
u @GeneratedValue pour définir un attribut dont la valeur est générée par le
conteneur

Beans rendus persistants

u explicitement (action persist)
u par attachement (liens de propagation configurables)

© 2009, F. Boyer 51
 Programmation d’un Entity Bean

import javax.persistence.Entity; @Id @GeneratedValue

… (strategy=GenerationType.AUTO)
@Entity
@NamedQuery( public long getId(){
name="tousLesParticipants", return this.id;
query="SELECT * FROM Participant p") }
public void setId(long id){
public class Participant{ this.id = id;
}
private long id; public Ecole getEcole(){
private String name; return ecole;
private Ecole ecole; }
public void setEcole(Ecole ecole){
public Participant() {} this.ecole = ecole;
public Participant(String name) { }
setName(name); …
}

© 2009, F. Boyer 52
 Programmation d’un Entity Bean

import javax.persistence.Entity; @Id @GeneratedValue

@Entity (strategy=GenerationType.AUTO)
@NamedQuery( public long getId() {
name="toutesLesEcoles", return this.id;
query="SELECT * FROM Ecole e") }
public void setId(final long id) {
public class Ecole { this.id = id;
private long id; }
private Collection<Participant> public Collection<Participant>
participants; getParticipants() {
… return participants;
}
public Ecole() {} public setParticipants(
public Ecole(String name) { Collection<Participant>participants){
setName(name); this.participants = participants;
} }
..

© 2009, F. Boyer 53
 Dépendance vers des Entity Beans

@Stateless
public class InscriptionBean implements Inscription {
@PersistenceContext private EntityManager em; // em injecté

void enregistre(String nom) {

Participant p = new Participant(nom);
em.persist(p);
}

Collection<Participant> participantsFinder() {
Query q = em.createNamedQuery("tousLesParticipants");
return q.getResultList();
}

ParticipantDTO infos(String nom) {

Query q = em.createQuery(
"select OBJECT(i) from Participant p where p.nom = :np");
q.setParameter("np", nom);
Participant p = (Participant) q.getSingleResult();
...
© 2009, F. Boyer 54
 Dépendance vers des Entity Beans

@Stateless
public class InscriptionBean implements Inscription {
@PersistenceContext
private EntityManager em;

// recherche par la primary key

Participant participantFinder(long participantId) {
return em.find(Participant.class, Integer.valueOf(participantId));
}

...

© 2009, F. Boyer 55
 Les relations

Définition de relations entre composants persistants

u Gestion optimisée
u Cardinalité 1-1, 1-n, n-1, n-n
v @OneToOne, @OneToMany, @ManyToOne, @ManyToMany
u Principe
v Annote un champ d’une classe
v Attribut mappedBy permet de désigner le champ qui définit la
relation dans l’autre classe

© 2009, F. Boyer 56
 Sans les relations…

import javax.persistence.Entity; import javax.persistence.Entity;

@Entity @Entity
public class Entreprise { public class Participant {
long id; long id;
String nom; String nom;
Collection<Participant> participants; Entreprise entreprise;
... ...
} }

ENTREPRISE PARTICIPANT

ENTREPRISE_ID PARTICIPANT_ID
NOM NOM
.. ENTREPRISE_PARTICIPANTS
ENTREPRISE_ID

Les colonnes
ENTREPRISE_PARTICIPANTS et
ENTREPRISE_ID représentent les
mêmes informations !!

© 2009, F. Boyer 57
 Avec les relations
(OneToMany / ManyToOne)

import javax.persistence.Entity; import javax.persistence.Entity;

@Entity @Entity
public class Entreprise { public class Participant {
long id; ... long id; ... nom de la colonne
de jointure
Entreprise entreprise;
@OneToMany(mappedBy="entreprise")
Collection<Participant> participants; @ManyToOne
@JoinColumn(name="MonEntreprise_id")
public Collection<Participant> public Entreprise getEntreprise(){
getParticipants(){ return entreprise;}
return participants;}
public void setEntreprise(Entreprise e){
public void setParticipants this.entreprise = e;}
(Collection<Participant> participants){ ...
this.participants = participants;}
ENTREPRISE PARTICIPANT
public void addParticipant(..){ ENTREPRISE_ID PARTICIPANT_ID
Participant p = new Participant(..); NOM NOM
getParticipants().add(p);} MONENTREPRISE_ID
...

© 2009, F. Boyer 58
 Avec les relations (ManyToMany)

import javax.persistence.Entity; import javax.persistence.Entity;

@Entity @Entity

public class Ecole { public class Participant {

String nom; String nom;
@ManyToMany
@ManyToMany(mappedBy="ecoles") @JoinTable(name="ECOLES_PARTICIPANTS",
Collection<Participant> participants; joinColumns=
... @joinColumn(name="CI_PARTICIPANT_ID",
referencedColumnName="PARTICIPANT_ID"),
inverseJoinColumns=
@joinColumn(name="CI_ECOLE_ID",
referencedColumnName="ECOLE_ID"))
private Collection<Ecoles> ecoles;
...

ECOLE PARTICIPANT ECOLES_PARTICIPANTS

ECOLE_ID
PARTICIPANT_ID CI_PARTICIPANT_ID (foreign key)
NOM NOM CI_ECOLE_ID (foreign key)
MONENTREPRISE_ID

© 2009, F. Boyer 59
 Message Driven Beans (MDB)

Bean sans état

Réagit à des messages envoyés sur une destination JMS
Permet de désynchroniser et fiabiliser l’échange avec le client
Dépendance vers une destination JMS
u Un MDB est agit comme un MessageListener
v Pour une Queue (1 récepteur pour un message)
v Pour un Topic (n récepteurs pour un message)

Base JMS
u ConnectionFactory pour créer des queues/topics
u Connection pour créer une connexion vers une queue / un topic

© 2009, F. Boyer 60
 Bean Message Driven

@MessageDriven(
activationConfig =
{ @ActivationConfigProperty(
propertyName="destination", propertyValue="InscriptionsQueue"),
@ActivationConfigProperty(
propertyName="destinationType", propertyValue="javax.jms.Queue")
})
public class NouvelleInscriptionBean implements
javax.jms.MessageListener{
@resource private String secretaireEcole = "ecole.secretaire@monorg.fr";

public void onMessage(Message m) { // toujours appelé par le conteneur

javax.mail.Message mailmess = new MimeMessage(...);
mailmess.setRecipients(secretaireEcole);
mailmess.setSubject(“Nouvelle inscription - " + ecole);
mailmess.setContent(...)
Transport.send(mailmess);
}
...
© 2009, F. Boyer 61
 Publication de message (depuis un
client par exemple)

@Resource(mappedName="jms/ConnectionFactory")
private static ConnectionFactory connectionFactory;

@Resource(mappedName=”jms/InscriptionQueue”)
private static Queue queue;

Connection connection = factory.createConnection();

Session session = connection.createSession(false,
Session.AUTO_ACKNOWLEDGE);
MessageProducer messageProducer= session.createProducer(queue);

// on peut envoyer k messages

Message message = session.createTextMessage(" …." );
messageProducer.send(message);
...
}

© 2009, F. Boyer 62
 Fonctionnalités avancées
- Timer Beans
- Callbacks applicatives
- Transactions
- Sécurité

© 2009, F. Boyer 63
 Composants EJB Timer

@
Pour les beans sans état seulement
Resource TimerService permet de créer des timers
Timer permet de déclencher des actions
périodiquement

@Stateless
public class InscriptionBean implements Inscription, TimerSession {
@Resource TimerService timerService;

public void createTimer(long delai) {

Timer timer = TimerService.createTimer(delai, “”);
}

@timeout public void envoiPubEcole(Timer timer){..}

...

© 2009, F. Boyer 64
 Callbacks applicatives :
spécialisation du cycle de vie

Permet d’ajouter des traitements métier à certains moments du cycle de vie d’un
bean

Session bean
u @PostConstruct : après la création
u @PreDestroy : avant la destruction
u @PrePassivate : avant la passivation (swapping out), seulement pour statefull
u @PostActivate : après l’activation (swapping in)
u @afterBegin : après le démarrage d’une transaction, avant invocation de toute méthode
métier
u @beforeCompletion : juste avant la terminaison de la transaction
u @afterCompletion : juste avant la terminaison de la transaction

Entity bean
u @ejbCreate
u @ejbPostCreate
u @ejbRemove
u @ejbPostRemove
u …

© 2009, F. Boyer 65
 Callbacks applicatives : intercepteurs

Permet d’ajouter des traitements métier avant/après

les méthodes des beans

u @Interceptors : méthodes devant être interceptées

u @AroundInvoke : méthodes d’interception
u InvocationContext: contexte de l’interception
v Méthode interceptée
v Permet de continuer la méthode (proceed())

© 2009, F. Boyer 66
 Gestion des transactions

Applicables aux profils de composants

u Session
u Message Driven Bean

Propriétés ACID
u Atomicity, Consistency, Isolation, Durability

Gestion déclarative ou programmative (JTA API)

Utilisation de javax.transaction.UserTransaction
Contrôle de la transaction (timeout, « rollbackonly »)

© 2009, F. Boyer 67
 Exemple de gestion transactionnelle
programmative (client lourd)

public final class Client {

...
Inscription inscr;

...
UserTransaction utx
=ctxt.lookup("javax.transaction.UserTransaction");
utx.begin();

Context ctx = new javax.naming.InitialContext();

Inscription inscription = (Inscription)
ctx.lookup(Inscription.class.getName());
inscription.enregistre(name);
inscr.enregistre(…);
...

utx.commit(); // ou utx.rollback();
}

© 2009, F. Boyer 68
 Gestion déclarative des transactions
(« container-managed »)

Méthodes transactionnelles définies dans les EJB (meilleure

conception)
Annotations de méthode @TransactionAttribute
u « NotSupported » : si transaction courante, elle est suspendue
u « Required » : si pas de transaction, nouvelle transaction
u « RequiresNew » : nouvelle transaction (si tx courante, suspendue)
u « Mandatory » : exception si pas de transaction courante
u « Supports » : si transaction courante, l ’utiliser
u « Never » : exception si transaction courante
u Seuls « Required » et « NotSupported » valables pour les MDB
L’infrastructure gère la mise à jour transactionnelle des données
persistantes, mais c’est au programmeur de gérer si nécessaire
le rafraîchissement de l’état de ses EJB.

© 2009, F. Boyer 69
 Exemple de gestion transactionnelle
déclarative

…
@Stateless
@TransactionManagement(TransactionManagementType.CONTAINER)
public class InscriptionBean implements Inscription {

@Resource
private SessionContext context;

@TransactionAttribute(TransactionAttributeType.REQUIRED)
public void enregistre(String nom) {
...
} catch(EnregistrementException e) {
context.setRollbackOnly();
}
...
}
...
© 2009, F. Boyer 70
 Exemple de gestion transactionnelle
déclarative

Pour les EJB Statefull

u Utiliser les callbacks afterBegin(), beforeCompletion() et

afterCompletion() pour gérer l’état de l’EJB

u beforeCompletion() est la dernière occasion de faire aborter la

transaction, en positionnant la propriété setRollbackOnly

u afterCompletion (boolean comitted) permet de rafraîchir l’état de

l’EJB en cas de rollback, si l’on a sauvegardé cet état lors de
l’appel à afterBegin().

© 2009, F. Boyer 71
 Gestion de l'authentification et des
autorisations

Notions de base
u "principal"= identifiant (utilisateur)
u "credential"="principal" authentifié
u "role"=profil d'autorisation Navigateur
Web
Authentification requête réponse
formulaire infos
u Valide un "principal" et associe un ressource
de "login" d'authentification
ressource
protégée protégée
Conteneur
"credential" à sa session
Authentification à "crédential" Web
u "credential" passé au système
d'autorisation Autorisation

Autorisation servlet
Conteneur
u Vérification de droits d'utilisation ou
EJB
d'accès Autorisation

u Basé sur les "roles" EJB session

u Règle : accès autorisé si un
"credential" est dans un "role"
autorisant l'accès à la ressource

© 2009, F. Boyer 72
 Principes de Sécurité

Authentification et autorisation peuvent être gérés au niveau de chaque

tiers (Web, EJB, etc), et peuvent être déclaratifs / programmatiques.
Web tiers: indiquer au servlet container quelles resources doivent être
sécurisées et comment

web.xml :
<login-config>
<auth-method>BASIC </auth-method>
<realm-name>InscriptionsRealm </realm-name>
</login-config>
<security-constraint>
<web-resource-collection>
<web-resource-name> Inscription Admin </web-resource-name>
<url-pattern>/admin/*</url-pattern>
</web-resource-collection>

<auth-constraint>
<role-name>ADMIN</role-name>
</auth-constraint>
</security-constraint>

© 2009, F. Boyer 73
 Exemple de gestion de sécurité
déclarative

…
@DeclareRoles(“BUYER”, “ADMIN”)
@Stateless
...
public class InscriptionBean implements Inscription {

@RolesAllowed(“ADMIN”)
public void desenregistre(String nom) {
...
}
@PermitAll
public void enregistre(String nom) {
...
}

© 2009, F. Boyer 74
 Conclusion

Une des solutions industrielles les plus abouties

u Prise en charge des contraintes techniques
u Gestion du packaging et du déploiement
u Spectre fonctionnel large

Vers une stabilisation des spécifications

u Capitalisation importante sur Corba
u Support XML / Web Services (Java EE 1.4 = 1000 pages de « tutorial »)
v L'interface fournie par un session bean peut être exposée comme un
Web Service

Problèmes de maturité
u Persistance (co-existance avec JDO)
u Modèle de composants (manque d’homogénéité, problèmes avec gestion
de l’héritage)

© 2009, F. Boyer 75
 Plus d’information…

http://java.sun.com/
http://www.theserverside.com/
http://developer.java.sun.com/developer/technicalArti
cles/J2EE/
http://developer.java.sun.com/developer/onlineTrainin
g/J2EE/
http://www.triveratech.com/
http://jonas.objectweb.org/

© 2009, F. Boyer 76