Développement N-Tiers

La plate-forme Java EE
Extrait du livre Développements n-tiers avec Java EE
Par Jérôme Lafosse - mlny84 (traducteur)
Date de publication : 26 janvier 2012
Cet article est un extrait gratuit de l'ouvrage Développements n-tiers avec Java EE,
Chapitre 1 : la plate-forme Java EE. On y présente les composants, les conteneurs, les API
et les services de Java EE.
La plate-forme Java EE par Jérôme Lafosse
1 - Présentation et historique...................................................................................................................................... 3
2 - Composants et architectures Java EE.................................................................................................................. 4
2-A - Les composants clients ou tiers Client......................................................................................................... 5
2-A-1 - Les clients Web.................................................................................................................................... 5
2-A-2 - Les clients Applets............................................................................................................................... 5
2-A-3 - Les applications clientes...................................................................................................................... 5
2-B - Les composants Web ou tiers Web..............................................................................................................6
2-C - Les composants métier ou tiers Métier........................................................................................................ 6
3 - Les conteneurs Java EE........................................................................................................................................8
4 - API et services Java EE......................................................................................................................................10
4-A - Java Servlet (Technologie Java EE - Conteneur Web).............................................................................. 10
4-B - JavaServer Pages (JSP) (Technologie Java EE - Conteneur Web)........................................................... 10
4-C - JavaServer Pages Standard Tag Library (JSTL) (Technologie Java EE - Conteneur Web)....................... 10
4-D - JavaServer Faces (JSF) (Technologie Java EE - Conteneur Web)........................................................... 10
4-E - Java DataBase Connectivity (JDBC) (Technologie Java SE - Conteneur Web, Conteneur EJB, Conteneur
Application)........................................................................................................................................................... 10
4-F - Java Persistence API (JPA) (Technologie Java SE - Conteneur Web, Conteneur EJB et Conteneur
Application)........................................................................................................................................................... 11
4-G - Java Transaction API (JTA) (Technologie Java EE - Conteneur Web, Conteneur EJB)............................ 11
4-H - Enterprise JavaBeans (EJB) (Technologie Java EE - Conteneur EJB)......................................................11
4-I - Java Message Service API (JMS) (Technologie Java EE � Conteneur Web, Conteneur EJB et Conteneur
Application)........................................................................................................................................................... 11
4-J - JavaMail (Technologie Java SE - Conteneur Web, Conteneur EJB).......................................................... 11
4-K - Java Authorization Service Provider Contract for Containers (JACC) (Technologie Java EE - Conteneur
Web, Conteneur EJB).......................................................................................................................................... 11
4-L - Java Authentication Service Provider Interface for Containers (JASPIC) (Technologie Java EE - Conteneur
Web, Conteneur EJB).......................................................................................................................................... 12
4-M - Java Authentication and Authorization Service (JAAS) (Technologie Java EE - Conteneur Web, Conteneur
EJB)...................................................................................................................................................................... 12
4-N - Java API for XML Registries (JAXR) (Technologie Java EE - Conteneur Web, Conteneur EJB, Conteneur
Application)........................................................................................................................................................... 12
4-O - Java API for XML Processing (JAXP) (Technologie Java SE - Conteneur Web, Conteneur EJB, Conteneur
Application)........................................................................................................................................................... 12
4-P - Java Architecture for XML Binding (JAXB) (Technologie Java SE - Conteneur Web, Conteneur EJB,
Conteneur Application)......................................................................................................................................... 12
4-Q - Java API for XML Web Services (JAX-WS) (Technologie Java SE - Conteneur Web, Conteneur EJB,
4-R - Java API for RESTful Web Services (JAX-RS) (Technologie Java EE - Conteneur Web, Conteneur
EJB)...................................................................................................................................................................... 12
4-S - Java Naming and Directory Interface (JNDI) (Technologie Java SE - Conteneur Web, Conteneur EJB,
4-T - JavaBeans Activation Framework (Technologie Java SE - Conteneur Web, Conteneur EJB, Conteneur
Application)........................................................................................................................................................... 13
-2-
Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par
les droits d'auteur. Copyright ® Jérôme Lafosse. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans
l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts. Cette page est déposée à la SACD.
http://jlafosse.developpez.com/java/developpement-n-tiers/plate-forme-java-EE/
1 - Présentation et historique
Dans le monde actuel de l'informatique et des technologies Internet, les applications sont de plus en plus
conséquentes, rapides et doivent être réalisées en un minimum de temps et de coût. Le triptyque de gestion de projets
Délais-Moyens-Objectifs est toujours d'actualité et demande aux sociétés informatiques de créer des applications
dans un temps donné avec les ressources adaptées dans un souci de productivité. Sun Microsystems, désormais
Oracle Corporation, propose pour cela la plate-forme Java Enterprise Edition ou Java EE, véritable référence pour le
développement d'applications d'envergure et supportant en standard la programmation, la persistance des données,
les transactions, la sécurité ou encore le déploiement de projets sur serveur applicatif.
Oracle Corporation est une entreprise américaine créée à la fin des années 70. Sun
Microsystems, éditeur de logiciels, était à l'origine du langage Java et des technologies
Java EE. Le 20 avril 2009, Oracle rachète Sun Microsystems. Ainsi tout au long de
l'ouvrage ces noms d'entreprises seront utilisés.
La plate-forme Java EE (Enterprise Editio, anciennement J2EE) propose un développement simplifié, rapide et
robuste reposant désormais sur la configuration par annotations, directement dans les fichiers source. La sortie de
Java EE version 6 en 2009 correspond à l'anniversaire des dix ans de la plate-forme. La première version standard
J2EE 1.2 a été développée par Sun en 1999 et contenait 10 spécifications ou Java Specification Requests (JSR).
Les Enterprises JavaBeans (EJB) permettaient de gérer la couche métier d'accès aux données alors que les Servlets
et JavaServer Pages (JSP) permettaient de développer les applications serveur. La version J2EE 1.3 sortie en 2001
n'apportait pas de nouveautés essentielles mais plutôt des améliorations de la plate-forme à la suite des demandes
utilisateur, comme la configuration par fichier XML.
La version J2EE 1.4 proposait 20 spécifications lors de sa sortie fin 2003. Cette version apportait le support des
services Web et des EJB version 2.1. Mais cette version conséquente était difficile à utiliser, tester et déployer.
Les développements par couches, de type Modèle Vue Contrôleur (MVC), ne facilitent pas la compréhension de
l'ensemble, et les technologies Servlet et JSP ne sont pas adaptées pour un développement rapide. En réponse à
cela, quelques frameworks ou outils spécialisés voyaient le jour, comme Struts et Spring pour la partie développement
serveur, et Hibernate ou TopLink pour la persistance.
La version Java EE 5 sortie en 2006 proposait 23 spécifications et apportait une réponse à cela en proposant
désormais un outil de développement côté serveur adapté au design pattern MVC, nommé JavaServer Faces. Cette
nouvelle version était une étape majeure pour la plate-forme Java EE qui s'orientait vers la simplicité, en proposant
les EJB 3 associés à JPA (Java Persistence API) pour la persistance des données, JAX-WS (Java API for XML based
Web Services) 2.0 pour les services Web en lieu et place de JAX-RPC (Java API for XML based RPC) et surtout le
principe des annotations Java 5 pour la configuration des applications (configuration du déploiement, persistance,
EJB ou autres) en remplacement des nombreux fichiers XML.
Désormais, la version Java EE 6 sortie en 2009 propose 28 spécifications et se concentre essentiellement sur la
facilité d'utilisation de la plate-forme pour le développement, les tests et le déploiement. Cette nouvelle mouture
propose une simplification des EJB avec la version 3.1, l'utilisation abondante des annotations pour faciliter le
développement et la sortie de JAX-RS (Java API for RESTful Web Services) 1.1 pour le développement de services
Web.
Java EE est désormais un standard utilisé par de nombreuses sociétés à travers le monde professionnel et celui
de l'Open Source. Plusieurs outils peuvent être associés à Java EE comme les serveurs d'applications (GlassFish,
Websphere, Weblogic, JBoss...), des frameworks de développement (Struts, Spring...), ou encore des outils de
persistance (EclipseLink, Hibernate...).
Cette dernière mouture de la plate-forme Java EE version 6 propose les principales nouveautés :
• L'API JAX-RS.
• L'injection de dépendances et de ressources avec Contexts and Dependency Injection (CDI).
-3-
• L'interface d'authentification pour le conteneur.

• Les nouveaux composants EJB 3.1 qui facilitent encore leur utilisation.
• La nouvelle version des Servlets (3.0) et des JavaServer Pages (2.2).
• Une nouvelle API JavaServer Faces (2.0) (JSF) pour la couche ou tiers Web.
2 - Composants et architectures Java EE
Les développements Java EE reposent sur un découpage en couches ou tiers, nous parlons alors d'applications
multi-tiers. Trois grands tiers sont représentés :
• La couche présentation (tiers Web).

• La couche métier (tiers Métier ou tiers Business).
• La couche stockage des informations (tiers Enterprise Information System).
Les applications sont découpées en plusieurs composants réalisant des fonctionnalités spécifiques et installés
sur une machine serveur ou sur plusieurs tiers distribués. Les composants Java EE sont des unités autonomes
assemblées dans une application Java EE composée de classes Java et de fichiers, et communiquant avec d'autres
composants. De même, le code métier écrit est indépendant de la couche de présentation, ce qui est utile pour
changer cette dernière ou pour l'afficher sur divers supports (Internet, Téléphonie...).
D'après le schéma ci-après, la spécification Java EE définit les composants suivants :
• Les composants Clients ou tiers Client sont des applications clientes (logiciel installé en local ou navigateur
Web ou Applets) s'exécutant sur la machine des utilisateurs.
• Les composants Web ou tiers Web sont les technologies Servlets, JavaServer Pages et Java- Server Faces.
• Les composants métier ou tiers Métier sont des composants Enterprises JavaBeans (EJB) représentant la
logique métier, s'exécutant sur le serveur Java EE et dialoguant avec la couche de stockage (EIS : Enterprise
Information System).
Architecture Java EE standard
Une application Java EE multi-tiers correspond à un ensemble de couches. Souvent considérée comme étant une
architecture trois tiers, celle-ci est distribuée de manière physique sur trois machines :
• La machine des clients.

• Le serveur d'applications Java EE.
• Le serveur de base de données ou de stockage.
-4-
2-A - Les composants clients ou tiers Client
La plate-forme Java EE propose trois types de clients : les clients Web, les Applets et les applications clientes riches
type Java SE.
2-A-1 - Les clients Web
Un client Web consiste en des pages Web de différents types (HTML, XHTML, XML, JavaScript ou autres) générées
à partir de composants exécutés côté serveur dans un conteneur Web et capables de répondre aux requêtes HTTP
en provenance du navigateur Internet. Ces programmes côté serveur sont représentés en Java EE par les Servlets,
pages JSP et JSF. Ces programmes serveur ne réalisent en général pas directement les accès aux bases de données
mais s'occupent de la logique applicative.
2-A-2 - Les clients Applets
Les Applets sont des interfaces graphiques Java SE exécutées dans un navigateur Web. Ces applications utilisent
une interface graphique évoluée de type SWING et sont exécutées dans une machine virtuelle Java installée dans
le navigateur. Cependant cette technique est plus contraignante à maintenir, requiert des accès et des droits pour
la sécurité et nécessite un plug-in pour les navigateurs. Les clients Web sont donc préférables pour la création du
tiers Client.
2-A-3 - Les applications clientes
Une application de type client est un logiciel riche, qui s'exécute sur la machine du client et fournit un ensemble
de services aux utilisateurs par l'intermédiaire d'une interface graphique évoluée encore appelée Graphical User
Interface (GUI).
Les clients et le serveur dialoguent ensemble par l'intermédiaire d'un composant standardisé nommé JavaBean
ou classe Plain Old Java Object (POJO). Un composant JavaBean peut être vu comme la plus petite unité de
communication entre les couches ou tiers Java EE. Les composants JavaBeans sont des objets, instances de
classes POJO, composés de propriétés et de leurs accesseurs associés pour accéder aux données. Les JavaBeans
s'exécutent sur le serveur Java EE et dialoguent avec les clients ou avec la base de données (tiers EIS).
Ces applications riches sont développées avec les composants SWING en général, exécutées avec Java Web Start
ou Application Client Container (ACC) et déployées dans le projet Enterprise ARchive (EAR).
L'acronyme POJO est utilisé pour faire référence à la simplicité d'utilisation d'un objet
Java. Les JavaBeans (à ne pas confondre avec les EJB) sont des composants logiciels
simples réutilisables et manipulables. Pour être une classe JavaBean, celle-ci doit
respecter certaines conventions pour son utilisation, sa réutilisation et sa connexion
JavaBean : la classe doit être sérialisable (pour les sauvegardes et lectures), avoir un
constructeur par défaut (sans argument), et les propriétés des méthodes doivent être
accessibles via des méthodes (accesseurs).
-5-
Communication Java EE entre les différents tiers
La figure ci-dessus montre les différents types de clients utilisés dans une plate-forme Java EE. Les clients riches
de type application communiquent directement avec le tiers Métier alors que les clients de type navigateur Internet
communiquent à travers le tiers Web par l'intermédiaire de pages exécutées sur le serveur et générées par des
Servlets, JSP ou JSF.
2-B - Les composants Web ou tiers Web
Les composants Web Java EE sont des Servlets et/ou des pages JavaServer Pages et/ou des JavaServer Faces. Les
Servlets sont des classes Java, capables d'intercepter et de gérer les requêtes du protocole HTTP. Les pages JSP
sont des documents textuels exécutés comme des Servlets apportant une solution simplifiée pour la programmation
de pages Web. La technologie JavaServer Faces est construite à partir de Servlets et fournit un framework de
développement pour accélérer la création d'applications Web.
2-C - Les composants métier ou tiers Métier
Les composants métier ou tiers Métier représentent la couche business, avec les données du système, et sont de
deux types :
• Les entités beans (entity bean ou bean entity) peuvent être exécutées par un conteneur léger (pas forcément
un serveur Java EE) et permettent de réaliser la persistance des données à partir des JavaBeans et de Java
Persistence API (JPA).
• Les Enterprise JavaBeans offrent des possibilités plus riches comme la gestion des transactions, les accès
directs par clients riches ou encore la gestion automatique des sessions utilisateur, mais sont exécutés sur un
conteneur lourd, c'est-à-dire compatible Java EE.
-6-
Tiers Web et Tiers Métier Java EE
La figure ci-dessus présente le découpage du tiers Métier avec les entités beans et les Enterprise JavaBeans. Les
informations sont reçues par un client léger au travers du tiers Web et des pages Internet, ou directement depuis
un client lourd. Ces informations sont ensuite envoyées sous la forme de JavaBeans, images des informations en
provenance des clients et à destination du tiers Métier pour stockage. Dans le sens inverse, les Enterprise JavaBeans
(EJB) lisent les données en provenance du système de stockage, réalisent des opérations si nécessaire, et sont
envoyés au client.
La partie stockage des données, nommée tiers Enterprise Information System (EIS) est directement liée au tiers
Métier et correspond dans la majorité des cas, aux systèmes de gestion de bases de données (Derby, MySQL,
PostgreSQL, Oracle ou autres) ou à un enterprise resource planning (ERP), un gros système transactionnel ou
n'importe quel système de stockage évolué.
Architecture évoluée Java EE
La figure précédente représente une architecture optimisée d'une application Java EE. Trois types de clients sont
représentés (client Web, client Applet et client Application), le serveur Web utilisé en frontal est le serveur Internet de
-7-
référence : Apache. Ce serveur renvoie indirectement les résultats des pages dynamiques exécutées par le serveur
d'applications Java EE, et directement les contenus statiques de type images, CSS, JavaScript ou autres.
La partie contrôleur contient la logique de traitement. Cette couche dialogue avec les différents types d'Enterprise
JavaBeans (Stateless Bean, Stateful Bean et Message Driven Beans). La couche métier est gérée par le standard
JPA, permettant de paramétrer les classes ainsi que l'outil de persistance EclipseLink, le tout configuré par le fichier
persistence.xml.
3 - Les conteneurs Java EE
Les serveurs Java EE proposent plusieurs types de conteneurs (containers) pour chaque type de composant. Chaque
conteneur a un rôle bien défini et offre un ensemble de services pour les développeurs :
• L'annuaire de nommage d'accès aux ressources : Java Naming and Directory Interface (JNDI) est une
interface unifiée de gestion de nommage pour les services et l'accès à ceux-ci par des applications.
• L'injection dynamique de ressources.
• La gestion des accès aux bases de données.
• Le modèle de gestion de la sécurité.
• Le paramétrage des transactions.
Les exécutions et développements sont donc directement liés au conteneur utilisé et une application Java EE côté
tiers Web ne sera pas programmée comme une application côté tiers EJB, par exemple. Les accès aux ressources
nommées, les accès aux bases de données ou encore l'injection dynamique de ressources seront différents. Pour
résumer, un conteneur permet de gérer le cycle de vie et la gestion des ressources.
Une application Java EE de type Web nécessite un conteneur Web pour son exécution alors qu'une application
utilisant les EJB nécessite un conteneur EJB pour son exécution. Chaque conteneur propose un ensemble de services
avec ses avantages et ses contraintes.
-8-
Serveur Java EE et conteneurs
L'architecture Java EE présentée dans la figure ci-dessus est découpée selon plusieurs domaines ou services,
appelés des conteneurs ou containers. D'après les précédents schémas, il existe en Java EE cinq types de
conteneurs :
• Java EE serveur, logiciel fournisseur du conteneur Web et EJB.

• Web Container ou conteneur Web, capable d'exécuter des pages JSP, Servlets et programmes JSF
(implémentation JSF nécessaire). Ces composants s'exécutent avec le conteneur serveur Java EE. Ce
conteneur supporte les protocoles HTTP et HTTPS et dialogue avec différents types de clients (navigateur,
application).
• EJB Container ou conteneur EJB, responsable de la couche métier et de l'exécution des EJB. Ce conteneur
fournit le mécanisme de gestion des EJB, la gestion de leur cycle de vie, les transactions, le service de
nommage JNDI et la possibilité des déclenchements asynchrones.
• Applet Container ou conteneur Applet, responsable de l'environnement d'exécution des Applets Java.
Ce type d'application consiste en un navigateur Web et le plug-in Java, lancés en même temps sur le poste
client. Ces programmes sont lancés dans un « bac à sable » aussi nommé « sandbox » afin de gérer la
sécurité des accès sur le poste client.
• Application Client Container (ACC) ou conteneur des applications clientes, permet l'exécution
d'applications Java SE. L'application de type client et son conteneur sont lancés sur le client en simultané.
Le conteneur d'applications client (ACC) propose une bibliothèque de classes, un système de gestion de
sécurité et le service de nommage JNDI pour les applications Java SE. La communication directe entre le
conteneur client et le conteneur EJB est réalisée avec les technologies RMI-IIOP, alors que la communication
avec le conteneur Web est réalisée avec le protocole HTTP pour les services Web, par exemple.
-9-
Ces différents types de conteneurs et leur utilisation seront présentés dans la suite de cet ouvrage mais il est
primordial de comprendre leur fonctionnement avant de commencer à développer.
4 - API et services Java EE
La plate-forme Java EE est la plus importante proposée par Oracle et regroupe les services de la plate-forme Java
SE. Les services et API Java EE sont donc associés à une plate-forme et un ou plusieurs conteneurs. Les conteneurs
étudiés précédemment proposent plusieurs services pour le développement d'applications. En tant que développeur,
nous pouvons utiliser la totalité des services ou bien au contraire sélectionner uniquement les techniques nécessaires
à la réalisation du projet. Chaque service s'exécute dans un des cinq conteneurs étudiés précédemment et offre
d'autres méthodes en fonction de ce conteneur.
4-A - Java Servlet (Technologie Java EE - Conteneur Web)
Ce service Java EE s'exécute dans le conteneur Web et propose un ensemble de classes de gestion des échanges
HTTP de type requête-réponse. Avec la nouvelle version de Java EE, la technologie Servlet 3.0 facilite la configuration
et supporte les annotations ou encore les traitements asynchrones.
4-B - JavaServer Pages (JSP) (Technologie Java EE - Conteneur Web)
La technologie JavaServer Pages (JSP) s'exécute dans le conteneur Web et utilise le mécanisme de génération de
Servlets à partir de documents textuels. Les JSP 2.2 contiennent des données statiques de type HTML, XHTML,
JavaScript ou autres, et des balises ou tags JSP nommés JSTL correspondant à du code Java.
4-C - JavaServer Pages Standard Tag Library (JSTL) (Technologie Java EE - Conteneur Web)
La technologie JavaServer Pages Tag Library (JSTL) est encapsulée dans des pages JSP et propose une librairie
de balises XHTML standardisées. Ces balises proposent de gérer les conditions et itérations, l'internationalisation,
les affichages HTML ou encore l'accès aux bases de données.
4-D - JavaServer Faces (JSF) (Technologie Java EE - Conteneur Web)
La technologie JavaServer Faces s'exécute dans le conteneur Web et correspond à la réponse du consortium Java
EE en matière de framework de développement côté serveur. JSF 2.0 est un framework de développement de projets
Web proposant la construction rapide de code serveur, la validation des entrées, la gestion des modèles objets,
la configuration de la navigation, les conversions de données, l'utilisation d'annotations, les balises et technologies
d'affichages de données pour la partie Vue, le support de la technologie Ajax en natif et bien d'autres fonctionnalités.
JSF est orienté composant et repose sur un cycle de vie proche du développement d'applications Java SE (écouteurs,
évènements...).
4-E - Java DataBase Connectivity (JDBC) (Technologie Java SE - Conteneur Web, Conteneur
EJB, Conteneur Application)
La technologie Java DataBase Connectivity (JDBC) permet de gérer les commandes SQL et les dialogues avec
les différents SGBD relationnels. JDBC est utilisée lorsque nous devons accéder à une base de données dans
une Servlet, page JSP, page JSF ou autres. L'API JDBC propose un ensemble de classes et interfaces pour se
connecter aux différents SGBD du marché mais également les paquetages de manipulation des données. JDBC est
une technologie sous-jacente à JPA.
- 10 -
4-F - Java Persistence API (JPA) (Technologie Java SE - Conteneur Web, Conteneur EJB et
Conteneur Application)
Java Persistence API (JPA) est un standard Java utilisé pour la persistance des données. Ce mécanisme de
persistance utilise le principe de mapping objet/relationnel et relationnel/objet afin de permettre de stocker les objets
dans la base de données et inversement de pouvoir lire les données relationnelles et les transformer en objets.
L'API Java Persistence 2.0 propose les services suivants :
• La gestion de la persistance.
• Un langage de requêtage évolué : Java Persistence Query Language (JPQL).
• Un mécanisme de mapping objet/relationnel ORM à partir de métadonnées (fichiers XML ou annotations).
• Une API à typage fort pour le requêtage.
4-G - Java Transaction API (JTA) (Technologie Java EE - Conteneur Web, Conteneur EJB)
Java Transaction API (JTA) fournit un standard de gestion des transactions pour une architecture Java EE et propose
par défaut le mode autocommit pour la gestion des transactions, mais offre également les mécanismes de commit
et rollback pour une optimisation des transactions. Cependant, cette API est rarement utilisée directement par le
développeur, mais plutôt en association avec d'autres API.
4-H - Enterprise JavaBeans (EJB) (Technologie Java EE - Conteneur EJB)
Les composants Enterprise JavaBeans s'exécutent dans le conteneur dédié EJB et correspondent à la couche ou
tiers Métier de l'application. Ces EJB 3.X sont des classes composées de champs et de méthodes d'accès. Java EE
propose deux familles d'EJB : les session beans et message-driven beans.
Les session beans représentent les conversations entre le client et le serveur, qu'elles soient avec ou sans état. Un
Message-Driven Bean (MDB) mélange un session bean et un écouteur de message permettant ainsi la réception
asynchrone de messages. Ces services utilisent Java Message Service (JMS) pour leur fonctionnement. La nouvelle
version de Java EE offre la possibilité d'empaqueter les EJB directement dans des archives WAR (Web ARchive),
l'utilisation du Design Pattern Singleton dans les session beans et la possibilité d'utiliser des EJB légers avec un
serveur Java ne proposant pas le conteneur EJB.
4-I - Java Message Service API (JMS) (Technologie Java EE � Conteneur Web, Conteneur
EJB et Conteneur Application)
Java Message Service API (JMS) est le standard permettant aux applications Java EE de créer, d'envoyer, de recevoir
et de traiter les messages asynchrones en mode point à point ou multi destinations.
4-J - JavaMail (Technologie Java SE - Conteneur Web, Conteneur EJB)
Les applications Java EE utilisent l'API JavaMail pour l'envoi d'e-mails. L'API JavaMail fournit pour cela un ensemble
de classes de gestion.
4-K - Java Authorization Service Provider Contract for Containers (JACC) (Technologie Java
EE - Conteneur Web, Conteneur EJB)
La sécurité des services est regroupée sous le terme Java Authentification and Authorization Service (JAAS)
et permet de gérer l'authentification et les accès clients. L'API Java Authorization Service Provider Contract for
Containers (JACC) définit un contrat entre une application Java EE et un fournisseur de services. La spécification
Java ACC définit les classes du paquetage java.security.Permission pour la gestion des autorisations.
- 11 -
4-L - Java Authentication Service Provider Interface for Containers (JASPIC) (Technologie
Java EE - Conteneur Web, Conteneur EJB)
L'API Java Authentication Service Provider Interface for Containers (JASPIC) propose une interface de service
d'authentification pour les dialogues entre le client et le serveur.
4-M - Java Authentication and Authorization Service (JAAS) (Technologie Java EE - Conteneur
Web, Conteneur EJB)
La technologie Java Authentication and Authorization Service (JAAS) fournit les mécanismes d'authentification et
d'autorisation pour un groupe ou utilisateur spécifique lançant l'application. JAAS est une version du standard
Pluggable Authentication Module (PAM).
4-N - Java API for XML Registries (JAXR) (Technologie Java EE - Conteneur Web, Conteneur
Java API for XML Registries (JAXR) permet un accès au tiers Métier à travers le Web.
4-O - Java API for XML Processing (JAXP) (Technologie Java SE - Conteneur Web,
Conteneur EJB, Conteneur Application)
La plate-forme Java permet l'utilisation de configuration à base de fichiers au format XML. Les services de la
bibliothèque Java API for XML Processing (JAXP) permettent le support des documents XML en utilisant une
bibliothèque pour le parsage XML : Document Object Model (DOM) et Simple API for XML (SAX) ainsi qu'un
mécanisme de feuilles de style : Extensible Stylesheet Language Transformations (XSLT). JAXP permet aux
différentes applications Java de manipuler des documents XML, pour la description et le déploiement des applications,
indépendamment du processeur XML utilisé.
4-P - Java Architecture for XML Binding (JAXB) (Technologie Java SE - Conteneur Web,
L'API Java Architecture for XML Binding (JAXB) fournit un mécanisme simple de transformation d'objet en document
XML et inversement, pour une utilisation en Java. JAXB peut également être utilisée avec JAX-WS ou JAX-RS et
permet l'échange de messages avec l'utilisation des services Web.
4-Q - Java API for XML Web Services (JAX-WS) (Technologie Java SE - Conteneur Web,
L'API Java API for XML Web Services (JAX-WS) fournit un support des services Web et utilise pour cela l'API
JAXB (pour la transformation Objet/XML et XML/Objet) et l'API SOAP with Attachments API pour Java (SAA). La
bibliothèque JAX-WS remplace Java API for XML-based RPC (JAX-RPC) et propose un support des services Web en
utilisant le protocole SOAP. Les messages supportent les accès JNDI des composants et le principe de sérialisation/
désérialisation.
4-R - Java API for RESTful Web Services (JAX-RS) (Technologie Java EE - Conteneur Web,
Conteneur EJB)
L'API Java for RESTful Web Services (JAX-RS) permet le développement Web de services utilisant l'architecture
REpresentational State Transfer (REST). Une application JAX-RS est une application Web composée de classes
- 12 -
empaquetées dans une archive WAR fournissant un ensemble de services. JAX-RS permet d'exposer des classes
POJO sous forme de ressources REST manipulables via le protocole HTTP.
4-S - Java Naming and Directory Interface (JNDI) (Technologie Java SE - Conteneur Web,
L'API Java Naming and Directory Interface (JNDI) fournit un mécanisme de nommage de type annuaire pour l'accès
aux ressources. Ces ressources peuvent être de différents types mais le but est d'associer les objets à un nom (bind)
et de retrouver ces objets (lookup) dans un annuaire de nommage semblable à LDAP, DNS ou NIS. Nous pouvons
ainsi nommer une source de données de type base de données, un Enterprise JavaBean, une session JavaMail ou
autres. JNDI permet une utilisation et un accès depuis une application de type client, un EJB ou un composant Web.
Un composant conservé dans l'annuaire JNDI est accessible par l'intermédiaire de la

classe InitialContext sous le nom java:comp/env.
Avec l'arrivée massive des annotations depuis Java EE 5, le développeur n'a plus besoin
de faire des recherches JNDI, tout est implémenté en standard.
4-T - JavaBeans Activation Framework (Technologie Java SE - Conteneur Web, Conteneur

JavaBeans Activation Framework (JAF) est utilisé par l'API JavaMail pour la gestion des types MIME. JAF permet
de déterminer le type d'un ensemble de données encapsulées dans l'e-mail. L'API permet de déterminer le type et
de créer un JavaBean adapté en fonction de celui-ci.
La plate-forme Java EE propose également un outil de gestion (management) Java Management Extensions (JMX)
pour le contrôle des conteneurs et du serveur. Elle propose enfin un outil de gestion du déploiement afin de
standardiser le mécanisme de déploiement entre les produits Java EE et les applications.
Le tableau présenté ci-dessous récapitule les spécifications Java EE 6 définies dans la JSR-316 et contenant 28
spécifications.
Spécification Version JSR

Java EE 6 316
Tiers Web
JSF 2 314
JSP 2,2 245
JSTL 1,2 52
Servlet 3 315
Expression Language (EL) 1,2 245
Tiers Enterprise JavaBean
EJB 3,1 318
- 13 -

Développement N-Tiers

Transféré par

Informations du document

Titre original

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

Développement N-Tiers

Transféré par

Droits d'auteur :

Formats disponibles

La plate-forme Java EE

Extrait du livre Développements n-tiers avec Java EE

Par Jérôme Lafosse - mlny84 (traducteur)

Date de publication : 26 janvier 2012

• L'interface d'authentification pour le conteneur.

2 - Composants et architectures Java EE

• La couche présentation (tiers Web).

D'après le schéma ci-après, la spécification Java EE définit les composants suivants :

Architecture Java EE standard

• La machine des clients.

2-A - Les composants clients ou tiers Client

2-A-1 - Les clients Web

2-A-2 - Les clients Applets

2-A-3 - Les applications clientes

Communication Java EE entre les différents tiers

2-B - Les composants Web ou tiers Web

2-C - Les composants métier ou tiers Métier

Tiers Web et Tiers Métier Java EE

Architecture évoluée Java EE

3 - Les conteneurs Java EE

Serveur Java EE et conteneurs

• Java EE serveur, logiciel fournisseur du conteneur Web et EJB.

4 - API et services Java EE

4-A - Java Servlet (Technologie Java EE - Conteneur Web)

4-B - JavaServer Pages (JSP) (Technologie Java EE - Conteneur Web)

4-D - JavaServer Faces (JSF) (Technologie Java EE - Conteneur Web)

L'API Java Persistence 2.0 propose les services suivants :

4-H - Enterprise JavaBeans (EJB) (Technologie Java EE - Conteneur EJB)

4-J - JavaMail (Technologie Java SE - Conteneur Web, Conteneur EJB)

Un composant conservé dans l'annuaire JNDI est accessible par l'intermédiaire de la

4-T - JavaBeans Activation Framework (Technologie Java SE - Conteneur Web, Conteneur

Spécification Version JSR

Vous aimerez peut-être aussi