JAVA WEB DAY 05_JSP-EL-JSTL-三层架构

最新推荐文章于 2024-08-02 23:04:45 发布
最新推荐文章于 2024-08-02 23:04:45 发布
阅读量313 收藏 1
点赞数
分类专栏： Java Web 文章标签： jsp jstl
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/NTT0101/article/details/108658015
版权

文章目录

JSP - EL - JSTL - 三层架构

目标

  • 能够说出 jsp 的优势
  • 能够编写 jsp 代码片段、声明、脚本表达式
  • 能够说出 el 表达式的作用
  • 能够使用 el 表达式获取 javabean 的属性
  • 能够使用 jstl 标签库的 if 标签
  • 能够使用 jstl 标签库的foreach 标签
  • 能够使用 jstl 标签库的 choose 标签

01_JSP 概述-[★★]

JSP 的概念：

  • Java Server Page Java 服务器页面，一开始是运行在服务器端的，最终也会被解析成 html 响应给浏览器。

JSP 的优势

  • 既可以开发静态资源：方便编写HTML，CSS，JS代码
  • 也可以开发动态资源：可以编写Java代码操作数据获得动态数据
  • 需求：浏览器上输出服务器当前的时间，并且设置样式，效果图如下
    在这里插入图片描述
  • 示例代码
<%@ page import="java.util.Date" %>
<%@ page import="java.text.SimpleDateFormat" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>显示服务器时间</title>
</head>
<body>
    <h1 style="color: red">服务器现在的时间是：
        <%
            // 获得当前服务器时间
            Date date = new Date();
            // 创建日期格式化对象
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            String dateStr = sdf.format(date);
            // 输出日期字符串到浏览器
            // out是JSP的内置对象：可以直接在JSP页面中使用
            out.println(dateStr);
        %>
    </h1>
</body>
</html>

02_JSP 的执行过程-[★★]

  1. 浏览器请求JSP文件时，服务器内部会先将JSP文件进行翻译，翻译得到一个Servlet文件：XxxServlet.java
  2. 将翻译得到的Servlet文件进行编译产生字节码文件：XxxServlet.class
  3. 将字节码文件加载到内存中并创建对象：XxxServlet servlet = new XxxServlet();
  4. 调用Servlet对象的service方法处理请求和响应数据

03_JSP 常见问题-[★★]

03_01 JSP 和 Servlet 是什么关系？

JSP 就是 Servlet

  • 查看源码：看类的继承体系
public final class showTime_jsp extends org.apache.jasper.runtime.HttpJspBase
public abstract class HttpJspBase extends HttpServlet

03_02 JSP 什么时候翻译成 Servlet？

浏览器第一次访问时翻译，
如果下一次访问内容没有发生变化，则不会翻译了，直接创建Servlet对象调用service方法。
如果JSP文件的内容改变了，则会再次执行翻译和编译等动作。

04_JSP 脚本表达式-[★★★★]

  • JSP 脚本表达式
JSP脚本表达式说明
语法<%=变量名或表达式%>
作用输出变量的值或表达式计算结果
注意%和=之间不能有空格
  • 需求：利用脚本表达式输出变量的值和计算表达式的值并输出。
  • JSP 示例代码
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>JSP脚本表达式</title>
</head>
<body>
     <%--
      需求：利用脚本表达式输出变量的值和计算表达式的值并输出。
      JSP脚本表达式
        语法：<%=变量名或表达式%>
        作用：输出变量的值或表达式的计算结果
        注意：%和=之间不能有空格
      --%>
      <%
          // 定义变量
          int age = 18;
      %>
      <%--输出变量的值
             <%=age%>翻译到Servlet中等价于：out.print(age);
      --%>
      <%=age%> <br>
      <%--输出表达式的值
            <%=3*5%>翻译到Servlet中等价于：out.print(3*5);
      --%>
      <%=3*5%>
</body>
</html>

05_JSP 代码片段-[★★★★]

  • JSP 代码片段
JSP代码片段说明
语法<% Java代码 %>
作用在JSP页面执行一段Java代码
翻译之后出现在Servlet的service方法中

  • 需求：在脚本中创建一个ArrayList，添加三个名字，在 ol-li 中有序列表输出，使用 Java 中的 for 循环输出。

  • JSP 代码

<%@ page import="java.util.ArrayList" %>
<%@ page import="java.util.List" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>JSP代码片段</title>
</head>
<body>
    <%--
        需求：在脚本中创建一个ArrayList，添加三个名字，在 ol-li 中有序列表输出，
        使用 Java 中的 for 循环输出。

        JSP代码片段语法：<% 在JSP页面执行Java代码 %>
    --%>

    <%
        // JSP代码片段中编写的Java代码翻译之后出现在service方法中
        // 定义集合
        List<String> list = new ArrayList<>();
        // 添加元素
        list.add("孙悟空");
        list.add("猪八戒");
        list.add("包青天");
    %>

    <%--有序列表--%>
    <ol>
        <% for (int i = 0; i < list.size(); i++) {  %>
            <li><%=list.get(i)%></li>
        <%}%>
    </ol>

</body>
</html>

06_JSP 声明-[★★★★]

  • JSP 声明
