四：Day05—JSP

新手小菜鸟上路

已于 2023-09-27 09:30:35 修改

阅读量37

点赞数

文章标签： java java-ee 开发语言

于 2023-09-21 08:42:02 首次发布

本文链接：https://blog.csdn.net/qq_51318621/article/details/133079452

版权

一、JSP的使用

1. JSP的引入

有一种特殊的文件，我们可以在它内部编写HTML代码、CSS代码、js代码还有Java代码。编写完之后，再有一个工具，将这个特殊的文件转换成Servlet，在转换好的Servlet中，之前写的Java代码还在，而HTML、css、js代码都使用writer的方式给写好。这个特殊的文件就是jsp文件。这个工具就是Tomcat服务器中的jsp引擎。

2. JSP展示数据实例

<%@ page import="java.util.List" %>
<%@ page import="com.bjsxt.pojo.Emp" %>
<%@ page import="java.util.ArrayList" %>
<%@ page import="java.util.Date" %>
<%@ page import="java.text.SimpleDateFormat" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
  <head>
    <title>$Title$</title>

    <style>
      table{
        width: 550px;
        margin: 0 auto;
        border: 1px solid red;
        border-collapse:collapse;
        text-align: center;
      }
      td,th{
        border: 1px solid red;
      }
    </style>
  </head>
  <body>

    <%
      //从数据库中查询
      List<Emp> list = new ArrayList<>();
      list.add(new Emp(1, "张无忌", "经理", new Date(), 5000.0));
      list.add(new Emp(2, "赵敏", "主管", new Date(), 3000.0));
      list.add(new Emp(3, "金毛狮王", "职员", new Date(), 2000.0));
      list.add(new Emp(4, "灭绝师太", "职员", new Date(), 2000.0));
      list.add(new Emp(5, "周芷若", "总监", new Date(), 8000.0));
    %>

    <table>
      <tr>
        <th>编号</th>
        <th>姓名</th>
        <th>职位</th>
        <th>生日</th>
        <th>工资</th>
      </tr>

      <% SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); %>
      <% for (Emp emp : list) {%>

      <tr>
        <td><%out.write(emp.getId()+"");%></td>
        <td><%out.write(emp.getName());%></td>
        <td><%out.write(emp.getPosition());%></td>
        <td><%out.write(sdf.format(emp.getBirthday()));%></td>
        <td><%out.write(emp.getSalary()+"");%></td>
      </tr>

      <% }%>
    </table>
  </body>
</html>

3. JSP执行原理及流程

JSP看似是HTML代码，看似是页面，但其实是一种后端技术。
当我们第一次发送请求访问jsp资源时，Tomcat服务器中的JSP加载引擎会将该JSP资源转换成一个 .java 文件(Servlet)。
这个 .java文件其实就是一个Servlet，在这个Servlet中已经将写在JSP中的HTML代码以writer.print()的方式编写好了，然后将数据响应给浏览器的。
JSP本质上就是一个Servlet，JSP中的HTML代码就相当于我们之前在Servlet中写的writer.write()代码。

3.1 JSP执行过程

JSP的执行过程大致可以分为三个时期：转换、编译、执行。

转换/翻译（translation）	Tomcat中的JSP引擎将JSP网页转换成Servlet，得到一个.java文件。
编译（compile）	通过javac命令将.java文件编译成 .class文件。
运行	运行.class字节码文件，处理请求。

具体运行过程：

浏览器发起请求访问jsp。

Tomcat服务器接收到请求后调用对应的Servlet处理请求，调用JspServlet。

JspServlet将请求的jsp文件转换成对应的Java文件并完成编译。

将编译后的class文件加载到内存并执行，其实就是运行一个Servlet。

最后得到结果数据响应浏览器。

转换后的代码如下：

package org.apache.jsp;

import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.jsp.*;
import java.util.List;
import com.bjsxt.pojo.Emp;
import java.util.ArrayList;
import java.util.Date;
import java.text.SimpleDateFormat;

