Programmation JEE/Version imprimable

Nuvola-inspired File Icons for MediaWiki-fileicon-ps.png

Ceci est la version imprimable de Programmation JEE.

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


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

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 JEEModifier

J2EE (Java to EE) 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 J2EE est essentiellement un environnement fournissant :

Environnement d'exécution de JEEModifier

Un des avantages majeurs de JEE est de faire abstraction de l'infrastructure d'exécution. En effet, J2EE 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 JEEModifier

  • 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 coté 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).

  • J2EE Connector

Facilite les connexions aux plates-formes autres que JEE.

  • JAAS (Java Authentication and Authorization Service)

Permet aux applications J2EE 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 JEEModifier

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 HTTPModifier

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 HTTPModifier

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

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 coté 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 servletsModifier

Exemple de servletModifier

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

DescriptionModifier

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

Déployement sous TomCatModifier

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

http://localhost:999/webTest/Hello

Résultat dans le browser :

Hello World

Anatomie de l'urlModifier

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

Méthodes d'informations sur l'URLModifier

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

          // Recuperation du parametre par le nomParametre
        request.getParameter(nomParametre);

 // Retourne une enumeration de tous les parametres d'une requete
request.getParameterNames();

 // Retourne toutes les valeurs du parametre de nomParametre
        request.getParameterValues(nomParametre);

          // Retourne une iteration de nom de parametres
        request.getParameterMap();

Méthodes de lecture des En-TêtesModifier

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

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

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

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

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 ressourcesModifier

RequestDispatcherModifier

includeModifier

Inclusion d'une ressource externe.

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

forwardModifier

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>

RedirectionModifier

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

locationModifier

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

redirectModifier

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

FiltresModifier

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

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 servletsModifier

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

InstallationModifier

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 JSPModifier

@pageModifier

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

@includeModifier

Permet d'inclure une autre ressource dans la page JSP

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

@taglibModifier

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

ScriptletsModifier

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

<%! %>Modifier

Déclaration de variables ou de méthodes

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

<% %>Modifier

Insertion d'instructions de code

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

<%= %>Modifier

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

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

<%-- --%>Modifier

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.

ExempleModifier

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

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

requestModifier

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

responseModifier

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

pageContextModifier

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

sessionModifier

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

applicationModifier

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

outModifier

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

configModifier

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

exceptionModifier

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 JSPModifier

jsp:useBeanModifier

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

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

Attributs :

  • name :
  • property :


Exemple :

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

jsp:setPropertyModifier

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

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

Forward une requête client.


Exemple :

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

jsp:pluginModifier

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 XMLModifier

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 aussiModifier


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 langageModifier

DéclarationModifier

OpérateursModifier

ExceptionsModifier

BibliothèquesModifier

StandardModifier

XMLModifier

Internationalisation et formatModifier

Accès au bases de donnéesModifier


Configurer Eclipse

EclipseModifier

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.

Installation de EclipseModifier

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 EclipseModifier

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.

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. Plusieurs vues peuvent partager le même cadre, auquel cas, un 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


Apache TomcatModifier

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

LancementModifier

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

Contenu sujet à caution 

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.

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