# Programmation JEE/Version imprimable

* Si vous imprimez cette page, choisissez « Aperçu avant impression » dans votre navigateur, ou cliquez sur le lien Version imprimable dans la boîte à outils, vous verrez cette page sans ce message, ni éléments de navigation sur la gauche ou en haut.
* Cliquez sur Rafraîchir cette page pour obtenir la dernière version du wikilivre.
* Pour plus d'informations sur les version imprimables, y compris la manière d'obtenir une version PDF, vous pouvez lire l'article Versions imprimables.
Une version à jour et éditable de ce livre est disponible sur Wikilivres, une bibliothèque de livres pédagogiques, à l'URL : https://fr.wikibooks.org/wiki/Programmation_JEE

# Présentation du JEE

* Présentation du JEE
* Le protocole HTTP
* Servlets
* Portlets
* JSP
* JSF
* JSTL
* JDBC
* EJB
* WildFly
* Configurer Eclipse
* Parcourir une API
Modifier ce modèle

## Présentation

JEE (Java Entreprise Edition) est la version entreprise de la plate-forme "Java" qui se compose de l'environnement "JSE" ainsi que de nombreuses API et composants destinés à une utilisation "côté serveur" au sein du système d'information de l'entreprise. Il s'agit donc d'une évolution du Java.
Dès son origine, Java a révolutionné plusieurs domaines de l'informatique, que ça soit la téléphonie, l'internet ou les applications d'entreprise. Par la suite, Sun avait réorganisé son offre autour de trois briques :
* Java Micro Edition (JME) qui cible les terminaux portables.
* Java Standard Edition (JSE) qui vise les postes clients.
* Java Entreprise Edition (JEE) qui définit le cadre d'un serveur d'applications et d'intégration.

## La plate-forme JEE

JEE (Java Entreprise Edition) est une norme qui va spécifier à la fois l'infrastructure de gestion de vos applications et les API des services utilisées pour concevoir ces applications.
Cette technologie se compose de :
* Servlets,
* Portlets,
* JSP : JavaServer Pages,
* JSF : JavaServer Faces,
* Bibliothèque JSTL,
* EJB : Enterprise JavaBeans,
* JNDI : API de connexion à des annuaires, notamment des annuaires LDAP, et espace de noms d’objet (ENC),
* JDBC : API de connexion à des bases de données,
* Java Message Service (JMS) : API de communication asynchrone par message,
* JCA : API de connexion, notamment à des PGI,
* JavaMail : API de gestion des mails,
* JMX : Extension d’administration des applications,
* JPA : API de gestion de la rémanence des données,
* JTA : API de gestion des transactions,
* Java API for XML Processing (JAXP) : API d’analyse XML,
* JAXM : API de communication asynchrone par XML,
* JAX-RPC : API de communication synchrone par XML, par exemple à l’aide du protocole SOAP,
* JAXB : API de sérialisation par XML,
* JAXR : API de gestion des registres XML, permettant d’enregistrer des Web Services en ebXML,
* Java RMI : API de communication distante entre des objets Java,
* Java IDL : API de communication entre objets Java et objets non-Java, via le protocole CORBA.
La plateforme JEE est essentiellement un environnement fournissant :

### Environnement d'exécution de JEE

Un des avantages majeurs de JEE est de faire abstraction de l'infrastructure d'exécution. En effet, JEE spécifie les rôles et les interfaces pour les applications, ainsi que l'environnement d'exécution dans lequel les applications sont déployées. Ceci permet aux développeurs d'application de ne pas avoir à reprogrammer les services d'infrastructure.

### Les API JEE