JSP声明说明
语法<%! %>
作用用于在JSP中定义成员变量或成员方法
  • 需求说明：在JSP代码片段创建一个字符串，使用脚本表达式输出
  • JSP 代码
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>JSP声明</title>
</head>
<body>
    <%--
    需求说明
        - 在JSP代码片段创建一个字符串，使用脚本表达式输出
        - 在声明中也创建一个同名的字符，使用脚本表达式输出，会不会有问题？

    JSP声明语法：<%! 定义成员变量或成员方法 %>
    --%>

    <%-- 在JSP代码片段创建一个字符串，使用脚本表达式输出 --%>
    <%
        // 定义字符串：翻译Servlet的service方法中，属于局部变量
        String name = "小波";
    %>

    <%-- 在声明中也创建一个同名的字符串，使用脚本表达式输出 --%>
    <%!
        // 定义字符串：翻译到Servlet中成员变量的位置
       String name = "小泽";

        // 定义成员方法
        public int sum(int a,int b){
            return  a + b;
        }
    %>
    <%--使用脚本表达式输出--%>
    <%=name%> <br> <%--out.print(name);--%>
    <%--使用脚本表达式输出--%>
    <%=this.name%> <br> <%--out.print(name);--%>

    <%--调用sum方法--%>
    <%=sum(1,1)%> <%--out.print(sum(1,1))--%>

</body>
</html>

07_JSP 内置对象概述-[★★★★★]

  • JSP九大内置对象[面试]
对象名类型描述
requestHttpServletRequest请求对象
responseHttpServletResponse响应对象
outJspWriter具有缓冲区的字符输出流
sessionHttpSession会话域对象
applicationServletContext上下文对象
configServletConfigServlet配置对象
exceptionThrowable异常对象
pagethis代表JSP当前页面
pageContextPageContext页面域对象

08_JSP 四大作用域-[★★★★]

  • JSP 中四个作用域对象
作用域类型和对象名范围
页面域PageContext pageContext同一个页面有效
请求域HttpServletRequest request同一个请求有效
会话域HttpSession session同一个会话有效
上下文域ServletContext application同一个应用有效
  • 与页面域有关的方法
方法名说明
void setAttribute(String key, Object value)往页面域中存储数据
Object getAttribute(String key)从页面域中获取数据
void removeAttribute(String key)从页面域中删除数据
void removeAttribute(String key, int scope)从指定的作用域中删除数据
Object findAttribute(String key)从四个作用域中根据键获取值
从小范围到大范围开始查找
如果找到则停止查找，如果都没有找到则返回null
  • scope的四个取值

PageContext.PAGE_SCOPE：对应于页面域
PageContext.REQUEST_SCOPE：对应于请求域
PageContext.SESSION_SCOPE：对应于会话域
PageContext.APPLICATION_SCOPE：对应于上下文域

如何选择四大作用域：

  • 小范围作用域能满足需求则选择小范围的作用域

  • 示例代码

  • one.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>

    <%--需求：在1个页面中，在四个域保存四个同名的值，分别是100,200,300,400，转发到另一个页面显示。--%>
    <%
        // 页面域
        pageContext.setAttribute("num", 100);
        // 请求域
        request.setAttribute("num", 200);
        // 会话域
        session.setAttribute("num", 300);
        // 上下文域
        application.setAttribute("num", 400);

        // 转发到two.jsp
        request.getRequestDispatcher("two.jsp").forward(request, response);
    %>
</body>
</html>
  • two.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>从四个作用域中获取数据</title>
</head>
<body>

    <%--获取页面域数据--%>
    <%=pageContext.getAttribute("num")%>

    <%--获取请求域数据--%>
    <%=request.getAttribute("num")%>

    <%--获取会话域数据--%>
    <%=session.getAttribute("num")%>

    <%--获取上下文域数据--%>
    <%=application.getAttribute("num")%>

    <%--自动查找--%>
    <%=pageContext.findAttribute("num")%>

</body>
</html>

09_JSP 三大指令概述-[★★]

09_01 三大指令

  • 指令的语法：<%@指令名 属性名=属性值 ....%>
指令名称语法作用
page<%@page 属性名=属性值 …%>设置页面的基本信息
告诉Tomcat服务器如何翻译JSP页面
include<%@include file=“JSP文件地址” %>在JSP页面中静态包含另一个JSP页面
taglib<%@taglib uri=“地址” prefix=“前缀” %>用于在JSP页面中导入标签库

10_JSP 之 include 指令使用-[★★]

  • include 指令
    作用：用于静态包含其它的页面
    语法： <%@include file="被包含的JSP页面"%>
    好处：实现页面复用

  • 示例代码

<div id="header">
    <%@include file="header.jsp"%>
</div>

11_JSP 之 page 指令使用-[★★★]

  • page 指令
    作用：page 是 jsp 中必须使用的一个指令，用于设置 JSP 上各种页面的属性，告诉 tomcat 如何将一个 JSP 翻译成 Servlet
    位置：可以放在 JSP 中任何位置，一般建议放在页面的最顶部
  • page 指令常用属性名
page指令常用属性名作用
language=“java”设置页面使用编程语言
默认是java且只能是java
import="{package.class | package.*}"在页面中导入Java类
errorPage=“relative_url”设置当前页面出现错误时跳转的页面
isErrorPage=“true|false”设置当前页面是否是一个错误页面
true：是错误页面，可以使用exception对象
false：不是，则不能使用exception对象
contentType=“mimeType [ ;charset=characterSet ]”设置当前页面的内容类型和编码
isELIgnored=“true | false”设置是否忽略EL表达式
true：忽略，EL不起作用
false：不忽略，EL能起作用
session=“true|false”设置是否禁用session
false：禁用，无法操作会话域的数据
true：不禁用，默认值

11_01 page 指令常用属性

  • 导包相关属性
导包属性：import 