public final class index_jsp extends org.apache.jasper.runtime.HttpJspBase
    implements org.apache.jasper.runtime.JspSourceDependent,
                 org.apache.jasper.runtime.JspSourceImports {

  private static final javax.servlet.jsp.JspFactory _jspxFactory =
          javax.servlet.jsp.JspFactory.getDefaultFactory();

  private static java.util.Map<java.lang.String,java.lang.Long> _jspx_dependants;

  private static final java.util.Set<java.lang.String> _jspx_imports_packages;

  private static final java.util.Set<java.lang.String> _jspx_imports_classes;

  static {
    _jspx_imports_packages = new java.util.HashSet<>();
    _jspx_imports_packages.add("javax.servlet");
    _jspx_imports_packages.add("javax.servlet.http");
    _jspx_imports_packages.add("javax.servlet.jsp");
    _jspx_imports_classes = new java.util.HashSet<>();
    _jspx_imports_classes.add("java.util.List");
    _jspx_imports_classes.add("com.bjsxt.pojo.Emp");
    _jspx_imports_classes.add("java.util.Date");
    _jspx_imports_classes.add("java.text.SimpleDateFormat");
    _jspx_imports_classes.add("java.util.ArrayList");
  }

  private volatile javax.el.ExpressionFactory _el_expressionfactory;
  private volatile org.apache.tomcat.InstanceManager _jsp_instancemanager;

  public java.util.Map<java.lang.String,java.lang.Long> getDependants() {
    return _jspx_dependants;
  }

  public java.util.Set<java.lang.String> getPackageImports() {
    return _jspx_imports_packages;
  }

  public java.util.Set<java.lang.String> getClassImports() {
    return _jspx_imports_classes;
  }

  public javax.el.ExpressionFactory _jsp_getExpressionFactory() {
    if (_el_expressionfactory == null) {
      synchronized (this) {
        if (_el_expressionfactory == null) {
          _el_expressionfactory = _jspxFactory.getJspApplicationContext(getServletConfig().getServletContext()).getExpressionFactory();
        }
      }
    }
    return _el_expressionfactory;
  }

  public org.apache.tomcat.InstanceManager _jsp_getInstanceManager() {
    if (_jsp_instancemanager == null) {
      synchronized (this) {
        if (_jsp_instancemanager == null) {
          _jsp_instancemanager = org.apache.jasper.runtime.InstanceManagerFactory.getInstanceManager(getServletConfig());
        }
      }
    }
    return _jsp_instancemanager;
  }

  public void _jspInit() {
  }

  public void _jspDestroy() {
  }

  public void _jspService(final javax.servlet.http.HttpServletRequest request, final javax.servlet.http.HttpServletResponse response)
      throws java.io.IOException, javax.servlet.ServletException {

    final java.lang.String _jspx_method = request.getMethod();
    if (!"GET".equals(_jspx_method) && !"POST".equals(_jspx_method) && !"HEAD".equals(_jspx_method) && !javax.servlet.DispatcherType.ERROR.equals(request.getDispatcherType())) {
      response.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED, "JSPs only permit GET, POST or HEAD. Jasper also permits OPTIONS");
      return;
    }

    final javax.servlet.jsp.PageContext pageContext;
    javax.servlet.http.HttpSession session = null;
    final javax.servlet.ServletContext application;
    final javax.servlet.ServletConfig config;
    javax.servlet.jsp.JspWriter out = null;
    final java.lang.Object page = this;
    javax.servlet.jsp.JspWriter _jspx_out = null;
    javax.servlet.jsp.PageContext _jspx_page_context = null;


    try {
      response.setContentType("text/html;charset=UTF-8");
      pageContext = _jspxFactory.getPageContext(this, request, response,
                null, true, 8192, true);
      _jspx_page_context = pageContext;
      application = pageContext.getServletContext();
      config = pageContext.getServletConfig();
      session = pageContext.getSession();
      out = pageContext.getOut();
      _jspx_out = out;

      out.write("\n");
      out.write("\n");
      out.write("\n");
      out.write("\n");
      out.write("\n");
      out.write("\n");
      out.write("<html>\n");
      out.write("  <head>\n");
      out.write("    <title>$Title$</title>\n");
      out.write("\n");
      out.write("    <style>\n");
      out.write("      table{\n");
      out.write("        width: 550px;\n");
      out.write("        margin: 0 auto;\n");
      out.write("        border: 1px solid red;\n");
      out.write("        border-collapse:collapse;\n");
      out.write("        text-align: center;\n");
      out.write("      }\n");
      out.write("      td,th{\n");
      out.write("        border: 1px solid red;\n");
      out.write("      }\n");
      out.write("    </style>\n");
      out.write("  </head>\n");
      out.write("  <body>\n");
      out.write("\n");
      out.write("    ");

      //从数据库中查询
      List<Emp> list = new ArrayList<>();
      list.add(new Emp(1, "张无忌", "经理", new Date(), 5000.0));
      list.add(new Emp(2, "赵敏", "主管", new Date(), 3000.0));
      list.add(new Emp(3, "金毛狮王", "职员", new Date(), 2000.0));
      list.add(new Emp(4, "灭绝师太", "职员", new Date(), 2000.0));
      list.add(new Emp(5, "周芷若", "总监", new Date(), 8000.0));
    
      out.write("\n");
      out.write("\n");
      out.write("    <table>\n");
      out.write("      <tr>\n");
      out.write("        <th>编号</th>\n");
      out.write("        <th>姓名</th>\n");
      out.write("        <th>职位</th>\n");
      out.write("        <th>生日</th>\n");
      out.write("        <th>工资</th>\n");
      out.write("      </tr>\n");
      out.write("\n");
      out.write("      ");
 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); 
      out.write("\n");
      out.write("      ");
 for (Emp emp : list) {
      out.write("\n");
      out.write("\n");
      out.write("      <tr>\n");
      out.write("        <td>");
out.write(emp.getId()+"");
      out.write("</td>\n");
      out.write("        <td>");
out.write(emp.getName());
      out.write("</td>\n");
      out.write("        <td>");
out.write(emp.getPosition());
      out.write("</td>\n");
      out.write("        <td>");
out.write(sdf.format(emp.getBirthday()));
      out.write("</td>\n");
      out.write("        <td>");
out.write(emp.getSalary()+"");
      out.write("</td>\n");
      out.write("      </tr>\n");
      out.write("\n");
      out.write("      ");
 }
      out.write("\n");
      out.write("    </table>\n");
      out.write("  </body>\n");
      out.write("</html>\n");
    } catch (java.lang.Throwable t) {
      if (!(t instanceof javax.servlet.jsp.SkipPageException)){
        out = _jspx_out;
        if (out != null && out.getBufferSize() != 0)
          try {
            if (response.isCommitted()) {
              out.flush();
            } else {
              out.clearBuffer();
            }
          } catch (java.io.IOException e) {}
        if (_jspx_page_context != null) _jspx_page_context.handlePageException(t);
        else throw new ServletException(t);
      }
    } finally {
      _jspxFactory.releasePageContext(_jspx_page_context);
    }
  }
}

