您现在的位置是：首页 > 后端

当前栏目

JavaWeb——JSP技术

JSP 技术 javaweb

2023-09-14 09:14:08 时间

1.JSP重点知识及实现

jsp中我们使用html作为模板，使用java代码填充一些数据
    1.jsp我们可以当作html使用
jsp中如何写java代码？
    1.声明成员变量和成员方法
    2.声明局部变量和一些代码
    3.使用打印输出语句输出一些数据
jsp中写java表达式，使用输出语句输出数据
    语法:<%=%>
    注意:表达式后面不要跟上;
    表达式的内容最终是使用os.print()输出
脚本:我们写的java代码片段
    语法:<%%>
    注意:1.一个页面中，java脚本可以写多个
2.无论写几个脚本，最终会被翻译到service方法中
3.脚本中声明的变量时局部变量
声明:声明成员变量和成员方法
    语法:<%!%>
    注意:1.一个页面中，java声明可以写多个
2.声明的是成员变量和成员方法

<%@ page import="java.text.SimpleDateFormat" %>
<%@ page import="java.util.Date" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>测试jsp</title>
</head>
<body>
<%=10%><br>
<%="hello"%><br>
<%=10+10%><br>
<%=10>5%><br>

<%
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    String date = sdf.format(new Date());
%>
<%=date%>
<br>
<%!
    String user = "admin";
    String password = "123456";
%>
<%=user%><br>
<%=password%><br>
<%!
    public void show(){
        System.out.println("今天天气不错");
    }
%>
<%
    show();
%>
</body>
</html>

编译指令:告诉tomcat这个页面该怎么翻译
include指令:用来将另外的jsp给包含在当前jsp中
    作用:将多个jsp合并成一个jsp
    语法:<%@include file=""%>
    本质:将被包含的页面输出的内容合并到主页面中，所以只产生了一个java文件
    注意:1.被包含的页面只需要写body中的html代码片段即可
        2.如果被包含的页面内容发生变化，最后合并的java文件内容也会发生改变，如果说被包含的页面的内容经常改变，主页面就会被频繁的翻译和编译
        3.使用场景:被包含的页面内容不经常改变

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%--<%@include file="01_test.jsp" %>--%>
<%@include file="03_showTime.jsp" %>
<html>
<head>
    <title>主页面包含从页面</title>
</head>
<body>
这个是主页面，另外的是从页面
</body>
</html>

<%@ page import="java.text.SimpleDateFormat" %>
<%@ page import="java.util.Date" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" errorPage="04_errorPage.jsp" %>
<%
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    String date = sdf.format(new Date());
%>
<%=date%>
<br>
这是被包含的页面<br>
账号:<input type="text"/>
密码:<input type="password">
<select name="" id="">
    <option value="">请选择</option>
</select>

<%@ page contentType="text/html;charset=UTF-8" language="java" isErrorPage="true" %>
<html>
<head>
    <title>错误处理</title>
</head>
<body>

</body>
</html>

jsp的内置对象有9个
         对象名数据类型
         Request HttpServletRequest
         Response HttpServletResponse
         pageContext         PageContext
         session HttpSession
         application ServletContext
         config   ServletConfig
         out JspWriter
         page Object      -- 代表当前页面对象
         exception Exception   isErrorPage="true"这个为true的错误处理页面才有

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>内置对象</title>
</head>
<body>
<%
    //    HttpSession session1 = request.getSession();
//    session1.setAttribute("user", "admin");
//    session.setAttribute("password", "root");

%>

<%="hello"%>
</body>
</html>

pageContext:页面上下文对象
1.使用这个对象可以让我们获取到其它8个内置对象
    这个功能一般不使用，我们自己定义自定义标签使用
2.pageContext这是一个域对象,可以使用常见域对象的操作方法
    a.setAttribute(key,value)和getAttribute(key)可以保存和获取域对象中的数据
    b.可以操作其它3个域对象中的数据
        public static final int PAGE_SCOPE = 1;
        public static final int REQUEST_SCOPE = 2;
        public static final int SESSION_SCOPE = 3;
        public static final int APPLICATION_SCOPE = 4;
    c.使用通用简单的方式获取其它域对象中的数据
        findAttribute(key):该方法会按照从小到大的顺序从4个域对象中挨个查找指定的key

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>pageContext</title>
</head>
<body>
<%
    //    pageContext.getSession();