导包方式：
	import="包名1..类名" 一次导入一个
	import="包名1..类名,...." 一次导入多个类
  • 编码相关的属性
Content-Type：设置页面内容的类型和编码
contentType="text/html;charset=UTF-8" 等价 response.setContentType("text/html;charset=UTF-8")

注意：如果JSP页面中包含中文，则必须设置：<%@ page contentType="text/html;charset=UTF-8" language="java" %>
  
language：设置JSP页面可以使用的编程语言，默认值是java，而且只能是java
  • 错误相关的属性

errorPage属性作用：设置当前JSP页面如果出现错误(异常)要跳转的页面地址

<%@ page
        contentType="text/html;charset=UTF-8"
        language="java"
        errorPage="error.jsp" 
%>

isErrorPage属性作用：设置当前页面是否是一个错误页面

isErrorPage="true"  当前页面是一个错误页面，就可以使用内置对象exception获取异常信息
isErrorPage="false" 当前页面不是一个错误页面，就不可以使用内置对象exception，默认值false
  • 错误页面的三种跳转方式
  1. 设置errorPage属性
<%@ page contentType="text/html;charset=utf-8" language="java" errorPage="error.jsp" %>
  1. 设置错误码(在web.xml配置文件中指定错误码的方式)
<error-page>
    <!--出现500错误-->
    <error-code>500</error-code>
    <!--location：出错后跳转到哪一个页面-->
    <location>/500.jsp</location>
</error-page>

<error-page>
    <!--出现404错误-->
    <error-code>404</error-code>
    <!--location：出错后跳转到哪一个页面-->
    <location>/404.jsp</location>
</error-page>
  1. 设置错误类型(在web.xml配置文件中指定错误类型的方式)
<error-page>
    <!--异常的类型，指定异常类全名-->
    <exception-type>java.lang.NullPointerException</exception-type>
    <!--location出错后跳转到哪一个页面-->
    <location>/404.jsp</location>
</error-page>

12_JSP 的三大动作概述-[★★]

  • 三大动作

JSP动作就是JSP的内置标签，可以直接使用，以jsp开头

JSP三大常用动作名称语法作用
Jsp:include<jsp:include page=“被包含的JSP页面地址” ></jsp:include>动态包含另一个JSP页面
Jsp:forward<jsp:forward page=“转发的页面地址”></jsp:forward>转发到另一个JSP页面
Jsp:param<jsp:param name=“参数名” value=“参数值”></jsp:param>用于给动态包含或转发的页面传递参数

13_JSP 之 include 动态包含-[★★]

  • include动作与include指令的区别
include指令：静态包含include动作动态包含
语法<%@include file=“header.jsp”%><jsp:include page=“header.jsp”></jsp:include>
包含方式静态包含：包含的是页面的内容动态包含：包含的是页面的执行结果
生成Servlet个数1个2个

注意：如果2个页面中有相同的变量，不能使用静态包含，而应该使用动态包含。

  • 实例代码
<div id="header">
    <%--动态包含header.jsp页面--%>
    <jsp:include page="header.jsp"></jsp:include>
</div>

14_JSP 之 forward 和 param 动作-[★★]

  • forward 和 param 动作的作用
  • forward动作
    作用：实现页面跳转(转发)
    语法：<jsp:forward page="跳转地址"></jsp:forward>
  • param动作
    作用：给要跳转的页面(或被包含的页面)传递参数
    语法：<jsp:param name="名字" value="值"></jsp:param>
  • 案例演示
  1. 从demo1.jsp 转发到 demo2.jsp
  2. demo1转发的时候带两个参数：username和age，在demo2中获取并且输出
  3. 汉字乱码问题的解决
  • demo1.jsp 代码
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>JSP动作之forward</title>
</head>
<body>
   <%
       // 设置请求参数的编码
       request.setCharacterEncoding("utf8");
   %>
    <%--直接转发到demo06.jsp并传递参数--%>
    <jsp:forward page="demo06.jsp">
        <jsp:param name="username" value="小武"/>
        <jsp:param name="age" value="20"/>
    </jsp:forward>

</body>
</html>
  • demo2.jsp 代码
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>获取参数显示</title>
</head>
<body>
    <%--获取请求参数--%>
    <%

        // 获取用户名
        String username = request.getParameter("username");
        // 获得年龄
        String age = request.getParameter("age");
        // 输出用户名和年龄
        out.print(username+"==>" + age);
    %>
</body>
</html>

15_EL 表达式概述-[★★]

  • EL 表达式主要用于替换 JSP 页面中的脚本表达式，让Jsp的代码更加简化。

EL 的概念：
  Expression Language
  表达式语言

EL 的作用：
  1. 获取作用域中的数据
  2. 用于执行各种运算：算术、逻辑、三目运算…

EL 的语法：
  ${变量名或表达式}

16_EL 获取作用域数据-[★★★]

使用EL获取数据的前提：数据必须存储到作用域中