3.2 JSP的性能问题

JSP的执行性能和Servlet的执行性能上的差别只在第一次的执行上。因为在第一次执行jsp时，jsp要经过转换、编译、执行三个过程。而之后再次访问jsp页面时，就直接执行第一次所产生的Servlet即可，不需要每次都转换、编译。

JSP和HTML相比的话肯定是要慢的，他们的机制就不一样，JSP本质上是Servlet，在请求jsp时，要经过执行，其内部是通过大量的IO流形式将内容发送给页面的，IO流就是一种比较耗费资源的操作。而HTML本身资源是已经存在的，不需要服务器执行什么操作。

但JSP是动态资源，可以动态的展示数据。

3.3 JSP加载引擎

查看Tomcat conf/web.xml文件发现，这里默认配置了一个JSP的加载引擎-JspServlet。

<servlet>
    <servlet-name>jsp</servlet-name>
    <servlet-class>org.apache.jasper.servlet.JspServlet</servlet-class>
    <init-param>
        <param-name>fork</param-name>
        <param-value>false</param-value>
    </init-param>
    <init-param>
        <param-name>xpoweredBy</param-name>
        <param-value>false</param-value>
    </init-param>
    <load-on-startup>3</load-on-startup>
</servlet>
<servlet-mapping>
    <servlet-name>jsp</servlet-name>
    <url-pattern>*.jsp</url-pattern>
    <url-pattern>*.jspx</url-pattern>
