52-EL和JSTL核心技术

EL和JSTL核心技术

EL表达式（熟悉）---------------------------

基本概念：

EL（Expression Language）表达式提供了在JSP中简化表达式的方法，可以方便地访问各种数据并输出

主要功能：

依次访问pageContext、request、session和application作用域对象存储的数据

获取请求参数值

访问Bean对象的属性

访问集合中的数据

输出简单的运算结果

访问内置对象的数据：

访问方式：

<%=request.getAttribute("varName")%>
用EL实现: ${ varName }

执行流程：

<%--
  Created by IntelliJ IDEA.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>


    


<%
    /*pageContext.setAttribute("name1", "pageContext对象中的属性值：zhangfei");
    request.setAttribute("name2", "request对象中的属性值：guanyu");
    session.setAttribute("name3", "session对象中的属性值：liubei");
    application.setAttribute("name4", "session对象中的属性值：zhaoyun");*/
    //pageContext.setAttribute("name", "pageContext对象中的属性值：zhangfei");
    //request.setAttribute("name", "request对象中的属性值：guanyu");
    //session.setAttribute("name", "session对象中的属性值：liubei");
    application.setAttribute("name", "session对象中的属性值：zhaoyun");
%>

<%-- 使用JSP中原始方式获取数据和打印 --%>
<%--<%= "name1的数值为：" + pageContext.getAttribute("name1") %>
   <%– zhangfei 
    –%>
<%= "name2的数值为：" + request.getAttribute("name2") %>
       <%– guanyu –%>
<%= "name3的数值为：" + session.getAttribute("name3") %>
       <%– liubei –%>
<%= "name4的数值为：" + application.getAttribute("name4") %>
   <%– zhaoyun 
    –%>--%>
<%-- 使用EL表达式实现获取数据和打印 --%>
<%--
name1的数值为：${name1}

name2的数值为：${name2}

name3的数值为：${name3}

name4的数值为：${name4}
--%>
name的数值为：${name}

<%-- 结果从范围依次查找，从小到大
    即pageContext到application一路找getAttribute方法找过去，找到了，则不找了，即取找到的值，--%>

访问请求参数的数据：

在EL之前使用下列方式访问请求参数的数据

request.getParameter(name)

request.getParameterValues(name)

在EL中使用下列方式访问请求参数的数据

param：接收的参数只有一个值

paramValues：接受的参数有多个值

${param.name}

${paramValues.hobby[0]}

<%--
  Created by IntelliJ IDEA.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>


    




    姓名：

    爱好：唱歌

         跳舞

         学习

    

<%@ page import="java.util.Arrays" %><%--
  Created by IntelliJ IDEA.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>


    


<%
    request.setCharacterEncoding("utf-8");
    //注意：jsp变成java与转译的编码格式有关，而这里是设置request的编码格式（post）
%>
<%-- 使用JSP语法中的原始方式获取请求参数值 --%>
<%--<%= "姓名是：" + request.getParameter("name") %>

<%= "爱好是：" + Arrays.toString(request.getParameterValues("hobby")) %>
--%>

<%-- 使用EL表达式中的方式获取请求参数值 --%>
姓名是：${param.name}

爱好是：${Arrays.toString(paramValues.hobby)}

爱好是：${paramValues.hobby[0]}

<%-- param相当于找getParamter的对应参数化的值
即param.name  ==>  request.getParameter("name")--%>
<%-- paramValues相当于找getParamterValues的对应参数化的值
即paramValues.hobby[0]  ==>  request.getParameterValues("name")[0]--%>

访问Bean对象的属性：

访问方式：

//方式一： $ { 对象名 . 属性名 }，例如：${user.name}
//方式二： $ { 对象名 ["属性名"] }，例如：${user["name"]}

<%@ page import="com.lagou.demo01.Person" %><%--
  Created by IntelliJ IDEA.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>


    


<%-- 使用JSP语法规则中的原始方式实现对象的创建和设置以及输出 --%>
<%
    Person person = new Person();
    person.setName("zhangfei");
    person.setAge(30);
    pageContext.setAttribute("person", person);

    pageContext.setAttribute("var1", "name");
    pageContext.setAttribute("var2", "age");

%>

