Programmation_JEE_Version_imprimable.pdf

Programmation JEE
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
Vous avez la permission de copier, distribuer et/ou modifier ce
document selon les termes de la Licence de documentation libre
GNU, version 1.2 ou plus récente publiée par la Free Software
Foundation ; sans sections inaltérables, sans texte de première page
de couverture et sans Texte de dernière page de couverture. Une
copie de cette licence est incluse dans l'annexe nommée « Licence
de documentation libre GNU ».

Présentation du JEE
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.
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,
Présentation
La plate-forme JEE

Java IDL : API de communication entre objets Java et objets non-Java, via le protocole
CORBA.
La plateforme JEE est essentiellement un environnement fournissant :
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.
L'API JEE 5 est [ici (http://download.oracle.com/javaee/5/api/)]
L'API JEE 6 est [ici (http://download.oracle.com/javaee/6/api/)]
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
Environnement d'exécution de JEE
Les API JEE

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...
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.
Développement d'application JEE

Le protocole HTTP
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.
Exemple :
GET /page.html HTTP/1.0
Host: example.com
Referer: http://example.com/
User-Agent: CERN-LineMode/2.15 libwww/2.17b3
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.
Exemple :
HTTP/1.0 200 OK
Date: Fri, 31 Dec 1999 23:59:59 GMT
Server: Apache/0.8.4
Content-Type: text/html
Content-Length: 59
Requêtes HTTP
Les réponses HTTP

Expires: Sat, 01 Jan 2000 00:59:59 GMT
Last-modified: Fri, 09 Aug 1996 14:21:40 GMT
<TITLE>Exemple</TITLE>
<P>Ceci est une page d'exemple.</P>
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
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.
Contenu de la réponse