//    request.setAttribute();
    pageContext.setAttribute("user", "admin");
    pageContext.setAttribute("password", "root", PageContext.SESSION_SCOPE);
    pageContext.setAttribute("password", "123456",PageContext.REQUEST_SCOPE);

%>
<%
    out.println(pageContext.getAttribute("user"));
%><br>
<%=session.getAttribute("password")%><br>
<%=pageContext.getAttribute("password", PageContext.SESSION_SCOPE)%><br>
<%=pageContext.findAttribute("password")%><br>
</body>
</html>

1.我们在开发中使用jsp的时候不写java代码
    我们使用输出表达式获取域对象中的数据，可以使用el表达式取代输出表达式，取代的就是向页面输出数据的java代码
        el表达式语法:${表达式}
        el使用场景:
            1.最常见的输出域对象中的数据
            2.el表达式配合html标签使用很方便
        注意:
            在使用el表达式获取域对象中的数据的时候，无需指定域对象。
            类似于pageContext.findAttribute()按照从小到大的顺序挨个查找。

<%@ page import="java.util.HashMap" %>
<%@ page import="Junior2.day0119_jsp.entity.Student" %>
<%@ page import="java.util.List" %>
<%@ page import="java.util.ArrayList" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>el表达式</title>
    <style type="text/css">
        .one {
            color: red;
        }
    </style>
</head>
<body>
<%
    request.setAttribute("user", "admin");
    int[] nums = {1, 2, 3};
    request.setAttribute("ids", nums);
    HashMap<String, String> maps = new HashMap<>();
    maps.put("张三", "zhangsan");
    maps.put("李四", "lisi");
    maps.put("王五", "wangwu");
    session.setAttribute("maps", maps);

    Student student = new Student();
    student.setId(100);
    student.setUser("admin");
    student.setAge(23);
    session.setAttribute("s1", student);

    List<Student> list = new ArrayList<>();
    list.add(student);
    request.setAttribute("list", list);
%>
<%=10%>&nbsp;${10}<br>
<%=10 + 10%>&nbsp;${10+10}<br>
<%="hello"%>&nbsp;${"hello"}<br>
<%=request.getAttribute("user")%>&nbsp;${user}<br>

<form action="">
    账号:<input type="text" name="user" value="${user}">
</form>

<%--el表达式获取数组类型的数据--%>
${ids[0]}${ids[1]}${ids[2]}<br>
<%--el表达式获取map类型的数据--%>
${maps["张三"]}<br>
${maps.get("李四")}<br>
<%--使用el表达式获取自定义数据类型的属性--%>
${s1.id}<br>
${s1.user}<br>
${s1.age}<br>
<%--el表达式获取list集合，读取里面自定义数据类型的属性--%>
${list[0].id}<br>
${list[0].user}<br>
${lsit[0].age}<br>
</body>
</html>

如果需要在页面迭代输出一些数据，或者加入一些流程控制语句配合html标签，页面写起来很复杂，所以
el表达式为了取代输出表达式
jstl标签为了取代java脚本

<%@ page import="java.util.ArrayList" %>
<%@ page import="java.util.List" %>
<%@ page import="Junior2.day0119_jsp.entity.Student" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<%
    Student s1 = new Student(100, "admin1", 10);
    Student s2 = new Student(200, "admin2", 20);
    Student s3 = new Student(300, "admin3", 30);


    ArrayList<Student> ss = new ArrayList<>();
    ss.add(s1);
    ss.add(s2);
    ss.add(s3);
    request.setAttribute("student", ss);