作用域Java代码EL的写法
页面域<%=pageContext.getAttribute(“name”)%>${pageScope.键名}
请求域<%=request.getAttribute(“name”)%>${requestScope.键名}
会话域<%=session.getAttribute(“name”)%>${sessionScope.键名}
上下文域<%=application.getAttribute(“name”)%>${applicationScope.键名}
自动查找<%=pageContext.findAttribute(“name”)%>${键名}

  • 使用 EL 从四个作用域中获取数据

  • 示例代码

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>EL获取作用域数据</title>
</head>
<body>
    <%
        // 页面域
        pageContext.setAttribute("name", "jack");
        // 请求域
        request.setAttribute("name", "luck");
        // 会话域
        session.setAttribute("name", "lily");
        // 上下文域
        application.setAttribute("name", "rose");
    %>

    <h1>根据键name从不同的作用域获取值</h1>

    页面域 ==> JSP写法：<%=pageContext.getAttribute("name")%> &nbsp;&nbsp;EL的写法：${pageScope.name} <hr>
    请求域 ==> JSP写法：<%=request.getAttribute("name")%> &nbsp;&nbsp;EL的写法：${requestScope.name} <hr>
    会话域 ==> JSP写法：<%=session.getAttribute("name")%> &nbsp;&nbsp;EL的写法：${sessionScope.name} <hr>
    上下文域 ==> JSP写法：<%=application.getAttribute("name")%> &nbsp;&nbsp;EL的写法：${applicationScope.name} <hr>
    自动查找 ==> JSP写法：<%=pageContext.findAttribute("name")%> &nbsp;&nbsp;EL的写法：${name} <hr>


</body>
</html>

17_EL 获取不同类型的数据-[★★★]

EL获取 JavaBean 数据： ${对象名.成员变量名}
EL获取List集合数据：${集合名[索引]} 或 ${集合名.get(索引)}
EL获取数组数据：${数组[索引]}
EL获取Map集合数据：${map集合名['键']}

  • 注意事项：键名中如果有特殊字符的写法
变量名[“键名”]
可以使用双引号或单引号，如：${map["no3-no4"]}
  • 使用EL获取JavaBean、List集合、数组、Map集合等类型的数据
  • 示例代码
<%@ page import="com.pkx._01show_time.Employee" %>
<%@ page import="java.util.ArrayList" %>
<%@ page import="java.util.List" %>
<%@ page import="java.util.HashMap" %>
<%@ page import="java.util.Map" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>EL获取不同类型的数据</title>
</head>
<body>
    <%
        // 创建员工对象：Javabean
        Employee emp = new Employee("貂蝉", 10000);

        // 创建List集合
        List<String> list = new ArrayList<>();
        list.add("孙悟空");
        list.add("猪八戒");

        // 创建数组
        int[] arr = {100,54};

        // 创建Map集合
        Map<String,String> map = new HashMap<>();
        map.put("no1", "牛魔王");
        map.put("no2", "猪八戒");
        map.put("no3-no4", "白骨精");

        // 将数据存储到作用域中
        pageContext.setAttribute("emp", emp);
        pageContext.setAttribute("list", list);
        pageContext.setAttribute("arr", arr);
        pageContext.setAttribute("map", map);
    %>

    <h1>得到JavaBean的属性值</h1>
    姓名：${emp.name}, 工资：${emp.salary} <hr>

    <h1>取出集合List中的元素</h1>
    ${list.get(0)}  &nbsp; ${list.get(1)} <br>
    ${list[0]}  &nbsp; ${list[1]} <hr>

    <h1>取出数组中的元素</h1>
    ${arr[0]}  &nbsp; ${arr[1]} <hr>

    <h1>取出Map中的元素</h1>
    ${map.no1} &nbsp; ${map.no2} &nbsp; ${map.no3-no4}<br>
    ${map['no1']} &nbsp; ${map['no2']} &nbsp; ${map['no3-no4']}<br>

</body>
</html>

## 18_EL 中使用表达式-[★★★]

在EL表达式中执行算术运算，只要字符串是数值都会执行算术运行。

<%
	request.setAttribute("a","20");
	request.setAttribute("b","20");
%>
  • 算术表达式
算术运算符说明范例
+加${a+b}
-减${a-b}
*乘${a*b}
/ 或 div除${a/b}
% 或 mod取余${a%b}
  • 比较表达式
关系运算符说明范例
== 或 eq等于（equal）${a == b}
!= 或 ne不等于（not equal）${a != b}
< 或 It小于（Less than）${a< b}
<= 或 le小于等于（Less than or equal）${a <= b}
> 或 gt大于（Greater than）${a > b}
>= 或 ge大于等于（Greater than or equal）${a >= b}
  • 逻辑表达式
关系运算符说明范例
&& 或 and交集（与）${ture && false}
|| 或 or并集（或）${true || false}
! 或 not非${not true}
  • 三元运算

${逻辑判断 ? 真的值 : 假的值};

  • 判空表达式
${empty 变量名} 变量一定要存放在作用域中
1）如果变量名在作用域中为空，不存在，返回true
2）如果变量名为空串，返回true
3）变量名是一个集合，如果集合中没有元素，返回true

19_JSTL 标签库概述-[★★]

为什么使用JSTL

  • 因为JSP页面主要用于显示的，最好不要写java代码<%%>，如果不用JSTL就得写java代码。
  • 对于页面设计人员来说，使用Java语言操作动态数据是比较困难的，而采用标签和表达式语言相对容易一些， JSTL 的使用为页面设计人员和后台开发人员的分工协作提供了便利。
  • 为了简化 JSP 页面的设计。

JSTL是什么

  • JSP Standard Tag Library
  • JSP标准标签库

JSTL的作用：

  • 用来代替JSP代码片段

JSTL的使用步骤

  1. 下载JSTL相关类库
    jstl-impl.jar
    javax.servlet.jsp.jstl.jar
  2. 将类库导入到项目中
  3. 在JSP页面引入标签库
  4. 在JSP页面使用标签库的标签操作数据

20_JSTL 核心标签之 <c:if>