<%--<%= "获取到的姓名为：" + person.getName() %>

<%= "获取到的年龄为：" + person.getAge()  %>
--%>
<%-- 使用EL表达式实现属性的获取和打印 --%>
<%--获取到的姓名是：${person.name}

获取到的年龄是：${person.age}
--%>
<%-- 另外一种写法 --%>
<%--${person["name"]}

${person["age"]}
--%>
<%-- 测试一下动态取值的效果 --%>
获取到的姓名是：${person.name}

${person["age"]}

<%-- 相当于下面的get方法，但是只会默认调用对应的getxxx方法，且xxx首字母大小写忽略
但是[]形式可以放特殊的符号，如点，而有些需要使用点的会报错，如param，所以最好使用[]
--%>
获取到的年龄是：<%=person.getAge()%>

动态取值的结果为：${person[var1]}
<%-- 相当于person[对应对象.getAttribute("var1")]，这里是person["name"]
其中对应对象.getAttribute("var1")也是依次查找范围的值，即pageContext到application的getAttribute方法的值
找到，就取值，然后不找了
--%>
${person.getAge()}<%-- 也可以这样，底层判断是否为方法，是，则调用结果
    即就是${30}，这样，变成了值放入了，在EL表达式里，{}里面都会变成字符串，即不会当场调用
   直接的输出${person}，就是自动调用toString方法
    --%>

主要区别：

当要存取的属性名中包含一些特殊字符，如： . 或 ,等并非字母或数字的符号，就一定要使用 [ ]而不是.的方式

使用[]的方式可以动态取值，具体方式如下：

<% request.setAttribute("prop","age");%>

${ user[prop] }

访问集合中的数据：

${student[0].name}，取出类，然后取出name

<%@ page import="java.util.LinkedList" %>
<%@ page import="java.util.List" %>
<%@ page import="java.util.HashMap" %>
<%@ page import="java.util.Map" %><%--
  Created by IntelliJ IDEA.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>


    


<%
    // 准备一个List集合并添加数据内容
    List list = new LinkedList<>();
    list.add("two");
    list.add("one");
    list.add("three");
    // 将整个集合放入指定的内置对象中
    pageContext.setAttribute("list", list);

    // 准备一个Map集合并添加数据
    Map map = new HashMap<>();
    map.put("one", 1);
    map.put("two", 2);
    map.put("th.ree", 3);
    // 将整个集合放入指定的内置对象中
    pageContext.setAttribute("map", map);

%>

<%-- 使用EL表达式实现集合中数据内容的获取 --%>
集合中下标为0的元素是：${list[0]}
    <%-- two 相当于下面的方式--%>
${list.get(0)}

集合中下标为1的元素是：${list[1]}
    <%-- one --%>
集合中下标为2的元素是：${list[2]}
    <%-- three --%>

<%-- 使用EL表达式实现Map集合中数据内容的获取 不支持下标 --%>
整个Map集合中的元素有：${map}
 <%-- 直接输出所有数据，且是数组的形式--%>
获取带有特殊字符key对应的数值为：${map["th.ree"]}
   <%-- 3 相当于map的get方法
    集合没有动态的，但类有
    --%>

常用的内置对象：

上面的作用域用来明确要求取那个范围的值，而不用依次取了，用法如下

//session.setAttribute("name", "session对象中的属性值：liubei");
//application.setAttribute("name", "session对象中的属性值：zhaoyun");
//一般情况下使用：${name}，取的是liubei
//若使用：${applicationScope.name}，取的是zhaoyun

常用的运算符：

常用的算术运算符：

常用的关系运算符：

常用的逻辑运算符：

条件运算符：

//${条件表达式? 语句1 : 语句2} 

验证运算符：

//${empty 表达式}
//返回布尔值判断表达式是否为"空"值，null值、无元素的集合或数组、长度为零的String被认为是空值

<%@ page import="java.util.List" %>
<%@ page import="java.util.LinkedList" %>
<%@ page import="java.util.Arrays" %><%--
  Created by IntelliJ IDEA.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>实现常用运算符的使用</title>
</head>
<body>
<%
    // 通过内置对象设置属性的方式来准备操作数
    request.setAttribute("ia", 5);
    request.setAttribute("ib", 2);
    request.setAttribute("b1", true);
    request.setAttribute("b2", false);