* L'API JEE 5 est [ici]
* L'API JEE 6 est [ici]
Les API sont des Outil logiciel, constitué d'un ensemble de modules dotés de fonctions communes, et qui permet de produire automatiquement des applications Java ou des applets personnalisés.
Parmi ses composants les plus courants, on trouve :
* EJB (Enterprise JavaBeans Technology)
L'EJB, environnement d'exécution fournissant des services (sécurité, communications, cycle de vie...), définit comment les composants serveurs sont écrits et fournit un lien standard entre le composant et l'application qui l'utilise. Un client n'accède donc jamais directement à un composant et doit pour cela passer par une interface locale et une interface distance. L'interface locale décrit le cycle d'existence du composant en définissant des méthodes permettant de le trouver, de le créer, de le détruire. Et L'interface distante spécifie les méthodes que ce composant présente au monde extérieur.
* JDBC (Java Database Connectivity)
Une API qui permet aux programmes Java d'interagir avec les bases de données relationnelles (type SQL).
* Servlet et JSP (JavaServer Pages)
Composants réseau qui sont destinés à une exécution orientée question / réponse. La technologie JSP est une extension de la notion de Servlet permettant de simplifier la génération de pages web dynamiques. JSP est un concurrent direct de l'ASP et du PHP. Un servlet est un composant côté serveur, écrit en Java, dont le rôle est de fournir une trame générale pour l'implémentation de paradigmes "requête / réponse". Ils remplacent les scripts CGI tout en apportant des performances bien supérieures.
* JMS (Java Message Service)
Permet à 2 composants d'applications JEE de créer, envoyer et recevoir des messages.
* JTA (Java Transaction API) et JTS (Java Transaction Service)
Les spécification JTA et JTS permettent aux composants d'être renforcés par un support des transactions.
* JavaMailTM Technology
Permet l'envoi d'e-mails d'une manière indépendante de la plate-forme et du protocole.
* JAF (JavaBeans Activation Framework)
Utilisé par JavaMail, JAF permet de déterminer le type d'un flux de données, son accès, et les opérations possibles sur lui.
* JAXP (Java API for XML)
Cette API permet de manipuler, créer et modifier des documents XML. JAXP supporte les parseur DOM (Document Object Model) et SAX (Simple API for XML).
* JEE Connector
Facilite les connexions aux plates-formes autres que JEE.
* JAAS (Java Authentication and Authorization Service)
Permet aux applications JEE d'authentifier et d'autoriser l'exécution par les utilisateurs.
* JNDI
Extension Java standard qui fournit une API permettant de localiser et d'utiliser des ressources : il peut y avoir un appel à des services CORBA, DNS, NIS, LDAP...

## Développement d'application JEE

Une application JEE commence par la création de composants JEE.
Ces composants sont ensuite regroupés en modules auquel on associe des descripteurs de déploiement.
Ces modules JEE peuvent ensuite être déployés comme application à part entière ou être assemblés avec un descripteur de déploiements JEE et être déployés en tant qu'application JEE.

# Le protocole HTTP

* Présentation du JEE
* Le protocole HTTP
* Servlets
* Portlets
* JSP
* JSF
* JSTL
* JDBC
* EJB
* WildFly
* Configurer Eclipse
* Parcourir une API
Modifier ce modèle
Les clients JEE utilisent le protocole HTTP pour communiquer avec un serveur JEE. HTTP définit les demandes qu'un client peut envoyer à un serveur et les réponses que le serveur peut envoyer en réponse. Chaque demande contient une URL, qui est une chaîne qui identifie un composant Web ou d'un objet statique, comme une page HTML ou un fichier image.
Le serveur JEE convertit une requête HTTP à un objet de requête HTTP et la remet à la composante Web identifiées par l'URL de requête. Le composant Web remplit un objet de réponse HTTP, le serveur qui convertit en réponse HTTP et l'envoie au client.

## Requêtes HTTP

Exemple :
Une requête HTTP se compose d'une méthode, une URL, les champs d'en-tête et un corps. HTTP 1.1 définit les méthodes demande suivante:
| GET | Récupère la ressource identifiée par l'URL. |
| HEAD | Retourne les en-têtes de la ressource identifiée par l'URL. |
| POST | Envoi des données à traiter par la ressource spécifiée par l'URL. |
| PUT | Stocker une ressource sous l'URL indiquée. |
| DELETE | Supprime la ressource identifiée par l'URL. |
| OPTIONS | Retourne les méthodes HTTP et options prises en charge par le serveur pour l'URL spécifiée. |
| TRACE | Retourne les en-têtes envoyés avec demande de traces pour l'URL spécifiée. |
HTTP 1.0 ne comprend que les méthodes GET, HEAD et POST. Bien que les serveurs JEE n'ont besoin de supporter que le protocole HTTP 1.0, en pratique, de nombreux serveurs, y compris ceux du SDK JEE, prennent en charge HTTP 1.1.