</servlet-mapping>

可以看到，请求jsp页面的请求都会被jsp加载引擎所匹配到，那么该引擎有什么作用？

转换JSP页面：将JSP页面转换成一个Servlet。
编译JSP对应的Java文件：JSP引擎调用Java编译器对这个Servlet进行编译，得到可执行文件class。
请求处理：JSP引擎调用java虚拟机来解释执行class文件，得到结果响应浏览器。

4. JSP的继承结构

JSP文件转换成JAVA代码之后,它默认继承了HttpJspBase,实现了JspSourceDependent,和JspSourceImports两个接口,其中HttpJspBase又继承了HttpServlet ,也就是说,JSP本质上就是一个Servlet。

HttpJSPBase代码:

public abstract class HttpJSPBase extends HttpServlet implements HttpJSPPage {
    private static final long serialVersionUID = 1L;
    protected HttpJSPBase() {
    }
    @Override
    public final void init(ServletConfig config)
            throws ServletException {
        super.init(config);
        JSPInit();
        _JSPInit();
    }
    @Override
    public String getServletInfo() {
        return Localizer.getMessage("JSP.engine.info", Constants.SPEC_VERSION);
    }
    @Override
    public final void destroy() {
        JSPDestroy();
        _JSPDestroy();
    }
    @Override
    public final void service(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException
    {
        _JSPService(request, response);
    }
    @Override
    public void JSPInit() {
    }
    public void _JSPInit() {
    }
    @Override
    public void JSPDestroy() {
    }
    protected void _JSPDestroy() {
    }
    @Override
    public abstract void _JSPService(HttpServletRequest req,HttpServletResponse resp)
            throws ServletException, IOException;
}

HttpJSPBase重写了init,service和destory方法。并且自定义了 jspInit, jspService, jspDestory。

然后在重写的init方法中调用了 JSPInit,在重写的service方法中调用了 jspService,在重写的destory方法中调用了 jspDestory。

我们JSP的文件编译成JAVA代码后,继承HttpJspBase重写的方法是 jspInit, jspService, jspService。

5. JSP中的java代码

在jsp中可以通过 <%%> 和 <%!%>两种方式来书写代码，这两种方式中写的Java代码在转换后生成的代码在Servlet中位置是不一样的，前者在_jspService方法中，后者在Servlet中作为类的成员。

下面以定义变量举例，在jsp中定义局部变量和成员变量：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <%--  定义局部变量  --%>
    <%
        int a = 10;
    %>

    <%--  定义成员变量  --%>
    <%!
        int b = 20;
    %>
</body>
</html>

JSP本质上是Servlet，在Servlet中我们是不推荐定义一些成员变量的。

6. JSP中的注释

JSP中可以写HTML、Java、CSS、JS代码，那么也就可以写这些语言的注释，并且JSP也有自己的注释方式。JSP的注释格式是：<%--注释内容--%>

不同的注释是有差异的，通过下面案例对比一下：

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

    <style>
        /*我是css注释*/
    </style>

    <script>
        //我是JS注释
        /*我是JS注释*/
    </script>
</head>
<body>
    <!--我是HTML注释-->

