Médiaforma

All posts tagged java

Java – Sessions

Categories: java
Comments: No

Les variables de session sont accessibles :

  • en écriture, avec la méthode session.putValue(nom, valeur);
  • en lecture, avec la méthode session.getValue(nom);

nom est le nom de la variable de session et valeur est la valeur à y stocker.

Voici une petite servlet qui indique le nombre de fois qu’une page a été vue :

<html>
  <head>
    <title>Traitement du formulaire</title>
  </head>
  <body>
    <%
      Integer nombre = (Integer) session.getValue("session.compteur");
      if (nombre == null) nombre = new Integer(1);
      else nombre = new Integer(nombre.intValue()+ 1);
      session.putValue("session.compteur", nombre);
      out.println("Cette page a été vue " + nombre + " fois.");
    %>
  </body>
</html>

Voici un exemple de formulaire contenant deux champs textuels (prenom et nom) et un bouton submit. La page traitement.jsp sera exécutée lorsque l’utilisateur cliquera sur le bouton submit et les données seront passées selon la méthode POST :

<html>
  <head>
    <title>Formulaire</title>
  </head>
  <body>
    <form action="traitement.jsp" method="post">
      Votre prénom <input type="text" name="prenom"><br/>
      Votre nom <input type="text" name="nom"><br/>
      <input type="submit" value="Valider">
    </form>
  </body>
</html>

Pour réceptionner les données envoyées par le formulaire, vous utiliserez la méthode request.getParameter() en précisant l’attribut name de la balise qui fournit une donnée. Voici le code à utiliser :

<html>
  <head>
    <title>Traitement du formulaire</title>
  </head>
  <body>
    <%
      String prenom = request.getParameter("prenom");
      String nom = request.getParameter("nom");
      out.println("Bonjour " + prenom + " " + nom);
    %>
  </body>
</html>

Et voici le résultat :

 

 


Pour utiliser une classe dans une servlet, vous pouvez insérer une directive <%@page%> en précisant le paramètre import, ou insérer le chemin complet de la méthode Java à utiliser. A titre d’exemple, ces deux servlets sont équivalentes :

Version 1 – En insérant le chemin de la classe dans l’instruction

<html>
  <head>
    <title>Accès à une classe Java</title>
  </head>
  <body>
    Aujourd’hui nous sommes le <%= new java.util.Date().toString() %>.
  </body>
</html>

Version 2 – En important la classe

<%@ page import="java.util.Date" %>
<html>
  <head>
    <title>Accès à une classe Java</title>
  </head>
  <body>
    Aujourd’hui nous sommes le <%= new Date().toString() %>.
  </body>
</html>

 

Ces deux servlets produisent le même effet :

 

 

 

Exercice

Définissez une servlet qui affiche la date du jour en français, comme dans la capture d’écran ci-après :

 

 

Solution

<%@ page import="java.util.Date" %>
<html>
  <head>
    <title>Date en français</title>
  </head>
  <body>
    <% String[] jours = {"Dimanche", "Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi" };
    Date laDate = new Date();
    int leJour = laDate.getDay();
    out.println("Aujourd'hui, nous sommes " + jours[leJour]);
    %>
  </body>
</html>

Nous allons définir une page d’erreur comme ceci :

<html>
<body>
  <%@ page isErrorPage="true" %>
  Nom de l’exception : <%= exception.toString() %><br/>
  Message de l’exception : <%= exception.getMessage() %><br/>
</body>
</html>

Saisissez ces lignes dans un éditeur de texte et sauvegardez le fichier sous le nom erreur.jsp dans le dossier c:\Program Files\Apache Software Foundation\Tomcat 8.0\webapps\test.

Vous allez maintenant saisir ce code et le sauvegarder dans le fichier testErreur.jsp, toujours dans le même dossier :

<%@ page errorPage="erreur.jsp" %>

<html>
  <head>
    <title>Taille et couleur</title>
  </head>
  <body>
    <% String s=null;
       out.println(s.length());
    %>
  </body>
</html>

Ce code génère une erreur de type NullPointerException. Voici la page affichée lorsque vous tapez l’URL http://localhost:8080/test/testErreur.jsp dans votre navigateur :

 

 


Vous allez maintenant écrire quelques servlets et les exécuter sous Tomcat.

Rendez-vous dans le dossier d’installation de Tomcat : c:\Program Files\Apache Software Foundation\Tomcat 8.0 par défaut. Déplacez-vous dans le sous-dossier webapps, créez le dossier premier et le fichier premier.jsp. Insérez les instructions suivantes dans ce fichier :

<html>
  <head>
    <title>Premier test JSP</title>
  </head>
  <body>
    <%
      out.println("<ul>");
      for (int i=0;i<5;i++)
         out.println("<li>"+i);
      out.println("</ul>");
    %>
  </body>
</html>