%>
<table border="1" cellpadding="0" width="500" height="300">
    <tr>
        <td>编号</td>
        <td>姓名</td>
        <td>年龄</td>
    </tr>
    <%
        List<Student> list = (List<Student>) request.getAttribute("student");
        int length = list.size();
    %>
    <%
        for (int i = 0; i < length; i++) {
    %>
    <tr>
        <td><%=list.get(i).getId()%>
        </td>
        <td><%=list.get(i).getUser()%>
        </td>
        <td><%=list.get(i).getAge()%>
        </td>
    </tr>
    <%
        }
    %>
</table>
</body>
</html>

内置标签:
jsp的内置标签有7个，又称jsp的7个动作指令

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>内置标签</title>
</head>
<body>
<%--
    内置标签:
        jsp的内置标签有7个，又称jsp的7个动作指令
--%>
<jsp:include page="10_test.jsp">
    <jsp:param name="user" value="admin"/>
</jsp:include>
</body>
</html>

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>测试内置标签</title>
</head>
<body>
这是被包含的页面
<%=request.getParameter("user")%>
<%=request.getParameter("password")%>
</body>
</html>

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<jsp:forward page="10_test.jsp">
    <jsp:param name="password" value="root"/>
</jsp:forward>
</body>
</html>

c:set :设置值
1.可以直接修改域对象中的数据的属性
2.直接在域对象中添加一个键值对
c:out :在浏览器输出一个表达式的值，类似于java的输出表达式
c:if :类似于if流程控制语句
c:choose :类似于java的switch语句
c:foreach:循环语句
c:forTokens:循环，循环迭代字符串，类似于java,String的split方法

items:需要迭代的集合
var:当前迭代的元素
varStatus:当前迭代的状态对象
begin:从哪个索引开始迭代
end:到哪个索引结束迭代
step:迭代的步长

items:需要迭代的字符串
delims:使用什么字符分隔
var:分隔后的数组，迭代的元素使用什么变量接收

<%@ page import="Junior2.day0119_jsp.entity.Student" %>
<%@ page import="java.util.ArrayList" %>
<%@ page import="java.util.List" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<html>
<head>
    <title>Title</title>
    <style type="text/css">
        .one {
            color: red;
        }

        .two {
            background-color: pink;
        }
    </style>
</head>
<body>
<%
    Student student = new Student(100, "admin", 20);
    request.setAttribute("user", student);
%>
<%--给域对象中的user对应的student对象的user属性重新赋值--%>
<c:set target="${user}" property="user" value="张三"></c:set>
${user.user}
<%--直接给域对象添加一个键值对--%>
<c:set scope="request" var="password" value="root"></c:set>
${password}

<c:out value="10"></c:out>
<c:out value="${password}"></c:out>
<%--根据域对象中学生的id值来决定这个p标签使用one这个样式，如果id==100，就是用one这个样式--%>
<p <c:if test="${user.id==100}">class="one"</c:if>>这是一段文字</p>

<c:if test="${user.id==100}">
    学生的id是100
</c:if>

<c:choose>
    <:c:when test="${user.id==100}">学生的id是100</:c:when>
    <:c:when test="${user.id==200}">学生的id是200</:c:when>
    <c:otherwise>学生的id是其他值</c:otherwise>
</c:choose>

<%
    Student s1 = new Student(100, "admin1", 10);
    Student s2 = new Student(200, "admin2", 20);
    Student s3 = new Student(300, "admin3", 30);
    ArrayList<Student> ss = new ArrayList<>();
    ss.add(s1);
    ss.add(s2);
    ss.add(s3);
    request.setAttribute("student", ss);
%>
<table border="1" cellpadding="0" width="500" height="300">
    <tr>
        <td>索引</td>
        <td>编号</td>
        <td>姓名</td>
        <td>年龄</td>
        <td>总数</td>
    </tr>
    <c:forEach var="stu" step="2" items="${student}" varStatus="sta">
        <tr <c:if test="${sta.count % 2 == 1}"> class="two"></c:if></tr>
        <td>${sta.index}</td>
        <td>${stu.id}</td>
        <td>${stu.user}</td>
        <td>${stu.age}</td>
        <td>${sta.count}</td>
        </tr>
    </c:forEach>

    <c:forTokens items="aa,bb,cc,dd" delims="," var="ss">
        ${ss}-
    </c:forTokens>

    <%--重定向--%>
    <%--    <c:redirect url="/index.jsp"></c:redirect>--%>