    <%--我是jsp注释--%>
</body>
</html>

通过查看转换后的文件和查看浏览器中的页面源码发现：

注释类型	进入转译文件	响应给浏览器
JSP注释	no	no
JAVA注释	yes	no
HTML,css,js注释	yes	yes

7. JSP的使用建议

JSP和Servlet本质上是相同的。所以说，JSP页面功能和Servlet中功能完全可以互换。

JSP的编码风格是在HTML中嵌入少量的Java代码，它用于展示数据比较方便。

Servlet适合编写Java代码。

所以在MVC分层上，我们往往将Servlet作为控制层，将JSP作为视图层。

以后通过Servlet去处理请求，得到结果，然后通过JSP来进行结果展示。

二、JSP中的常用指令标签

1. 概述

指令标签是JSP页面上的一种特殊标签，JSP指令可以用来设置整个JSP页面相关的属性，如网页的编码方式、网页使用的脚本语言、导包等。

指令标签的语法： <%@ directive attribute="value" %>

JSP中的三种指令标签：

指令	描述
<%@ page %>	定义网页依赖属性，如脚本语言、error页面、缓存需求等等
<%@ include %>	包含其他文件
<%@ taglib %>	引入标签库的定义

2. page指令标签

属性	描述
buffer	指定out对象使用缓冲区的大小
autoFlush	控制out对象的缓存区
contentType	指定当前JSP页面的MIME类型和字符编码
errorPage	指定当JSP页面发生异常时需要转向的错误处理页面
isErrorPage	指定当前页面是否可以作为另一个JSP页面的错误处理页
extends	指定servlet从哪一个类继承
import	导入要使用的Java类
info	定义JSP页面的描述信息
isThreadSafe	指定对JSP页面的访问是否为线程安全
language	定义JSP页面所用的脚本语言，默认是Java
session	指定JSP页面是否使用session，默认是使用
isELIgnored	指定是否执行EL表达式
isScriptingEnabled	确定脚本元素能否被使用

<%@ page contentType="text/html;charset=UTF-8" language="java"
         import="com.bjsxt.pojo.Emp" pageEncoding="utf-8" errorPage="error500.jsp"
         isErrorPage="true" %>
<%--
    contentType:告诉浏览器响应的数据类型及编码格式
    language:设置jsp页面中使用的脚本语言
    import:导包
    pageEncoding:当前页面的编码格式
    errorPage:指定错误页，当前页面发生错误时，显示错误页面的信息
    isErrorPage:指定当前页面为错误提示页，也可以接收异常对象
--%>

<html>
<head>
    <title>Title</title>
</head>
<body>
    <%
        int a = 1/0;
    %>
</body>
</html>

errorPage是一种处理错误提示页的功能。除了jsp的这种错误提示功能外，我们也可以在web.xml中配置各种错误提示页。

注意：如果jsp中配置的错误页和web.xml中配置的错误页冲突的话，以jsp中指定的errorPage为准，它的优先级更高。

<error-page>
    <error-code>500</error-code>
    <location>/error500.jsp</location>
</error-page>
<error-page>
    <error-code>404</error-code>
    <location>/error404.jsp</location>
</error-page>

3. include指令标签

JSP可以通过include指令来包含其他文件。被包含的文件可以是jsp文件、HTML文件或文本文件。
包含的文件就像是jsp文件的一部分，会被同时编译执行。
除了使用include指令标签可以实现引入外，使用jsp:include动作也可以实现引入。

案例：

这个是hello1.jsp文件：

<body>
    我是hello1.jsp页面内容。<br>

    <%--
        静态引入，被引入的jsp页面不会单独生成java代码文件，当前页和被引入页会生成一个java文件
    --%>
    <%@ include file="hello2.jsp"%>