作用：用于页面执行判断
语法：<c:if test="${条件表达式}"></c:if>

  • 需求：如果用户提交的age大于18，则显示"你已经成年，可浏览器该网站…"，否则显示未成年。

  • 示例代码

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%--引入核心标签库--%>
<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<html>
<head>
    <title>JSTL核心标签之if</title>
</head>
<body>
    <%-- http://localhost:8080/day05/demo09.jsp?age=20
     需求：如果用户提交的age大于18，则显示"你已经成年，可浏览器该网站..."，否则显示未成年
    if标签的作用：用于JSP页面进行判断
        test属性：设置判断条件，必须设置，如果条件成立则执行标签体的代码
    注意事项：if标签没有对应的else标签

    param是EL内置对象，用于获取用户提交的请求参数
    --%>
    <c:if test="${not empty param.age}">
        <c:if test="${param.age >= 18}">
            你已经成年，可浏览器该网站...
        </c:if>
        <c:if test="${param.age < 18}">
            你还未成年，需要在父母陪同下浏览该网站...
        </c:if>
    </c:if>
</body>
</html>

21_JSTL 核心标签之 <c:choose>

作用：用于多分支判断
语法：

<c:choose>
	<c:when test="条件表达式">
      	......
    </c:when>
      ........
    <c:otherwise>
      	........
    </c:otherwise>0
</c:choose>
  • 需求：通过输入分时，得到评级。在一个表单 grade.jsp 输入一个分数，提交给自己。然后在同一个页面中根据分数输出相应的等级：80~100 优秀 60~80 及格 0~60不及格 其它输出分数不正确，效果图如下
  • 示例代码
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>JSTL核心标签之choose</title>
</head>
<body>
    <%--
    需求：通过输入分时，得到评级。
        - 在一个表单 grade.jsp 输入一个分数，提交给自己。然后在同一个页面中根据分数输出相应的等级：
        80~100  优秀
        60~80  及格
        0~60  不及格  其它输出分数不正确，效果图如下
    --%>
    请输入分数：
    <form action="demo10.jsp" method="get">
        <input type="text" name="score" value="${param.score}">
        <input type="submit" value="评级">
    </form>

    <%--
        choose标签作用：用于执行多分支判断
        常用子标签：
            when标签：等价于switch语句的case，test属性：设置条件
            otherwise标签：等价于switch语句的default语句
    --%>
    <c:if test="${not empty param.score}">
        <c:choose>
            <c:when test="${param.score >= 80 && param.score <=100 }">
                优秀
            </c:when>
            <c:when test="${param.score >= 60 && param.score < 80 }">
                及格
            </c:when>
            <c:when test="${param.score >= 0 && param.score < 60 }">
                不及格
            </c:when>
            <c:otherwise>
                你输入的分数有误
            </c:otherwise>
        </c:choose>
    </c:if>
</body>
</html>

22_JSTL 核心标签之 <c:forEach>

forEach标签的作用：用来遍历集合或数组

forEach标签的语法：

<c:forEach items="数组或集合" var="元素">

</c:forEach>
属性名属性类型是否支持EL属性描述
items数组或集合true使用EL表达式，代表集合或数组
varStringfalsevar的变量名代表集合中的每一个元素
varStatusStringfalse代表每一个元素的状态对象，一共有4个元素
属性的含义见下表

+varStatus对象的属性

属性数据类型含义
indexint当前遍历元素的索引
countint遍历到当前元素为止遍历的元素个数
firstboolean当前元素是否是第一个元素
lastboolean当前元素是否是最后一个元素
  • JSP 代码
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>学生信息表</title>
</head>
<body>
    <table border="1" width="600" cellspacing="0" cellpadding="0">
        <tr>
            <th>序号</th>
            <th>学号</th>
            <th>姓名</th>
            <th>性别</th>
            <th>成绩</th>
        </tr>
    </table>
</body>
</html>
  • Student类代码
public class Student {
    private int id;
    private String name;
    private boolean gender; // true 男 false 女
    private double score;

    public Student(int id, String name, boolean gender, double score) {
        this.id = id;
        this.name = name;
        this.gender = gender;
        this.score = score;
    }

    public Student() {
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public boolean isGender() {
        return gender;
    }

    public void setGender(boolean gender) {
        this.gender = gender;
    }

    public double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", gender=" + gender +
                ", score=" + score +
                '}';
    }
}
  • Servlet类代码
package com.pkx._02foreach;

import com.pkx._01show_time.Student;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Arrays;
import java.util.List;

// 目标：查询所有学生信息
@WebServlet(urlPatterns = "/list")
public class ListStudentServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // 创建集合存储学生信息：假装从数据库查询的学生信息
        List<Student> stus = Arrays.asList(
                new Student(1000,"猪八戒",true,65)
                ,new Student(2000,"白骨精",false,85)
                ,new Student(3000,"嫦娥",false,90)
                ,new Student(4000,"唐僧",true,87)
                ,new Student(5000,"蜘蛛精",false,85));

        // 将集合存储到请求域中
        request.setAttribute("stus", stus);

        // 跳转到listStu.jsp页面显示数据
        request.getRequestDispatcher("listStu.jsp").forward(request, response);
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doPost(request, response);
    }
}
  • 遍历集合
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>学生信息表</title>
</head>
<body>
    <table border="1" width="600" cellspacing="0" cellpadding="0">
        <tr>
            <th>序号</th>
            <th>学号</th>
            <th>姓名</th>
            <th>性别</th>
            <th>成绩</th>
            <th>是第一个吗</th>
            <th>是最后一个吗</th>
        </tr>

        <%--
            forEach标签作用：用于遍历集合或数组
                items属性：设置要遍历的数组或集合
                var属性：用来记录当前遍历的元素
                varStatus属性：当前遍历元素的状态对象


            varStatus对象常用属性：
                index：当前遍历元素在集合中的索引
                count：遍历到当前元素为止，一共遍历了多少个元素
                first：当前遍历的元素是否是集合中的第一个元素，是返回true
                last： 当前遍历的元素是否是集合中的最后一个元素，是返回true

            for(Student stu:stus){
                stu.getId();
            }
        --%>
        <c:forEach items="${requestScope.stus}" var="stu" varStatus="status">
            <tr>
                <td>${status.index + 1}</td>
                <td>${stu.id}</td>
                <td>${stu.name}</td>
                <td>${stu.gender? "男":"女"}</td>
                <td>${stu.score}</td>
                <td>${status.first}</td>
                <td>${status.last}</td>
            </tr>
        </c:forEach>
    </table>