</table>
</body>
</html>

2.Jsp基础

2.1 Jsp引入

Servlet：服务端技术，我们使用servlet进行服务端编程

如果在html页面上，我们无法获取servlet产生数据，上述的问题可以解决，但是相对麻烦

解决办法：

js方面的实现：使用异步通讯技术（AJAX），这种解决方案催生了前端开发这个职业，前后端分离
java方面的实现：使用响应输出流将页面代码使用流输出到浏览器

如果使用第2种解决方案，java开发人员需要写服务端程序，还需要些大量的html代码，很麻烦，如果能专注于服务端程序的实现和数据的处理，是极好的。

Java官方就提供了JSP这个技术：客户端技术，由jsp充当页面，既包含html代码又包含java代码

2.2 Jsp的特点

1. 页面中既有html代码，又有java代码

2. jsp必须在web服务器中才能运行

2.3 体验jsp页面作用

需求：显示当前时间到浏览器上

2.4 Jsp的执行过程

问题：访问http://localhost:8080/day08/01_showtime.jsp的过程

a.我们第一次访问这个jsp的时候，tomcat找到这个jsp，将jsp给翻译为java文件将01_showtime.jspà_01_005fshowtime_jsp.java

b.将翻译的java文件再编译为class文件_01_005fshowtime_jsp.javaà_01_005fshowtime_jsp.class

c. 读取class文件，创建对象

d.调用对象的_jspService方法，返回内容到浏览器

第一次访问jsp：走（1）（2）（3）（4）

第n次访问jsp：走（4）

注意：jsp文件修改了或jsp的临时文件被删除了，要重新走翻译（1）和编译（2）的过程Jsp就是servlet

2.5 疑问

问题：为什么Jsp就是servlet！！！

public final class _01_005fshowtime_jsp extends org.apache.jasper.runtime.HttpJspBase

HttpJspBase继承于HttpServlet

所以我们说jsp就是一个servlet

Servlet的生命周期：

执行构造方法 --第一次访问执行
执行init方法 --第一次访问执行
执行service方法 --每次访问执行
执行destroy方法 --容器关闭的时候执行

Jsp的生命周期：

将jsp翻译为java文件 --第一次访问执行
将java文件编译为class文件 --第一次访问执行
创建对象 --第一次访问执行
执行_jspInit() --第一次访问执行
执行_jspService() --每次访问执行
执行_jspDestroy() --容器关闭的时候执行

3 Jsp语法

3.1 Jsp模板

Jsp其实就是Html+java

Jsp的模板就是html页面

Jsp我们可以当html使用

3.2 Jsp表达式

语法：<%=变量或者表达式%>

作用：在页面输出变量或者表达式的值

注意：表达式后面不用添加分号

3.3 Jsp的脚本

语法：<%java代码%>

作用：在此处写java语句，可以写多条，声明变量

注意：

此处声明的变量，将会定义在service方法中，所以是局部变量
脚本在一个页面中能定义多个，但是都是编译在service方法中
脚本中不能声明方法

3.4 Jsp的声明

语法：<%!java代码 %>

作用：声明成员变量和成员方法

注意：

此处声明的变量和方法，将会定义为成员变量和成员方法
脚本在一个页面中能定义多个声明代码

3.5 Jsp的注释

<%--注释代码--%>

4 Jsp的三大指令

4.1 include指令

语法：<%@ include file="页面"%>

作用：将另一个页面包含到当前页面中

注意：

1.被包含的页面不会被翻译和编译

2.被包含的页面只写对应的html代码即可，不用写完整的页面结构

3.被包含的页面的内容如果发生改变，外面的页面也需要重新翻译和编译

4.静态include使用较少

4.2 page指令

语法：<%@ page %>

作用：告诉web服务器如何翻译这个jsp

<%@ page contentType="text/html;charset=UTF-8" –告诉浏览器输出的内容的格式和字符集

language="java" – 告诉服务器使用什么语言翻译jsp

import="java.util.Date" –告诉服务器翻译jsp的时候需要导入哪个类