    <%--
        动态引入：被引入的页面会生成独立的java代码，在当前页生成的java代码中使用
        org.apache.jasper.runtime.JspRuntimeLibrary.include(request, response, "hello3.jsp", out, false);
        引入其他页面
    --%>
    <jsp:include page="hello3.jsp"></jsp:include>
</body>

静态引入: @include 被引入的网页和当前页生成代码后形成了一个java文件。

动态引入: jsp:include 被引入的JSP页面会生成独立的java代码。

4. taglib指令标签

taglib就是标签库的意思，我们可以在jsp页面中引入其他的标签库，帮我们去快速简单的做一些事情，后面JSTL标。签库会详细介绍。

taglib指令的语法：<%@ taglib uri="uri" prefix="prefixOfTag" %>

三、JSP内置对象

1. 什么是内置对象

因为JSP的本质是Servlet,在JSP文件经过转译之后,生成JAVA代码,在运行时,JSP给我们准备好了九个可以直接使用而不用我们自己去new的对象,这九个对象我们称之为内置对象。

内置对象完全由JSP自行去维护, 我们直接使用即可。

2. 九大内置对

2. 九大内置对象

2.1 对象介绍

四个域对象	pageContext	page域	当前页面内可用。
	request	reqeust域	一次请求。
	session	session域	一次会话, 多次请求。
	application	application域	整个项目运行, 多次请求, 多次会话。
响应对象	response	响应对象
输出流对象	out	打印流对象。
其他三个对象	servletConfig	由于JSP本身也是一个Servlet,所以容器也会给我们准备一个ServletConfig。
	page	就是JSP转换的Servlet的对象，也就是当前JSP对象本身。
	exception	异常对象,在错误提示页上使用,当isErrorpage=true 才具有该对象。

2.2 注意事项

response对象：

当服务器创建request对象时会同时创建用于响应客户端的response对象。

out对象 ：

是 JspWriter 类的实例，不是PrinterWriter的实例；用来在response对象中写入内容。JspWriter类包含了大部分java.io.PrintWriter类中的方法。不过，JspWriter增了一些专为处理缓存而设计的方法。另外JspWriter类会抛出IOExceptions异常。最初的JspWriter类对象根据页面是否有缓存来进行不同的实例化操作。可以在page指令中使用。buffered='false'属性来轻松关闭缓存。

pageContext对象：

PageContext类的实例，用来代表整个JSP页面；提供对JSP页面所有对象以及命名空间的访问。

3. Servlet与JSP的联系和区别

联系：

JSP和Servlet都是Sun公司推出的动态网页技术。
基于Servlet开发页面的繁琐性，推出JSP来简化页面开发。
JSP本质上是一个Servlet，会翻译成一个Servlet。

区别：

JSP使人们把显示和逻辑分隔成为可能，这意味着两者的开发可并行进行；而Servlet并没有把两者分开。
JSP是在HTML代码里写JAVA代码,框架是HTML;而Servlet是在JAVA代码中写HTML代码，本身是个JAVA类。
Servlet需要在web.xml中配置，而JSP无需配置。
目前JSP主要用在视图层负责显示，而Servlet主要用在控制层负责调度

强调：JSP表面上是一个HTML，本质上是一个Servlet。

4. JSP的使用总结

创建Jsp文件，在项目的web目录下创建。
使用page指令设置Jsp的转译细节(一般自动生成的就够用)。
使用tablib指令引入第三方的自定义标签来使用(JSTL标签)。
使用HTML，CSS，JQuery完成页面的开发。
使用<%%>声明java脚本片段完成数据的动态拼接。
1. <%%>：生成在_jspService()方法中
2. <%! %>：生成在类中
3. <%= %>：生成在_jspService()方法中，输出
获取request或者session中的数据拼接到当前页面中(内置对象)。

四、EL表达式

可以在jsp页面中使用EL表达式来获取域对象中的数据（核心思想获取数据）。

1. 特点

可以获取作用域对象中的数据。
底层使用的是反射，在使用的时候可以通过键名即可获取对应的值。
简化了在jsp页面中使用<%%>获取域对象数据的方式。

2. 使用

2.1 基本语法

${键名}，键名是域对象中存储的数据的键。
${键名.属性名.属性名…}，可以获取域对象中级联属性的值。
${键名[角标]}，获取域对象中存储的list集合或者数组中指定角标的数据。

注意：${} 不仅可获取域对象中的数据，而且会将该数据打印到浏览器中。如果获取不到数据，也不会报错，只是不显示而已。

2.2 作用域数据查找顺序

使用EL表达式获取域数据的时候，如果没有指明作用域，那会按照作用域由小到大的顺序去找，直到找到为止： pageContext ---> request ---> session ---> application

2.3 指定获取某个作用域中的数据

${pageScope.键名} 获取page域对象中的数据
${requestScope.键名} 获取request域对象中的数据
${sessionScope.键名} 获取session域对象中的数据
${applicationScope.键名} 获取application域对象中的数据

2.4 获取request对象中的请求数据

${param.键名}，可以获取request中携带的请求参数的数据

2.5 获取request对象中Cookie的key value

${cookie.JSESSIONID.name}
${cookie.JSESSIONID.value}

2.6 EL表达式使用比较运算和算术运算

${键名逻辑运算符键名}
${键名算术运算符键名}

注意： + 表示的是算术运算，而不是字符串拼接。

3. 案例

<%@ page import="com.bjsxt.pojo.Emp" %>
<%@ page import="java.util.List" %>
<%@ page import="java.util.Map" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <h2>使用脚本方式获取数据</h2>
    <ul>
        <li>获取简单数据：<%out.write(request.getAttribute("name").toString());%></li>
        <li>获取对象数据：<%out.write(((Emp)request.getAttribute("emp")).getName());%></li>
        <li>获取list集合数据：<%out.write(((List)request.getAttribute("list")).get(0).toString());%></li>
        <li>获取map集合数据：<%out.write(((Map)request.getAttribute("map")).get("key1").toString());%></li>
    </ul>
    <h2>使用EL表达式方式获取数据</h2>
    <ul>
        <li>获取简单数据：${name}</li>
        <li>获取对象数据：${emp}</li>
        <li>获取list集合数据：${list[0]}</li>
        <li>获取map集合数据：${map.key1}</li>
    </ul>

