Partager un résumé des expressions EL dans la technologie des pages JSP

Cet article présente principalement le concept, le rôle et l'utilisation des expressions EL dans la technologie des pages JSP en Java. Les amis dans le besoin peuvent se référer aux

Concepts

. Le langage d'expression, ou expression EL, ou EL en abrégé, est un langage de programmation spécial à usage général en Java, emprunté à JavaScript et XPath. Sa fonction principale est d'intégrer des applications Web Java dans des pages Web (telles que JSP) pour accéder au contexte de la page et aux objets dans différentes portées, obtenir les valeurs des attributs d'objet ou effectuer des calculs ou des opérations de jugement simples. Lorsque EL obtient certaines données, il convertira automatiquement le type de données.

Fonctions principales :

1) Obtenir des données

L'expression EL est principalement utilisée pour remplacer les expressions de script dans les pages JSP Formule 332000003288cabbdff89f9a8e5a919b pour récupérer des objets Java et obtenir des données de différents types de domaines Web. (Objets dans un certain domaine Web, accès aux attributs Javabean, accès aux collections de listes, accès aux collections de cartes, accès aux tableaux)

2) Effectuer des opérations

Utiliser l'expression EL Les formules peuvent effectuez quelques opérations relationnelles de base, opérations logiques et opérations arithmétiques dans les pages JSP pour effectuer quelques opérations logiques simples dans les pages JSP. ${user==null}

3) Obtenir des objets communs dans le développement Web EL

L'expression définit certains objets implicites En utilisant ces objets implicites, les utilisateurs de développement Web peuvent. obtenir facilement des références à des objets courants sur le Web et obtenir les données de ces objets.

4) Appel de méthodes Java

L'expression EL permet aux utilisateurs de développer des fonctions EL personnalisées pour appeler des méthodes de classes Java via des expressions EL dans les pages JSP.

Remarque : c2e5868eecb32499c932f05f78ece5cd indique s'il faut désactiver le langage EL, TRUE signifie interdit. FALSE signifie que le langage EL n'est pas interdit est activé par défaut dans JSP2.0

<.> 2. Syntaxe

commence par "${" et se termine par "}" :

${EL表达式}

Exemple :

${ str } //输出字符串变量str的值
${ 1 + 2 } //输出1+2的结果
${ user.name} //输出user对象的name属性 访问对象user的getName()方法以得到name成员的值。
${user[“name”] } //同上
${ sessionScope[“user”].name } //同上
${list[0]} //访问list对象的第一项。
${map[“key”]} //访问map指定键的值。

3. Récupérer les opérateurs

EL propose deux opérateurs : et [ ] pour accéder aux données :

. une entrée de mappage telle que : ${ user.name}

[ ] peut accéder aux éléments d'une collection ou d'un tableau, et peut également accéder aux propriétés d'un Bean. Par exemple : ${ arr[0].name}

Similarités et différences :

Identique : peut être utilisé pour accéder aux propriétés de l'objet

Différence : quand Si le nom de l'attribut consulté contient des caractères spéciaux, tels que . > 4. Opérateurs :

user.my-name应{user[“my-name”]}

● Il existe cinq opérateurs arithmétiques : +, -, *,/ou p, % ou mod

● Il existe six opérateurs relationnels : == ou eq, ! = ou ne, ebd473c87e36e09bed7b5e747e8c132c ou gt, 1cb84248307cdd5f3f30c64aa5992888= ou ge

● Il existe trois opérateurs logiques : && ou et, || ! ou pas

● Il existe trois autres opérateurs : Opérateur vide, opérateur conditionnel, () opérateur

Objets implicites

JSP EL prend en charge les objets implicites répertoriés dans le tableau suivant :

Vous pouvez utiliser ces objets dans des expressions comme des variables.

Regrouper par fonction comme suit :

1) Valeur du paramètre d'accès :

param : Le nom du paramètre de requête unique correspondant peut être obtenu de la valeur. Par exemple : $(param.name) est équivalent à request.getParameter (name).

paramValues : Le tableau de chaînes correspondant peut être obtenu en fonction du nom du paramètre. Par exemple : ${paramvalues.name) est équivalent à request.getParamterValues(name).

Remarque : L'objet param renvoie une seule chaîne, tandis que l'objet paramValues ​​​​​​renvoie un tableau de chaînes.

2) Accéder aux informations d'en-tête

en-tête : Vous pouvez obtenir la valeur d'en-tête de chaîne unique correspondante dans les informations d'en-tête de la demande. L'expression header.name est équivalente à request.getHeader(name). Tel que {header[« user-agent »]}. L’en-tête de l’agent utilisateur peut être imprimé.