pageEncoding="UTF-8" – 告诉服务器jsp的代码使用哪个字符集，这句代码可以解决开

发工具中中文乱码的问题

errorPage="error.jsp" -- 当这个jsp报错了，直接跳转到配置的错误处理页面

isErrorPage="false" -- 表示当前jsp不是错误处理页面

4.3 taglib指令

总结：

1.Jsp的执行过程

tomcat服务器完成：jsp文件->翻译成java文件->编译成class字节码文件-> 构造类对象->

调用方法

tomcat的work目录下存放jsp运行时的临时文件！！

2.Jsp语法

2.1 jsp表达式：<%=变量或表达式%> 向浏览器输出变量或表达式计算的结果

2.2 jsp脚本： <% java代码 %> 执行java代码原理：翻译到_jspService（）方法中

2.3 jsp声明： <%! 变量或方法 %> 声明jsp的成员变量或成员方法

2.4 jsp注释： <%!-- jsp注释 --%> 用于注释jsp代码，不会翻译到java文件中，也不会执行。

3.jsp的三大指令

3.1 include指令：用于包含其他页面。原理：先合并再翻译，叫静态包含

3.2 page指令：告诉tomcat服务器如何把jsp文件翻译成java文件

language：翻译的动态语言。

import：类导入

jsp文件编码问题：

pageEncoding：告诉tomcat服务器使用什么编码翻译jsp文件（jsp->java文件）

contentType: tomcat服务器发送给浏览器的数据编码（tomcat服务器->浏览器）

异常错误相关的：

errorPage: 指定当前jsp页面的错误处理页面。

isErorrPage: 指定当前页面是否为错误处理页面。false，不是错误处理页面，则不能使用

exception内置对象；true，是错误处理页面，可以使用exception内置对象。

配置全局的错误处理页面：

ession: 是否开启session功能。false，不能用session内置对象；true，可以使用session内置对象。

buffer: jsp页面的缓存区大小。

isELIgnore：是否忽略EL表达式。

3.JSP加强重点

1 Jsp的内置对象（重点）

1.1 什么是内置对象？

我们在写jsp脚本或者jsp表达式的时候，有可能会使用到一些request，response，session类似的对象，我们如果使用的时候先手动创建比较麻烦，所以java在设计jsp的时候，帮我们自动创建了一些对象供我们使用，无需手动创建。

帮我们创建的内置对象一共有9个。

举例：

写servlet的时候：

HttpSession session = request.getSession();

String sid = session.getId();

写Jsp的时候：

String sid = session.getId();

1.2 9大内置对象

对象名数据类型

Request HttpServletRequest

Response HttpServletResponse

pageContext PageContext

session HttpSession

application ServletContext

config ServletConfig

out JspWriter

page Object -- 代表当前页面对象

exception Exception isErrorPage="true"这个为true的错误处理页面才有

1.3 Out对象

Out对象的数据类型是JspWriter，JspWriter可以理解为带有缓冲区的printWriter，

作用：将数据输出到浏览器

printWriter:不带缓冲区输出流

writer():没有缓冲区，调用一次方法，就直接向浏览器输出数据

JspWriter：带缓冲区的输出流

writer():调用一次方法，数据先进入缓冲区，满了之后才向浏览器输出

什么时候缓冲区才向浏览器输出数据呢？

1.缓冲区满了

2.刷新缓冲区

3.Jsp加载完毕

1.4 pageContext对象

pageContext：jsp上下文对象

a.可以获取其他八个内置对象

使用pageContext.getxxx()可以获取其它8个内置对象

这个使用方式不是我们平时使用的，我们在写一些自定义标签的时候使用

b.本身是一个域对象

pageContext是一个域对象，pageContext代表的是当前页面的范围

pageContextàrequestàsessionàservletContext

保存数据：

pageContext.setAttribute(String key,Object Value):向pageContext域中添加一个键值对

pageContext.setAttribute(String key,Object Value,int 域常量):向域常量代表的域中添加一个键值对

获取数据：

pageContext.getAttribute(String key):从pageContext域中根据指定的key获取值