Servlets
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
package servlet;
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
* Servlet implementation class Hello
*/
@WebServlet("/Hello")
public class Hello extends HttpServlet {
private static final long serialVersionUID = 1L;
/**
* @see HttpServlet#HttpServlet()
*/
public Hello() {
super();
// TODO Auto-generated constructor stub
}
/**
* @see HttpServlet#doGet(HttpServletRequest request,
HttpServletResponse response)
*/
protected void doGet(HttpServletRequest request,
throws
ServletException, IOException {
// TODO Auto-generated method stub

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.
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 :
response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
try {
out.println("Hello World");
} finally {
out.close();
}
}
/**
* @see HttpServlet#doPost(HttpServletRequest request,
*/
protected void doPost(HttpServletRequest request,
HttpServletResponse response) throws ServletException,
IOException {
doGet(request,response);
}
}
Description
Déployement sous TomCat
<web-app xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-
app_3_0.xsd"
version="3.0"
metadata-complete="true">

<servlet>
<servlet-name>Hello</servlet-name><!-- Nom de la classe --
>

Le WEB-INF comprend donc :
WEB-INF
web.xml
classes
servlet
Hello.class
http://localhost:999/webTest/Hello
Résultat dans le navigateur :
Hello World
[Protocol://][DNS]:[PORT]/[RootEntryDirectory]/[ServletName]
<servlet-class>servlet.Hello</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>Hello</servlet-name>
<url-pattern>/Hello</url-pattern>
</servlet-mapping>

<web-app>
Appel de la servlet
Anatomie de l'url
Méthodes d'informations sur l'URL
// Retourne le nom du serveur
request.getServerName();
// Retourne le port du serveur
request.getServerPort();
// Retourne le nom de l'application hébergeant la
servlet

Exemple dans la servlet :
request.getContextPath();
// Retourne le chemin de la servlet
request.getServletPath();
// Retourne type de la requete http utillisee
request.getMethod();
// Retourne parametres passes dans URL
request.getQueryString();
// Retourne URL utilisee pour contacter la servlet
request.getRequestURL();
// Retourne l'adresse locale
request.getLocalAddr();
request.getLocalName();
request.getLocalPort();
request.getRemoteAddr();
request.getRemoteHost();
package servlet;
import java.io.*;
/**
* Servlet implementation class Hello
*/
@WebServlet("/Hello")
public class Hello extends HttpServlet {
/**
*/
public Hello() {
super();

}
protected void processRequest(HttpServletRequest request,
throws ServletException, IOException {
try {
out.println(request.getServerName());
out.println("<br/>");
out.println(request.getServerPort());
out.println(request.getContextPath());
out.println(request.getServletPath());
out.println(request.getMethod());
out.println(request.getQueryString());
out.println(request.getRequestURL());
out.println(request.getLocalAddr());
out.println(request.getLocalName());
out.println(request.getLocalPort());
out.println(request.getRemoteAddr());
out.println(request.getRemoteHost());
} finally {
out.close();
}
}
/**
*/
IOException {
processRequest(request, response);
}
/**

Cet appel : http://localhost:999/webTest/Hello
localhost
999
/webTest
/Hello
GET
null
http://localhost:999/webTest/Hello
127.0.0.1
localhost
999
127.0.0.1
127.0.0.1
*/
}
}
Méthodes de lecture des paramètres
// Récuperation du paramètre par le nomParametre
request.getParameter(nomParametre);
// Retourne une énumeration de tous les paramètres d'une
requête
request.getParameterNames();
// Retourne toutes les valeurs du paramètre de nomParametre
request.getParameterValues(nomParametre);

// Retourne une itération de nom de paramètres
request.getParameterMap();
Méthodes de lecture des En-Têtes
// Retourne les noms du header
request.getHeaderNames();
// Retourne les headers
request.getHeaders();
// Retourne le nombre d'octets dans la requête
request.getContentLength();
// Retourne le type de contenu de la requête
request.getContentType();
// Retourne la langue privilégiée
request.getLocale();
// Retourne la liste des langues
request.getLocales();
// Retourne la date du header
request.getDateHeader(String name);
// Retourne le header spécifié par le "name"
request.getHeader(String name);
// Retourne les headers spécifiés par le "name"
request.getHeaders(String name);
Méthodes d'ajout d'informations à la requête
// Assure le stockage d'un objet dans l'objet
HttpServletRequest
request.setAttribute(String name, Object o);
// Retourne l'objet stocké "name"
request.getAttribute(String name);
// Returne une enumeration des noms d'attributs
request.getAttributeNames();
// Supprime l'attribut "name" des attributs de la

Les en-têtes HTTP sont utilisés pour ajouter à la réponse des informations supplémentaires.
(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:
requête
request.removeAttribute(String name);
Méthodes d'ajout des en-têtes
// Cette méthode permet d'indiquer la nature des
informations présentes dans la réponse
response.setContentType(String type);
// Cette méthode indique la langue locale
response.setLocale(Locale loc);
// Cette méthode ajoute le header "name" avec sa
valeur "value"
response.addHeader(String name, String value);
Élaboration du corps de la réponse
package servlet;
import java.io.*;
/**
* Servlet implementation class ReponseHttp2
*/
@WebServlet("/ReponseHttp2")
public class ReponseHttp2 extends HttpServlet {
/**

Dans cet exemple nous faisont appel à processRequest(request, response) pour obtenir
invariablement le traitement en get et post
Les codes de status sont répartis en 5 catégories :
1XX : informatif
2XX : succès
3XX : redirection
4XX : erreur client
5XX : erreur serveur
*/
public ReponseHttp2() {
super();
}
response.sendRedirect("images/toto.jpg");
}
/**
*/
IOException {
processRequest(request,response);
}
/**
*/
IOException {
processRequest(request,response);
}
}
Élaborer une réponse HTTP

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.
package servlet;
import java.io.*;
/**
* Servlet implementation class ReponseHTTP
*/
@WebServlet("/ReponseHTTP")
public class ReponseHTTP extends HttpServlet {
/**
*/
public ReponseHTTP() {
super();
}
try {
response.sendError(HttpServletResponse.SC_SERVICE_UNAVAILABLE,
"le serveur est surchargé. Veuillez réessayer plus tard");
} finally {
out.close();
}
}
/**

Inclusion d'une ressource externe.
Transfert du resultat d'une servlet vers une autre ressource.
*/
IOException {
}
/**
*/
IOException {
}
}
Autres ressources
RequestDispatcher
include
RequestDispatcher rd = null;
rd = getServletContext().getRequestDispatcher("/header.html");
rd.include(request, response);
forward
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.RequestDispatcher;
import javax.servlet.HttpServlet;
import javax.servlet.HttpServletRequest;
import javax.servlet.HttpServletResponse;

La ressource de destination : result.jsp
Le serveur informe le navigateur de faire une requête HTTP vers l'url indiquée.
public class Result extends HttpServlet {
try {
int result = 10;
RequestDispatcher rd = null;
rd =
getServletContext().getRequestDispatcher("/result.jsp");
request.setAttribute("resultat", result);
rd.forward(request, response);
} finally {
out.close();
}
}
}
<%@page contentType="text/html" pageEncoding="UTF-8">
<%@page import="java.text.*" %>
<html>
<body>
<%
resultat=(double) request.getAttribute("resultat");
%>
Resultat : <%= resultat %>
</body>
</html>
Redirection
location
response.setStatus(HttpServletResponse.SC_MOVED_PERMANENTLY); //
Pour une réponse HTTP 301

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.
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.
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.
response.setHeader("location", "http://www.google.be"); // Pour
une réponse HTTP 302
redirect
response.sendRedirect("http://www.google.be");
Filtres
Évènements
Synchronisation des servlets
public class ... {
public void method() {
out = response.getWriter();
synchronized(this) {
compteur++;
}
out.println("La valeur du compteur est " + compteur);

JSP
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é.
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 :
1. Apache Tomcat (http://tomcat.apache.org/download-70.cgi)
2. Glassfish (https://glassfish.java.net/)
3. JBoss Application Server (https://www.jboss.org/)
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 FilesApache Software
FoundationTomcat 7.0webappsexamples). L'URL pointant vers ce répertoire est
http://localhost:8080/examples/.
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
Installation
Directives JSP
@page
<%@page contentType="text/html"
pageEncoding="UTF-8"
errorPage="erreur.jsp"
import="java.util.*"
%>

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 try{}catch{} 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
Permet d'inclure une autre ressource dans la page JSP
Permet d'utiliser une bibliothèque de balises JSP en utilisant un espace de nom.
Les scriptlets permettent l'injection de scripts interprétables dans une pile HTML.
Déclaration de variables ou de méthodes
@include
<%@include file="./chunk.jsp" %>
@taglib
<%-- Défini l'espace de nom "fmt" pour utiliser une bibliothèque
de balises --%>
<%@taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
<%-- Par la suite on utilise l'espace de nom fmt pour les
balises de la bibliothèque --%>
<fmt:setBundle basename="informatique.ressources" />
<fmt:message key="service" />
Scriptlets
<%! %>
<%!
double tva=1.21;

Insertion d'instructions de code
Évaluation d'expression, le résultat est retourné en out.println()
Commentaires
Contrairement à un commentaire HTML standard entre , les commentaires JSP entre <%-- et
--%> ne sont pas écrits dans la page HTML générée.
double calculTarif(double prix)
{
return prix*tva;
}
%>
<% %>
<%
double tva=1.21;
out.println(Double.parseDouble(request.getParameter("prix"))*tva
);
%>
<%= %>
<%=new Date().toLocalString() %>
<%-- --%>
<%-- Ceci est un commentaire --%>
Exemple
<%-- index.jsp --%>
<%@ page language="java" contentType="text/html; charset=ISO-
8859-1"
pageEncoding="ISO-8859-1"
errorPage="erreur.jsp"
%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"

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
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html;
charset=ISO-8859-1">
<title>Insert title here</title>
</head>
<body>
<%!
String[] langages = {"Java", "CLisp", "Scheme", "OCaml"};
%>
<%
// levée d'une ArrayIndexOutOfBoundsException
for (int i=0; i < 4; i++) {
out.println(langages[i]);
}
%>
</body>
</html>
<%-- erreur.jsp --%>
<%@ page isErrorPage="true"%>
<html>
<body>
exception levée <b> <%= exception %> </b>
<hr>
<h3>trace de la pile</h3>
<pre>
<%
java.io.PrintWriter pw = new java.io.PrintWriter(out);
exception.printStackTrace(pw);
%>
</pre>
</body>
</html>
Objets implicites

Ensemble de variables prédéfinies pour accéder directement à certains objets
permet d'avoir une référence à HttpServletRequest utilisé pour contacter la JSP
permet d'avoir une référence à HttpServletResponse qui transfert le résultat du traitement de la JSP au client
permet d'avoir un accès à pageContext de la JSP.
permet d'avoir une référence à HttpSession associé au client.
référence ServletContext associé à l'application contenant la JSP.
référence le flux de sortie de JspWriter permettant d'écrire dans la réponse HTTP.
permet de référencer ServletConfig associé à la JSP.
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.
Crée une instance d'un objet javabean.
Attributs :
id :
request
response
pageContext
session
application
out
config
exception
Balises JSP
jsp:useBean

scope :
class :
type :
beanName :
Exemple :
Prend la valeur d'une propriété d'un javabean.
Attributs :
name :
property :
Exemple :
Assigne une valeur à la propriété d'un javabean.
Attributs :
name :
property :
value :
Exemple :
<jsp:useBean>
id="leManager"
type="pack.Personne"
class="pack.Manager"
scope="request"
</jsp:useBean>
jsp:getProperty
<jsp:getProperty name="leManager" property="nom" />
jsp:setProperty
<jsp:useBean id="manager" scope="session" class="pack.Manager"
type="pack.Manager" />

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 :
Forward une requête client.
Exemple :
Gère l'insertion d'un applet dans une page JSP.
Attributs :
type :
code :
codebase :
archive :
name :
align :
width :
<jsp:setProperty name="manager" property="heureConnexion"
value="<%=new Date().toLocaleString()%>" />
jsp:include
<jsp:include page="/NbColis">
<jsp:param name="code" value="
<%=request.getParameter("codeClient") %>" />
</jsp:include>
jsp:forward
<jsp:forward page="/servlet/login">
<jsp:param name="username" value="jsmith" />
</jsp:forward>
jsp:plugin

height :
vspace / hspace :
jreversion :
nspluginurl :
iepluginurl :
Exemple :
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 //
ZK
<jsp:plugin type=applet code="Molecule.class" codebase="/html">
<jsp:params>
<jsp:param name="molecule"
value="molecules/benzene.mol" />
</jsp:params>
<jsp:fallback>
<p>Impossible de charger l'applet</p>
</jsp:fallback>
</jsp:plugin>
Syntaxe XML
Voir aussi

JSTL
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.
Cette section est vide, pas assez détaillée ou incomplète.
Expressions langage
Déclaration
Opérateurs
Exceptions
Bibliothèques
Standard
XML
Internationalisation et format
Accès au bases de données

Configurer 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)[1]
(compilateur non intégré).
Le Python via PyDev[2].
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.
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 :
Name: Nom du plugin
URL: adresse du plugin, ex :
http://www.eclipse.org/cdt/downloads.php
Bouton Finish, choisir un miroir proche puis continuer l'installation.
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
Eclipse
Installation de Eclipse
Utilisation de Eclipse

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.
Eclipse
L'éditeur de code possède des raccourcis clavier pratiques rendant l'édition des lignes de code plus rapide :
Touches Effet
Shift ↵ Enter Ajouter une nouvelle ligne après la ligne courante.
Ctrl ↑ / ↓ Faire défiler la vue vers le haut/le bas.
Ctrl
Shift
↑ / ↓
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.
Édition de lignes

Ctrl Alt ↑ / ↓
Dupliquer la ligne courante ou les lignes sélectionnées vers
le haut/le bas.
Ctrl
Shift
: Commenter/Décommenter la ligne courante.
L'éditeur de code peut compléter automatiquement le code là où se trouve le curseur :
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).
Alt
Shift
:
Complète avec la seule possibilité, ou produit un bip s'il y a
plusieurs possibilités.
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.
Complétion de code
Navigation et autres astuces

Sa version Helios se configure facilement pour travailler avec un serveur Apache Tomcat 7.
Pour ce faire, il faut :
1. Installer Tomcat (http://tomcat.apache.org/whichversion.html) sans mot de passe. Ne pas le
lancer ;
2. Installer Eclipse For Java EE Developers (http://www.eclipse.org/downloads/) avec le JRE
pour pouvoir l'exécuter ;
3. Aller soit dans :
Window > Preferences > Server > Runtime Environments[3] [4] ;
ou Window > Show View > Other > Server puis cliquer en bas dans la nouvelle
fenêtre[5] ;
(si Server n'est pas dans la liste, c'est que vous n'avez pas la version d'Eclipse For
Java EE Developers)
4. Ajouter Apache Tomcat en allant chercher le chemin ;
5. Spécifier le nom à paraître, le chemin du répertoire d'installation de Tomcat sur le disque ;
6. 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.
Pour initier un environnement de développement JEE il faut :
1. Cliquer droit dans le Project Explorer d'Eclipse ;
2. 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.
Apache Tomcat
Lancement

Récupérée de « https://fr.wikibooks.org/w/index.php?title=Programmation_JEE/Version_imprimable&oldid=519623 »
La dernière modification de cette page a été faite le 3 août 2016 à 12:26.
Les textes sont disponibles sous licence Creative Commons attribution partage à l’identique ; d’autres termes
peuvent s’appliquer.
Voyez les termes d’utilisation pour plus de détails.
Parcourir une API
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.
GFDL
Vous avez la permission de copier, distribuer et/ou
modifier ce document selon les termes de la licence de
documentation libre GNU, version 1.2 ou plus récente
publiée par la Free Software Foundation ; sans sections
inaltérables, sans texte de première page de couverture et
sans texte de dernière page de couverture.
1. https://eclipse.org/cdt/
2. (anglais) http://pydev.org/
3. http://www.eclipse.org/webtools/jst/components/ws/M4/tutorials/InstallTomcat.html
4. http://www.coreservlets.com/Apache-Tomcat-Tutorial/tomcat-7-with-eclipse.html
5. https://www.youtube.com/watch?v=df1zCMrEWZ8

Programmation_JEE_Version_imprimable.pdf

Recommandé

Recommandé

Contenu connexe

Similaire à Programmation_JEE_Version_imprimable.pdf

Similaire à Programmation_JEE_Version_imprimable.pdf (20)

Programmation_JEE_Version_imprimable.pdf