markdown 表达语言EL

Posted 2021-05-06

# Expression Language

les expressions EL permettent via une syntaxe très épurée d'effectuer des tests basiques sur des expressions, et de manipuler simplement des objets et attributs dans une page, et cela sans nécessiter l'utilisation de code ni de script Java !

Il vous est possible d'inclure toute une série d'opérateurs :

- Opérateurs arithmétiques, applicables à des nombres : `+, -, *, /, %`
- Opérateurs logiques, applicables à des booléens : `&&, ||, !`
- Opérateurs relationnels, basés sur l'utilisation des méthodes `equals()`
  et `compareTo()` des objets comparés : `==` ou `eq`, `!=` ou `ne`, `<` ou `lt`, `>` ou `gt`, `<=` ou `le`, `>=` ou `ge`.
- Pour vérifier l'égalité d'objets de type non standard via une EL, il faudra probablement réimplémenter les méthodes `equals()`.
- Pour effectuer une comparaison, il faudra vérifier que l' objet implémente bien l'interface Comparable.


### Les classes utilisées dans la JSP doivent avoir les getters pour que les propriétées soit accessible:

```
<!-- Un Bean ou un Model -->
public class Test {
  private String name;
  public String getName() {
    return this.name;
  }
}

<!-- Dans la servlet on instancie Test dans la variable test et on renvoi à la JSP. -->
public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
  Test test = new Test();
  request.setAttribute( "test", test );
  this.getServletContext().getRequestDispatcher( VUE_GET ).forward( request, response );
}

<!-- Dans la JSP, "GetName" de l'objet test sera appelé pour récupérer la propriété privé "name" -->
${test.name}
```


Examples :

```
<!-- Il est possible d' utiliser également des simple quotes (apostrophes) dans une expression EL -->
${ 'a' < 'b' }
<!-- Utilisation de gt sur des objets String -->
${ 'hip' gt 'hit' }
<!-- Utilisation de lt sur des objets Interger -->
${ 12 lt 8 }
<!-- Plusieurs comparaisons -->
${ 'a' < 'b' && 'hip' gt 'hit' }
<!-- Un test sur une opération -->
${ 6 * 7 == 48 }
<!-- Opérateur ternaire -->
${ 6 > 7 ? 'ok' : 'ko' }
<!-- Si la variable test est vide ou undefined toto est affiché -->
${ empty test ? 'toto' : 'titi' }
```

## La manipulation d'objet

### La manipulation de beans 

```
<!-- Syntaxe conseillée pour récupérer la propriété 'prenom' du bean 'coyote'. -->
${ coyote.prenom }

<!-- Syntaxe déconseillée car on différencie moins les beans avec les collections de cette façon. -->
${ coyote["prenom"] }

<!-- Syntaxe correcte, car il est possible d'expliciter la méthode d'accès à la propriété. Préférez toutefois la notation précédente. -->
${ coyote.getPrenom() }

<!-- Syntaxe erronée : la première lettre de la propriété doit être une minuscule. -->
${ coyote.Prenom }

<!-- Comparaison d'égalité entre la propriété prenom et la chaîne "Jean-Paul" -->
${ coyote.prenom == "Jean-Paul" }

<!-- Vérification si la propriété prenom est vide ou nulle -->
${ empty coyote.prenom }

<!-- Condition ternaire qui affiche la propriété prénom si elle n'est ni vide ni nulle, et la chaîne "Veuillez préciser un prénom" sinon -->
${ !empty coyote.prenom ? coyote.prenom : "Veuillez préciser un prénom" }
```

### La manipulation de collections
Objets de type java.util.List, java.util.Set, java.util.Map

- Il est impossible d'utiliser directement l'opérateur point pour accéder à un élément d'une liste ou d'un tableau. Les syntaxes `${entiers.1}` ou `${animaux.2}` enverront une exception à l'exécution.
- Il est possible d'utiliser directement l'opérateur point pour accéder à un élément d'un objet `Map` comme pour les objets JavaBeans
- Une pratique efficace veut que l'on réserve la notation avec l'opérateur point pour l'accès aux propriétés d'un bean, 
  et que l'on utilise les crochets pour accéder aux contenus d'une `Map`. 
  Ainsi en lisant le code d'une page JSP, il devient très simple de savoir si l'objet manipulé dans une expression EL est un bean ou une `Map`.

Example avec un objet List :

```
<!-- Appel à une méthode de l'objet -->
${ legumes.get(1) }<br />
<!-- Utilisation de crochets contenant directement l'indice de l'élément voulu -->
${ legumes[1] }<br />
<!-- Utilisation de crochets contenant l'indice de l'élément entouré d'apostrophes -->
${ legumes['1'] }<br />
<!-- Utilisation de crochets contenant l'indice de l'élément entouré de guillemets -->
${ legumes["1"] }
```

Example avec un tableau :

```
<!-- Le tableau initialisé depuis la servlet -->
String[] animaux = {"chien", "chat", "souris", "cheval"};
<!-- Récupération des données depuis la JSP -->
${ animaux[2] }<br />
${ animaux['2'] }<br />
${ animaux["2"] }<br />
```

Example avec un objet Map :

```
<!-- Les quatre syntaxes suivantes retournent la valeur associée à la clé "cookies" de la Map de desserts  -->
${ desserts.cookies }<br />
${ desserts.get("cookies") }<br />
${ desserts['cookies'] }<br />
${ desserts["cookies"] }<br />
<!-- Il est également possible d'utiliser un objet au lieu d'initialiser la clé souhaitée directement dans l'expression -->
String element = "cookies"; 
request.setAttribute("element",element);
${ desserts[element] }<br />
```