</body>
</html>
  • 遍历数组和Map
<%@ page import="java.util.Map" %>
<%@ page import="java.util.HashMap" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>JSTL核心标签之forEach遍历map和数组</title>
</head>
<body>

    <%
        // 创建数组
        int[] arr = {100,54};

        // 创建Map集合
        Map<String,String> map = new HashMap<>();
        map.put("no1", "牛魔王");
        map.put("no2", "猪八戒");
        map.put("no3", "白骨精");

        pageContext.setAttribute("arr", arr);
        pageContext.setAttribute("map", map);
    %>

    <h1>ForEach遍历数组</h1>
    <c:forEach items="${arr}" var="num">
        ${num}
    </c:forEach>

    <h1>ForEach遍历map</h1>

    <%--遍历map时获得的是一个一个Entry对象：一个Entry对象就封装一个键值对数据
        可以通过EL获取Entry对象的key和value --%>
    <c:forEach items="${map}" var="entry">
        ${entry.key} ==> ${entry.value} <br>
    </c:forEach>

</body>
</html>

23_三层架构的概述

  1. 三层架构概述
    表现层：直接和用户交互：展示数据给用户看或接收用户输入的数据。
    业务层：处理业务逻辑，比如转账
    数据访问层(持久层)：专门和数据库交互：对数据库进行增删改查操作

  2. 访问方式
    用户 --> 表现层 --> 业务层 --> 数据访问层 --> 数据库

  3. 分层的作用(好处)
    提高代码的复用性
    提高代码的维护性
    提高代码的扩展性

  4. 分层的方式：不同的层使用不同包
    表现层：com.pkx.servlet
    业务层：com.pkx.service
    数据访问层：com.pkx.dao
    工具类：com.pkx.utils
    测试类：com.pkx.test
    实体类：com.pkx.bean/domain/entity/pojo
    …

  5. 开发步骤：一般从下往上开发
    dao --> service --> servlet/jsp/html

24_用户注册案例

  • 案例分析
  1. 使用数据库保存用户的账号和密码
  2. 定义User类
  3. 编写DAO层，增加saveUser和findUser方法
  4. 编写业务层增加register和isExist方法
  5. 编写编写层代码RegisterServlet
  • 实现步骤
  1. 使用数据库保存用户的账号和密码，创建user表保存账号密码
-- 使用数据库保存用户的账号和密码，创建user表保存账号密码
create table user(
	id int primary key auto_increment,
	username varchar(20) not null unique,
	password varchar(20) not null
)
  1. 定义 User 类
package cn.pkx.entity;

/**
 * @Package cn.pkx.entity
 * @Author pkxing
 * @Date 2020-05-07 12:24
 * @Version 1.0
 */
public class User {
    private int id;
    private String username;
    private String password;

    public User() {
    }

    public User(String username, String password) {
        this.username = username;
        this.password = password;
    }

    public User(int id, String username, String password) {
        this.id = id;
        this.username = username;
        this.password = password;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}
  1. 编写DAO层，增加saveUser和findUser方法
package com.pkx.dao;

import com.pkx.entity.User;

/**
 * 数据访问层：对数据库进行CRUD操作
 */
public class UserDao {

    /**
     * 保存用户信息：注册
     * @param user
     * @return true 保存成功， false 保存失败
     */
    public boolean saveUser(User user){
        System.out.println("操作数据库..." + user);
        return true;
    }
}
  • 编写业务层增加register和isExist方法
package com.pkx.service;

import com.pkx.dao.UserDao;
import com.pkx.entity.User;

/**
 * 业务逻辑层
 */
public class UserService {

    // 数据访问对象
    private UserDao userDao = new UserDao();
    
    /**
     * 用户注册
     */
    public boolean register(User user){
        return userDao.saveUser(user);
    }
}
  • RegisterServlet类代码
package com.pkx.servlet;

import com.pkx.entity.User;
import com.pkx.service.UserService;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

/**
 * 实现注册
z */
@WebServlet(urlPatterns = "/user")
public class RegisterServlet extends HttpServlet {

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // 1. 接收请求参数：用户名和密码
        String username = request.getParameter("username");
        String password = request.getParameter("password");
        // 2. 将请求参数封装成User对象
        User user = new User(username, password);
        // 3. 调用业务层方法实现注册
        UserService us = new UserService();
        boolean result = us.register(user);
        // 4. 根据结果做页面的跳转
        if (result) {
            // 注册成功
            response.sendRedirect("index.jsp");
        } else {
            // 注册失败
            response.sendRedirect("login.jsp");
        }
    }
}