pageContext.setAttribute(String key,int 域常量):从指定的域中获取指定的key对应的值域常量：

    public static final int PAGE_SCOPE = 1;

    public static final int REQUEST_SCOPE = 2;

    public static final int SESSION_SCOPE = 3;

    public static final int APPLICATION_SCOPE = 4;

自动查找值：

pageContext.findAttribute(String key):从四个域中挨个查找指定的key对应的值，查找的顺序是从小到大，找到后就停止查找

/1.向pageContext域中添加键值对
    pageContext.setAttribute("user","admin");
//2.同过pageContext对象向session域中添加键值对
    pageContext.setAttribute("pass","123",PageContext.SESSION_SCOPE);
    pageContext.setAttribute("pass","456",PageContext.APPLICATION_SCOPE);
//3.获取pageContext域中的值
    Object user = pageContext.getAttribute("user");
    out.println(user);
//4.获取session域中的值
    Object pass = pageContext.getAttribute("pass",PageContext.SESSION_SCOPE);
    out.println(pass);
//5.自动查找获取session域中的值
    Object pass1 = pageContext.findAttribute("pass");
    out.println(pass1);

2 Jsp中的四个域对象

pageContext request session application

page request session servletContext

作用域从小到大排列

添加方法：setAttribute(String key,Object Value):添加键值对

获取方法：getAttribute(String key):获取键对应的值

删除方法：removeAttribute(String key):根据键删除值

3 Jsp的最佳实践

Servlet：服务端程序，我们写java代码（流程控制语句，变量……）

Jsp:页面的模板，我们主要作为页面展示数据

Servlet + jsp + 数据库

Servlet：

获取请求参数
编写业务逻辑
返回响应数据

Jsp：

作为页面展示
获取服务端产生的数据展示在页面上

数据库：

保存用户输入的数据
保存servlet产生的数据
查询用户需要的数据

4 EL表达式

4.1 EL作用

Expression Language表达式语言

作用：取代jsp表达式，在jsp页面输出数据

如果我们想要在页面上输出变量的值或者表达式的值，我们一般使用jsp表达式来输出

<%=变量或者表达式%>

现在有了El表达式，我们就不在使用jsp的表达式了

我们一般是配合标签使用的

4.2 EL语法

语法：${表达式}

使用场景：

我们使用它的最多的时候是获取域中的数据

获取域中数据：

1.自动查找

${key}等效于pageContext.findAttribute(String key)

1.指定域对象查找${域对象.key}等效于pageContext.setAttribute(String key,int 域常量)域对象：pageScope requestScope sessionScope applicationScpoe

5 jsp标签

5.1 jsp标签的作用

我们在页面中经常写java表达式输入变量或者表达式的值

经常写java脚本：

流程控制语句

声明局部变量

转发跳转页面

……

我们使用jsp的原则是少些java代码设置不写java代码

刚才讲了el表达式可以输出表达式或变量的值

现在我们将如何使用标签替换java脚本

5.2 Jsp标签分类

1）jsp内置标签 jsp已经内置，我们直接使用

2）JSTL标签需要我们先导入，才能在页面使用

3）自定义标签需要我们先导入，才能使用

5.3 动作标签

JSP的内置标签我们有称为jsp的7个动作标签

1.转发标签： <jsp:forward />

<jsp:forward page="index.jsp"></jsp:forward>

2.参数标签： <jsp:pararm/>

在转发或者动态包含的时候，传递请求参数，不能单独使用这个标签，需要配合

转发或者动态包含标签

<jsp:forward page="index.jsp">
<jsp:param name="user" value="admin"></jsp:param>
<jsp:param name="pass" value="123"></jsp:param>
</jsp:forward>

3.包含标签： <jsp:include/>

<jsp:include page="05_page.jsp"></jsp:include>

动态include和静态include有什么区别？

语法不同：静态include是编译指令，动态include是动作指令
传参：静态include不能传递参数，动态include可以传递参数
原理不同：静态include是先合并再翻译，动态include是先翻译再合并。开发中我们一般使用动态include，动态include可以保证被包含页面的内容出现在指定的位置