headerValues : le nom de l'en-tête de la requête peut être mappé à un tableau numérique. Par exemple, ${headerValues.name} équivaut à request.getHeaderValues(name).

Remarque

 : L'objet header renvoie une valeur unique, tandis que headerValues ​​​​​​renvoie un tableau de chaînes.

3) Accéder à d'autres détails sur la demande ou la page de l'utilisateur

pageContext :

pageContext.request Obtenir l'objet de la demande | {pageContext.session} |Obtenir l'objet de session

pageContext.request.queryString|Obtenir la chaîne de paramètres de la requête {pageContext.request.requestURL} |Obtenir l'URL de la requête, mais n'inclut pas le paramètre chaîne de la requête

pageContext.request.contextPath|Le nom de l'application web servie {pageContext.request.method}|Récupérer la méthode HTTP (GET, POST)

pageContext.request.protocol |Obtenir le protocole utilisé ( HTTP/1.1, HTTP/1.0){pageContext.request.remoteUser} |Obtenir le nom d'utilisateur

pageContext.request.remoteAddr|取得用户的IP地址{pageContext.session.new} |判断session是否为新的，所谓新的session，表示刚由 server产生而client尚未使用 的

pageContext.session.id|取得session的ID{pageContext.servletContext.serverInfo}|取得主机端的服务信息

4）访问不同作用域的变量，如 Web 上下文、会话、请求、页面：

pageScope ：取得页面范围的值

如用 pageScope.objectName访问一个JSP中页面范围的对象，还可以使用{pageScope.objectName.attributeName} 访问对象的属性。

requestScope：取得请求范围的变量值

该对象允许访问请求对象的属性。如用 requestScope.objectName访问一个JSP请求范围的对象，还可以使用{requestScope.objectName.attributeName} 访问对象的属性。

sessionScope：取得会话范围的变量值

该对象允许访问会话对象的属性。如：$sessionScope.name}

applicationScope：取得应用程序范围的变量值

该隐式对象允许访问应用程序范围的对象

5) 访问Cookie中的值

如要取得cookie中有一个设定名称为username的值，可以使用${cookie.username} 来取得它。

六、使用sun提供的标准 EL函数库

由于在JSP页面中显示数据时，经常需要对显示的字符串进行处理，SUN公司针对于一些常见处理定义了一套EL函数库供开发者使用。

这些EL函数在JSTL开发包中进行描述，因此在JSP页面中使用SUN公司的EL函数库，需要导入JSTL开发包，并在页面中导入EL函数库。

使用EL函数库

1) 导入 jstl jar包

2) 在相应的jsp页面添加引用

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8" import="java.util.*" %>
<!--导入需要使用taglib指令 --> 
 
<%@ taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions" %>
<!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=UTF-8">
<title>el function demo</title>
</head>
<body>
 
   <%
       String[] strs = {"a","b","c"};//定义一个字符数组
       List list = new ArrayList();//定义一个list集合
       list.add("a");//向集合中添加一个字符
       pageContext.setAttribute("arr", strs);//将字符数据以arr的名字保存在page域中
       pageContext.setAttribute("list", list);//将list集合以list的名字保存在page域中
    %>
 
${fn:length(arr) }<br/><!--3-->
${fn:length(list) }<br/><!--1-->
${fn:toLowerCase("Hello") }<br/> <!-- hello -->
${fn:toUpperCase("Hello") }<br/> <!-- HELLO -->
${fn:contains("abc", "a")}<br/><!-- true -->
${fn:containsIgnoreCase("abc", "Ab")}<br/><!-- true -->
${fn:contains(arr, "a")}<br/><!-- true -->
${fn:containsIgnoreCase(list, "A")}<br/><!-- true -->
${fn:endsWith("Hello.java", ".java")}<br/><!-- true -->
${fn:startsWith("Hello.java", "Hell")}<br/><!-- true -->
${fn:indexOf("Hello-World", "-")}<br/><!-- 5 -->
${fn:join(arr, ";")}<br/><!-- a;b;c -->
${fn:replace("Hello-World", "-", "+")}<br/><!-- Hello+World -->
${fn:join(fn:split("a;b;c;", ";"), "-")}<br/><!-- a-b-c -->
${fn:substring("0123456789", 6, 9)}<br/><!-- 678 -->
${fn:substring("0123456789", 5, -1)}<br/><!-- 56789 -->
${fn:substringAfter("Hello-World", "-")}<br/><!-- World -->
${fn:substringBefore("Hello-World", "-")}<br/><!-- Hello -->
${fn:trim("   a b c   ")}<br/><!-- a b c -->
${fn:escapeXml("<html></html>")}<br/> <!-- <html></html> --> 
</body>
</html>