%>

<%-- 实现上述所有操作数的获取和打印 --%>
ia的数值为：${ia}<br/>      <%-- 5 --%>
ib的数值为：${ib}<br/>      <%-- 2 --%>
b1的数值为：${b1}<br/>      <%-- true --%>
b2的数值为：${b2}<br/>      <%-- false --%>
<hr/>

<%-- 实现算术运算符的使用 --%>
ia+ib的结果为：${ia+ib}<br/>    <%-- 7 --%>
ia-ib的结果为：${ia-ib}<br/>    <%-- 3 --%>
ia*ib的结果为：${ia*ib}<br/>    <%-- 10 --%>
ia/ib的结果为：${ia/ib}<br/>    <%-- 2.5 与java不同，这里会保留小数点，底层操作保留--%>
ia%ib的结果为：${ia%ib}<br/>    <%-- 1 --%>
<hr/>

<%-- 实现关系运算符的使用 --%>
ia大于ib的结果为：${ia > ib}<br/>  <%-- true --%>
ia大于等于ib的结果为：${ia >= ib}<br/>  <%-- true --%>
ia< ib的结果为：${ia < ib}<br/>  <%-- false 注意：由于<是一个开始标签的符号，会与其他特殊符号发生响应
所以不能这样写，如
<和：,：如果是:那么可以，因为是一个标识，但若是：(中文冒号)，则会报错，不是一个标识
这时最好分开，即< 和：，这样就不会当成开始标签的一体了
-%>
ia小于等于ib的结果为：${ia <= ib}<br/>  <%-- false --%>
ia等于ib的结果为：${ia == ib}<br/>  <%-- false --%>
ia不等于ib的结果为：${ia != ib}<br/>  <%-- true --%>
<hr/>

<%-- 实现逻辑运算符的使用 --%>
b1并且b2的结果为：${b1 && b2}<br/>  <%-- false --%>
b1或者b2的结果为：${b1 || b2}<br/>  <%-- true --%>
b1取反的结果为：${ !b1 }<br/>  <%-- false --%>
b2取反的结果为：${ !b2 }<br/>  <%-- true --%>
<hr/>

<%
    String str1 = null;
    String str2 = "";
    String str3 = "hello";

    List<Integer> list1 = new LinkedList<>();
    List<Integer> list2 = Arrays.asList(11, 22, 33, 44, 55);

    request.setAttribute("str1", str1);
    request.setAttribute("str2", str2);
    request.setAttribute("str3", str3);
    request.setAttribute("list1", list1);
    request.setAttribute("list2", list2);

%>
<%-- 实现条件运算符和验证运算符的使用 --%>
ia和ib之间的最大值为：${ia>ib? ia: ib}<br/>
判断是否为空的结果是：${empty str1}<br/>    <%-- true --%>
判断是否为空的结果是：${empty str2}<br/>    <%-- true --%>
判断是否为空的结果是：${empty str3}<br/>    <%-- false --%>
判断是否为空的结果是：${empty list1}<br/>    <%-- true --%>
判断是否为空的结果是：${empty list2}<br/>    <%-- false 
没设置对应对象值，返回空，即null
--%>

</body>
</html>

JSTL标签（熟悉）：

基本概念：

JSTL( JSP Standard Tag Library ) 被称为JSP标准标签库

开发人员可以利用这些标签取代JSP页面上的Java代码，从而提高程序的可读性，降低程序的维护难度

使用方式：

下载JSTL的jar包并添加到项目中，下载地址为：https://tomcat.apache.org/download-taglibs.cgi

shift+左键，可以选择多个文件，一个一个点

在JSP页面中使用taglib指定引入jstl标签库，方式为：

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>

常用核心标签：

输出标签：

 用来将指定内容输出的标签

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%--
  Created by IntelliJ IDEA.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>


    




<%--
//虽然上面是输出value的值，但其实还是底层的操作，进行输出的
就如我们<%符号类似，底层操作，但输出的还是out.write方法输出
--%>

设置标签：

 用来设置属性范围值的标签

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%--
  Created by IntelliJ IDEA.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>


    


