JSP

JSP其实是一个Servlet，JSP页面在JSP容器内运行。
第一次请求一个JSP页面时，Servlet/JSP容器要做两件事：

  1. 将JSP页面转换成一个JSP实现类，这是一个实现了javax.servlet.jsp.JspPage接口或其子接口javax.servlet.jsp.HttpjspPage的Java类，所生成的Servlet类名取决于Servlet容器。
  2. 如果转换成功，Servlet/JSP会编译Servlet类，之后,容器加载和实例化Java字节码，并执行它对Servlet所做的生命周期操作。

对于同一个JSP页面的后续请求，Servlet容器会查看这个JSP页面从最后一次转换以来是否修改过。如果修改过，那么重新转换和编译执行。如果没有救说明存在该JSP的Servlet了。第一次调用JSP页面的时间总是比后续的更长，因为需要转换和编译。对此可以采用以下优化措施：

  1. 配置应用程序，在启动时调用所有JSP页面
  2. 预先编译JSP页面，并将他们以Servlet的方式部署

JSP API 包含4个包：

  1. javax.servlet.jsp，包含核心类和接口,Servlet容器会用它们将JSP页面转换成Servlet。JspPage和HttpJspPage接口是这个包中的重要成员。所有页面都必须实现JspPage或HttpJspPage。
  2. javax.servlet.jsp.tagext，包含用于开发定制标签的类型。
  3. javax.el，提供Unified Expression Language API
  4. javax.servlet.jsp.el，提供Servlet容器必须支持的类，以便支持JSP的Expression Language

JSP页面可以包含模版数据和句法元素，模版元素就是页面内的html标签和文本，而句法则是jsp页面内独有的语法元素。
比如一个简单的index.jsp页面：

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!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>JSP compiled</title>
</head>
<body>Hello World
</body>
</html>

则会被转换成叫index_jsp.java根据Servlet容器不同起名有差异

*
 * Generated by the Jasper component of Apache Tomcat
 * Version: Apache Tomcat/8.0.30
 * Generated at: 2016-08-11 21:05:20 UTC
 * Note: The last modified time of this file was set to
 *       the last modified time of the source file after
 *       generation to assist with modification tracking.
 */
package org.apache.jsp;

import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.jsp.*;

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 = null;
  }

  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");
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("<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">\n");
      out.write("<html>\n");
      out.write("<head>\n");
      out.write("<meta http-equiv=\"Content-Type\" content=\"text/html; charset=UTF-8\">\n");
      out.write("<title>JSP compiled</title>\n");
      out.write("</head>\n");
      out.write("<body>Hello World\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);
    }
  }
}

如果你想看到你自己部署的Web服务器上的JSP转换出来的文件，可以到Tomcat的根目录下work/Catalina/应用名/org/apache/jsp/下找到转换后的java源代码(请确保加载了该JSP页面，可以浏览器访问生成一下JSP)
所以我们就知道
JSP -> 转换为Java源码.java文件 -> 编译为Java编译后的.class文件
观察生成的源码我们知道页面主体被转换成一个_jspService方法，这个方法在HttpJspPage里定义，并且通过HttpJspBase的service方法实现调用。

隐式对象

Servlet容器会将及格对象给它运行的Servlet，例如HttpServletRequest和HttpServletResponse，并且在init方法中中获得ServletConfig。
在JSP中可以通过使用九大隐式对象来获得这些对象，如下表所示：

对象类型
requestjavax.servlet.HttpServletRequest
responsejavax.servlet.HttpServletResponse
outjavax.servlet.jsp.JspWriter
sessionjavax.servlet.http.HttpSession
applicationjavax.servlet.ServletContext
configjavax.servlet.ServletConfig
pageContextjava.servlet.jsp.PageContext
pagejavax.servlet.jsp.HttpJspPage
exceptionjava.lang.Throwable

在编译后的servlet类_jspService方法，就可以看到

    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;
    ....
    ....
    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;

比如在JSP代码中可以这样使用这些对象

<% 
    String userName =  request.getParameter("userName");
%>