5.4 JSTL标签

JSTL (全名：java standard tag libarary - java标准标签库 )

JSTL标签的分类：

核心标签库 <c:标签> 比如：循环、表达式赋值、基本输入输出等

格式化标签库 <fmt:标签> 格式化显示数据的工作

Sql标签库 <sql:标签> 操作数据库

XML标签库操作xml数据的

5.5 使用JSTL标签步骤

1. 先导入jar包

2. 在使用标签的jsp页面上使用

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

3. 使用标签（核心标签库的重点标签）

保存数据： <c:set></c:set>

1.可以直接修改域对象中的数据的属性

<c:set target="${stu}" property="sname" value="李四"></c:set>

2.直接在域对象中添加一个键值对

<c:set var="user" scope="session" value="admin"></c:set>

获取数据： <c:out value=""></c:out>

主要用于输出数,配合el表达式使用，等效于<%=%>

<c:out value="${user}"></c:out><br>
<c:out value="${stu.sname}"></c:out><br>
<c:out value="${stu.age}"></c:out>

单条件判断： <c:if test=""></c:if>

<c:if test="${sname == 'tom'}">
姓名是tom
</c:if>
<c:if test="${age == 20}">
年龄是20
</c:if>

多条件判断：<c:choose></c:choose>

<c:when test=""></c:when>

<c:otherwise></c:otherwise>

类似于if-else 和 switch语句

<c:choose>
    <c:when test="${age == 10}">
        年龄是10
    </c:when>
    <c:when test="${age == 20}">
        年龄是20
    </c:when>
    <c:otherwise>

        年龄不是10
    </c:otherwise>
</c:choose>

循环数据： <c:forEach></c:forEach>

<table>
    <tr>
        <td>编号</td>
        <td>姓名</td>
        <td>年龄</td>
    </tr>
    <c:forEach var="student" items="${users}" begin="0" end="4" step="2" varStatus="status">
        <tr <c:if test="${status.count % 2 == 1}">class="tr1"</c:if>>
            <%--奇数行使用样式--%>
            <td>${status.count}</td>
            <td>${student.sname}</td>
            <td>${student.age}</td>
        </tr>
    </c:forEach>
</table>

Var：每次迭代出来的元素使用这个变量接收

Items：需要迭代的集合

Begin：从哪个索引开始迭代

End：到哪个索引结束

Step：每个几个元素迭代一次

varStatus：代表当前迭代的状态

<c:forTokens items="" delims=""></c:forTokens>

<c:set var="ss" value="aa,bb,cc" scope="request"></c:set>
<c:forTokens items="${ss}" delims="," var="str">
${str}=
</c:forTokens>

Var : 分隔字符串，然后迭代出来的每个小串使用该变量接收

Items: 需要分隔的字符串

Delims: 使用哪个字符进行分隔

重定向： <c:redirect></c:redirect>

<c:redirect url="11_page.jsp"></c:redirect>

猜你喜欢

Dart的文件、目录和链接（1）
lnmp架构下php安全配置分享
2013年7月14日-地图展示
【回答问题】ChatGPT上线了！给我推荐20个比较流行的图像分割模型！
FPGA | 深入理解复位
【Python】列表循环修改索引
Excel：Excel使用技巧经验总结之(利用Excel自带功能统计各个字段不同类别及其个数并进行图表可视化+非编程实现)图文教程之详细攻略
关于设置MX记录
Redis的频道发布与消息订阅
C++用顶层函数重载操作符(二) 顶层函数的优势
[WPF]控件应用多个样式（转）
问题-delphi XE2 Stack Overflow- save your work and restart CodeGear
Cocoapods的安装和使用
Linux中Shell脚本--awk的用法
AFNetworking使用总结
超级实用,解密云原生监控技术，使用prometheus轻松搞定redis监控

相关主题

java web jsp
27. JSP
JSP技术
jsp 技术
JSP page对象
JSP session对象
JSP 总结
JSP学习_01
JSP
什么是jsp？
JSP连接MySQL
JSP--JavaBean
jsp:javaBean
jsp(2)
jsp EL 表达式

zl程序教程