    <h2>指明域对象获取数据</h2>
    <ul>
        <li>获取request域数据：${requestScope.requestParam}</li>
        <li>获取session域数据：${sessionScope.sessionParam}</li>
        <li>获取application域数据：${applicationScope.applicationParam}</li>
    </ul>

    <h2>使用逻辑表达式</h2>
    ${3 > 4}<br>
    ${5 + 8}
</body>
</html>

五、JSTL标签库学习

（核心思想：使用数据）

可以使用JSTL标签来完成一些例如循环、判断等情况的与数据输出。JSTL的作用就是：替换在Jsp中声明的Java逻辑代码。

1. 介绍

JSTL标签库是第三方发明的自定义的标签，每个标签都有自己特定的含义表示一个具体的java逻辑。我们要在JSP中使用JSTL必须使用taglib标签引入第三方的标签库资源。标签库的内容有:

核心标签库
SQL标签库
函数标签库
格式化标签库
XML标签库

2. 使用

使用步骤：

在项目中导入JSTL的jar包。
在jsp页面中通过taglib指令引入jstl标签库。
使用jstl标签完成开发。

3.案例

3.1 判断

<%@ 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>
</head>
<body>

<%
    request.setAttribute("gender", "0");
%>
<%--
    c:if 标签的作用就相当于Java中的if判断
    格式是： <c:if test="${EL 比较运算符 值}">条件成立输出的内容</c:if>
--%>
<c:if test="${gender == '0'}">
    性别是男。
</c:if>
</body>
</html>

3.2 循环

<%@ 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>
</head>

<body>
    <c:forEach items="${list}" var="emp">
        ${emp.id}---${emp.name}---${emp.position} <br>
    </c:forEach>

<c:forEach begin="0" end="10" var="i" step="1" varStatus="status">
    ${i} --- ${status.index}
</c:forEach>

</body>
</html>

新手小菜鸟上路

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
四：Day05—JSP

指令标签是JSP页面上的一种特殊标签，JSP指令可以用来设置整个JSP页面相关的属性，如网页的编码方式、网页使用的脚本语言、导包等。指令标签的语法：指令描述定义网页依赖属性，如脚本语言、error页面、缓存需求等等包含其他文件引入标签库的定义因为JSP的本质是Servlet,在JSP文件经过转译之后,生成JAVA代码,在运行时,JSP给我们准备好了九个可以直接使用而不用我们自己去new的对象,这九个对象我们称之为内置对象。
复制链接

扫一扫