## Les réponses HTTP

Exemple :
Une réponse HTTP contient un code de résultat, les champs d'en-tête et un corps. Le protocole HTTP prévoit le code de résultat et de tous les champs d'en-tête à retourner avant tout le contenu du corps.
Certains codes d'état couramment utilisés sont les suivants:
    200 : Indique que la ressource demandée à été trouvée
    404 : Indique que la ressource demandée n'est pas disponible
    401 : Indique que la demande requiert une authentification HTTP
    500 : Indique une erreur dans le serveur HTTP qui a empêché de satisfaire la demande
    503 : Indique que le serveur HTTP est temporairement surchargé, et incapable de gérer la demande

### Contenu de la réponse

Le contenu de la réponse suit la liste des en-têtes HTTP. Sa taille peut être connue à l'avance et spécifiée dans le champ Content-Length. C'est le cas des fichiers envoyés directement comme réponse (HTTP statique).
Pour les réponses dynamiques (générées par un script par exemple), la taille n'est pas connue à l'avance. Le serveur peut stocker en mémoire le contenu afin de connaitre la taille. Cependant ce stockage doit avoir une limite afin de ne pas être à cours de mémoire pour les réponses dynamiques de grande taille.
Dans ce cas, si le client le supporte, le serveur peut utiliser l'encodage en morceaux (chunked). Le serveur ne spécifie pas la taille (donc pas de Content-Length spécifié), et fournit le contenu au client par morceaux de taille fixe spécifiée avant chaque morceau. Le dernier morceau comportant une taille nulle pour indiquer la fin de la réponse.

# Servlets

* Présentation du JEE
* Le protocole HTTP
* Servlets
* Portlets
* JSP
* JSF
* JSTL
* JDBC
* EJB
* WildFly
* Configurer Eclipse
* Parcourir une API
Modifier ce modèle
Un servlet est une classe JAVA côté serveur qui reçoit des données HTTP et qui opère un ou des traitements et devant respecter les contraintes de ce protocole HTTP.

## Les servlets
### Exemple de servlet
#### Description

On remarque deux méthodes dans cette classe : doGet et doPost, la première répond par HTTP à l’envoi d'une requête GET, la seconde à l'envoi d'une requête POST. Comme l'on veut que dans les deux cas la servlet réponde, doPost renvoie à doGet.

### Déployement sous TomCat

* Placer la classe compilée avec son package dans le répertoire classes de WEB-INF du répertoire web de travail (ici : webTest)
* Modifier le web.xml de WEB-INF en ajoutant :
Le WEB-INF comprend donc :

### Appel de la servlet

http://localhost:999/webTest/Hello
Résultat dans le navigateur :

### Anatomie de l'url

