Programmation JEE/Version imprimable

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

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

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 :

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.

Les réponses HTTP

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
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

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

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, HttpServletResponse response)              
                                               throws ServletException, IOException {
 
        // TODO Auto-generated method stub
       
        response.setContentType("text/html;charset=UTF-8");
    PrintWriter out = response.getWriter();
        try {
            out.println("Hello World");
        } finally {
            out.close();
        }
    }

    /**
     * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
     */
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // TODO Auto-generated method stub

        doGet(request,response);
    }
}

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 :

<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">  

  <!-- Début ici -->

    <servlet>
      <servlet-name>Hello</servlet-name><!-- Nom de la classe -->
      <servlet-class>servlet.Hello</servlet-class><!-- Arborescence de la classe : avec le package -->
    </servlet>
    <servlet-mapping>
        <servlet-name>Hello</servlet-name><!-- Nom de la classe -->
        <url-pattern>/Hello</url-pattern><!-- Pattern de la classe dans l'url -->
    </servlet-mapping>

   <!-- Fin ici -->

<web-app>

Le WEB-INF comprend donc :

   WEB-INF
     web.xml
     classes
       servlet
         Hello.class

Appel de la servlet

http://localhost:999/webTest/Hello

Résultat dans le navigateur :

Hello World

Anatomie de l'url

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

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
        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();

Exemple dans la servlet :

package servlet;

import java.io.*;
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
    }

    protected void processRequest(HttpServletRequest request, HttpServletResponse response)
    throws ServletException, IOException {
    response.setContentType("text/html;charset=UTF-8");
    PrintWriter out = response.getWriter();
    try {
    out.println(request.getServerName());
    out.println("<br/>");
    out.println(request.getServerPort());
    out.println("<br/>");
    out.println(request.getContextPath());
    out.println("<br/>");
    out.println(request.getServletPath());
    out.println("<br/>");
    out.println(request.getMethod());
    out.println("<br/>");
    out.println(request.getQueryString());
    out.println("<br/>");
    out.println(request.getRequestURL());
    out.println("<br/>");
    out.println(request.getLocalAddr());
    out.println("<br/>");
    out.println(request.getLocalName());
    out.println("<br/>");
    out.println(request.getLocalPort());
    out.println("<br/>");
    out.println(request.getRemoteAddr());
    out.println("<br/>");
    out.println(request.getRemoteHost());
    } finally {
    out.close();
    }
    }
   
    /**
     * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
     */
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    // TODO Auto-generated method stub
   
      processRequest(request, response);
    }

    /**
     * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
     */
    protected void doPost(HttpServletRequest request, HttpServletResponse response)
     throws ServletException, IOException {
    // TODO Auto-generated method stub

    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 requête
        request.removeAttribute(String name);

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.

          // 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

• (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:

package servlet;

import java.io.*;

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 ReponseHttp2
 */
@WebServlet("/ReponseHttp2")
public class ReponseHttp2 extends HttpServlet {
private static final long serialVersionUID = 1L;
       
    /**
     * @see HttpServlet#HttpServlet()
     */
    public ReponseHttp2() {
        super();
        // TODO Auto-generated constructor stub
    }
   
    protected void processRequest(HttpServletRequest request, HttpServletResponse response)
    throws ServletException, IOException {
    response.sendRedirect("images/toto.jpg");
    }
   
/**
* @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
*/
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
// TODO Auto-generated method stub
processRequest(request,response);
}

/**
* @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
*/
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
// TODO Auto-generated method stub
processRequest(request,response);
}

}

• 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.

package servlet;

import java.io.*;

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 ReponseHTTP
 */
@WebServlet("/ReponseHTTP")
public class ReponseHTTP extends HttpServlet {
private static final long serialVersionUID = 1L;
       
    /**
     * @see HttpServlet#HttpServlet()
     */
    public ReponseHTTP() {
        super();
        // TODO Auto-generated constructor stub
    }

    protected void processRequest(HttpServletRequest request, HttpServletResponse response)
    throws ServletException, IOException {
    response.setContentType("text/html;charset=UTF-8");
    PrintWriter out = response.getWriter();
    try {
    response.sendError(HttpServletResponse.SC_SERVICE_UNAVAILABLE, "le serveur est surchargé. Veuillez réessayer plus tard");
    } finally {
    out.close();
    }
    }
   
/**
* @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
*/
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
// TODO Auto-generated method stub
processRequest(request, response);
}

/**
* @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
*/
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
// TODO Auto-generated method stub
processRequest(request, response);
}

}