<%-- 表示设置一个名字为name的属性，对应的数值为zhangfei，有效范围为：page --%>
<%-- pageContext.setAttibute("name", "zhangfei") --%>

<%-- 使用out标签打印出来 --%>

<%-- EL表达式可以写在字符串里面进行解释，而普通的直接值或者变量，在字符串里会变成字符串
只所以这样，是因为${}符号会被识别，然后操作信息，而单纯的字符串不会
所以这就是为什么要有EL表达式的原因了，是为了在字符串里进行操作
--%>


<%-- 设置一个对象的属性值并打印出来 --%>



    <%-- target指定向谁设置，若没有，则就是创建变量，无论是什么操作，基本上scope都默认page
    若不同范围，则不会操作，且会报错，因为会判断该范围内是否有指定对象存在，不存在则报错
    因为无论怎么操作，都是放入对应范围对象里面的，即对应的setAttribute方法里，取值也是对应getAttribute方法
    底层如此操作，因为地址是相同的，所以是这里设置了，地址值发生改变
    --%>
<%-- 类似于jsp:setProperty ,即
其中name变成了target，都是指定对方，实际上就是指定对象，因为直接输出${person}时，返回toString方法
而使用target则得到了该引用，与name得到一样，但双方都不可以使用各自的获得对象的方式
这是jstl的一种方式
    
    其中property使用的是对应setxxx方法，xxx的首字母不忽略大小写
--%>


<%-- EL表达式一般是操作变量，对于类来说底层操作对应变量的get方法
    使用[]也是，但需要是字符串，
    而对于[]来说，集合的话，单集合，如List，则是数组形式，也可以使用对应方法
    双集合，如map，则是字符串形式，也可以使用对应方法
    上面的各种形式，方法不限制，只是EL表达式简写了一些操作而已，上面普通的操作不会报错，各有各的简写
    之后若[]里不是字符串的话，就是操作范围key，获得对应的值，但集合不可这样操作
    则使用范围的操作
    或者依次得到
    单纯的直接写操作范围key，那么就是对应的值，这是简写形式
    由于会识别${}，即可以在字符串里操作，且可以除底层操作外，做另外的操作，将他看成一个数值
    即可以对他进行操作，如变为数组输出
    单纯的符合${}的，实际上是输出的，因为没有赋值，在字符串里一般赋值给别人
    在使用El表达式时，首先要符合El表达式的操作，才可进行简化，否则相当于没写一样
    
    上面El表达式是因为符号的原因才被进行字符串里的操作
    所以<%=%>也可以写进字符串里面，都通过符号进行操作，底层操作时，消除两边引号进行赋值
    且<%=%>里写El表达式时，会报错
    EL表达式里写<%=%>，也会报错，不可嵌套，因为他们互不识别对方
    
    其中<%=%>是可以操作直接定义的变量的，因为底层直接消除引号写入
    而El表达式不可，因为，底层他并没有获得直接变量的传参，即没有定义变量的值
    只有写入的参数总值
    在jstl里无论什么操作在底层都是_jspx_meth_c_005fforEach_005f1(_jspx_page_context)
    所以的内容都传入了，所以中间的操作都是由这个方法和参数决定的
    
    可以理解为EL表达式就是直接获得其他存放好的东西的简化，如set存放，类存放，集合存放
    --%>

删除标签：

 用来删除指定数据的标签

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%--
  Created by IntelliJ IDEA.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>


    


<%-- 设置一个属性值并打印 --%>




<%-- 删除这个属性值后再次打印 --%>


    <%-- 当没有值时，default的值就是该值，即默认为无名--%>

单条件判断标签：

 
    满足条件执行

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%--
  Created by IntelliJ IDEA.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>


    


<%-- 设置一个变量以及对应的数值 --%>




<%-- 判断该年龄是否成年，若成年则提示已经成年了 --%>

 <%-- 当然true也可以，只是EL表达式可以在字符串里进行操作--%>

    


    

    
        
    

由于上面的" c:if "，只能嵌套，当嵌套多次的话，没有层次感，所以就有了多条件判断的标签

多条件判断标签：

 
      
        满足条件执行  
    
    … 
        
        不满足上述when条件时执行
    

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%--
  Created by IntelliJ IDEA.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>


    


