Servlet/JSP | JSP - EL (Expression Language)
  1. Introduction
  2. Les littéraux du langage EL
  3. Opérateurs du langage EL
    1. Les opérateurs arithmétiques
    2. Les opérateurs relationnels
    3. Les opérateurs logiques
    4. L'opérateur ternaire "? :" (COND ? STMT1 : STMT2)
    5. L'opérateur empty
    6. Les opérateurs d'accès "." et "[]"
    7. Précédence des opérateurs
  4. Objets implicites
    1. L'objet "pageContext"
    2. Les objets "pageScope", "requestScope", "sessionScope", "applicationScope"
    3. Les objets "param", "paramValues"
    4. L'objet "initParam"
    5. Les objets "header", "headerValues"
    6. L'objet "cookie"
  1. Introduction
    EL offre la possibilité d'écrire des expressions qui vont être évaluées dynamiquement à l'exécution de la page.
    Une expression peut être un accès à une variable, une opération sur des variables, ou une invocation de méthode.
    Voici un exemple d'utilisation d'une expression EL :

    Voici le code Java généré par le container de servlets :

    La valeur de l'expression ${x*y} est passée en paramètre à la méthode proprietaryEvaluate.
    À l'exécution de la page JSP l'expression va être évaluée et la valeur résultante de l'exécution de cette expression va être écris dans la sortie.

    Une expression EL est placée entre deux accolades "{" et "}" avec le caractère "$" placé avant la première accolade ouvrante : ${EL_Expression}
    À noter que les expressions EL ne permettent pas d'écrire des instructions de flux de commande (conditions, boucles).
  2. Les littéraux du langage EL
    Le typage n'est pas explicite avec EL, il est inféré par le compilateur dépendamment de la valeur de l'expression.
    Il y a cependant cinq catégories de littéraux qui sont mappés avec cinq types correspondants du langage Java.

    Notes :
    - Pour les littéraux "true", "false", et "null", il faut respecter la casse sinon l'évaluateur des expressions EL va considérer qu'il s'agit d'un nom de variable.
    - Pour les chaines de caractères, il est possible d'utiliser le caractère d'échappement "\" pour échapper les caractères ("), ('), et (\) : (\"), (\'), (\\).
  3. Opérateurs du langage EL
    1. Les opérateurs arithmétiques
      EL offre les opérateurs d'addition (+), soustraction (-), division (/ ou div), modulo (% ou mod), changement de signe (-).
      Ces opérateurs ont le même comportement que ceux du langage Java, à l'exception des cas suivants :
      • L'opérateur d'addition (+) s'applique uniquement aux nombres, et il n'est pas possible de l'utiliser avec des chaînes de caractères pour faire la concaténation, comme c'est le cas en Java.
        Ainsi l'opération ${"abc" + "12"} génère une exception java.lang.NumberFormatException : java.lang.NumberFormatException: For input string: "abc".

      • Les opérandes de ces opérateurs peuvent être des littéraux ou des variables et leurs valeurs peuvent être des nombres mais aussi des chaînes de caractères à condition que la chaîne de caractères soit convertible en une valeur numérique, par exemple l'opération ${"5" - "4"} donne le résultat "1".
        Vous obtiendrez l'exception vu ci-dessus si la conversion de un des opérandes de ces opérateurs échoue.

      • Si la variable est inexistante ou que sa valeur est nulle, alors par défaut l'évaluateur des expressions EL la traite comme si sa valeur est "0".
        Cela s'applique aussi au littéral null qui est considéré comme "0" lorsqu'il est utilisé comme opérande de ces opérateurs.
        Ainsi l'opération ${null + "4"} donne le résultat "4".

      • La division sur la valeur "0" ne génère pas une exception puisqu'elle est considérée une division réelle.
        Et donc le résultat de l'opération ${"5" / "0"} est la valeur "Infinity" (comme c'est le cas pour Java lorsque la division est réelle).

      • L'opérateur modulo performe une opération entière si les deux opérandes sont des valeurs entière, sinon, si un des opérandes et réel alors l'opérateur modulo performe une opération réelle.
        Ainsi l'opération ${"5" % 2} donne le résultat "1".
        Et l'opération ${"5" % "2.0"} donne le résultat "1.0".

      • L'opérateur unaire "-" permet de changer le signe d'un opérande (nombre) à la négative ou positive selon le signe du nombre.
        Ainsi l'opération ${- (4)} donne le résultat "-4".
        Et l'opération ${- (-5)} donne le résultat "5".

    2. Les opérateurs relationnels
      Nom de l'opérateur EL EL (syntaxe java)
      égale à eq
      (exemple : ${5 eq 2})       		==
      (exemple : ${5 == 2})
      différent de ne
      (exemple : ${5 ne 2})       		!=
      (exemple : ${5 != 2})
      plus grand que gt
      (exemple : ${5 gt 2})       		>
      (exemple : ${5 > 2})
      plus grand ou égale à ge
      (exemple : ${5 ge 2})       		>=
      (exemple : ${5 >= 2})
      plus petit que lt
      (exemple : ${5 lt 2})       		<
      (exemple : ${5 < 2})
      plus petit ou égale à le
      (exemple : ${5 le 2})       		<=
      (exemple : ${5 <= 2})

      Ces opérateurs s'appliquent autant sur des nombres que des chaînes de caractères.
      Le type de l'opération de comparaison dépend du type des opérandes :
      • Si les deux opérandes sont des nombres alors la comparaison est numérique.
        Exemple : ${5 le 22}.
        Résultat : "true".

      • Si un des opérandes est un nombre et la valeur du deuxième opérande est convertible en valeur numérique alors la comparaison est numérique.
        Exemple : ${5 le "22"}.
        Résultat : "true".

      • Si les deux opérandes sont des chaînes de caractères alors la comparaison est faite sur des chaînes de caractères.
        Exemple (1) : ${"5" le "22"}.
        Résultat : "false".
        Exemple (2) : ${"abc" le "xyz"}.
        Résultat : "true".

      • Sinon, si un des opérandes est un nombre et la valeur du deuxième opérande n'est pas convertible en valeur numérique alors l'évaluateur des expressions EL génère une exception javax.el.ELException.
        Exemple : ${5 le "abc"}.
        Résultat : javax.el.ELException: Cannot convert abc of type class java.lang.String to class java.lang.Long.

    3. Les opérateurs logiques
      Nom de l'opérateur
      		 EL
      		 Évaluation de la condition
      négation NOT
      		 not
      		 Exemple (1) : ${not x}
      Exemple (2) : ${! x}
      la condition est vraie si x est false
      la condition est fausse si x est true
      !
      opérateur AND
      		 and
      		 Exemple (1) : ${x and y}
      Exemple (2) : ${x && y}
      la condition est vraie si x et y sont true
      la condition est fausse si x ou/et y sont false
      &&
      opérateur OR
      		 or
      		 Exemple (1) : ${x or y}
      Exemple (2) : ${x || y}
      la condition est vraie si x ou/et y sont true
      la condition est fausse si x et y sont false
      ||

      Notes :
      L'évaluation d'une valeur qui n'est pas « true » est toujours fausse.
      Cela s'applique autant pour des chaînes de caractères (à l'exception de la chaîne de caractères "true"), des valeurs numériques, des variables non définies, et le littéral null.

      Exemples :
    4. L'opérateur ternaire "? :" (COND ? STMT1 : STMT2)
      L'opérateur ternaire utilise une expression conditionnelle, qui retourne true ou false, pour déterminer l'expression à exécuter.
      L'opérateur est équivalemment à une instruction if...else : if(COND) STMT1; else STMT2;
    5. L'opérateur empty
      L'application de l'opérateur empty est évaluée à vraie si l'opérande est null, l'opérande est une chaîne de caractères vide, l'opérande est une variable non définie, ou l'opérande est une variable dont la valeur est null.
      L'évaluation est aussi vraie si l'opérande est un tableau vide ou une collection vide.
      Autrement l'évaluation est fausse.

      Exemples :
    6. Les opérateurs d'accès "." et "[]"
      les opérateurs "." et "[]" permettent d'accéder aux propriétés d'un objet bean et aux éléments d'un tableau ou d'une collection de type List ou Map.
      • Accéder aux propriétés d'un objet bean :
        Les propriétés correspondent aux méthodes "getter" qui respectent la spécification de nommage des propriétés JavaBeans (les méthodes retournent une valeur et n'ont pas de paramètres).
        Pour accéder aux propriétés on spécifié le nom de la méthode sans le préfixe "get".

        L'opérateur "." peut être utilisé pour accéder aux propriétés du bean ${REFERENCE_NAME.PROPERTY_NAME}.

        De même l'opérateur "[]" peut être utilisé pour accéder aux propriétés du bean : le nom de la propriété est spécifié entre deux crochets.
        Le nom de la propriété peut être mis soit entre deux quottes doubles ${REFERENCE_NAME["PROPERTY_NAME"]} ou deux quottes simples ${REFERENCE_NAME["PROPERTY_NAME"]}.


        Si la valeur d'une propriété est un objet bean, alors il est possible d'utiliser ces opérateurs pour accéder aux propriétés du bean référencé :
        - ${REFERENCE_NAME.PROPERTY_NAME1.PROPERTY_NAME2}
        - ${REFERENCE_NAME["PROPERTY_NAME1"]["PROPERTY_NAME2"]}.

        Dans certains cas le nom de la propriété peut provenir d'une variable ; par exemple le nom d'un paramètre ou attribut du scope REQUEST. Dans ce cas il est possible d'utiliser l'opérateur "[]" pour accéder à la propriété :


      • Accéder aux éléments d'un tableau :
        Déclarer un tableau :

        Accéder aux éléments du tableau :

        Accéder aux éléments du tableau en utilisant un indice variable :


      • Accéder aux éléments d'une List :
        Déclarer une liste :

        Accéder aux éléments de la liste :

        Accéder aux éléments de la liste en utilisant un indice variable :


      • Accéder aux éléments d'une Map :
        Déclarer une Map :

        Accéder aux éléments de la Map :

        Accéder aux éléments de la Map en utilisant un indice variable :


    7. Précédence des opérateurs
      Si plusieurs opérateurs sont utilisés sans les parenthèses alors la priorité des opérateurs est résolue selon l'ordre présenté ici-bas.
      Si des opérateurs sont situés au même niveau alors la priorité s'applique de droite à gauche.
      1. [] .
      2. ()
      3. - (opérateur unaire : changement de signe) not ! empty
      4. * / div % mod
      5. + - (opérateur binaire : soustraction)
      6. < > <= >= lt gt le ge
      7. == != eq ne
      8. && and
      9. || or
      10. ? :
  4. Objets implicites
    EL offre des variables qui référencent des objets implicites.

    1. L'objet "pageContext"
      La variable "pageContext" peut être utilisée pour accéder aux propriétés de l'instance PageContext de la page JSP.
      Les règles pour accéder aux propriétés de l'objet sont celles vues avec les operateurs "." et "[]" pour accéder aux propriétés d'un objet bean s'appliquent aussi pour cette variables.
      Donc toutes les méthodes de la classe PageContext qui respectent la nomenclature JavaBeans sont accessibles.
      Par exemple, la classe PageContext déclare la méthode getRequest() qui retourne un objet de type ServletRequest qui lui-même déclare la méthode getServerName().
      Cette méthode est accessible comme suit :
    2. Les objets "pageScope", "requestScope", "sessionScope", "applicationScope"
      Ces variables référencent des objets, de type Map, qui donnent accès aux attributs des scopes "PAGE", "REQUEST", "SESSION", et "APPLICATION".

      Notes : Comme ces objets sont de type Map, donc les même règles, vues pour les operateurs "." et "[]" pour accéder aux éléments d'une Map, s'appliquent aussi pour ces variables.

      Notes : Il est possible d'accéder aux attributs de ces 4 scopes sans expliciter le scope, par exemple ${attr0}, dans ce cas la recherche est faite en utilisant la fonction "findAttribute" de la classe "PageContext" ${PageContext.findAttribute("attr0") qui va chercher l'attribut dans ces 4 scopes.
    3. Les objets "param", "paramValues"
      Ces variables référencent des objets, de type Map, qui donnent accès aux paramètres de la requête http.
      La variable "param" peut être utilisée pour lire la valeur d'un paramètre.
      La variable "paramValues" représente chaque paramètre par un tableau qui contient toutes les valeurs du paramètre, cela est utile pour lire les valeurs d'un paramètre qui a plusieurs valeurs.
      Si la variable "param" est utilisée avec un paramètre à plusieurs valeur, alors la valeur lue est celle du premier élément du tableau du paramètre référencé par la variable "paramValues".

      Notes : Comme ces objets sont de type Map, donc les même règles, vues pour les operateurs "." et "[]" pour accéder aux éléments d'une Map, s'appliquent aussi pour ces variables.
    4. L'objet "initParam"
      Cette variable donne accès aux paramètres d'initialisation de l'application (ServletContext).
      Notes : Comme cet objet est de type Map, donc les même règles, vues pour les operateurs "." et "[]" pour accéder aux éléments d'une Map, s'appliquent aussi pour cette variable.
    5. Les objets "header", "headerValues"
      Ces variables référencent des objets, de type Map, qui donnent accès aux entêtes de la requête http.
      La variable "header" peut être utilisée pour lire la valeur d'un entête.
      La variable "headerValues" représente chaque entête par un tableau qui contient toutes les valeurs de l'entête, cela est utile pour lire les valeurs d'un entête qui a plusieurs valeurs.
      Si la variable "header" est utilisée avec un entête à plusieurs valeur, alors la valeur lue est celle du premier élément du tableau de l'entête référencé par la variable "headerValues".

      Notes : Comme ces objets sont de type Map, donc les même règles, vues pour les operateurs "." et "[]" pour accéder aux éléments d'une Map, s'appliquent aussi pour ces variables.
    6. L'objet "cookie"
      Cette variable donne accès aux paramètres des cookies de la requête http.

      Notes : Comme cet objet est de type Map, donc les même règles, vues pour les operateurs "." et "[]" pour accéder aux éléments d'une Map, s'appliquent aussi pour cette variable.
© 2010-2022  mtitek