[Protocol://][DNS]:[PORT]/[RootEntryDirectory]/[ServletName]

### Méthodes d'informations sur l'URL

Exemple dans la servlet :
Cet appel : http://localhost:999/webTest/Hello

### Méthodes d'ajout des en-têtes

Les en-têtes HTTP sont utilisés pour ajouter à la réponse des informations supplémentaires.

### Élaboration du corps de la réponse

* (PrintWriter)getWriter permet de transferer du texte dans le corps de la réponse HTTP
* (ServletOutputStream)getOutputStream permet de transférer du binaire dans le corps de la réponse HTTP
Ne jamais utiliser ces deux objets simultanément sous peine d'une exception IllegalStateException
Voici un exemple d'envoi binaire:
* Dans cet exemple nous faisont appel à processRequest(request, response) pour obtenir invariablement le traitement en get et post

### Élaborer une réponse HTTP

Les codes de status sont répartis en 5 catégories :
    1XX : informatif
    2XX : succès
    3XX : redirection
    4XX : erreur client
    5XX : erreur serveur
Le détail des codes est disponible chez http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html
* setStatus(int rc)
* sendError(int sc, String message)
... permettent de changer le status d'erreur de la page. Pour exemple nous allons générer une erreur serveur.

## Autres ressources
### RequestDispatcher
#### include

Inclusion d'une ressource externe.

#### forward

Transfert du resultat d'une servlet vers une autre ressource.
La ressource de destination : result.jsp

### Redirection

Le serveur informe le navigateur de faire une requête HTTP vers l'url indiquée.

#### redirect
## Filtres

Les filtres ajoutent un traitement sur une requête HTTP avant qu'elle soit reçue par une servlet ou sur la réponse HTTP avant qu'elles soient transmises.
Leurs roles sont :
* Contrôle des accès
* Journalisation des accès
* Décompression des données
* Décryptage
* Conversion des données
Plusieurs réponses peuvent être exécutées successivement. La classe filtre doit implémenter javax.servlet.Filter.

## Évènements

Les évènements nous informent des opérations de l'application comme l'instanciation et la destruction des objets.
* Évènements liés à l'application : Ceux déclenchés par servlet context.
* Évènements liés aux sessions : Les classes de ce type doivent implémenter HttpSessionListener, HttpSessionAttributeListener.

## Synchronisation des servlets

Cette synchronisation permet d'éviter au serveur d'utiliser deux threads en même temps, par exemple, lorsque deux instances de la même classe appellent une même méthode par deux clients différents. synchronized(this) doit être appliquées aux traitements critiques comme les compteurs.

# JSP

* Présentation du JEE
* Le protocole HTTP
* Servlets
* Portlets
* JSP
* JSF
* JSTL
* JDBC
* EJB
* WildFly
* Configurer Eclipse
* Parcourir une API
Modifier ce modèle
Java Server Pages ou JSP est une technologie basée sur Java permettant de créer des pages web dynamiques à l'aide du langage java en l'intégrant au contenu HTML de la page à l'aide de scriptlets. Le code source est ensuite pré-compilé en Java Applets, puis converti en fichier HTML par le serveur d'applications. Ainsi le code n'est pas diffusé et devient difficilement téléchargeable depuis un navigateur web à moins d'en avoir l'accès. De ce fait, les risques de piratage en sont réduits. On compare souvent cette technologie à PHP, mais son fonctionnement se rapproche bien plus d'ASP .NET car le code est compilé et non interprété.

## Installation

Windows et Ubuntu ne permettent pas de lire les fichiers .jsp par défaut. Il faut donc télécharger et installer un serveur d'application Java EE tel que :
* Apache Tomcat
* Glassfish
* JBoss Application Server
et bien d'autres encore.
Pour Tomcat, une fois lancé (dans Windows : démarrer, exécuter..., services.msc, ou bien en commande DOS : net start "Tomcat7") il suffit de placer les fichiers .jsp dans le répertoire adéquat pour qu'ils soient interprétés par le serveur (par défaut sur Windows 7 dans C:\Program Files\Apache Software Foundation\Tomcat 7.0\webapps\examples\). L'URL pointant vers ce répertoire est http://localhost:8080/examples/.

## Directives JSP
### @page

Définit le code généré durant le traitement de la page JSP
Attributs :
* language="language" : langage à utiliser dans la jsp
* extends="package.nomDeClasse" : nom de la classe dont la page JSP va hériter
* import="nomDePackage1, nomDePackage2..." : noms des packages importés dans le code
* session="booléen" : détermine si la session est accessible depuis la JSP
* buffer="taille" : détermine la taille du buffer utilisé par JspWriter de la JSP
* autoFlush="booléen" : indique si le contenu du buffer doit être envoyé automatiquement vers le client une fois plein
* isThreadSafe="booléen" : indique le modèle de thread utilisé pour le traitement de la requête HTTP concernant la page JSP
* errorPage="url relative" : ressource appelée quand une exception est déclenchée et qu'il n'y a pas de trycatch dans la page
* isErrorPage="booléen" : indique si la page gère les exceptions
* contentType="type Mime" : indique le type de documents contenus dans la réponse HTTP généré par la JSP
* pageEncoding="type d'encodage" : détermine le type d'encodage des caractères de la réponse HTTP

### @include

Permet d'inclure une autre ressource dans la page JSP

### @taglib

Permet d'utiliser une bibliothèque de balises JSP en utilisant un espace de nom.

## Scriptlets

Les scriptlets permettent l'injection de scripts interprétables dans une pile HTML.
Déclaration de variables ou de méthodes
Insertion d'instructions de code
Évaluation d'expression, le résultat est retourné en out.println
Commentaires
Contrairement à un commentaire HTML standard entre <!-- et -->, les commentaires JSP entre <%-- et --%> ne sont pas écrits dans la page HTML générée.

### Exemple

Lorsqu'une erreur est levée par exemple en remplaçant le nombre d'itérations de 4 à 5, la directive page renvoie sur erreur.jsp

## Objets implicites

Ensemble de variables prédéfinies pour accéder directement à certains objets

### request

permet d'avoir une référence à HttpServletRequest utilisé pour contacter la JSP

### response

permet d'avoir une référence à HttpServletResponse qui transfert le résultat du traitement de la JSP au client

### pageContext

permet d'avoir un accès à pageContext de la JSP.

### session

permet d'avoir une référence à HttpSession associé au client.

### application

référence ServletContext associé à l'application contenant la JSP.

### out

référence le flux de sortie de JspWriter permettant d'écrire dans la réponse HTTP.

### config

permet de référencer ServletConfig associé à la JSP.

### exception

est disponible seulement dans une page dédiée aux erreurs et permet de référencer Exception qui redirige sur cette page de gestion d'erreur.

## Balises JSP
### jsp:useBean

Crée une instance d'un objet javabean.
Attributs :
* id :
* scope :
* class :
* type :
* beanName :
Exemple :

### jsp:getProperty

Prend la valeur d'une propriété d'un javabean.
Attributs :
* name :
* property :
Exemple :

### jsp:setProperty

Assigne une valeur à la propriété d'un javabean.
Attributs :
* name :
* property :
* value :
Exemple :

### jsp:include

Inclut une ressource statique ou dynamique et possède la balise <jsp:param> permettant de transmettre des paramètres à la ressource par l'attribut name (nom du paramètre) et l'attribut value (valeur du paramètre).
Attributs :
* page :
* flush :
Exemple :

### jsp:forward

Forward une requête client.
Exemple :

### jsp:plugin

Gère l'insertion d'un applet dans une page JSP.
Attributs :
* type :
* code :
* codebase :
* archive :
* name :
* align :
* width :
* height :
* vspace / hspace :
* jreversion :
* nspluginurl :
* iepluginurl :
Exemple :

## Syntaxe XML

| Syntaxe JSP | Syntaxe XML | Commentaires |
| <%@page %> | <jsp:directive.page></jsp:directive.page> | attributs identiques pour les deux versions |
| <%@include %> | <jsp:directive.include></jsp:directive.include> | attributs identiques pour les deux versions |
| <%@taglib %> | pas de correspondance | utiliser xmlns:XXX de la balise <jsp:root> |
| <%! %> | <jsp:declaration></jsp:declaration> | // |
| <% %> | <jsp:scriptlet></jsp:scriptlet> | // |
| <%= %> | <jsp:expression></jsp:expression> | // |
| <%-- --%> | pas de correspondance | // |

## Voir aussi

* ZK

# JSTL

* Présentation du JEE
* Le protocole HTTP
* Servlets
* Portlets
* JSP
* JSF
* JSTL
* JDBC
* EJB
* WildFly
* Configurer Eclipse
* Parcourir une API
Modifier ce modèle
La JSTL a été mise en place pour satisfaire à la "separation of concerns". Les différentes parties du projet pouvant être dispatchée à différents collaborateurs.

## Bibliothèques
### Standard
### Accès au bases de données
# Configurer Eclipse
## Eclipse

Eclipse est un environnement de développement intégré (EDI), générique et extensible (site officiel http://www.eclipse.org). Son système de plugins permet d'ajouter des fonctionnalités diverses.
Initialement prévu pour développer en Java, grâce aux plugins il peut maintenant également gérer des projets développés avec d'autres langages de programmation tels que :
* Le C et le C++ grâce à l'ensemble de plugins CDT (C Development Toolkit) (compilateur non intégré).
* Le Python via PyDev.
* Avant l'arrivée d'Android Studio, le développement pour Android se faisait avec Eclipse grâce à l'ensemble de plugins ADT (Android Development Toolkit).
Certains IDE sont basés sur Eclipse, et permettent par exemple le développement de logiciel embarqués pour des systèmes temps réel.

### Installation de Eclipse

La page de téléchargement d'Eclipse permet de récupérer une version déjà adaptée au langage ciblé sur http://www.eclipse.org/downloads/. Mais pour installer un plugin manuellement, il faut :
* Lancer Eclipse, puis dans le menu déroulant :Help>Software Updates>Find and Install...
* Cocher Search for new features to install, bouton Next. Bouton New Remote Site..., entrer l'adresse de téléchargement :
* Bouton Finish, choisir un miroir proche puis continuer l'installation.

### Utilisation de Eclipse

L'interface de l'IDE Eclipse est basée sur différentes perspectives. Une seule perspective n'est visible à la fois, et se compose de plusieurs vues. Exemples :
* La perspective "Java" se compose par défaut de la vue "Package Explorer", de la vue éditeur de code en Java avec un onglet par fichier ouvert, de la vue "Outline" donnant la hiérarchie des éléments composant la classe du fichier ouvert.
* La perspective "Debug" est ouverte automatiquement au lancement d'une application en mode débogage et se compose par défaut de la vue "Debug" affichant la pile d'appel, de la vue des points d'arrêt nommée "Breakpoints", de la vue éditeur de code en Java avec un onglet par fichier ouvert, de la vue "Outline" donnant la hiérarchie des éléments composant la classe du fichier ouvert.
* Deux ou plusieurs perspectives peuvent être affichées conjointement.
Chaque vue est une sous-fenêtre qui a un titre et se place dans un cadre particulier de la fenêtre de l'IDE. Les vues peuvent être déplacées à la souris par drag and drop pour changer la disposition de la perspective. Plusieurs vues peuvent partager le même cadre, auquel cas, une barre d'onglets permet de basculer entre les vues. Un double clic sur le titre d'une vue provoque l'affichage du cadre qui la contient en pleine fenêtre, réduisant les autres cadres à une icône sur les côtés. Un second double clic restaure les cadres.
Le menu "Window" permet de changer de perspective, et d'ajouter des vues à la perspective courante. Une vue peut également être retirée de la perspective affichée en utilisant la croix à droite du titre de la vue.

#### Édition de lignes

L'éditeur de code possède des raccourcis clavier pratiques rendant l'édition des lignes de code plus rapide :
| Touches | Touches | Effet |
| Shift | ↵ Enter | Ajouter une nouvelle ligne après la ligne courante. |
| Ctrl | ↑/↓ | Faire défiler la vue vers le haut/le bas. |
| CtrlShift | ↑/↓ | Déplacer le curseur sur le membre précédent/suivant de la classe. |
| Alt | ↑/↓ | Déplacer la ligne courante ou les lignes sélectionnées vers le haut/le bas dans le texte. |
| CtrlAlt | ↑/↓ | Dupliquer la ligne courante ou les lignes sélectionnées vers le haut/le bas. |
| CtrlShift | : | Commenter/Décommenter la ligne courante. |

#### Complétion de code

L'éditeur de code peut compléter automatiquement le code là où se trouve le curseur :
| Touches | Touches | Effet |
| Ctrl | Espace | Ouvrir la liste des suggestions de complétion. Une fois la suggestion choisie, la validation se fait par l'une des touches suivantes : ↵ Enter, n'ajoute rien derrière la suggestion ; Espace ou ., ajoute également le caractère produit derrière la suggestion. Toute autre touche produit le caractère sans valider (annuler la complétion). |
| AltShift | : | Complète avec la seule possibilité, ou produit un bip s'il y a plusieurs possibilités. |

#### Navigation et autres astuces

* Dans les codes sources dépassant la hauteur de fenêtre de l'éditeur, placez le pointeur de la souris sur l'accolade fermante d'un bloc pour voir apparaître un résumé du code d'ouverture du bloc en bulle d'aide. Ceci est fort utile pour vérifier quel bloc est fermé par l'accolade sans avoir à faire défiler le code.
* Placez le pointeur de la souris sur un identifiant de classe, méthode ou variable et enfoncez la touche Ctrl pour faire apparaître un lien cliquable vers la définition.
* Cliquez sur un identifiant de membre de classe pour faire apparaître toutes les occurrences d'utilisation dans le fichier : à la fois dans le texte et dans la barre de défilement. Les blocs apparaissant dans la barre de défilement sont cliquables pour faire défiler le code à la position de l’occurrence. Il y a deux couleurs distinctes pour les occurrences utilisées en lecture (accès, appel, ...) et celles utilisées en écriture (affectation).
    Il peut arriver que cela ne semble pas fonctionner car l'éditeur peut être dans un mode autre que celui par défaut. Il faut dans ce cas appuyer une ou deux fois la touche Échap pour que cela fonctionne.

## Apache Tomcat

Sa version Helios se configure facilement pour travailler avec un serveur Apache Tomcat 7.
Pour ce faire, il faut :
* Installer Tomcat sans mot de passe. Ne pas le lancer ;
* Installer Eclipse For Java EE Developers avec le JRE pour pouvoir l'exécuter ;
* Aller soit dans :
** Window > Preferences > Server > Runtime Environments ;
** ou Window > Show View > Other > Server puis cliquer en bas dans la nouvelle fenêtre ;
    (si Server n'est pas dans la liste, c'est que vous n'avez pas la version d'Eclipse For Java EE Developers)
* Ajouter Apache Tomcat en allant chercher le chemin ;
* Spécifier le nom à paraître, le chemin du répertoire d'installation de Tomcat sur le disque ;
* Laisser le JRE par défaut. Si Eclipse fonctionne, le JRE par défaut suffit.
À l'exécution du projet sous Eclipse ou au débogage, Eclipse chargera le projet dans une instance de Tomcat.

## Lancement

Pour initier un environnement de développement JEE il faut :
* Cliquer droit dans le Project Explorer d'Eclipse ;
* Choisir New > Web > Dynamic web project.
N'hésitez pas à faire des tests dans ce répertoire mais ne touchez pas au répertoire Server, ou il faudra recommencer la procédure de configuration de Tomcat s'il est corrompu.
Pour reconfigurer Tomcat dans les préférences, il faudra alors effacer ce répertoire Server.

# Parcourir une API

Le texte qui suit n'a pas été rédigé par une personne formellement compétente en la matière. Son contenu est donc sujet à caution.
* Présentation du JEE
* Le protocole HTTP
* Servlets
* Portlets
* JSP
* JSF
* JSTL
* JDBC
* EJB
* WildFly
* Configurer Eclipse
* Parcourir une API
Modifier ce modèle
Pour retrouver une fonctionnalité dans l'API.
Prenons celui-ci pour exemple : http://docs.oracle.com/javase/1.5.0/docs/api/index.html?java/util/Date.html
On tente d'identifier la classe pouvant contenir la fonction. Et on la parcours en détail à défaut d'avoir un moteur de recherche sur l'API.
La connaissance approfondie de l'API Java s'effectue par la lecture.
* ↑ https://eclipse.org/cdt/
* ↑ (anglais) http://pydev.org/
* ↑ http://www.eclipse.org/webtools/jst/components/ws/M4/tutorials/InstallTomcat.html
* ↑ http://www.coreservlets.com/Apache-Tomcat-Tutorial/tomcat-7-with-eclipse.html
* ↑ https://www.youtube.com/watch?v=df1zCMrEWZ8