函数库详细介绍

String toUpperCase(String input)：把字符串参数转换成大写，并返回

String toLowerCase(String input)：把字符串参数转换成小写，并返回

int indexOf(String input, String substring)：返回input中substring出现的索引位置

boolean contains(String input, String substring)：查看input中是否包含substring，包含返回true，否则返回false；

boolean containsIgnoreCase(String input, String substring)：在忽略大小写的情况下，查看input中是否包含substring，包含返回true，否则返回false

boolean startsWith(String input, String substring)：判断input是否是以substring为前缀，如果是就返回true，否则就返回false

boolean endsWith(String input, String substring)：判断input是否是以substring为后缀，如果是就返回true，否则就返回false

String substring(String input, int beginIndex, int endIndex)：以beginIndex为开始值，endIndex为结束值，在input上截取子串

String substringAfter(String input, String substring)：获取input中，substring所在位置后面的字符串

substringBefore(String input, String substring)：获取input中，substring所在位置前面的字符串 String escapeXml(String input)：把input中“a49f0050de68a7521e560d1cb8dde1e7“、”&“、”'“、“””进行转义；

String trim(String input)：去除input中的前后空格；

String replace(String input, String substringBefore, String substringAfter)：将input中的substringBefore替换成substringAfter；

String[] split(String input, String delimiters)：以delimiters为标识分割input，返回一个字符串数组；

int length(Object obj)：可以获取字符串、数组、各种集合的长度；

String join(String array[], String separator)：将array数组中的元素以separator连接起来，返回一个字符串

七、EL调用自定义函数 （调用普通类的静态方法）

EL很强大，除了使用SUN提供的标准EL函数库外，还可以调用自定义函数：

● EL表达式语法允许开发人员开发自定义函数，以调用Java类的方法。语法：${prefix：method(params)}

● 在EL表达式中调用的只能是Java类的静态方法，这个Java类的静态方法需要在TLD文件中描述，才可以被EL表达式调用。

● EL自定义函数用于扩展EL表达式的功能，可以让EL表达式完成普通Java程序代码所能完成的功能。

EL Function开发步骤

只要实现以下三个步骤就可以在静态页面中用${prefix：method(params)} 调用自定义function了

编写一个Java类的静态方法

编写标签库描述符（tld）文件，在tld文件中描述自定义函数。

在JSP页面中导入和使用自定义函数

下面来个案例：

1）编写一个Java类的静态方法

public class GetMax {
  public static int togetMax(int a, int b){
    return a>b?a:b;
  }
}

2）编写标签库描述符（tld）

<?xml version="1.0" encoding="UTF-8"?> 
<taglib xmlns="http://java.sun.com/xml/ns/j2ee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-jsptaglibrary_2_0.xsd" 
version="2.0">  
  <tlib-version>1.0</tlib-version><!-- 定义的版本 --> 
  <short-name>mytaglib</short-name><!--这个名字可以随便取，尽量与文件名相同，这样我们知道文件在哪儿 并与prefix对应--> 
  <uri>http://localhost:8080/springmvc-1</uri><!-- 这个地址是随便取得。到时候jsp页面引入这个地址 -->          
  <function><!-- 定义函数 --> 
    <name>toGetMax</name>
    <function-class>elfunction.GetMax</function-class><!-- 定义函数的类全名称 --> 
    <function-signature>int toGetMax(int,int)</function-signature> 
    <!--说明 返回值类型 函数名 以及 参数类型 --> 
  </function> 
</taglib>

3）在web.xml中指定tld文件的位置（这步可以省略，因为应用会自动找到 /WEB-INF/下的tld文件）

<jsp-config> 
    <taglib> 
      <!-- 此处uri可以自己随便定义，但后面用时一定与这里一样 --> 
      <taglib-uri> 
        http://localhost:8080/springmvc-1
      </taglib-uri> 
      <!-- tld文件的路径 --> 
      <taglib-location> 
        /WEB-INF/tags/mytaglib.tld
      </taglib-location> 
    </taglib> 
  </jsp-config>

4）在JSP页面中导入和使用自定义函数

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
 
<%@ taglib uri="http://localhost:8080/springmvc-1" prefix="mytaglib"%> 
<!-- prefix 是前缀的意思，应与mytaglib.tld中的<short-name>对应 -->
 
<!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=UTF-8">
<title>custom EL function test</title>
</head>
<body>
  1和2求最大值 = ${mytaglib:toGetMax(1,2)}
</body>
</html>

运行截图

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!