<%-- 设置一个变量代表考试的成绩并指定数值 --%>




<%-- 进行多条件判断和处理 --%>


    
        
    
    
        
    
    
        
    

<%-- 从上到下，当有一个when成立，则后面的都不执行，即跳出
且choose里面只能包含when和otherwise标签，其他的无论是标签还是直接值都不可以
 否则报错，但不管他们里面的标签和值
 当when都没有成立时，就执行otherwise标签的内容，且otherwise标签只能有一个，否则报错
 当然，这两个标签里也可以嵌套多条件标签等等，因为这个内容由你操作
 --%>

循环标签：

    …

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%--
  Created by IntelliJ IDEA.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>


    


<%
    // 准备一个数组并初始化
    String[] sArr = {"11", "22", "33", "44", "55"};
    pageContext.setAttribute("sArr", sArr);
%>
<%-- 使用循环标签遍历数组中的所有元素 --%>

    



<%-- 跳跃性遍历 间隔为2  也就是跳过一个遍历一个 --%>

    



<%-- 指定起始和结尾位置 从下标1开始到3结束，包含1和3--%>

    

<%--
其中var得到的是数组的值，所以可以直接" ${值} "输出
而begin则是开始的位置，end结束的位置，开始和结束都包括，他们代表着下标
step则是下标加多少的意思，如下标为1，那么下次直接为3，若加的下标超过总下标，那么跳出循环，默认加1
开始不加，当循环一次再加
--%>

常用函数标签：

<%@ taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions" %>

<%@ taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions" %>
<%--
  Created by IntelliJ IDEA.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>


    


<%
    pageContext.setAttribute("var", "Hello World!");
%>
原始字符串为：${var}
    <%-- HelloWorld --%>
判断该字符串是否包含指定字符串的结果为：${fn:contains(var, "Hello")}
   <%-- true --%>
将字符串中所有字符转换为大写的结果为：${fn:toUpperCase(var)}
           <%-- HELLO WORLD!--%>
将字符串中所有字符转换为小写的结果为：${fn:toLowerCase(var)}
           <%-- hello world!--%>

常用格式化标签：

<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>

<%@ page import="java.util.Date" %>
<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
<%--
  Created by IntelliJ IDEA.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>


    


<%
    // 获取当前系统时间
    Date date = new Date();
    pageContext.setAttribute("date", date);
%>

当前系统时间为：${date}


<%-- 这里是先得值，过滤后，在得值，输出的是最后的值，即value变化两次--%>

自定义标签：

如果上面几个标签不能满足需求，程序员也可以自定义标签，步骤如下：

编写标签类继承SimpleTagSupport类或TagSupport类并重写doTag方法或doStartTag方法

package com.lagou.demo01;

import javax.servlet.jsp.JspException;
import javax.servlet.jsp.JspWriter;
import javax.servlet.jsp.tagext.SimpleTagSupport;
import java.io.IOException;

public class HelloTag extends SimpleTagSupport {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public void doTag() throws JspException, IOException {
        // 获取输出流
        JspWriter out = this.getJspContext().getOut();
        // 写入数据到浏览器
        out.write("自定义标签哦！" + name);
        // 关闭流对象
        out.close();
    }
}

定义标签库文件（tld标签库文件）并配置标签说明文件到到WEB-INF下：

<taglib 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-
                            jsptaglibrary_2_1.xsd"
        version="2.1">

    <tlib-version>1.0tlib-version> 
    <short-name>myshort-name> 
    <uri>http://lagou.comuri> 

    
    <tag>
        <name>helloname> 
        <tag-class>com.lagou.demo01.HelloTagtag-class>
        
        <body-content>emptybody-content>
        
        <attribute>
            <name>namename>
            
            <required>truerequired> 
        attribute>
    tag>
taglib>

<%@ taglib prefix="my" uri="http://lagou.com" %>
<%--
  Created by IntelliJ IDEA.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>


    


 <%-- 调用xml中指定类的指定方法--%>

在JSP中添加taglib指令引入标签库使用：

<%@ taglib prefix="hello" uri="http://lagou.com" %>

这样以后就可以自定义标签来操作了