Autres ressources

RequestDispatcher

include

Inclusion d'une ressource externe.

RequestDispatcher rd = null;
rd = getServletContext().getRequestDispatcher("/header.html");
rd.include(request, response);

forward

Transfert du resultat d'une servlet vers une autre ressource.

import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.HttpServlet;
import javax.servlet.HttpServletRequest;
import javax.servlet.HttpServletResponse;

public class Result extends HttpServlet {
   protected void doGet(HttpServletRequest request, HttpServletResponse response)
     throws ServletException, IOException {
       
       response.setContentType("text/html;charset=UTF-8");
       PrintWriter out = response.getWriter();
       try {
         int result = 10;
         RequestDispatcher rd = null;
         rd = getServletContext().getRequestDispatcher("/result.jsp");
         request.setAttribute("resultat", result);
         rd.forward(request, response);
       } finally {
         out.close();
       }
   }
}

La ressource de destination : result.jsp

<%@page contentType="text/html" pageEncoding="UTF-8">
<%@page import="java.text.*" %>
<html>
  <body>
    <%
    resultat=(double) request.getAttribute("resultat");
    %>

    Resultat : <%= resultat %>
  </body>
</html>

Redirection

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

location

response.setStatus(HttpServletResponse.SC_MOVED_PERMANENTLY); // Pour une réponse HTTP 301
response.setHeader("location", "http://www.google.be"); // Pour une réponse HTTP 302

redirect

response.sendRedirect("http://www.google.be");

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.

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é.

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 :

1. Apache Tomcat
2. Glassfish
3. 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

<%@page contentType="text/html"
        pageEncoding="UTF-8"
        errorPage="erreur.jsp"
        import="java.util.*"
%>

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 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

@include

Permet d'inclure une autre ressource dans la page JSP

  <%@include file="./chunk.jsp" %>

@taglib

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

<%-- 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

Les scriptlets permettent l'injection de scripts interprétables dans une pile HTML.

<%! %>

Déclaration de variables ou de méthodes

<%!
   double tva=1.21;
   double calculTarif(double prix)
   {
      return prix*tva;
   }
%>

<% %>

Insertion d'instructions de code

<%
   double tva=1.21;
   out.println(Double.parseDouble(request.getParameter("prix"))*tva);
%>

<%= %>

Évaluation d'expression, le résultat est retourné en out.println()

<%=new Date().toLocalString() %>

<%-- --%>

Commentaires

<%-- Ceci est un commentaire --%>

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

<%-- 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" "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>

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

<%-- 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

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:useBean>
   id="leManager"
   type="pack.Personne"
   class="pack.Manager"
   scope="request"
</jsp:useBean>

jsp:getProperty

Prend la valeur d'une propriété d'un javabean.

Attributs :

• name :
• property :

Exemple :

<jsp:getProperty name="leManager" property="nom" />

jsp:setProperty

Assigne une valeur à la propriété d'un javabean.

Attributs :

• name :
• property :
• value :

Exemple :

<jsp:useBean id="manager" scope="session" class="pack.Manager" type="pack.Manager" />
<jsp:setProperty name="manager" property="heureConnexion" value="<%=new Date().toLocaleString()%>" />

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:include page="/NbColis">
   <jsp:param name="code" value="<%=request.getParameter("codeClient") %>" />
</jsp:include>

jsp:forward

Forward une requête client.

Exemple :

<jsp:forward page="/servlet/login"> 
  <jsp:param name="username" value="jsmith" /> 
</jsp:forward>

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 :

<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

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

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.

Expressions langage

Déclaration

Cette section est vide, pas assez détaillée ou incomplète.

Opérateurs

Cette section est vide, pas assez détaillée ou incomplète.

Exceptions

Cette section est vide, pas assez détaillée ou incomplète.

Bibliothèques

Standard

Cette section est vide, pas assez détaillée ou incomplète.

XML

Cette section est vide, pas assez détaillée ou incomplète.

Internationalisation et format

Cette section est vide, pas assez détaillée ou incomplète.

Accès au bases de données

Cette section est vide, pas assez détaillée ou incomplète.

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 :

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.

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.

Eclipse

Édition de lignes

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.
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		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 :

1. Installer Tomcat sans mot de passe. Ne pas le lancer ;
2. Installer Eclipse For Java EE Developers avec le JRE pour pouvoir l'exécuter ;
3. 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)

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.

Lancement

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.

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.

Cette section est vide, pas assez détaillée ou incomplète.

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.