Exécutez ce code en entrant l’URL http://localhost:8080/test/premier.jsp dans la barre d’adresse de votre navigateur. Voici ce que vous devez obtenir :

 

 

 

Exercice

Ecrivez un servlet qui effectue les actions suivantes :

  • Définition de la variable int taille et initialisation à 30 ;
  • Définition de la variable string couleur et initialisation à red ;
  • Affichage d’un texte en utilisant les variables taille et couleur.

Voici le résultat à obtenir :

 

 

Solution

Voici le code :

<html>
  <head>
    <title>Taille et couleur</title>
  </head>
  <body>
    <% int taille = 30; String couleur = "red"; %>
    <font color="<%=couleur%>" size="<%=taille%>">Bonjour JSP</font>
  </body>
</html>

 

Affichez le code de la page. Voici ce que vous devriez obtenir :

<html>
  <head>
    <title>Taille et couleur</title>
  </head>
  <body>

    <font color="red" size="30">Bonjour JSP</font>
  </body>
</html>

Comme vous pouvez le voir, le code JSP a été remplacé par du code HTML.


Considérez le code suivant :

public class GenericsTypeAvant {

    private Object t;
     public Object get() {
        return t;
    }

    public void set(Object t) {
        this.t = t;
    }

    public static void main(String args[]){
        GenericsTypeAvant type = new GenericsTypeAvant();
        type.set(12);
        String str = (String) type.get();
    }
}
Ce code se compile correctement, mais il produit une erreur CassCastException à l’exécution. En effet, le nombre 12 ne peut pas être casté en un String :

 

 

Considérez maintenant le code suivant :

public class GenericsTypeMaintenant<T> {

    private T;

    public T get(){
        return this.t;
    }

    public void set(T t1){
        this.t=t1;
    }

    public static void main(String args[]){
        GenericsTypeMaintenant<String> type = new GenericsTypeMaintenant<>(); // Type String
        type.set("chaîne"); // OK

        GenericsTypeMaintenant<Integer> type1 = new GenericsTypeMaintenant<>(); //Type Integer
        type1.set(12); //OK
        //type1.set("abc"); //Invalide

        GenericsTypeMaintenant type2 = new GenericsTypeMaintenant(); //Type quelconque
        type2.set("texte"); //OK
        type2.set(10); //Valide

    }
}

Le type T est spécifié dans la classe :

public class GenericsTypeMaintenant<T>

Lors de l’instanciation d’un objet de classe GenericsTypeMaintenant, on définit le type de l’objet passé. Par exemple, un type String :

GenericsTypeMaintenant<String> type = new GenericsTypeMaintenant<>();

On passe alors un objet de type String au setter après l’instanciation de la classe :

type.set("chaîne");

Si on lui passe un autre type, une erreur sera déclenchée à la compilation.

Par exemple, cette instruction :

type.set(12);

Provoque une erreur à la compilation :

 

 

Lors de l’instanciation d’un objet GenericsTypeMaintenant, on peut aussi définir un type Integer :

GenericsTypeMaintenant<Integer> type1 = new GenericsTypeMaintenant<>();

 

Dans ce cas, les instructions suivantes ne produiront aucune erreur de compilation :

GenericsTypeMaintenant<Integer> type1 = new GenericsTypeMaintenant<>();
type1.set(12); //OK

 

Par contre, ces instructions provoqueront une erreur à la compilation :

GenericsTypeMaintenant<Integer> type1 = new GenericsTypeMaintenant<>();
type1.set("abc"); //Invalide

 

Si aucun type n’est spécifié :

GenericsTypeMaintenant type2 = new GenericsTypeMaintenant();

 

Une valeur de type quelconque peut être passée au setter. Ainsi, ces deux instructions sont correctes :

type2.set("texte");
type2.set(10);

Java – Generics

Categories: java
Comments: No

Les generics sont apparus avec la version 5 de Java. Ils ajoutent une vérification à la compilation pour éviter des erreurs de type ClassCastException à l’exécution.

Un premier exemple

Examinez ce code :

import java.util.ArrayList;
import java.util.List;

public class Generics {

    public static void main(String[] args) {
        List = new ArrayList();
        list.add("abc");
        list.add(new Integer(5));

        for(Object obj : list){
          //Ce casting conduit à une exception au runtime
          String str=(String) obj;
          //Traitement sur l’objet str
        }
    }
}

Voici l’erreur qui se produit à l’exécution :

 

 

 

Pour éviter ce type d’erreur, vous pouvez utiliser des generics. La définition de la collection se fait comme ceci :

import java.util.ArrayList;
import java.util.List;

public class Generics {

    public static void main(String[] args) {
      List<String> list1 = new ArrayList<String>();
      list1.add("abc");
      //Cette instruction produit une erreur à la compilation
      list1.add(new Integer(5));

      // Aucun casting n’est nécessaire
      // L’erreur ClassCastException est ainsi évitée
      for(String str : list1){
        //Traitement sur l’objet str
      }
    }
}