总结

JSP

  • 脚本表达式
     语法：<%=变量名 或 表达式%>
     作用：输出变量的值或表达式计算结果

  • 代码片段
     语法：<% Java代码 %>
     作用：在JSP页面执行一段Java代码
        翻译之后出现在Servlet的service方法中

  • 声明
     语法：<%! %>
     作用：用于在JSP中定义成员变量或成员方法

  • 九大内置对象：
     request、response、session、application、config、page、pageContext、exception、out

  • 三大指令
    page：<%@page 属性名=属性值 ....%>
    include：<%@include file="JSP文件地址" %>
    taglib：<%@taglib uri="地址" prefix="前缀" %>

  • 三大动作
    Jsp:include：<jsp:include page="被包含的JSP页面地址" ></jsp:include>
    Jsp:forward：<jsp:forward page="转发的页面地址"></jsp:forward>
    Jsp:param：<jsp:param name="参数名" value="参数值"></jsp:param>

EL

  • EL的语法：${变量名或表达式}

JSTL
语法：

  • <c:if test="${条件表达式}"></c:if>
  • <c:choose>
    <c:when test="条件表达式">
    ......
    </c:when>
    ........
    <c:otherwise>
    …
    </c:otherwise>
    </c:choose>
  • `<c:forEach items=“数组或集合” var=“元素”>

</c:forEach>`

NTT0101
关注
专栏目录
会话跟踪技术：HttpSession和Cookie
错觉
12-18 6722
一、会话跟踪技术 1　什么是会话跟踪技术 我们需要先了解一下什么是会话！可以把会话理解为客户端与服务器之间的一次会晤，在一次会晤中可能会包含多次请求和响应。例如你给10086打个电话，你就是客户端，而10086服务人员就是服务器了。从双方接通电话那一刻起，会话就开始了，到某一方挂断电话表示会话结束。在通话过程中，你会向10086发出多个请求，那么这多个请求都在一个会话中。 在JavaWe
JSP的语法及相关内容详解
my lover
10-06 182
JSP语法 1.jsp模板元素jsp页面中的html内容称之为JSP模板元素 jsp模板元素定义了网页的基本骨架,即定义了页面的结构和外观.   2.jsp脚本表达式JSP脚本表达式用于将程序数据输出到客户端语法:&lt;%=  变量名或表达式  %&gt;     3.jsp脚本片段jsp脚本片段(1)语法:&lt;%  多行java代码%&gt;注意:jsp脚本片段中只能出现ja...
Java_Basic_Day17-JSP+EL+JSTL+开发模式
a1032818891的博客
07-06 163
 一、JSP技术1．jsp脚本和注释jsp脚本：1）&lt;%java代码%&gt; ----- 内部的java代码翻译到service方法的内部2）&lt;%=java变量或表达式&gt; ----- 会被翻译成service方法内部out.print()3）&lt;%!java代码%&gt; ---- 会被翻译成servlet的成员的内容 jsp注释： 不同的注释可见范围是不同1）Html注释...