pageContext

pageContext是指为页面创建的javax.servlet.jsp.PageContext。它提供了一些方法来获得和Servlet有关的对象。比如getRequest, getResponse, getServletContext, getServletConfig以及 getSession。这些没啥用，因为都是可以通过隐式对象访问到。
pageContext提供另外一些重要方法可以用来存取属性，getAttribute 和 setAttribute 方法等。
属性可以保存在一下四个范围内：page,request,session,application。其中page的范围最窄，仅能在当前页面能使用。还有请不要把隐式对象page当做是page域，而是指的隐式对象pageContext。request域指的是当前的ServletRequest，session域指的是HttpSession，application域指的是ServletCotext，简单的说就是你能调用getAttribute 和 setAttribute的对象。
什么是当前页面范围呢，看_jspService方法中

finally {
    _jspxFactory.releasePageContext(_jspx_page_context);
}

最后释放了pageContext资源。而我们的request 可能会因为请求转发而继续存在，session本身就是记录用户信息的也能在一定时间内存在。application则是整个应用存在时间内有效。

jsp注释风格

<%-- comment --%> jsp注释不会被发送到浏览器，不能嵌套

jsp指令

指令是第一种JSP元素，其指示JSP转换器应该如何将某个JSP页面转换成Servlet命令。JSP2.2中定义了几个指令，最重要的是这两个：page 和 include。

page指令

利用page指令可以就当前JSP页面的某些方面对JSP转换器提出指示。例如告诉JSP转换器隐式对象out应该有多大容量的缓存区，使用哪种内容类型。要导入那些Java类型。
语法如下：
<%@ page attribute1="value1" attribute2="value2"%>
page指令属性如下：

  • import，指定导入一种或多种Java类型。就和java代码中使用import类似。默认已经导入了java.lang, javax.servlet, javax.servlet.http, javax.servlet.jsp。
  • session，值为true时，表示页面参与Session管理，默认为true。
  • buffer，表示out缓冲区的大小
  • autoFlush，值为true时缓冲区自动刷新，false，必须显示调用flush方法
  • isThreadSafe，默认为false，servlet默认都是非线程安全的，如果为true，就会加入线程同步
  • info，指定所生成Servlet的getServletInfo方法返回值
  • errorPage，表明出现错误时候的错误页面
  • isErrorPage，该页面是否负责处理错误
  • contentType，response返回内容类型
  • pageEncoding，页面编码方式
  • isELIgnored，是否忽略EL表达式
  • language，页面使用的脚本语言，默认java,唯一有效值
  • extends，指定页面生成的JSP必须继承的类
  • deferredSyntaxAllowedAsLiteral，指明是否允许字符序列#{来获取作为该页面和编译的String字面值
  • trimDirectiveWhiteSpaces，是否从输入内容中删除只包含空格的模版文本,默认false。

page指令可以出现在任何地方，只有包含contentType和pageEncoding属性时才需要放在模版数据前。

include指令

include指令可以将一个文件的内容放到当前JSP页面中。
语法如下：
<%@ include file="url"%>
include方式有两种，一种是<jsp:include page="url" flush="true"/>,该种称为动态include，动态include主要是对动态页面的引入，它总是会检查所引入的页面的变化，如果所包含的资源在请求间发生变化，则下一次请求包含动作的jsp时，将包含资源的新内容。
另外一种是<%@ include file="url"%>，include指令在转换时一次性地将内容复制到jsp中，如果所包含的资源发生变化，则使用include指令的jsp将不能反应出新的内容，除非重新编译该jsp。
动态的引入时需要频繁的变化和页面信息的更新和交互，要占用大量的资源开销。降低页面的访问速度。如果在没必要动态引入的情况下，不要使用动态include。

脚本元素

之前说过JSP中默认允许的脚本为java，脚本元素将Java代码合并成一个JSP页面。
脚本元素有三种：

  • Scriptlet
  • 声明
  • 表达式

Scriptlet

Java代码块，以<%开始，%>结束。