Java-Web知识点-JSP&EL&JSTL&MVC
at10090的博客
08-16 211
JSP JSP:入门学习 概念: Java Server Pages： java服务器端页 可以理解为：一个特殊的页面，其中既可以指定定义html标签，又可以定义java代码 用于简化书写！！！ 原理:本质上就是一个Servlet JSP的脚本:JSP定义Java代码的方式 <% 代码 %>：定义的java代码，在service方法中。service方法中可以定义什么...
Java Web学习day10------EL、JSTL、Filter、Listener
dsh789的博客
12-01 139
EL、JSTL、Filter、ListenerEL1.、相关概念2.、基本语法3.、主要作用4、11大内置对象(了解)JSTL1. 相关概念2. 使用步骤3. 常见标签Filter1. 相关概念2. 快速入门3. 使用细节4. FilterConfigListener1. 相关概念2. 快速入门3. 主要作用 EL 1.、相关概念   表达式语言，可以很方便的获取数据，和jstl一起使用，消灭jsp页面中的<% 2.、基本语法   ${表达式} 3.、主要作用 （1）快速的获取域对象中的值   a)
web核心66-day12笔记(jsp , el和jstl)
qq_37224902的博客
09-07 164
web核心66-day12笔记 jsp和el表达式和jstl(只是了解,直接看文末总结吧!) 1. jsp: java server pages 1)jsp本质就是一个servlet 2)特点: 在页面既可以写java代码也可以写html代码 3)目的: 简化你拼接字符串的痛苦 4)创建jsp: 使用idea的创建功能 如果想将原来html页面...
JSP-MVC-EL表达式-JSTL
欧气满满大顺顺的博客
04-11 1308
JSP 指令 作用：用于配置JSP页面，导入资源文件 格式： <%@ 指令名称 属性名1=属性值1 属性名2=属性值2 … %> 分类： page ： 配置JSP页面的 contentType：等同于response.setContentType() 设置响应体的mime类型以及字符集 设置当前jsp页面的编码（只能是高级的IDE才能生效，如果使用低级工具，则需要设置p...
Java Web 11_JSP_EL_JSTL
m0_45178181的博客
05-05 145
这里写目录标题JSP:MVC：开发模式EL表达式JSTL三层架构：软件设计架构案例：用户信息列表展示 JSP: 1. 指令 * 作用：用于配置JSP页面，导入资源文件 * 格式： <%@ 指令名称 属性名1=属性值1 属性名2=属性值2 ... %> * 分类： 1. page ： 配置JSP页面的 * contentType：等同于response.setCon...
Day16_1--JSP了解学习之EL表达式语言入门教程
最新发布
gitee_nanzhi66的博客
08-02 484
EL（表达式语言）是JSP 2.0引入的一种语言，它提供了一种简单的方法来访问JavaBean属性、集合、数组等，而无需使用大量的Java代码。EL的语法简洁明了，让JSP页面更加易于维护。EL是一种简化JSP页面中Java代码的强大工具，使得页面更简洁、可读性更强。通过EL，你可以方便地访问对象属性、请求参数，并进行基本的运算和逻辑判断。掌握EL语法和用法，将大大提高你的JSP开发效率。
树懒-day10_jsp_el_jstl笔记
08-01
移动开发的小白树懒在学习web的技术，为以后的移动开发打下坚实的基石...
day_17_EL&&JSTL.zip
02-24
在Web开发中，EL（Expression Language）和JSTL（JavaServer Pages Standard Tag Library）是两个重要的技术，它们极大地简化了页面逻辑和数据绑定的过程。本案例“day_17_EL&&JSTL.zip”是一个综合性的登录系统，它...
day17_EL&JSTL.rar
01-13
标题 "day17_EL&JSTL.rar" 暗示了这个压缩包可能包含有关在Java Web开发中使用Expression Language（EL）和JSTL（JavaServer Pages Standard Tag Library）的学习材料。EL是用于在JSP页面中简洁地表达和访问...
JAVA WEB DAY 16_ 综合案例-联系人管理系统
NTT0101的博客
09-29 786
文章目录综合案例-联系人管理系统01-案例演示和功能说明-[★★]02-项目环境搭建和数据准备-[★★★]项目结构 综合案例-联系人管理系统 01-案例演示和功能说明-[★★] 查询联系人 删除联系人 添加联系人 修改联系人 02-项目环境搭建和数据准备-[★★★] 使用三层架构开发实现联系人CURD 项目结构 ...
JAVA WEB DAY 17_ Redis
NTT0101的博客
10-02 607
文章目录Redis01_NOSQL的概述-[★★]02_为什么要使用NOSQL-[★★]High Performance - 数据库高并发访问Huge Storage - 高海量数据的存储03_Redis的安装和启动-[★★]04_Redis五种数据类型及结构概述-[★★★★★]05_string类型操作命令-[★★★★★]06_hash类型操作命令-[★★★] Redis 01_NOSQL的概述-[★★] NOSQL：泛指非关系型数据库 02_为什么要使用NOSQL-[★★] NOSQL的好处：快
JAVA WEB DAY 01_Tomcat & Servlet
NTT0101的博客
09-12 480
文章目录Tomcat 服务器与 Servlet目标01 软件架构 [★]02 web资源概述[★]03 web服务器概述[★★]03_01 常见web服务器04 模拟一个 web 服务器[★]05 Tomcat 启动和关闭[★★★]06 Tomcat 目录结构[★★]07 Tomcat 启动时常见问题[★★★]08 Tomcat项目的发布方式[★★★★]方式1：webapps方式2：虚拟目录 Tomcat 服务器与 Servlet 目标 理解软件架构 启动 & 关闭 Tomcat 服务器
JAVA WEB DAY 09_MYSQL 基础语法
NTT0101的博客
09-20 392
文章目录MYSQL 基础语法目标01_数据库概述-[★★★]02_数据库安装与卸载-[★★★]03_MySQL目录结构-[★]04_数据库服务器启动和停止-[★★★]05_数据库登录和退出-[★★★]06_数据库服务器、数据库和表的关系-[★★★]07_实体类与表的对应关系-[★★]08_SQL 概述-[★★★]09_DDL 语句-操作数据库-[★★★★]10_SQLyog 工具安装和使用-[★★★]11_MySQL 数据类型-[★★]12_DDL 语句-操作数据表-[★★★★]13_DDL 语句-修改表结
JAVA WEB DAY 07_ jQuery 基础
NTT0101的博客
09-20 312
文章目录jQuery 基础目标01_jQuery 概述和导入-[★★★]02_ jQuery 对象与 JS 对象的转换-[★★★★]03_ jQuery 之基本选择器-[★★★★]04_ jQuery 之层级选择器-[★★★★]05_ jQuery 之属性选择器-[★★★★]06_ jQuery 之基本过滤选择器-[★★★★]07_ jQuery 之表单属性选择器-[★★★★]08_ jQuery 常用事件概述-[★★★]09_ jQuery 常用事件示例-[★★★★]10_事件切换函数与示例-[★★★★]
JAVA WEB DAY 18_ Maven
NTT0101的博客
10-02 283
文章目录Maven 基础01_Maven概述-[★]02_Maven的仓库-[★★]03_Maven的坐标-[★★]04_Maven的安装和配置-[★★★★★]05_IDEA绑定本地Maven服务器-[★★★★★]06_使用Maven向导创建JavaWeb工程-[★]07_使用插件创建JavaWeb工程-[★★★★★]08_Maven项目生命周期概述-[★★]09_Maven项目生命周期常用命令-[★★★★★]命令使用方式常用命令演示10_Maven自定义jar包演示-[★★★★★]案例需求11_依赖管理之
Java Web三层架构实战教程
"这是一个关于Java三层架构处理的学习文档，适合初学者...总结起来，这个文档涵盖了Java Web应用中的核心概念，包括三层架构的各个组成部分、数据库连接的配置以及JSP页面的编写，是学习和实践Java Web开发的良好资料。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值