<%
    List<String> week = new ArrayList<>();
    week.add("Monday");
    week.add("Tuesday");
    week.add("Wednesday");
    week.add("Thursday");
    week.add("Friday");
    week.add("Saturday");
    week.add("Sunday");
%>
Hello World<br/>
<% 
    out.print("A weeks has:" + "<br/>");
    for(int i = 0; i < 7; i++) {
        out.print(week.get(i) + "<br/>");
    }
%>

然后经过转换后生成的代码如下所示如下，上述页面中前面一个定义的Scriptlet变量后面是可见的。

    List<String> week = new ArrayList<>();
    week.add("Monday");
    week.add("Tuesday");
    week.add("Wednesday");
    week.add("Thursday");
    week.add("Friday");
    week.add("Saturday");
    week.add("Sunday");
//html template start
      out.write("\n");
      out.write("Hello World<br/>\n");
 //html template end
    out.print("A weeks has:" + "<br/>");
    for(int i = 0; i < 7; i++) {
        out.print(week.get(i) + "<br/>");
    }

表达式

表达式的运算结果会被填入隐式对象out的print方法中，以<%=开始， %>结束。
如下
Today is <%=java.util.Calendar.getInstance().getTime()%>
表达式后 不需要分号等同于下面这个Scriptlet:

Today is
<% 
out.print(java.util.Calendar.getInstance().getTime());
%>

声明

可以声明在JSP页面中能够使用的变量和方法，以<%!开始，%>结束。
比如

<%!
    List<String> week = new ArrayList<>();
%>
<%
    week.add("Monday");
    week.add("Tuesday");
    week.add("Wednesday");
    week.add("Thursday");
    week.add("Friday");
    week.add("Saturday");
    week.add("Sunday");
%>
Hello World<br/>
<% 
    showWeek(out);
%>
<%!
    public void showWeek(JspWriter out) throws IOException{
        out.print("A weeks has:" + "<br/>");
        for(int i = 0; i < 7; i++) {
            out.print(week.get(i) + "<br/>");
        }
    }
%>

还是和上个例子差不多，然后经过转换后生成的代码如下所示如下，可以发现在声明区域里的变量和方法都被统一移到生成代码类的前端定义了。声明可以在JSP任何位置定义，一个页面可以有多个声明。

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


    List<String> week = new ArrayList<>();


    public void showWeek(JspWriter out) throws IOException{
        out.print("A weeks has:" + "<br/>");
        for(int i = 0; i < 7; i++) {
            out.print(week.get(i) + "<br/>");
        }
    }

    ....
    ....

事实上现在开发很少用到脚本元素，大多是使用EL表达式和Tag，因为这和HTML语法类似，便于管理。

动作

类似于Tag，动作提供以标签样式执行默写操作。类似下面的格式：
<jsp:action property1="value1" property2="value2"/>

useBean

创建一个与某个Java类相关的变量，将表现逻辑和业务逻辑分隔开。事实上很少有了，因为有了强大的EL表达式。

<html>
<head>
</head>
<body>
<jsp:useBean id="today" class="java.util.Date" />
<%=today%>
</body
</html

include

之前讲过动态的包含另外一个资源，可以是JSP页面，Servlet或者是静态页面。

forward

forward将当前页面跳转到另外一个资源，该跳转是服务器这边的跳转。这里要说到另外一个概念就是redirect客户端方面的跳转。
forward后，服务器会将请求派遣至对应的servlet，实际上客户端那边根本不知道进行了跳转，地址栏不发生改变。
而redirect后，服务器返回30X状态码，告诉浏览器或者客户端，你请求的资源已经移到这个新的位置，所以客户端会跳转到这个新的位置去，地址栏发生改变。

# servlet
Logo
CSDN学习社区

CSDN联合极客时间，共同打造面向开发者的精品内容学习社区，助力成长！

更多推荐

cover

用 OpenAI Assistants 做大模型应用开发

avatar CSDN学习社区
cover

1 小时解读鸿蒙 10 大热点问题

avatar CSDN学习社区
cover

1 小时解读鸿蒙 10 大热点问题

avatar CSDN学习社区